| // 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.util.EcoreUtil; |
| 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.core.sequencer.Sequencer; |
| 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); |
| } |
| |
| } |
| */ |
| Scenario copiedScenario = EcoreUtil.copy(scenario); |
| if(scenario.getModel() != null) { |
| copiedScenario.setModel(EcoreUtil.copy(scenario.getModel())); |
| } |
| if(scenario.getSequencer() != null) { |
| copiedScenario.setSequencer(EcoreUtil.copy(scenario.getSequencer())); |
| } |
| |
| |
| final Simulation simulation = new Simulation(copiedScenario, |
| getAndIncrementSimulationSequenceNumber(), partitioner); |
| |
| |
| |
| if(copiedScenario.getCanonicalGraph() == null) |
| copiedScenario.initialize(); // needed for preferences ... |
| else copiedScenario.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) { |
| e.printStackTrace(); |
| 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 |