KSLProcessBuilder

The entity associated with the process

The simulation time that the process first started (activated) after being created. If the process was never started, this returns Double.NaN

Causes the current process to block until all the specified processes completes. This function does not activate the specified processes. The specified processes must have been previously activated. If all specified processes have already completed, then no blocking occurs. In other words, the call immediately returns. If any of the specified processes have terminated, then an exception occurs.

Causes the current process to block until the specified process completes. This function does not activate the specified process. The specified process must have been previously activated. If the specified process has already completed, then no blocking occurs. In other words, the call immediately returns. If the specified process has terminated, then an exception occurs.

Causes the blockage to be cleared and any entities suspended because of the blockage to be resumed. The blockage can only be cleared by the entity that created it.

This suspending function combines requestConveyor(), rideConveyor(), and exit() into one suspending function.

This suspending function combines access(), ride(), and exit() into one suspending function.

Causes the process to delay (suspend execution) for the specified amount of time.

This suspending function causes the item associated with the allocated cells to exit the conveyor. If there is no item associated with the allocated cells, the cells are immediately released without a time delay. If there is an item occupying the associated cells there will be a delay while the item moves through the deallocated cells and then the cells are deallocated. After exiting the conveyor, the cell allocation is deallocated and cannot be used for further interaction with the conveyor.

Causes the process to hold indefinitely within the supplied queue. Some other process or event is responsible for removing the entities and causing them to proceed with their processes NOTE: The entity is not signaled to resume its process unless you signal it. The entity cannot remove itself. Some other construct must do the removal and resumption.

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted for the specified interrupt time. After the interruption time has elapsed, the process experiencing the original delay continues a delay for the specified post interruption delay time.

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted for the specified interrupt time. After the interruption time has elapsed, the process experiencing the original delay continues with the post interruption time being equal to the time remaining on the original delay at the time of the interruption

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted for the specified interrupt time. After the interruption time has elapsed, the process experiencing the original delay continues a delay using its original delay time. That is, it restarts its original delay.

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted while the interrupting process executes to completion. After the interruption process has completed, the process experiencing the original delay continues a delay for the specified post interruption delay time. Note that this functionality requires three processes 1) to have the interruptDelay() call, 2) the process being interrupted, and 3) the process that is used as the interruption.

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted while the interrupting process executes to completion. After the interruption process has completed, the process experiencing the original delay continues a delay for time remaining on its original delay. Note that this functionality requires three processes 1) to have the interruptDelay() call, 2) the process being interrupted, and 3) the process that is used as the interruption.

This method allows a process to interrupt another process while that process is experiencing a delay. If the supplied process is not currently experiencing the named delay, then nothing happens. That is, the interrupt is ignored and the method just returns at the current time without suspending. If the supplied process is experiencing the named delay, then its delay is interrupted while the interrupting process executes to completion. After the interruption process has completed, the process experiencing the original delay continues a delay for the full original delay time. Note that this functionality requires three processes 1) to have the interruptDelay() call, 2) the process being interrupted, and 3) the process that is used as the interruption.

Causes movement of the entity from the specified location to the specified location at the supplied velocity. If the entity is not currently at fromLoc then its current location is quietly set to fromLoc, without movement before the move commences. To move directly from the current location, use moveTo().

Causes movement of the movable resource from its current location to the specified location at the supplied velocity. The entity experiences the time needed for the movable resource to move to the specified location.

Causes movement of the spatial element from its current location to the specified location at the supplied velocity. The entity will experience the time needed to move the spatial element.

Causes movement of the entity from its current location to the specified location using the entity's default velocity.

Causes movement of the entity from its current location to the specified location at the supplied velocity.

Causes movement of the entity and the movable resource from the current location to the specified location at the supplied velocity. The entity and the movable resource must be at the same location to start the movement. If not specified, the default velocity of the spatial element is used for the movement.

Causes movement of the entity and the spatial element from the current location to the specified location at the supplied velocity. The entity and the spatial element must be at the same location to start the movement. If not specified, the default velocity of the spatial element is used for the movement.

Causes the entity's process to perform the activity. The activity (and its blockage) are started, the activity delay occurs, and then the activity is completed such that the blockage is cleared. Entities that are waiting on the activity to complete will be resumed.

Causes the entity's process to perform a movement from one location to another. The movement (and its blockage) are started, the movement is completed such that the blockage is cleared. Entities that are waiting on the movement to complete will be resumed.

Causes the entity's process to perform an activity involving the usage of a resource pool. The usage (and its blockage) are started, the resource is seized, activity delay occurs, the resource is released and then the activity is completed such that the blockage is cleared. Entities that are waiting on the usage to complete will be resumed.

