desmoj.core.simulator

Class Entity

java.lang.Object

desmoj.core.simulator.NamedObject

desmoj.core.simulator.ModelComponent

desmoj.core.simulator.Schedulable

desmoj.core.simulator.Entity

Direct Known Subclasses:

EntityAnimation, Job, Lane, SimProcess, SpatialEntity

public abstract class Entity
extends Schedulable

Represents the superclass for all entities of a model. Entities are supposed to be scheduled together with a compatible event at a certain point of simulation time or relative to another event in present or future simulation time.

Entities typically encapsulate all information about a model entity relevant to the modeller. Events can manipulate these informations when the scheduled point of simulation time is reached and thus change the state of the model. When modelling different types of entities you need to derive different classes from this superclass. Each carrying the specific information to represent its counterpart in the system modelled. Thus a simulation of e.g. a factory would require both machines and material to be subclasses of class Entity. They can act on each other by scheduling themselves or other Entities with the appropriate events. To use more than one entity of one type, create multiple instances of the same Entity class. For better identification, all instances created from a subclass of class NamedObject (just as Entity is) get an individual identification number as a suffix to their name so there is no need to name each individual differently yourself.

Entities can carry a queuing priority that can be modified after the entity has been instantiated, applied for inserting Entities into any kind of Queues: The entity's priority determines it's position inside the queue on entering it. Although within a model all attributes of an entity could be made public it is advisable to support data hiding by providing methods for accessing the internal attributes, as always in oo-design.

Version:

DESMO-J, Ver. 2.5.1c copyright (c) 2015

Author:

Tim Lechler, modified by Justin Neumann Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

See Also:

Event, SimProcess, NamedObject

Constructor Summary

Constructors

Constructor and Description
Entity(Model owner, java.lang.String name, boolean showInTrace)

Method Summary

Modifier and Type	Method and Description
long	getIdentNumber() Returns the entity's identification number.
int	getQueueingPriority() Returns the entity's queuing priority.
java.util.List<QueueBased>	getQueues() Returns a list of queues and other QueueBased objects where this Entity is queued.
java.util.List<EventAbstract>	getScheduledEvents() Returns a list of events associated to this Entity object.
static boolean	isEqual(Entity a, Entity b) Checks if the two entities have the same priority.
static boolean	isLarger(Entity a, Entity b) Checks if the first of the two entities has a higher priority than the second.
static boolean	isLargerOrEqual(Entity a, Entity b) Checks if the first of the two entities has higher or same priority than the second.
static boolean	isNotEqual(Entity a, Entity b) Checks if the first of the two entities have different priorities.
boolean	isQueued() Tests if this Entity queued in a at least one queue or other QueueBased.
boolean	isSimProcess() Tests if this Entity actually is a SimProcess.
static boolean	isSmaller(Entity a, Entity b) Checks if the first of the two entities has a lower priority than the second.
static boolean	isSmallerOrEqual(Entity a, Entity b) Checks if the first of the two entities has lower or same priority than the second.
<E extends Entity> void	schedule(E who2, EventOf2Entities<?,E> what) Schedules this Entity to be manipulated by the given EventOf2Entities at the current time.
<E extends Entity> void	schedule(E who2, EventOf2Entities<?,E> what, TimeInstant when) Schedules this Entity to be manipulated by the given EventOf2Entities at the given point of time.
<E extends Entity> void	schedule(E who2, EventOf2Entities<?,E> what, TimeSpan dt) Schedules this Entity to be manipulated by the given EventOf2Entities at the current time plus the given offset.
<E extends Entity,F extends Entity> void	schedule(E who2, F who3, EventOf3Entities<?,E,F> what) Schedules this Entity to be manipulated by the given EventOf3Entities at the current time.
<E extends Entity,F extends Entity> void	schedule(E who2, F who3, EventOf3Entities<?,E,F> what, TimeInstant when) Schedules this Entity to be manipulated by the given EventOf3Entities at the given point of time.
<E extends Entity,F extends Entity> void	schedule(E who2, F who3, EventOf3Entities<?,E,F> what, TimeSpan dt) Schedules this Entity to be manipulated by the given EventOf3Entities at the current time plus the given offset.
void	schedule(Event<?> what) Schedules this Entity to be manipulated by the given Event at the current time.
void	schedule(Event<?> what, TimeInstant when) Schedules this Entity to be manipulated by the given Event at the given point of time.
void	schedule(Event<?> what, TimeSpan dt) Schedules this Entity to be manipulated by the given Event at the current time plus the given offset.
void	scheduleAfter(Schedulable after, Event<?> what) Schedules this Entity with the given Event to occur directly after the given Schedulable that is already scheduled.
<E extends Entity> void	scheduleAfter(Schedulable after, EventOf2Entities<?,E> what, E who2) Schedules this Entity with the given EventOf2Entities to occur directly after the given Schedulable that is already scheduled.
<E extends Entity,F extends Entity> void	scheduleAfter(Schedulable after, EventOf3Entities<?,E,F> what, E who2, F who3) Schedules this Entity with the given EventOf3Entities to occur directly after the given Schedulable that is already scheduled.
void	scheduleBefore(Schedulable before, Event<?> what) Schedules this Entity with the given Event to occur directly before the given Schedulable that is scheduled.
<E extends Entity> void	scheduleBefore(Schedulable before, EventOf2Entities<?,E> what, E who2) Schedules this Entity with the given EventOf2Entities to occur directly before the given Schedulable that is scheduled.
<E extends Entity,F extends Entity> void	scheduleBefore(Schedulable before, EventOf3Entities<?,E,F> what, E who2, F who3) Schedules this Entity with the given EventOf3Entities to occur directly before the given Schedulable that is scheduled.
<E extends Entity> void	schedulePreempt(E who2, EventOf2Entities<?,E> what) Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.
<E extends Entity,F extends Entity> void	schedulePreempt(E who2, F who3, EventOf3Entities<?,E,F> what) Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.
void	schedulePreempt(Event<?> what) Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.
void	setQueueingPriority(int newPriority) Sets the entity's queuing priority to a given integer value.

