diff -r 07b41fa8d1dd -r ca8a1b6995f6 tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/TraceCompilerEngine.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/TraceCompilerEngine.java Tue Aug 31 16:45:49 2010 +0300 @@ -0,0 +1,393 @@ +/* + * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * + * A singleton access point to functionality of Trace Compiler + * + */ +package com.nokia.tracecompiler.engine; + +import java.util.ArrayList; + +import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.TraceCompilerErrorCode; +import com.nokia.tracecompiler.engine.event.EventEngine; +import com.nokia.tracecompiler.engine.header.HeaderEngine; +import com.nokia.tracecompiler.engine.plugin.PluginEngine; +import com.nokia.tracecompiler.engine.project.ProjectEngine; +import com.nokia.tracecompiler.engine.propertyfile.PropertyFileEngine; +import com.nokia.tracecompiler.engine.rules.RulesEngine; +import com.nokia.tracecompiler.engine.source.SourceEngine; +import com.nokia.tracecompiler.engine.source.SourceListener; +import com.nokia.tracecompiler.engine.source.SourceProperties; +import com.nokia.tracecompiler.model.TraceCompilerException; +import com.nokia.tracecompiler.model.TraceModel; +import com.nokia.tracecompiler.plugin.TraceCompilerPlugin; + +/** + * A singleton access point to functionality of Trace Compiler + * + */ +final class TraceCompilerEngine implements SourceListener, TraceCompilerEngineInterface { + + /** + * TraceCompiler plug-in engine + */ + private PluginEngine pluginEngine; + + /** + * Event handler interface implementation + */ + private TraceCompilerEngineEvents eventEngine; + + /** + * Source editor engine + */ + private SourceEngine sourceEngine; + + /** + * Trace header engine + */ + private HeaderEngine headerEngine; + + /** + * Trace project engine + */ + private ProjectEngine projectEngine; + + /** + * Rule engine + */ + private RulesEngine rulesEngine; + + /** + * Trace property file engine + */ + private PropertyFileEngine propertyFileEngine; + + /** + * Source context manager + */ + private SourceContextManager contextManager; + + /** + * Location map + */ + private TraceLocationMap locationMap; + + /** + * Location converter + */ + private TraceLocationConverter locationConverter; + + /** + * Trace model + */ + private TraceModel model; + + /** + * Interface to the view + */ + private TraceCompilerEngineView view = new ViewAdapter(); + + /** + * Configuration + */ + private ConfigurationDelegate configurationDelegate; + + /** + * List of engines that need project open / export / close notifications + */ + private ArrayList engines = new ArrayList(); + + /** + * View has been registered flag + */ + private boolean isViewRegistered = false; + + /** + * Project path is stored in case the view unregisters and re-registers + */ + private String currentProjectPath; + + /** + * Gets the configuration of TraceCompiler + * + * @return the configuration + */ + TraceCompilerEngineConfiguration getConfiguration() { + return configurationDelegate; + } + + /** + * Gets the trace compiler interface + * + * @return this object + */ + TraceCompilerEngineInterface getTraceCompiler() { + return this; + } + + /** + * Gets the trace model + * + * @return the trace model + */ + TraceModel getModel() { + return model; + } + + /** + * Gets the source engine + * + * @return the source engine + */ + SourceEngine getSourceEngine() { + return sourceEngine; + } + + /** + * Gets the events interface + * + * @return the events interface + */ + TraceCompilerEngineEvents getEvents() { + return eventEngine; + } + + /** + * Adds a plug-in + * + * @param plugin + * the plugin + */ + void registerPlugin(TraceCompilerPlugin plugin) { + pluginEngine.add(plugin); + } + + /** + * Removes an existing plug-in + * + * @param plugin + * the plugin + */ + void unregisterPlugin(TraceCompilerPlugin plugin) { + pluginEngine.remove(plugin); + } + + /** + * Gets the source context manager + * + * @return the context manager + */ + public SourceContextManager getSourceContextManager() { + return contextManager; + } + + /** + * Starts TraceCompiler. + * @throws TraceCompilerException + */ + void start() throws TraceCompilerException { + configurationDelegate = new ConfigurationDelegate(); + rulesEngine = new RulesEngine(); + pluginEngine = new PluginEngine(); + model = new TraceModel(rulesEngine, pluginEngine.getVerifier()); + pluginEngine.setModel(model); + projectEngine = new ProjectEngine(model); + propertyFileEngine = new PropertyFileEngine(model); + eventEngine = new EventEngine(model); + sourceEngine = new SourceEngine(model); + locationMap = new TraceLocationMap(model); + locationConverter = new TraceLocationConverter(model); + sourceEngine.addSourceListener(this); + contextManager = new SourceContextManagerImpl(); + headerEngine = new HeaderEngine(model); + // Keep this order -> Exports need to be in correct order + // Property file engine manages the ID cache so it needs to be run + // before plug-in's and header + engines.add(projectEngine); + engines.add(propertyFileEngine); + engines.add(headerEngine); + engines.add(pluginEngine); + } + + /** + * Shuts down TraceCompiler + * @throws TraceCompilerException + */ + void shutdown() throws TraceCompilerException { + closeProject(); + } + + /** + * Registers the view + * + * @param view + * the view + * @throws TraceCompilerException + */ + void setView(TraceCompilerEngineView view) throws TraceCompilerException { + if (view == null) { + // Closes the project, but leaves the currentProjectName and + // currentProjectPath variables. When view re-registers the project + // is opened back + internalCloseProject(); + this.view = new ViewAdapter(); + isViewRegistered = false; + } else { + this.view = view; + isViewRegistered = true; + } + configurationDelegate.setConfiguration(this.view.getConfiguration()); + } + + /** + * Checks that model is valid + * + * @throws TraceCompilerException + * if model is not valid + */ + private void checkIsModelValid() throws TraceCompilerException { + if (!model.isValid()) { + throw new TraceCompilerException( + TraceCompilerErrorCode.MODEL_NOT_READY); + } + } + + /* + * (non-Javadoc) + * + * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#openProject(java.lang.String, + * java.lang.String) + */ + public void openProject(String modelName) throws Exception { + try { + if (view != null && isViewRegistered && !model.isValid()) { + projectEngine.openTraceProject(currentProjectPath, modelName); + for (TraceCompilerEngineBase engine : engines) { + engine.projectOpened(); + } + model.setValid(true); + sourceEngine.start(); + } + } catch (TraceCompilerException e) { + closeModel(); + throw e; + } + } + + /* + * (non-Javadoc) + * + * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#exportProject() + */ + public void exportProject() throws TraceCompilerException { + checkIsModelValid(); + if (model.getID() != 0) { + for (TraceCompilerEngineBase engine : engines) { + engine.exportProject(); + } + } else { + throw new TraceCompilerException( + TraceCompilerErrorCode.INVALID_MODEL_PROPERTIES_FOR_EXPORT); + } + } + + /* + * (non-Javadoc) + * + * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#closeProject() + */ + public void closeProject() throws TraceCompilerException { + internalCloseProject(); + currentProjectPath = null; + } + + /** + * Closes the project + * @throws TraceCompilerException + */ + private void internalCloseProject() throws TraceCompilerException { + if (model.isValid()) { + if (!TraceCompilerEngineGlobals.getConfiguration().getFlag( + TraceCompilerEngineConfiguration.CONSOLE_UI_MODE)) { + try { + // Plug-in's are not exported when project is closed + // They can do cleanup in traceProjectClosed call + for (TraceCompilerEngineBase engine : engines) { + if (engine != pluginEngine) { + engine.exportProject(); + } + } + } catch (TraceCompilerException e) { + getEvents().postError(e); + throw e; + } + } + // Engines are closed in reverse order + for (int i = engines.size() - 1; i >= 0; i--) { + engines.get(i).projectClosed(); + } + sourceEngine.shutdown(); + closeModel(); + } + } + + /** + * Closes the trace model + */ + private void closeModel() { + try { + if (model != null) { + model.reset(); + model.setValid(false); + } + } catch (Exception e) { + if (TraceCompilerEngineConfiguration.ASSERTIONS_ENABLED) { + getEvents().postAssertionFailed("Failed to close model", e); //$NON-NLS-1$ + } + } + } + + /* + * (non-Javadoc) + * + * @see com.nokia.tracecompiler.engine.SourceListener# + * sourceOpened(com.nokia.tracecompiler.engine.SourceProperties) + */ + public void sourceOpened(SourceProperties properties) throws TraceCompilerException { + locationMap.addSource(properties); + locationConverter.sourceOpened(properties); + } + + /** + * Get project path + * + * @return project path + */ + public String getProjectPath() { + return currentProjectPath; + } + + /** + * Set project path + * + * @param path + * the path + */ + public void setProjectPath(String path) { + currentProjectPath = path; + } + +}