Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## uchicago.src.sim.engine
Class ScheduleBase

    java.lang.Object
      uchicago.src.sim.engine.BasicAction
          uchicago.src.sim.engine.ScheduleBase

All Implemented Interfaces:
  TickCounter

Direct Known Subclasses:
  Schedule, SubSchedule

    public abstract class ScheduleBase

extends BasicAction
implements TickCounter

Abstract base class for Schedule and SubSchedule. Provides methods to schedule BasicActions for execution.

Version:
  $Revision: 1.26 $ $Date: 2005/07/15 18:19:20 $
Author:
  Nick Collier (Modified by Michael J. North)
See Also:
  `BasicAction`, `ActionGroup`, `Schedule`

Nested Class Summary
`static class` | `ScheduleBase.Order`

Field Summary
`protected ActionQueue` | `actionQueue`
`static ScheduleBase.Order` | `CONCURRENT` An action marked as CONCURRENT will occur at some point during a tick.
`protected ScheduleGroup` | `groupToExecute`
`protected long` | `indexCount`
`static ScheduleBase.Order` | `LAST` An action marked as LAST will occur at the end of a tick, after those marked CONCURRENT or RANDOM.
`protected ScheduleGroup` | `lastGroup`
`protected ActionQueue` | `lastQueue`
`protected boolean` | `preExecuted`
`protected RandomScheduleGroup` | `randGroup`
`static ScheduleBase.Order` | `RANDOM` RANDOM is just a more explanatory synonym for CONCURRENT.
`protected double` | `repeatInterval`
`protected double` | `ticks`
`protected ScheduleGroup` | `topGroup`

Fields inherited from class uchicago.src.sim.engine.BasicAction
`INTERVAL_UPDATER, ONE_TIME_UPDATER, updater`

Constructor Summary
`ScheduleBase()` Constructs a schedule that with a default execution interval of 1.
`ScheduleBase(double executionInterval)` Constructs a schedule that executes at the specified interval.