Methods inherited from class desmoj.core.simulator.Schedulable

assignReporter, cancel, getCorrespondingReportable, isCurrent, isScheduled, rename, reSchedule, reSchedule, reSchedulePreempt, scheduledNext, setCorrespondingReportable

Methods inherited from class desmoj.core.simulator.ModelComponent

current, currentEntity, currentEntityAll, currentEvent, currentModel, currentSimProcess, debugIsOn, debugOff, debugOn, getModel, isExperimentCompatible, isModelCompatible, presentTime, sendDebugNote, sendMessage, sendTraceNote, sendWarning, skipTraceNote, skipTraceNote, traceIsOn, traceOff, traceOn

Methods inherited from class desmoj.core.simulator.NamedObject

getName, getQuotedName, toString

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Entity

public Entity(Model owner,
              java.lang.String name,
              boolean showInTrace)

Method Detail

getScheduledEvents

public java.util.List<EventAbstract> getScheduledEvents()

Returns a list of events associated to this Entity object. If the Entity object is not currently scheduled, an empty list will be returned. Remind that all different Event classes can be included.

Returns:

List : The events associated to the entity

getIdentNumber

public long getIdentNumber()

Returns the entity's identification number.

Returns:

Long : The entity's identification number

getQueueingPriority

public int getQueueingPriority()

Returns the entity's queuing priority. Default priority of an entity is zero. Higher priorities are positive, lower priorities negative.

Returns:

int : The entity's priority

getQueues

public java.util.List<QueueBased> getQueues()

Returns a list of queues and other QueueBased objects where this Entity is queued.

Returns:

List : The QueueBaseds containing this entity; may be empty if entity is not queued.

isQueued

public boolean isQueued()

Tests if this Entity queued in a at least one queue or other QueueBased.

Returns:

boolean : Is true if this Entity is queued in at least one queue or other QueueBased, false otherwise.

isEqual

public static final boolean isEqual(Entity a,
                                    Entity b)

Checks if the two entities have the same priority. Note that this is a static method available through calling the entity's class i.e. Entity.isEqual(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has the same priority as b,/false otherwise

isLarger

public static final boolean isLarger(Entity a,
                                     Entity b)

Checks if the first of the two entities has a higher priority than the second. Note that this is a static method available through calling the entity's class i.e. Entity.isLarger(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has a larger priority than b,/false otherwise

isLargerOrEqual

public static final boolean isLargerOrEqual(Entity a,
                                            Entity b)

Checks if the first of the two entities has higher or same priority than the second. Note that this is a static method available through calling the entity's class i.e. Entity.isLargerOrEqual(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has a larger or equal priority than b,/false otherwise

isNotEqual

public static final boolean isNotEqual(Entity a,
                                       Entity b)

Checks if the first of the two entities have different priorities. Note that this is a static method available through calling the entity's class i.e. Entity.isNotEqual(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has a different priority than b,/false otherwise

isSimProcess

public boolean isSimProcess()