Causes the entity's process to perform an activity involving the usage of a resource. The usage (and its blockage) are started, the resource is seized, activity delay occurs, the resource is released and then the activity is completed such that the blockage is cleared. Entities that are waiting on the usage to complete will be resumed.

Releases the allocation of the resource

Releases ANY(ALL) allocations related to the resource that are allocated to the entity currently executing this process

Releases the allocations associated with using a ResourcePool

Releases ALL the resources that the entity has currently allocated to it

This suspending function requests the number of cells indicated at the entry location of the conveyor. If the number of cells are not immediately available the process is suspended until the number of cells can be allocated (in full). The request for the cells will wait for the allocation in the queue associated with the start of the segment associated with the entry location of the conveyor. After this suspending function returns, the entity holds the cells in the returned cell allocation, but the entity is not on the conveyor. The entity can then decide to ride on the conveyor using the cell allocation or release the cell allocation by exiting the conveyor without riding. The behavior of the conveyor during access is governed by the type of conveyor. A blockage occurs at the entry point of the segment while the entity has the allocated cells and before exiting or riding.

Causes the suspension to be resumed at the current time (i.e. without any delay). Errors will result if the suspension is not associated with a suspending entity via the suspend(suspension: Suspension) function or if the suspension has already been resumed.

This suspending function causes the entity to be associated with an item that occupies the allocated cells on the conveyor. The item will move on the conveyor until it reaches the supplied destination. After this suspending function returns, the item associated with the entity will be occupying the cells it requires at the exit location of the segment associated with the destination. The item will remain on the conveyor until the entity indicates that the cells are to be released by using the exit function. The behavior of the conveyor during the ride and when the item reaches its destination is governed by the type of conveyor. A blockage occurs at the destination location of the segment while the entity occupies the final cells before exiting or riding again. If the destination implements the LocationIfc then the current location property of the entity will be updated to this value at the completion of the ride.

This suspending function causes the entity to be associated with an item that occupies the allocated cells on the conveyor. The item will move on the conveyor until it reaches the supplied destination. After this suspending function returns, the item associated with the entity will be occupying the cells it requires at the exit location of the segment associated with the destination. The item will remain on the conveyor until the entity indicates that the cells are to be released by using the exit function. The behavior of the conveyor during the ride and when the item reaches its destination is governed by the type of conveyor. A blockage occurs at the destination location of the segment while the entity occupies the final cells before exiting or riding again. If the destination implements the LocationIfc then the current location property of the entity will be updated to this value at the completion of the ride.

Requests a number of units of the indicated movable resource.

Requests a number of units of the indicated resource. The queue that will hold the entity is internal to the resource. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling seize.

Requests a number of units of the indicated resource.

Requests a number of units from the indicated pool of resources The queue that will hold the entity is internal to the resource pool. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling seize.

Requests a movable resource from the indicated pool of resources The queue that will hold the entity is internal to the movable resource pool. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling seize.

Requests a number of units from the indicated pool of resources

Requests a movable resource from the indicated pool of resources The queue that will hold the entity is supplied to the movable resource pool. The movable resources in the pool will select requests from the queue. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling seize.

Permits simpler calling syntax when using a blocking queue within a KSLProcess This method will block (suspend) if the blocking queue is full. That is, if the blocking queue has reached its capacity. When space for the item becomes available, then the item is placed within the blocking queue.

This method will block (suspend) if the blocking queue is full. That is, if the blocking queue has reached its capacity. When space for the item becomes available, then the item is placed within the blocking queue.

This method will block (suspend) if the blocking queue is full. That is, if the blocking queue has reached its capacity. When space for the item becomes available, then the item is placed within the blocking queue.

Causes the blockage to be active. The blockage can only be started by the entity that created it.

Suspends the execution of the process. Since the process cannot resume itself, the client must provide a mechanism that resumes the process. The most basic strategy would be to store a "globally" available reference to the entity that is suspending. The reference can then be used to resume the process via the entity's resumeProcess() function.

An abstraction that represents a general suspension point within a process. Suspensions are one-shot. That is, once resumed they cannot be used again unless passed through the suspend(suspension: Suspension) function for a KSLProcess.

Causes the entity to be place itself in the hold queue if the entity to sync with is not within the hold queue. If the entity to sync with is in the hold queue, then the active entity will cause the held entity to resume at the curren time. This function facilitates a common use case between entities to allow them to sync in time.

