Event.java

/*
 * Class:        Event
 * Description:  provides event scheduling tools
 * 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;

public abstract class Event implements Comparable<Event> {
 
   protected Simulator sim;
   // simulator linked with the current event
 
   protected double priority;
   // priority of the event. Priority is a second parameter (after eventTime)
   // used to class events for their running order, in the EventList.
 
   protected double eventTime;
   // Planned time of occurence of this event. Negative if not planned.
   // Is protected because it is used (changed) in Process.
 
   // Replace that with instanceof simProcess to completely detach processes.
   // protected boolean isProcess = false;
   // Will be true for objects of the subclass Process of the class Event.
   // (i.e., true if this event is a process.)
 
   private int myra = 0;
   // A new event must always occur after those with same time and
   // same priority in the Event list. myra is used for that in
   // SplayTree.java.
 
   // For internal use
   public final int getRa() {
      return myra;
   }
 
   public final void setRa(int r) {
      myra = r;
   }

    * @param delay simulation time that must pass before the event happens
    */
   public Event() {
      this(Simulator.getDefaultSimulator());
   }

    * @param sim Instance of class Simulator associated with the new Event
    */
   public Event(Simulator sim) {
      if (sim == null)
         throw new NullPointerException();
      eventTime = -10.0;
      priority = 1.0;
      this.sim = sim;
   }

    * @param delay simulation time that must pass before the event happens
    */
   public void schedule(double delay) {
      if (delay < 0.0)
         throw new IllegalArgumentException("Cannot schedule in the past.");
      if (eventTime > -1.0)
         throw new IllegalStateException("Event already scheduled");
      eventTime = sim.time() + delay;
      sim.eventList.add(this);
   }

    * at the current time (as the next event).
    */
   public void scheduleNext() {
      if (eventTime > -1.0)
         throw new IllegalStateException("Event already scheduled");
      eventTime = sim.time();
      priority = 0.0;
      sim.eventList.addFirst(this);
   }

    * @param other event before which this event will be scheduled
    */
   public void scheduleBefore(Event other) {
      if (eventTime > -1.0)
         throw new IllegalStateException("Event already scheduled");
      eventTime = other.eventTime;
      priority = other.priority;
      sim.eventList.addBefore(this, other);
   }

    * @param other event after which this event will be scheduled
    */
   public void scheduleAfter(Event other) {
      if (eventTime > -1.0)
         throw new IllegalStateException("Event already scheduled");
      eventTime = other.eventTime;
      priority = other.priority;
      sim.eventList.addAfter(this, other);
   }

    * @param delay simulation time units that must elapse before the event happens
    */
   public void reschedule(double delay) {
      if (delay < 0.0)
         throw new IllegalArgumentException("Cannot schedule in the past.");
      if (eventTime < -1.0)
         throw new IllegalStateException("Event not scheduled");
      sim.getEventList().remove(this);
      eventTime = sim.time() + delay;
      sim.getEventList().add(this);
   }

    * @return `true` if the event could be cancelled
    */
   public boolean cancel() {
      boolean removed = false;
      if (eventTime >= sim.time())
         removed = sim.getEventList().remove(this);
      eventTime = -10.0;
      return removed;
   }

    * @return `true` if an event of this class was found and cancelled
    */
   public final boolean cancel(String type) {
      Event ev = sim.getEventList().getFirstOfClass(type);
      return ev.cancel();
   }

    * @return the simulator linked to the event
    */
   public final Simulator simulator() {
      return sim;
   }

    * @param sim the Simulator
    */
   public final void setSimulator(Simulator sim) {
      if (sim == null)
         throw new NullPointerException();
      if (eventTime > -1.0)
         throw new UnsupportedOperationException("Unable to set Simulator, current Event already scheduled");
      this.sim = sim;
   }

    * @return the time of occurence of the event
    */
   public final double time() {
      return eventTime;
   }

    * @param time new time of occurence for the event
    */
   public final void setTime(double time) {
      if (eventTime > -1.0)
         throw new UnsupportedOperationException("Unable to set time, current Event already scheduled");
      eventTime = time;
   }

    * @return the priority of the event
    */
   public final double priority() {
      return priority;
   }

    * @param priority new priority for the event
    */
   public final void setPriority(double priority) {
      if (eventTime > -1.0)
         throw new UnsupportedOperationException("Unable to set priority, current Event already scheduled");
      this.priority = priority;
   }

    * equal, or larger priority than event `e`.
    */
   public int compareTo(Event e) {
      if (eventTime < e.time())
         return -1;
      if (eventTime > e.time())
         return 1;
      // Si le moment de declenchement des "Event" est identique, on
      // examine leurs priorites.
      if (priority < e.priority())
         return -1;
      if (priority > e.priority())
         return 1;
      return 0;
   }

   public abstract void actions();
 
}