Tests if this Entity actually is a SimProcess. Although SimProcess have an individual life-cycle, they can also be handled like entities and be scheduled to be manipulated by an event.

Returns:

boolean : Is true if this Entity is an instance of class SimProcess,false otherwise

isSmaller

public static final boolean isSmaller(Entity a,
                                      Entity b)

Checks if the first of the two entities has a lower priority than the second. Note that this is a static method available through calling the entity's class i.e. Entity.isSmaller(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has a lower priority than b,/false otherwise

isSmallerOrEqual

public static final boolean isSmallerOrEqual(Entity a,
                                             Entity b)

Checks if the first of the two entities has lower or same priority than the second. Note that this is a static method available through calling the entity's class i.e. Entity.isSmallerOrEqual(a,b) where a and b are valid Entity objects.

Parameters:

a - Entity : First comparand entity

b - Entity : Second comparand entity

Returns:

boolean : Is true if a has a smaller or equal priority than b, /false otherwise

schedule

public void schedule(Event<?> what,
                     TimeInstant when)

Schedules this Entity to be manipulated by the given Event at the given point of time. Method returns with a warning message if either Entity or Event are already scheduled in the event-list. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

what - Event : The Event that manipulates this Entity

when - TimeInstant : The point in simulation time this event is scheduled to happen.

See Also:

SimClock

schedule

public void schedule(Event<?> what,
                     TimeSpan dt)

Schedules this Entity to be manipulated by the given Event at the current time plus the given offset. Method returns with a warning message if either Entity or Event are already scheduled in the EventList. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

what - Event : The Event that manipulates this Entity

dt - TimeSpan : The offset to the current simulation time at which the event is to be scheduled

See Also:

SimClock

schedule

public void schedule(Event<?> what)

Schedules this Entity to be manipulated by the given Event at the current time. Method returns with a warning message if either Entity or Event are already scheduled in the EventList. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

what - Event : The Event that manipulates this Entity

See Also:

SimClock

schedule

public <E extends Entity> void schedule(E who2,
                                        EventOf2Entities<?,E> what,
                                        TimeInstant when)

Schedules this Entity to be manipulated by the given EventOf2Entities at the given point of time. Method returns with a warning message if either Entity or Event are already scheduled in the event-list. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

when - TimeInstant : The point in simulation time this event is scheduled to happen.

See Also:

SimClock

schedule

public <E extends Entity> void schedule(E who2,
                                        EventOf2Entities<?,E> what,
                                        TimeSpan dt)

Schedules this Entity to be manipulated by the given EventOf2Entities at the current time plus the given offset. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

dt - TimeSpan : The offset to the current simulation time at which the event is to be scheduled

See Also:

SimClock

schedule

public <E extends Entity> void schedule(E who2,
                                        EventOf2Entities<?,E> what)

Schedules this Entity to be manipulated by the given EventOf2Entities at the current time. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

See Also:

SimClock

schedule

public <E extends Entity,F extends Entity> void schedule(E who2,
                                                         F who3,
                                                         EventOf3Entities<?,E,F> what,
                                                         TimeInstant when)

Schedules this Entity to be manipulated by the given EventOf3Entities at the given point of time. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

when - TimeInstant : The point in simulation time the event is scheduled to happen.

See Also:

SimClock

schedule

public <E extends Entity,F extends Entity> void schedule(E who2,
                                                         F who3,
                                                         EventOf3Entities<?,E,F> what,
                                                         TimeSpan dt)

Schedules this Entity to be manipulated by the given EventOf3Entities at the current time plus the given offset. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

dt - TimeSpan : The offset to the current simulation time at which the event is to be scheduled

See Also:

SimClock

schedule

public <E extends Entity,F extends Entity> void schedule(E who2,
                                                         F who3,
                                                         EventOf3Entities<?,E,F> what)

Schedules this Entity to be manipulated by the given EventOf3Entities at the current time. No preemption, i.e. a process calling this method will continue until passivated or hold.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

See Also:

SimClock

schedulePreempt

public void schedulePreempt(Event<?> what)
                     throws SuspendExecution

Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.

Parameters:

what - Event : The Event that manipulates this Entity

Throws:

SuspendExecution

See Also:

SimClock

schedulePreempt

public <E extends Entity> void schedulePreempt(E who2,
                                               EventOf2Entities<?,E> what)
                                        throws SuspendExecution

Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

Throws:

SuspendExecution

See Also:

SimClock

schedulePreempt

public <E extends Entity,F extends Entity> void schedulePreempt(E who2,
                                                                F who3,
                                                                EventOf3Entities<?,E,F> what)
                                                         throws SuspendExecution