Method Summary
`double` | `getCurrentTime()` Gets the current clock tick.
`double` | `getCurrentTimeDouble()` Deprecated.
`void` | `preExecute()`
`BasicAction` | `removeAction(BasicAction action)` Removes the specified action from this Schedule.
`void` | `removeActionAt(double at, BasicAction action)` Removes the specified action from this Schedule at the specified tick.
`BasicAction` | `scheduleActionAt(double at, BasicAction action)` Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order.
`BasicAction` | `scheduleActionAt(double at, BasicAction action, double duration)` Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order.
`BasicAction` | `scheduleActionAt(double at, BasicAction action, ScheduleBase.Order order)` Schedules the specified BasicAction to occur at the specified clock tick in the specified order.
`protected BasicAction` | `scheduleActionAt(double at, BasicAction action, ScheduleBase.Order order, double duration)` Schedules the specified BasicAction to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`protected BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`protected BasicAction` | `scheduleActionAt(double at, java.util.List list, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAt(double at, java.lang.Object o, java.lang.String methodName)` Schedules the execution of the specified method on the specified object to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.lang.Object o, java.lang.String methodName, double duration)` Schedules the execution of the specified method on the specified object to occur at the specified clock tick.
`BasicAction` | `scheduleActionAt(double at, java.lang.Object o, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order.
`protected BasicAction` | `scheduleActionAt(double at, java.lang.Object o, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAtInterval(double interval, BasicAction action)` Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks).
`BasicAction` | `scheduleActionAtInterval(double interval, BasicAction action, double duration)` Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks).
`BasicAction` | `scheduleActionAtInterval(double interval, BasicAction action, ScheduleBase.Order order)` Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order.
`protected BasicAction` | `scheduleActionAtInterval(double interval, BasicAction action, ScheduleBase.Order order, double duration)` Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order.
`BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order.
`protected BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order.
`BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`protected BasicAction` | `scheduleActionAtInterval(double interval, java.util.List list, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtInterval(double interval, java.lang.Object o, java.lang.String methodName)` Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks).
`BasicAction` | `scheduleActionAtInterval(double interval, java.lang.Object o, java.lang.String methodName, double duration)` Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks).
`BasicAction` | `scheduleActionAtInterval(double interval, java.lang.Object o, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order.
`protected BasicAction` | `scheduleActionAtInterval(double interval, java.lang.Object o, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order.
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks).
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks).
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order.
`protected BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order.
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`protected BasicAction` | `scheduleActionAtIntervalRnd(double interval, java.util.List list, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified interval.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.Class superClass, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick.
`BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.String methodName, ScheduleBase.Order order)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`protected BasicAction` | `scheduleActionAtRnd(double at, java.util.List list, java.lang.String methodName, ScheduleBase.Order order, double duration)` Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order.
`BasicAction` | `scheduleActionBeginning(double beginning, BasicAction action)` Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, BasicAction action, double duration)` Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.util.List list, java.lang.Class superClass, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.util.List list, java.lang.Class superClass, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.lang.Object o, java.lang.String methodName)` Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter.
`BasicAction` | `scheduleActionBeginning(double beginning, java.lang.Object o, java.lang.String methodName, double duration)` Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter.
`BasicAction` | `scheduleActionBeginningRnd(double beginning, java.util.List list, java.lang.Class superClass, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginningRnd(double beginning, java.util.List list, java.lang.Class superClass, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginningRnd(double beginning, java.util.List list, java.lang.String methodName)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.
`BasicAction` | `scheduleActionBeginningRnd(double beginning, java.util.List list, java.lang.String methodName, double duration)` Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter.

Methods inherited from class uchicago.src.sim.engine.BasicAction
`addToGroup, execute, getIntervalTime, getName, getNextTime, reSchedule, setIntervalTime, setName, setNextTime`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### LAST

    public static final ScheduleBase.Order LAST

  An action marked as LAST will occur at the end of a tick, after those marked CONCURRENT or RANDOM.

### CONCURRENT

    public static final ScheduleBase.Order CONCURRENT

  An action marked as CONCURRENT will occur at some point during a tick. This does not necessarily mean that it will happen simultaneously to other actions.

### RANDOM

    public static final ScheduleBase.Order RANDOM

  RANDOM is just a more explanatory synonym for CONCURRENT. This just points out that the action will be executed in a random order along with the other RANDOM/CONCURRENT actions at some tick.

### repeatInterval

    protected double repeatInterval

### ticks

    protected volatile double ticks

### actionQueue

    protected ActionQueue actionQueue

### lastQueue

    protected ActionQueue lastQueue

### topGroup

    protected ScheduleGroup topGroup

### randGroup

    protected RandomScheduleGroup randGroup

### lastGroup

    protected ScheduleGroup lastGroup

### groupToExecute

    protected ScheduleGroup groupToExecute

### preExecuted

    protected boolean preExecuted

### indexCount

    protected long indexCount

Constructor Detail

### ScheduleBase

    public ScheduleBase()

  Constructs a schedule that with a default execution interval of 1.

  See Also:
    `Schedule(double)`

### ScheduleBase

    public ScheduleBase(double executionInterval)

  Constructs a schedule that executes at the specified interval. (i.e a schedule with an interval of 2 executes all its BasicActions every other clock tick. The master Schedule built in a model and used to execute all the actions in the simulation will typicaly have an interval of 1.

  Parameters:
    `executionInterval` - the execution interval.

Method Detail

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        BasicAction action)

  Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. The BasicAction executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `action` - the action to execute.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        BasicAction action,
                                        ScheduleBase.Order order)

  Schedules the specified BasicAction to occur at the specified clock tick in the specified order. Order refers to the order of this action with respect to other actions executing at the same tick. The BasicAction executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `action` - the action to execute.
    `order` - the mode of the action - Schedule.LAST or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    protected BasicAction scheduleActionAt(double at,
                                           BasicAction action,
                                           ScheduleBase.Order order,
                                           double duration)

  Schedules the specified BasicAction to occur at the specified clock tick in the specified order. Order refers to the order of this action with respect to other actions executing at the same tick. The BasicAction executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `action` - the action to execute.
    `order` - the mode of the action - Schedule.LAST or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        BasicAction action,
                                        double duration)

  Schedules the specified BasicAction to occur at the specified clock tick in RANDOM order. The BasicAction executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `action` - the action to execute.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                BasicAction action)

  Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks).

  Parameters:
    `interval` - the interval at which to execute
    `action` - the BasicAction to execute
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                BasicAction action,
                                                double duration)

  Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks).

  Parameters:
    `interval` - the interval at which to execute
    `action` - the BasicAction to execute
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                BasicAction action,
                                                ScheduleBase.Order order)

  Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. Order is relative to other actions scheduled for this tick.

  Parameters:
    `interval` - the interval at which to execute
    `action` - the BasicAction to execute
    `order` - the order to execute this action relative to others scheduled for this tick. order is one of Schedule.LAST, or Schedule.RANDOM
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAtInterval

    protected BasicAction scheduleActionAtInterval(double interval,
                                                   BasicAction action,
                                                   ScheduleBase.Order order,
                                                   double duration)

  Schedule the specified BasicAction to execute at the specified interval, (e.g. every 3 clock ticks) in the specified order. Order is relative to other actions scheduled for this tick.

  Parameters:
    `interval` - the interval at which to execute
    `action` - the BasicAction to execute
    `order` - the order to execute this action relative to others scheduled for this tick. order is one of Schedule.LAST, or Schedule.RANDOM
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               BasicAction action)

  Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter.

  Parameters:
    `beginning` - the clock tick to begin executing
    `action` - the BasicAction to execute
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               BasicAction action,
                                               double duration)

  Schedules the specified BasicAction to execute starting at the specified clock tick and every tick thereafter.

  Parameters:
    `beginning` - the clock tick to begin executing
    `action` - the BasicAction to execute
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.lang.Object o,
                                        java.lang.String methodName)

  Schedules the execution of the specified method on the specified object to occur at the specified clock tick. This executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call on the object.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.lang.Object o,
                                        java.lang.String methodName,
                                        double duration)

  Schedules the execution of the specified method on the specified object to occur at the specified clock tick. This executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call on the object.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.lang.Object o,
                                        java.lang.String methodName,
                                        ScheduleBase.Order order)

  Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call on the object.
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAt

    protected BasicAction scheduleActionAt(double at,
                                           java.lang.Object o,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order,
                                           double duration)

  Schedules the execution of the specified method on the specified object to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once.

  Parameters:
    `at` - the clock tick to execute the action.
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call on the object.
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.lang.Object o,
                                                java.lang.String methodName)

  Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks).

  Parameters:
    `interval` - the interval at which to execute
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.lang.Object o,
                                                java.lang.String methodName,
                                                ScheduleBase.Order order)

  Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  Parameters:
    `interval` - the interval at which to execute
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.lang.Object o,
                                                java.lang.String methodName,
                                                double duration)

  Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks).

  Parameters:
    `interval` - the interval at which to execute
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    protected BasicAction scheduleActionAtInterval(double interval,
                                                   java.lang.Object o,
                                                   java.lang.String methodName,
                                                   ScheduleBase.Order order,
                                                   double duration)

  Schedules the execution of the specified method on the specified object at the specified interval, (e.g. every 3 clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  Parameters:
    `interval` - the interval at which to execute
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.lang.Object o,
                                               java.lang.String methodName)

  Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter.

  Parameters:
    `beginning` - the clock tick to begin executing
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.lang.Object o,
                                               java.lang.String methodName,
                                               double duration)

  Schedules the execution of the specified method on the specified object to start at the specified clock tick and continue every tick thereafter.

  Parameters:
    `beginning` - the clock tick to begin executing
    `o` - the object on which the method will be called
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once. Assumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.String methodName,
                                        double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once. Assumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once. Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
  Returns:
    the scheduled BasicAction
  See Also:
    `SimUtilities`

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.String methodName,
                                           double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once. Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the scheduled BasicAction
  See Also:
    `SimUtilities`

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.String methodName,
                                        ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  This action executes only once, and ssumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAt

    protected BasicAction scheduleActionAt(double at,
                                           java.util.List list,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order,
                                           double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  This action executes only once, and ssumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  This action executes only once, and ssumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtRnd

    protected BasicAction scheduleActionAtRnd(double at,
                                              java.util.List list,
                                              java.lang.String methodName,
                                              ScheduleBase.Order order,
                                              double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  This action executes only once, and ssumes all objects in the list are of the same class.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.util.List list,
                                                java.lang.String methodName,
                                                ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    protected BasicAction scheduleActionAtInterval(double interval,
                                                   java.util.List list,
                                                   java.lang.String methodName,
                                                   ScheduleBase.Order order,
                                                   double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions.

  Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.String methodName,
                                                   ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtIntervalRnd

    protected BasicAction scheduleActionAtIntervalRnd(double interval,
                                                      java.util.List list,
                                                      java.lang.String methodName,
                                                      ScheduleBase.Order order,
                                                      double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.util.List list,
                                                java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks). Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.util.List list,
                                                java.lang.String methodName,
                                                double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks). Assumes all objects in the list are of the same class.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks). Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.String methodName,
                                                   double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval. (e.g. every three clock ticks). Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `interval` - the interval at which to execute the method
    `list` - the list containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.util.List list,
                                               java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. Assumes all objects in the list are of the same class.

  Parameters:
    `beginning` - the clock tick at which to begin execution
    `list` - the List containing the objects on which the method will be called.
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.util.List list,
                                               java.lang.String methodName,
                                               double duration)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. Assumes all objects in the list are of the same class.

  Parameters:
    `beginning` - the clock tick at which to begin execution
    `list` - the List containing the objects on which the method will be called.
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionBeginningRnd

    public BasicAction scheduleActionBeginningRnd(double beginning,
                                                  java.util.List list,
                                                  java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `beginning` - the clock tick at which to begin execution
    `list` - the List containing the objects on which the method will be called.
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionBeginningRnd

    public BasicAction scheduleActionBeginningRnd(double beginning,
                                                  java.util.List list,
                                                  java.lang.String methodName,
                                                  double duration)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. Assumes all objects in the list are of the same class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  Parameters:
    `beginning` - the clock tick at which to begin execution
    `list` - the List containing the objects on which the method will be called.
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.Class superClass,
                                        java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once, and assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.Class superClass,
                                        java.lang.String methodName,
                                        double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once, and assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.Class superClass,
                                           java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once, and assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled. Note this may not be the action that is passed in.
  See Also:
    `SimUtilities`

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.Class superClass,
                                           java.lang.String methodName,
                                           double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick. This executes only once, and assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAt

    public BasicAction scheduleActionAt(double at,
                                        java.util.List list,
                                        java.lang.Class superClass,
                                        java.lang.String methodName,
                                        ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once, and assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAt

    protected BasicAction scheduleActionAt(double at,
                                           java.util.List list,
                                           java.lang.Class superClass,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order,
                                           double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once, and assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.Class superClass,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once, and assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtRnd

    public BasicAction scheduleActionAtRnd(double at,
                                           java.util.List list,
                                           java.lang.Class superClass,
                                           java.lang.String methodName,
                                           ScheduleBase.Order order,
                                           double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified clock tick in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This executes only once, and assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `at` - the clock tick to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.Class superClass,
                                                   java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks). This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.Class superClass,
                                                   java.lang.String methodName,
                                                   double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks). This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtInterval

    public BasicAction scheduleActionAtInterval(double interval,
                                                java.util.List list,
                                                java.lang.Class superClass,
                                                java.lang.String methodName,
                                                ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtInterval

    protected BasicAction scheduleActionAtInterval(double interval,
                                                   java.util.List list,
                                                   java.lang.Class superClass,
                                                   java.lang.String methodName,
                                                   ScheduleBase.Order order,
                                                   double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionAtIntervalRnd

    public BasicAction scheduleActionAtIntervalRnd(double interval,
                                                   java.util.List list,
                                                   java.lang.Class superClass,
                                                   java.lang.String methodName,
                                                   ScheduleBase.Order order)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionAtIntervalRnd

    protected BasicAction scheduleActionAtIntervalRnd(double interval,
                                                      java.util.List list,
                                                      java.lang.Class superClass,
                                                      java.lang.String methodName,
                                                      ScheduleBase.Order order,
                                                      double duration)

  Schedules the execution of the specified method on every object in the specified List to occur at the specified interval (e.g. every three clock ticks) in the specified order. Order is relative to the other actions scheduled for this tick where actions schedule for Schedule.LAST will execute after all non-LAST actions. This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `interval` - the tick interval at which to execute the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `order` - the order to execute this action relative to others in this tick. order is one of Schedule.LAST, or Schedule.RANDOM.
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.util.List list,
                                               java.lang.Class superClass,
                                               java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. This assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `beginning` - the tick at which to start the repeated execution of the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionBeginning

    public BasicAction scheduleActionBeginning(double beginning,
                                               java.util.List list,
                                               java.lang.Class superClass,
                                               java.lang.String methodName,
                                               double duration)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. This assumes all objects in the list are of the specified class.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `beginning` - the tick at which to start the repeated execution of the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
    `duration` - the length of the action.
  Returns:
    the actual BasicAction that was scheduled.

### scheduleActionBeginningRnd

    public BasicAction scheduleActionBeginningRnd(double beginning,
                                                  java.util.List list,
                                                  java.lang.Class superClass,
                                                  java.lang.String methodName)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `beginning` - the tick at which to start the repeated execution of the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### scheduleActionBeginningRnd

    public BasicAction scheduleActionBeginningRnd(double beginning,
                                                  java.util.List list,
                                                  java.lang.Class superClass,
                                                  java.lang.String methodName,
                                                  double duration)

  Schedules the execution of the specified method on every object in the specified List to occur beginning at the specified clock tick and every tick thereafter. This assumes all objects in the list are of the specified class. The list will be randomized with SimUtilites.shuffle before the the method is called on the objects.

  The intention here is that type of the objects in the list may different, but that they all share a common super-class or interface. The specified method must be a method of this super-class or interface.

  Parameters:
    `beginning` - the tick at which to start the repeated execution of the action
    `list` - the List containing the objects on which the method will be called
    `superClass` - the common super-class or interface
    `methodName` - the name of the method to call
  Returns:
    the actual BasicAction that was scheduled.
  See Also:
    `SimUtilities`

### getCurrentTime

    public double getCurrentTime()

  Gets the current clock tick.

  Specified by:
    `getCurrentTime` in interface `TickCounter`
  Returns:
    the current clock tick

### getCurrentTimeDouble

    public double getCurrentTimeDouble()

  Deprecated.

  Gets the current clock tick as a double precision number while maintaining compatibility with previous RePast releases.

  Returns:
    the current clock tick
  See Also:
    `getCurrentTime()`

### preExecute

    public void preExecute()

### removeAction

    public BasicAction removeAction(BasicAction action)

  Removes the specified action from this Schedule. Note that this is not recursive and will only a remove an action explicity added to this Schedule. It will not remove any actions contained by child containers of this Schedule.

  Parameters:
    `action` - the action to remove
  Returns:
    null if the specified BasicAction is not found in this Schedule or the BasicAction itself.

### removeActionAt

    public void removeActionAt(double at,
                               BasicAction action)

  Removes the specified action from this Schedule at the specified tick. The actual call to remove the action is made as part of the Schedule.LAST. Consequently, if the action is scheduled with Schedule.RANDOM order (the default order for scheduling actions), the action will execute during the specified tick and then be removed.

  Parameters:
    `at` - the tick at which to remove the action
    `action` - the action to remove

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD