Simulator.java

/*
 * Class:        Simulator
 * Description:  Represents the executive of a discrete-event simulator
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author
 * @since
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package umontreal.ssj.simevents;
 
import umontreal.ssj.simevents.eventlist.EventList;
import umontreal.ssj.simevents.eventlist.SplayTree;

public class Simulator {
 
   protected double currentTime = 0.0;
   // The current simulation time (clock).
 
   protected EventList eventList;
   // The list of future events.
   // Can be changed by the method \texttt{init}.
 
   protected boolean stopped = true;
   // Becomes true when the simulation has ended
   // (stopped has been called or the event list is empty).
 
   protected boolean simulating = false;
 
   protected ContinuousState continuousState = null;

   public static Simulator defaultSimulator = null;

   public Simulator() {
      eventList = new SplayTree();
   }

   public Simulator(EventList eventList) {
      if (eventList == null)
         throw new NullPointerException();
      this.eventList = eventList;
   }

   public double time() {
      return currentTime;
   }

   public void init() {
      // This has to be done another way in order to separate events and processes.
//      SimProcess.killAll();
      currentTime = 0.0;
      eventList.clear();
      stopped = false;
      simulating = false;
   }

   public void init(EventList evlist) {
      if (evlist == null)
         throw new NullPointerException();
      eventList = evlist;
      init(); // will clear the events in evlist
   }

   public EventList getEventList() {
      return eventList;
   }

   public boolean isSimulating() {
      return simulating;
   }

   public boolean isStopped() {
      return stopped;
   }

   protected Event removeFirstEvent() {
      if (stopped)
         return null;
      Event ev = eventList.removeFirst();
      if (ev == null)
         return null;
      currentTime = ev.eventTime;
      ev.eventTime = -10.0;
      return ev;
   }

   public void start() {
      if (eventList.isEmpty())
         throw new IllegalStateException("start() called with an empty event list");
      stopped = false;
      simulating = true;
      Event ev;
      try {
         while ((ev = removeFirstEvent()) != null && !stopped) {
            // while (!stopped && (ev = eventList.removeFirst()) != null) {
            // currentTime = ev.eventTime;
            // ev.eventTime = -10.0;
            ev.actions();
            // if ev is a thread object associated to a process,
            // the control will be transfered to this thread and the
            // executive will be passivated in the actions() method.
         }
      } finally {
         stopped = true;
         simulating = false;
      }
   }

   public void stop() {
      stopped = true;
   }

   public ContinuousState continuousState() {
      if (continuousState == null)
         continuousState = new ContinuousState(this);
      return continuousState;
   }


   public static Simulator getDefaultSimulator() {
      if (defaultSimulator == null)
         defaultSimulator = new Simulator();
      return defaultSimulator;
   }
 
}