Causes the entity to transfer from its current conveyor to another. The entity will suspend while accessing the required cells at the next conveyor. Once the desired cells are obtained the entity will exit its current conveyor and be positioned to ride on the next conveyor. After executing this function, the entity will be blocking the entry cell of the next conveyor and must then execute a rideConveyor() function to move on the new conveyor. The transfer will include the time needed for the entity to move through the exit cells of the current conveyor, any waiting to access the next conveyor, and be positioned to ride on the next conveyor.

Causes the entity to transfer from one conveyor to another. The entity will suspend while accessing the required cells at the next conveyor. Once the desired cells are obtained the entity will exit its current conveyor and be positioned to ride on the next conveyor. After executing this function, the entity will be blocking the entry cell of the next conveyor and must then execute a rideConveyor() function to move on the new conveyor. The transfer will include the time needed for the entity to move through the exit cells of the current conveyor, any waiting to access the next conveyor, and be positioned to ride on the next conveyor.

Causes transport of the entity via the movable resource from the entity's current location to the specified location at the supplied velocities. The entity experiences the time for the movable resource to move to its current location. If not specified, the default velocity of the movable resource is used for the movement. If the home base option is specified, the entity does not experience the time for the movable resource to proceed to its home base after the entity releases the movable resource.

Causes transport of the entity via a movable resource within the fleet from the entity's current location to the specified location at the supplied velocities. If not specified, the default velocity of the movable resource is used for the movement.

Uses the resource with the amount of units for the delay and then releases it. Equivalent to: seize(), delay(), release() The queue that will hold the entity is internal to the resource pool. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling use.

Uses the resource with the amount of units for the delay and then releases it. Equivalent to: seize(), delay(), release() The queue that will hold the entity is internal to the resource. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling use.

Uses the resource with the amount of units for the delay and then releases it. Equivalent to: seize(), delay(), release(). The queue that will hold the entity is internal to the resource. If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling use.

Uses the resource with the amount of units for the delay and then releases it. Equivalent to: seize(), delay(), release()

Uses the resource with the amount of units for the delay and then releases it. Equivalent to: seize(), delay(), release(). If the queue is priority based (i.e. uses a ranked queue discipline) the user should set the entity's priority attribute for use in ranking the queue prior to the calling use.

The purpose of this suspending function is to allow a batching entity to wait for a batch to be formed. If a batch can be formed using the candidate entity, then the batch is formed and the function returns false. If the batch cannot be formed, the candidate entity waits in the batch queue and suspends. If the batch can be formed, the batch is attached to the batching entity using the supplied batch name. The batching entity will hold the batched entities in a list associated with the supplied batch name via a map. The entities entering the batch queue wait until the number of entities satisfying the supplied predicate is equal to the supplied batch size. The returned Boolean value associated with the function indicates if the entity is part of the batch and if so, it must exit from the process. The entity that caused the batch to form, will cause the function to return false, when it returns from its suspension. All entities that enter this suspending function will suspend. The resumption of the suspension is predicated on the formation of the batch.

Causes the current process to suspend (immediately) until the specified process has run to completion. This is like run blocking. It activates the specified process and then waits for it to complete before proceeding. Since the current process suspends (immediately) the time until activation of the specified process will be included in the total time until the specified process completes.

Causes the process to halt, waiting for the signal to be announced. Some other process/event is necessary to cause the signal. The entities stop waiting for the signal and resume their processes when signaled.

Permits simpler calling syntax when using a blocking queue within a KSLProcess This method will block (suspend) until the required number of items that meet the criteria become available within the blocking queue.

Causes the current process to suspend (immediately) until the blockage has been completed. If the blockage is active, the entity will be suspended until the blockage is completed (cleared). If the blockage is not active, then no suspension occurs. Some other entity must cause the blockage to be started and completed. An entity cannot block itself.

Causes the current process to suspend (immediately) until the blocking task has been completed. If the blocking task is active (in progress), the entity will be suspended until the task is completed (cleared). If the blockage is not active, then no suspension occurs. Some other entity must cause the task to be started and completed. An entity cannot block itself.

Permits simpler calling syntax when using a blocking queue within a KSLProcess This method will block (suspend) until at least 1 item that meets the criteria is available within the blocking queue. If more than one is available, all items meeting the criteria will be returned.

This method will block (suspend) until at least 1 item that meets the criteria is available within the blocking queue. If more than one is available, all items meeting the criteria will be returned.

This method will block (suspend) until the required number of items that meet the criteria become available within the blocking queue.

Causes the process to yield (suspend execution) at the current time, for zero time units, and return control back to the event executive. This permits other events scheduled for the current time to proceed due to the ordering of events.