core/org.eclipse.stem.jobs/src/org/eclipse/stem/jobs/simulation/SimulationManager.java

// SimulationManager.java
package org.eclipse.stem.jobs.simulation;

/*******************************************************************************
 * Copyright (c) 2006, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.eclipse.stem.core.Utility;
import org.eclipse.stem.core.common.DublinCore;
import org.eclipse.stem.core.graph.Graph;
import org.eclipse.stem.core.graph.GraphFactory;
import org.eclipse.stem.core.graph.GraphPartitioner;
import org.eclipse.stem.core.scenario.Scenario;
import org.eclipse.stem.core.scenario.ScenarioInitializationException;
import org.eclipse.stem.core.scenario.ScenarioPackage;
import org.eclipse.stem.jobs.Activator;
import org.eclipse.stem.jobs.DisplaySafeExecutor;
import org.eclipse.stem.jobs.execution.ExecutableManager;

/**
 * This class manages the life-cycle of active {@link Simulation}s. There is a
 * singleton instance of the manager that is referenced by other parts of the
 * system to manage {@link Simulation}. It creates {@link Simulation} instances
 * from {@link Scenario} instances and can obtain {@link Scenario} instances
 * from file URI's or from {@link IConfigurationElement}'s. It maintains a
 * collection of all of the active {@link Simulation}s in the system and
 * generates {@link SimulationEvent}'s whenever a {@link Simulation} is added to
 * that collection or removed.
 * <p>
 * The {@link SimulationManager} maintains a sequence number and assigns
 * successive values of that number to the {@link Simulation} instances it
 * creates.
 */
