Uses of Interface
xuml.tools.model.compiler.runtime.Event

Packages that use Event

Package	Description
bytes
many_to_many_association_two
one_many_to_many_association
one_many_to_one_many_association
ordertracker
two_transitions_to_same_state
unary_many_association
unary_one_many
xuml.tools.model.compiler.runtime
xuml.tools.model.compiler.runtime.message
zero_one_to_zero_one

Uses of Event in bytes

Methods in bytes with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in many_to_many_association_two

Methods in many_to_many_association_two with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
B	B.cancelSignal(Event<B> event)
C	C.cancelSignal(Event<C> event)
D	D.cancelSignal(Event<D> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
B	B.event(Event<B> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
C	C.event(Event<C> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
D	D.event(Event<D> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
B	B.signal(Event<B> event) Asychronously queues the given signal against this entity for processing.
B	B.signal(Event<B> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
B	B.signal(Event<B> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
C	C.signal(Event<C> event) Asychronously queues the given signal against this entity for processing.
C	C.signal(Event<C> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
C	C.signal(Event<C> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
D	D.signal(Event<D> event) Asychronously queues the given signal against this entity for processing.
D	D.signal(Event<D> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
D	D.signal(Event<D> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in one_many_to_many_association

Methods in one_many_to_many_association with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
B	B.cancelSignal(Event<B> event)
C	C.cancelSignal(Event<C> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
B	B.event(Event<B> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
C	C.event(Event<C> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
B	B.signal(Event<B> event) Asychronously queues the given signal against this entity for processing.
B	B.signal(Event<B> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
B	B.signal(Event<B> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
C	C.signal(Event<C> event) Asychronously queues the given signal against this entity for processing.
C	C.signal(Event<C> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
C	C.signal(Event<C> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in one_many_to_one_many_association

Methods in one_many_to_one_many_association with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
B	B.cancelSignal(Event<B> event)
C	C.cancelSignal(Event<C> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
B	B.event(Event<B> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
C	C.event(Event<C> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
B	B.signal(Event<B> event) Asychronously queues the given signal against this entity for processing.
B	B.signal(Event<B> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
B	B.signal(Event<B> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
C	C.signal(Event<C> event) Asychronously queues the given signal against this entity for processing.
C	C.signal(Event<C> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
C	C.signal(Event<C> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in ordertracker

Classes in ordertracker that implement Event

Modifier and Type	Class and Description
static class	Depot.Events.Create Event implementation for event 'Create'
static class	Order.Events.ArrivedDepot Event implementation for event 'Arrived depot'
static class	Order.Events.ArrivedFinalDepot Event implementation for event 'Arrived final depot'
static class	Order.Events.Assign Event implementation for event 'Assign'
static class	Order.Events.CouldNotDeliver Event implementation for event 'Could not deliver'
static class	Order.Events.Create Event implementation for event 'Create'
static class	Order.Events.DeliverAgain Event implementation for event 'Deliver again'
static class	Order.Events.Delivered Event implementation for event 'Delivered'
static class	Order.Events.DeliveredByPickup Event implementation for event 'Delivered by pickup'
static class	Order.Events.Delivering Event implementation for event 'Delivering'
static class	Order.Events.DeliveryFailed Event implementation for event 'Delivery failed'
static class	Order.Events.NoMoreAttempts Event implementation for event 'No more attempts'
static class	Order.Events.PickedUp Event implementation for event 'Picked up'
static class	Order.Events.ReturnToSender Event implementation for event 'Return to sender'
static class	Order.Events.Send Event implementation for event 'Send'
static class	SystemEvent.Events.Create Event implementation for event 'Create'
static class	SystemEvent.Events.NewEvent Event implementation for event 'New Event'

Methods in ordertracker with parameters of type Event

Modifier and Type	Method and Description
Depot	Depot.cancelSignal(Event<Depot> event)
Order	Order.cancelSignal(Event<Order> event)
SystemEvent	SystemEvent.cancelSignal(Event<SystemEvent> event)
Depot	Depot.event(Event<Depot> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
Order	Order.event(Event<Order> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
SystemEvent	SystemEvent.event(Event<SystemEvent> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
Depot	Depot.signal(Event<Depot> event) Asychronously queues the given signal against this entity for processing.
Depot	Depot.signal(Event<Depot> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
Depot	Depot.signal(Event<Depot> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
Order	Order.signal(Event<Order> event) Asychronously queues the given signal against this entity for processing.
Order	Order.signal(Event<Order> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
Order	Order.signal(Event<Order> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
SystemEvent	SystemEvent.signal(Event<SystemEvent> event) Asychronously queues the given signal against this entity for processing.
SystemEvent	SystemEvent.signal(Event<SystemEvent> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
SystemEvent	SystemEvent.signal(Event<SystemEvent> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in two_transitions_to_same_state

Classes in two_transitions_to_same_state that implement Event

Modifier and Type	Class and Description
static class	A.Events.Create Event implementation for event 'Create'
static class	A.Events.First Event implementation for event 'First'

Methods in two_transitions_to_same_state with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in unary_many_association

Methods in unary_many_association with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
B	B.cancelSignal(Event<B> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
B	B.event(Event<B> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
B	B.signal(Event<B> event) Asychronously queues the given signal against this entity for processing.
B	B.signal(Event<B> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
B	B.signal(Event<B> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in unary_one_many

Methods in unary_one_many with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.

Uses of Event in xuml.tools.model.compiler.runtime

Subinterfaces of Event in xuml.tools.model.compiler.runtime

Modifier and Type	Interface and Description
interface	CreationEvent<T>

Methods in xuml.tools.model.compiler.runtime that return types with arguments of type Event

Modifier and Type	Method and Description
Class<Event<?>>	QueuedSignal.eventClass()

Methods in xuml.tools.model.compiler.runtime with parameters of type Event

Modifier and Type	Method and Description
T	Entity.event(Event<T> event) Runs the on-entry procedure associated with this event.
<T extends Entity<T>> String	Signaller.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
T	Entity.signal(Event<T> event) Signals the entity with the given event.
<T extends Entity<T>> void	EntityHelper.signal(Event<T> event)
T	Entity.signal(Event<T> event, scala.concurrent.duration.Duration delay) Signals the entity with the given event after the given delay.
T	Entity.signal(Event<T> event, long time) Signals the entity with the given event at the given epoch time in ms.
<T extends Entity<T>> void	EntityHelper.signal(Event<T> event, com.google.common.base.Optional<scala.concurrent.duration.Duration> delay)
<T extends Entity<T>> void	Signaller.signal(String fromEntityUniqueId, Entity<T> entity, Event<T> event, Long time, com.google.common.base.Optional<scala.concurrent.duration.FiniteDuration> repeatInterval)
<T extends Entity<T>> void	Signaller.signal(String fromEntityUniqueId, Entity<T> entity, Event<T> event, com.google.common.base.Optional<scala.concurrent.duration.Duration> delay)
<T extends Entity<T>> void	Signaller.signal(String fromEntityUniqueId, Entity<T> entity, Event<T> event, com.google.common.base.Optional<scala.concurrent.duration.Duration> delay, com.google.common.base.Optional<scala.concurrent.duration.FiniteDuration> repeatInterval)

Uses of Event in xuml.tools.model.compiler.runtime.message

Methods in xuml.tools.model.compiler.runtime.message that return Event

Modifier and Type	Method and Description
Event<T>	Signal.getEvent()

Constructors in xuml.tools.model.compiler.runtime.message with parameters of type Event

Constructor and Description
Signal(String fromEntityUniqueId, Class<Entity<T>> entityClass, Event<T> event, String id, scala.concurrent.duration.Duration delay, scala.concurrent.duration.FiniteDuration repeatInterval, Serializable entityId, String entityUniqueId)
Signal(String fromEntityUniqueId, Class<Entity<T>> entityClass, Event<T> event, String id, Long timeMs, com.google.common.base.Optional<scala.concurrent.duration.FiniteDuration> repeatInterval, Serializable entityId, String entityUniqueId)
Signal(String fromEntityUniqueId, Class<Entity<T>> entityClass, Event<T> event, String id, Long timeMs, Serializable entityId, String entityUniqueId)
Signal(String fromEntityUniqueId, Class<Entity<T>> entityClass, Event<T> event, String id, Serializable entityId, String entityUniqueId)

Uses of Event in zero_one_to_zero_one

Methods in zero_one_to_zero_one with parameters of type Event

Modifier and Type	Method and Description
A	A.cancelSignal(Event<A> event)
B	B.cancelSignal(Event<B> event)
A	A.event(Event<A> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
B	B.event(Event<B> event) Synchronously runs the on entry procedure associated with this event and also any signals to self that are made during the procedure.
static <T extends Entity<T>> String	Context.persistSignal(String fromEntityUniqueId, Object id, Class<T> cls, Event<T> event, long time, com.google.common.base.Optional<Long> repeatIntervalMs, String entityUniqueId)
A	A.signal(Event<A> event) Asychronously queues the given signal against this entity for processing.
A	A.signal(Event<A> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
A	A.signal(Event<A> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.
B	B.signal(Event<B> event) Asychronously queues the given signal against this entity for processing.
B	B.signal(Event<B> event, scala.concurrent.duration.Duration delay) Asychronously queues the given signal against this entity for processing after the delay specified.
B	B.signal(Event<B> event, long time) Asychronously queues the given signal against this entity for processing at the epoch time in ms specified.