Schedules this entity with an event to be executed immediately, preempting the process lifecycle executed at the moment.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

Throws:

SuspendExecution

See Also:

SimClock

scheduleAfter

public void scheduleAfter(Schedulable after,
                          Event<?> what)

Schedules this Entity with the given Event to occur directly after the given Schedulable that is already scheduled. Note that this event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly after the given Schedulable but the simulation clock will not change. Will return with a warning message if the Schedulable given as parameter is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled after the last occurrence.

Parameters:

after - Schedulable : The Schedulable this Entity should be scheduled after

what - Event : The Event to manipulate this Entity

scheduleAfter

public <E extends Entity> void scheduleAfter(Schedulable after,
                                             EventOf2Entities<?,E> what,
                                             E who2)

Schedules this Entity with the given EventOf2Entities to occur directly after the given Schedulable that is already scheduled. Note that the event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly after the given Schedulable but the simulation clock will not change. Will return with a warning message if the Schedulable given as parameter is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled after the last occurrence.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

after - Schedulable : The Schedulable the event should be scheduled after

scheduleAfter

public <E extends Entity,F extends Entity> void scheduleAfter(Schedulable after,
                                                              EventOf3Entities<?,E,F> what,
                                                              E who2,
                                                              F who3)

Schedules this Entity with the given EventOf3Entities to occur directly after the given Schedulable that is already scheduled. Note that the event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly after the given Schedulable but the simulation clock will not change. Will return with a warning message if the Schedulable given as parameter is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled after the last occurrence.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

after - Schedulable : The Schedulable this Entity should be scheduled after

what - Event : The Event to manipulate this Entity

scheduleBefore

public void scheduleBefore(Schedulable before,
                           Event<?> what)

Schedules this Entity with the given Event to occur directly before the given Schedulable that is scheduled. Note that this event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly before the given Schedulable but the simulation clock will not change. Issues a warning message if the Schedulable given is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled before the first occurrence.

Parameters:

before - Schedulable : The Schedulable this Entity should be scheduled before

what - Event : The Event to manipulate this Entity

scheduleBefore

public <E extends Entity> void scheduleBefore(Schedulable before,
                                              EventOf2Entities<?,E> what,
                                              E who2)

Schedules this Entity with the given EventOf2Entities to occur directly before the given Schedulable that is scheduled. Note that the event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly before the given Schedulable but the simulation clock will not change. Issues a warning message if the Schedulable given is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled before the first occurrence.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf2Entities.

what - EventOf2Entities : The event to be scheduled

before - Schedulable : The Schedulable this Entity should be scheduled before

scheduleBefore

public <E extends Entity,F extends Entity> void scheduleBefore(Schedulable before,
                                                               EventOf3Entities<?,E,F> what,
                                                               E who2,
                                                               F who3)

Schedules this Entity with the given EventOf3Entities to occur directly before the given Schedulable that is scheduled. Note that the event's point of simulation time will be set to be the same as the Schedulable's time. Thus the event will occur directly before the given Schedulable but the simulation clock will not change. Issues a warning message if the Schedulable given is not scheduled. If there are multiple schedules for the given Schedulable, the event will be scheduled before the first occurrence.

Parameters:

who2 - Entity : The second entity to be scheduled for the EventOf3Entities.

who3 - Entity : The third entity to be scheduled for the EventOf3Entities.

what - EventOf3Entities : The event to be scheduled

before - Schedulable : The Schedulable this Entity should be scheduled before

setQueueingPriority

public void setQueueingPriority(int newPriority)

Sets the entity's queuing priority to a given integer value. The default priority of each entity (unless assigned otherwise) is zero. Negative priorities are lower, positive priorities are higher. All values should be inside the range defined by Java's integral integer data type [-2147483648, +2147483647]. An entity's queuing priority can be used by the modeller to determine how the entity is treated by queues, though how precisely a queue will use the priority to determine sort order is up to it's queuing strategy:

• QueueBased.FIFO sorts entities by their queuing priority, highest priority first. Entities with the same priority are enqueued based on "first in, first out".
• QueueBased.LIFO also sorts entities by their priority, highest priority first. However, entities with the same priority are enqueued based on "last in, first out".
• QueueBased.Random assigns a random position to each entity entering the queue, disregarding priority.

Of course, the modeller is free to use the queuing priority to determine how entities are processed by the components he implements himself, whether they are queues or not.

Parameters:

newPriority - int : The new queuing priority value