public class SimulationManager extends ExecutableManager implements
		ISimulationListener {

	/**
	 * Singleton instance of the manager
	 */
	private static volatile SimulationManager INSTANCE = null;

	/**
	 * This is the sequence number assigned to each successive
	 * {@link Simulation} instance the manager creates.
	 */
	private static int sequenceNumber = 0;

	/**
	 * The collection of {@link ISimulationManagerListener}'s waiting to be told
	 * about {@link SimulationManagerEvent}s
	 */
	private final List<ISimulationManagerListener> listeners = new CopyOnWriteArrayList<ISimulationManagerListener>();

	/**
	 * The collection of {@link ISimulationManagerListenerSync}'s waiting to be
	 * told about {@link SimulationManagerEvent}s
	 */
	private final List<ISimulationManagerListenerSync> listenersSync = new CopyOnWriteArrayList<ISimulationManagerListenerSync>();

	/**
	 * Constant empty array.
	 */
	public static final ISimulation[] NONE = new Simulation[] {};

	/**
	 * This is the collection of active {@link Simulation} jobs
	 */
	private List<ISimulation> activeSimulations = null;

	/**
	 * The graph partitioner used to divide up the graph amonge worker threads and nodes 
	 */
	
	private GraphPartitioner partitioner;
	
	/**
	 * Constructor
	 */
	private SimulationManager() {
		activeSimulations = new ArrayList<ISimulation>();

		Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(
				ScenarioPackage.eNAME, new XMIResourceFactoryImpl());
		
		// Override using setGraphPartitioner if needed
		partitioner = GraphFactory.eINSTANCE.createSimpleGraphPartitioner();
	} // SimulationManager

	/**
	 * @return the singleton instance of the model
	 */
	public static final SimulationManager getManager() {
		if (INSTANCE == null) {
			synchronized (SimulationManager.class) {
				if (INSTANCE == null) {
					INSTANCE = new SimulationManager();
				}
			}
		}
		return INSTANCE;
	} // getModel

	/**
	 * Return the next simulation sequence number and increment the value.
	 * 
	 * @return the next simulation sequence number
	 */
	synchronized private static final int getAndIncrementSimulationSequenceNumber() {
		return sequenceNumber++;
	} // getAndIncrementSimulationSequenceNumber

	/**
	 * This is used for testing purposes to reset the state of the model.
	 */
	public static final void resetSimulationManager() {
		INSTANCE = null;
		sequenceNumber = 0;
	} // resetSimulationManager

	/**
	 * @return the active {@link Simulation}s
	 */
	public final List<ISimulation> getActiveSimulations() {
		return activeSimulations;
	} // getActiveSimulations

	/**
	 * setGraphPartitioner
	 * 
	 * @param p The partitioner
	 */
	
	public void setGraphPartitioner(GraphPartitioner p) {
		this.partitioner = p;
	}
	
	/**
	 * getGraphPartitioner
	 * 
	 * @return The graph partitioner
	 */
	
	public GraphPartitioner getGraphPartitioner() {
		return this.partitioner;
	}
	
	/**
	 * Add a {@link Simulation} to the collection of active {@link Simulation}s.
	 * 
	 * @param simulation
	 *            the {@link ISimulation} to add
	 */
	private final void addActiveSimulation(final ISimulation simulation) {
		activeSimulations.add(simulation);
		simulation.addSimulationListener(this);
		fireSimulationManagerChanged(new ISimulation[] { simulation }, NONE);
	} // addActiveSimulation

	/**
	 * Remove an {@link ISimulation} from the collection of active
	 * {@link ISimulation}s.
	 * 
	 * @param simulation
	 *            the {@link ISimulation} to remove
	 */
	private final void removeActiveSimulation(final ISimulation simulation) {
		activeSimulations.remove(simulation);
		// We're no longer a listener
		simulation.removeSimulationListener(this);
		fireSimulationManagerChanged(NONE, new ISimulation[] { simulation });
	} // removeActiveSimulation

	/**
	 * Create a {@link ISimulation} that's ready to run.
	 * 
	 * @param configurationElement
	 *            a {@link IConfigurationElement} that specifies the details of
	 *            a serialized {@link Scenario} that is in a plug-in
	 * @param monitor
	 *            a progress monitor
	 * @return an {@link ISimulation} constructed from the
	 *         {@link IConfigurationElement}, or null if there was a problem.
	 * 
	 * @Deprecated
	 */
	public ISimulation createSimulation(
			final IConfigurationElement configurationElement,
			final IProgressMonitor monitor) {
		ISimulation retValue = null;

		final String scenarioURIString = configurationElement
				.getAttribute(DublinCore.IDENTIFIER);

		try {
			retValue = createSimulation(URI.createURI(scenarioURIString),
					monitor);
		} catch (final Exception e) {
			Activator
					.logError(
							MessageFormat
									.format(
											Messages
													.getString("SimMgr.Deserialization_Error"), scenarioURIString), e); //$NON-NLS-1$
			retValue = null;
		}
		return retValue;
	} // createSimulation

	/**
	 * Create an {@link ISimulation} that's ready to run.
	 * 
	 * @param scenarioURI
	 *            the URI of a serialized {@link Scenario}
	 * @param monitor
	 *            a progress monitor
	 * @return an {@link ISimulation} constructed from the URI, or
	 *         <code>null</code> if there was a problem.
	 *         
	 * @Deprecated
	 */
	public ISimulation createSimulation(final URI scenarioURI,
			final IProgressMonitor monitor) {
		ISimulation retValue = null;

			try {
				
					// Read scenario
				monitor.subTask("Reading Scenario from file");
				Scenario simulationScenario = (Scenario)Utility.getIdentifiable(scenarioURI);
				
				monitor.subTask("Creating Simulation from Scenario");
				retValue = createSimulation(simulationScenario, monitor);
			} catch (final Exception e) {
				Activator
						.logError(
								MessageFormat
										.format(
												Messages
														.getString("SimMgr.Deserialization_Error"), scenarioURI.toString()), e); //$NON-NLS-1$
			retValue = null;
		}
		return retValue;
	} // createSimulation

	/**
	 * Create a {@link ISimulation} from a {@link Scenario} instance.
	 * 
	 * @param scenario
	 *            the {@link Scenario} to simulate
	 * @param monitor 
	 * 			  Progress monitor
	 * @return a {@link ISimulation} that's ready to run.
	 */
	public ISimulation createSimulation(final Scenario scenario, final IProgressMonitor monitor) {
		ISimulation retValue = null;
		try {
			final Preferences preferences = 
				org.eclipse.stem.jobs.Activator.getDefault()
					.getPluginPreferences();
			//boolean useCache = preferences
			//		.getBoolean(PreferenceConstants.USE_SCENARIOS_CACHING_BOOLEAN);

			Scenario simulationScenario = null;
			
/*	SED Commented out 7/8/10, caching doesn't work		
     if (useCache) {
				if (SimulationCaching.INSTANCE.isScenarioInCache(scenario.getURI())) {
					simulationScenario = SimulationCaching.INSTANCE.getCachedScenario(scenario.getURI());
					boolean running = false;
					for(ISimulation sim : getActiveSimulations()) {
						if(sim.getScenario().equals(simulationScenario)) {
							// The scenario is already running. Copy the whole scenario before resetting
							Scenario newSimulation = null;
							newSimulation = (Scenario)EcoreUtil.copy(simulationScenario);
							if(simulationScenario.getModel() != null) newSimulation.setModel((Model)EcoreUtil.copy(simulationScenario.getModel()));
							if(simulationScenario.getSequencer() != null) newSimulation.setSequencer((Sequencer)EcoreUtil.copy(simulationScenario.getSequencer()));
							running = true;
							break;
						}
					}
					if(!running)simulationScenario.reset(); // safe since canonical graph is set 
				}
				else {
					// Read scenario
					// Add to cache
					SimulationCaching.INSTANCE.addScenarioToCache(scenario);
				}
				
			}
*/
			
			final Simulation simulation = new Simulation(scenario,
					getAndIncrementSimulationSequenceNumber(), partitioner);
			
			if(scenario.getCanonicalGraph() == null) 
				scenario.initialize(); // needed for preferences ...
			else scenario.reset();
	
			simulation.setPriority(Job.LONG);
			
			// MAD 20-June-2011
			// Simulation API has display-safe option.  Simulation Adapter 
			// removed
			retValue = simulation; //new SimulationAdapter(simulation);

			addActiveSimulation(retValue);
		} catch (final ScenarioInitializationException se) {
			// We could get an exception here if the Scenario doesn't have
			// a Sequencer or Model which would cause problems when trying to
			// initialize
			Simulation.handleException(se, true);
			retValue = null;
		}
		return retValue;
	} // createSimulation

	/**
	 * Create a {@link ISimulation} from a {@link IConfigurationElement} and
	 * then start it running.
	 * 
	 * @param configurationElement
	 *            a {@link IConfigurationElement} that specifies the details of
	 *            a serialized {@link Scenario} that is in a plug-in
	 * 
	 *@Deprecated
	 */
	public void createAndRunSimulation(
			final IConfigurationElement configurationElement) {
		new Job(Messages.getString("SimMgr.Start_Sim")) { //$NON-NLS-1$
			@Override
			protected IStatus run(final IProgressMonitor monitor) {
				monitor.beginTask(Messages.getString("SimMgr.CrtSim"),
						IProgressMonitor.UNKNOWN);
				try {
					final ISimulation simulation = createSimulation(
							configurationElement, monitor);
					monitor.subTask(Messages.getString("SimMgr.Run"));
					simulation.run();
				} // try
				catch (final NullPointerException e) {
					// The error was logged in createSimulation
					monitor.done();
				}
				monitor.done();
				return Status.OK_STATUS;
			} // run
		}.schedule();
	} // createAndRunSimulation

	/**
	 * Create a {@link ISimulation} from a {@link Scenario} instance and then
	 * start it running.
	 * 
	 * @param scenario
	 *            the {@link Scenario} to be simulated
	 */
	public void createAndRunSimulation(final Scenario scenario) {
		new Job(Messages.getString("SimMgr.Start_Sim")) {
			@Override
			protected IStatus run(final IProgressMonitor monitor) {
				try {
					final ISimulation simulation = createSimulation(scenario, monitor);
					monitor.subTask(Messages.getString("SimMgr.Run"));
					simulation.run();
				} catch (final Exception e) {
					// The error was logged in createSimulation
					monitor.done();
				} // catch Exception
				return Status.OK_STATUS;
			} // run
		}.schedule();
	} // createAndRunSimulation

	
	/**
	 * Create an {@link ISimulation} from a {@link IConfigurationElement} and
	 * then start it running.
	 * 
	 * @param configurationElement
	 *            an {@link IConfigurationElement} that specifies the details of
	 *            a serialized {@link Scenario} that is in a plug-in
	 * 
	 * @Deprecated
	 */
	public void createAndStepSimulation(
			final IConfigurationElement configurationElement) {
		new Job(Messages.getString("SimMgr.Start_Sim")) { //$NON-NLS-1$
			@Override
			protected IStatus run(final IProgressMonitor monitor) {
				try {
					final ISimulation simulation = createSimulation(
							configurationElement, monitor);
					monitor.subTask(Messages.getString("SimMgr.Run"));
					simulation.step();
				} // try
				catch (final NullPointerException e) {
					// The error was logged in createSimulation
					monitor.done();
				}
				return Status.OK_STATUS;
			} // run
		}.schedule();
	} // createAndStepSimulation
	
	/**
	 * Create an {@link ISimulation} from a {@link Scenario} instance and then
	 * start it running.
	 * 
	 * @param scenario
	 *            the {@link Scenario} to be simulated
	 */
	public void createAndStepSimulation(final Scenario scenario) {
		new Job(Messages.getString("SimMgr.Start_Sim")) { //$NON-NLS-1$
			@Override
			protected IStatus run(final IProgressMonitor monitor) {
				try {
					final ISimulation simulation = createSimulation(scenario, monitor);
					monitor.subTask(Messages.getString("SimMgr.Run"));
					simulation.step();
				} // try
				catch (final NullPointerException e) {
					// The error was logged in createSimulation
					monitor.done();
				}
				return Status.OK_STATUS;
			} // run
		}.schedule();
	} // createAndStepSimulation

	
	/**
	 * Given a {@link Graph} find the {@link ISimulation} that created it.
	 * 
	 * @param graph
	 *            an instance of a {@link Graph}
	 * @return the {@link ISimulation} instance that created the {@link Graph},
	 *         <code>null</code>, if no match could be found.
	 */
	public ISimulation mapGraphToSimulation(final Graph graph) {
		ISimulation retValue = null;
		for (final ISimulation simulation : activeSimulations) {
			final Graph simulationGraph = simulation.getScenario()
					.getCanonicalGraph();
			// Is this the one we're looking for?
			if (graph == simulationGraph) {
				// Yes
				retValue = simulation;
				break;
			} // if
		} // for each ISimulation
		return retValue;
	} // mapGraphToSimulation

	/**
	 * @param listener
	 *            a listener wanting to be told about changes to the manager.
	 */
	public void addSimulationManagerListener(
			final ISimulationManagerListener listener) {
		if (!listeners.contains(listener)) {
			listeners.add(listener);
		}
	} // addSimulationManagerListener

	/**
	 * @param listener
	 *            a listener wanting to be told about changes to the manager.
	 */
	public void addSimulationManagerListenerSync(
			final ISimulationManagerListenerSync listener) {
		if (!listenersSync.contains(listener)) {
			listenersSync.add(listener);
		}
	} // addSimulationManagerListenerSync

	/**
	 * @param listener
	 *            a listener wanting NOT to be told about changes to the
	 *            manager.
	 */
	public void removeListener(final ISimulationManagerListener listener) {
		listeners.remove(listener);
	} // removeListener

	/**
	 * @param listener
	 *            a listener NOT wanting to be told about changes to the
	 *            manager.
	 */
	public void removeListenerSync(final ISimulationManagerListenerSync listener) {
		listenersSync.remove(listener);
	} // removeListener

	/**
	 * Tell the listeners about the change.
	 * 
	 * @param simulationsAdded
	 *            the {@link ISimulation}s added
	 * @param simulationsRemoved
	 *            the {@link ISimulation}s removed
	 */
	private void fireSimulationManagerChanged(
			final ISimulation[] simulationsAdded,
			final ISimulation[] simulationsRemoved) {
		final SimulationManagerEvent event = new SimulationManagerEvent(this,
				simulationsAdded, simulationsRemoved);

		for (final ISimulationManagerListener listener : listeners) {
			
			DisplaySafeExecutor.executeAsync(new Runnable() {
				public void run() {
					listener.simulationsChanged(event);
				}
			});
			
			// MAD 3/22/2011 Removing to test out new "safe" execution handler
//			try {
//				Display.getDefault().asyncExec(new Runnable() {
//					public void run() {
//						listener.simulationsChanged(event);
//					}
//				});
//			} catch (final Error ncdfe) {
//				// If we get this exception, it is because we're not running in
//				// eclipse. Just fire the event.
//				listener.simulationsChanged(event);
//			} // catch
		} // for

		for (final ISimulationManagerListenerSync listener : listenersSync) {
			DisplaySafeExecutor.executeSync(new Runnable() {
				public void run() {
					listener.simulationsChangedSync(event);
				}
			});

			// MAD 3/22/2011 Removing to test out new "safe" execution handler
//			try {
//				Display.getDefault().syncExec(new Runnable() {
//					public void run() {
//						listener.simulationsChangedSync(event);
//					}
//				});
//			} catch (final Error ncdfe) {
//				// If we get this exception, it is because we're not running in
//				// eclipse. Just fire the event.
//				listener.simulationsChangedSync(event);
//			} // catch
		} // for
	} // fireSimulationManagerChanged

	/**
	 * This is where the manager hears about changes in the {@link ISimulation}s
	 * it is managing. It is really only interested in those that "stop" so it
	 * can remove them from its collection of active {@link ISimulation}s.
	 * 
	 * @see org.eclipse.stem.jobs.simulation.ISimulationListener#simulationChanged(org.eclipse.stem.jobs.simulation.SimulationEvent)
	 */
	public void simulationChanged(final SimulationEvent event) {
		// Has a simulation stopped?
		if (event.getSimulationState().equals(SimulationState.STOPPED)) {
			// Yes
//			if (event.getSimulation() instanceof SimulationAdapter) {
//				SimulationAdapter stoppedSimulationAdapter = (SimulationAdapter)event.getSimulation();
//				Simulation stoppedSimulation = (Simulation)stoppedSimulationAdapter.getSimulation();
//				Activator.getDefault().getPluginPreferences().removePropertyChangeListener(stoppedSimulation);
//			}
			removeActiveSimulation(event.getSimulation());
		}
	} // simulationChanged

	
//	MAD 20-June-2011
//  New API added to enable "display safe" simulations by default without the need for
//	the simulation adapter.  Thus removing the simulation adapter.
	
//	/**
//	 * This class adapts a {@link Simulation} instance that runs as an
//	 * asynchronous Eclipse {@link Job} to be an {@link ISimulation} instance.
//	 * The adapter manages thread safety issues so that the UI thread can access
//	 * the {@link ISimulation} instance directly.
//	 */
//	public static class SimulationAdapter implements ISimulation,
//			ISimulationListener, ISimulationListenerSync {
//
//		/**
//		 * The collection of {@link ISimulationListener}'s waiting to be told
//		 * about {@link SimulationEvent}s.
//		 */
//		private final List<ISimulationListener> listeners = new CopyOnWriteArrayList<ISimulationListener>();
//
//		/**
//		 * The collection of {@link ISimulationListenerSync}'s waiting to be
//		 * told about {@link SimulationEvent}s.
//		 */
//		private final List<ISimulationListenerSync> listenersSync = new CopyOnWriteArrayList<ISimulationListenerSync>();
//
//		/**
//		 * The {@link Simulation} instance to adapt. This will be an instance of
//		 * {@link Simulation} which is also an eclipse {@link Job} and runs
//		 * asynchronously from the UI thread of eclipse. This adapter registers
//		 * as a listener of adapted {@link Simulation} and safely passes
//		 * {@link SimulationEvent}'s on to listeners in the UI or other threads.
//		 */
//		private final ISimulation simulation;
//
//		/**
//		 * Constructor
//		 * 
//		 * @param simulation
//		 *            the {@link Simulation} to adapt
//		 */
//		protected SimulationAdapter(final ISimulation simulation) {
//			this.simulation = simulation;
//			simulation.addSimulationListener(this);
//			simulation.addSimulationListenerSync(this);
//		} // SimulationAdapter
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#getName()
//		 */
//		public String getName() {
//			return simulation.getName();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#getNameWithSequenceNumber()
//		 */
//		public String getNameWithSequenceNumber() {
//			return simulation.getNameWithSequenceNumber();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.execution.IExecutable#getCreationTime()
//		 */
//		public Date getCreationTime() {
//			return simulation.getCreationTime();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.execution.IExecutable#getUniqueIDString()
//		 */
//		public String getUniqueIDString() {
//			return simulation.getUniqueIDString();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#getScenario()
//		 */
//		public Scenario getScenario() {
//			return simulation.getScenario();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#getSimulationState()
//		 */
//		public SimulationState getSimulationState() {
//			return simulation.getSimulationState();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#getSequenceNumber()
//		 */
//		public int getSequenceNumber() {
//			return simulation.getSequenceNumber();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#setSequenceNumber(int)
//		 */
//		public void setSequenceNumber(final int sequenceNumber) {
//			simulation.setSequenceNumber(sequenceNumber);
//		} // setSequenceNumber
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#pause()
//		 */
//		public void pause() {
//			simulation.pause();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#reset()
//		 */
//		public void reset() {
//			simulation.reset();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#run()
//		 */
//		public void run() {
//			simulation.run();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#step()
//		 */
//		public void step() {
//			simulation.step();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#stop()
//		 */
//		public void stop() {
//			simulation.stop();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.execution.IExecutable#isRunning()
//		 */
//		public boolean isRunning() {
//			return simulation.isRunning();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.execution.IExecutable#isStoppable()
//		 */
//		public boolean isStoppable() {
//			return simulation.isStoppable();
//		}
//
//		/**
//		 * @throws InterruptedException
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#join()
//		 */
//		public void join() throws InterruptedException {
//			simulation.join();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#cancel()
//		 */
//		public boolean cancel() {
//			return simulation.cancel();
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#addSimulationListener(org.eclipse.stem.jobs.simulation.ISimulationListener)
//		 */
//		public void addSimulationListener(final ISimulationListener listener) {
//			if (!listeners.contains(listener)) {
//				listeners.add(listener);
//			}
//		} // addSimulationListener
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#removeSimulationListener(org.eclipse.stem.jobs.simulation.ISimulationListener)
//		 */
//		public void removeSimulationListener(final ISimulationListener listener) {
//			listeners.remove(listener);
//		} // removeSimulationListener
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#addSimulationListenerSync(org.eclipse.stem.jobs.simulation.ISimulationListenerSync)
//		 */
//		public void addSimulationListenerSync(
//				final ISimulationListenerSync listener) {
//			if (!listenersSync.contains(listener)) {
//				listenersSync.add(listener);
//			}
//		}
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulation#removeSimulationListenerSync(org.eclipse.stem.jobs.simulation.ISimulationListenerSync)
//		 */
//		public void removeSimulationListenerSync(
//				final ISimulationListenerSync listener) {
//			listenersSync.remove(listener);
//		}
//
//		/**
//		 * Tell the listeners about the change in the {@link Simulation}s state
//		 * 
//		 * @param simulationState
//		 *            the new state of the {@link Simulation}
//		 */
//		protected void fireSimulationChanged(
//				final SimulationEvent event) {
//			final SimulationEvent ev = new SimulationEvent(this,
//					event.getSimulationState(), event.getIterationProgress());
//			for (final ISimulationListener listener : listeners) {
//				DisplaySafeExecutor.executeAsync(new Runnable() {
//					public void run()
//					{
//						listener.simulationChanged(ev);
//					}
//				});
//
//			} // for
//		} // fireSimulationManagerChanged
//
//		/**
//		 * Tell the listeners about the change in the {@link Simulation}s state
//		 * 
//		 * @param simulationState
//		 *            the new state of the {@link Simulation}
//		 */
//		protected void fireSimulationChangedSync(
//				final SimulationEvent event) {
//			final SimulationEvent ev = new SimulationEvent(this,
//					event.getSimulationState(), event.getIterationProgress());
//			for (final ISimulationListenerSync listener : listenersSync) {
//				DisplaySafeExecutor.executeSync(new Runnable() {
//					public void run()
//					{
//						listener.simulationChangedSync(ev);
//					}
//				});
//			} // for
//		} // fireSimulationChangedSync
//
//		/**
//		 * @see java.lang.Object#toString()
//		 */
//		@Override
//		public String toString() {
//			return simulation.toString();
//		} // toString
//
//		/**
//		 * This is where the adapted {@link Simulation} tells us of its state
//		 * changes and we need to adapt them to the UI thread.
//		 * 
//		 * @see org.eclipse.stem.jobs.simulation.ISimulationListener#simulationChanged(org.eclipse.stem.jobs.simulation.SimulationEvent)
//		 */
//		public void simulationChanged(final SimulationEvent event) {
//			fireSimulationChanged(event);
//			
////			try {
////				if (!Display.getDefault().isDisposed()) {
////					// Yes
////					Display.getDefault().asyncExec(new Runnable() {
////						public void run() {
////							fireSimulationChanged(event);
////						}
////					});
////				} // if
////			} // try
////			catch (final NullPointerException e) {
////				// Nothing to do, shutting down...
////			} // catch NullPointerException
////			catch (final Error ncdfe) {
////				// If we get this exception, it is because we're not running in
////				// eclipse. Just fire the event.
////				fireSimulationChanged(event);
////			} // catch
//
//		} // simulationChanged
//
//		/**
//		 * @see org.eclipse.stem.jobs.simulation.ISimulationListenerSync#simulationChangedSync(org.eclipse.stem.jobs.simulation.SimulationEvent)
//		 */
//		public void simulationChangedSync(final SimulationEvent event) {
//			fireSimulationChangedSync(event);
//			
////			try {
////				if (!Display.getDefault().isDisposed()) {
////					// Yes
////					Display.getDefault().syncExec(new Runnable() {
////						public void run() {
////							fireSimulationChangedSync(event);
////						}
////					});
////				} // if
////			} // try
////			catch (final NullPointerException e) {
////				e.printStackTrace();
////			} // catch NullPointerException
////			catch (final Error ncdfe) {
////				// If we get this exception, it is because we're not running in
////				// eclipse. Just fire the event.
////				fireSimulationChangedSync(event);
////			} // catch
//		} // simulationChangedSync
//
//		/**
//		 * @return the simulation
//		 */
//		public ISimulation getSimulation() {
//			return simulation;
//		}
//
//		public void addSimulationListener(
//				ISimulationListener simulationListener, boolean headlessSafe) {
//			// TODO Auto-generated method stub
//			
//		}
//
//		public void addSimulationListenerSync(
//				ISimulationListenerSync simulationListener, boolean headlessSafe) {
//			// TODO Auto-generated method stub
//			
//		}
//
//	} // SimulationAdapter
} // SimulationManager