tracesrv/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/TraceCompilerEngine.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tracesrv/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/TraceCompilerEngine.java Fri Oct 08 14:56:39 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<TraceCompilerEngineBase> engines = new ArrayList<TraceCompilerEngineBase>();
+
+ /**
+ * 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;
+ }
+
+}