Event

dvcompute_cons::simulation::event

Trait Event

pub trait Event {
    type Item;

    // Provided methods
    fn into_process(self) -> EventIntoProcess<Self>
       where Self: Sized { ... }
    fn into_composite(self) -> EventIntoComposite<Self>
       where Self: Sized { ... }
    fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F>
       where Self: Sized,
             U: Event,
             F: FnOnce(Self::Item) -> U { ... }
    fn map<B, F>(self, f: F) -> Map<Self, B, F>
       where Self: Sized,
             F: FnOnce(Self::Item) -> B { ... }
    fn zip<U>(self, other: U) -> Zip<Self, U>
       where Self: Sized,
             U: Event { ... }
    fn ap<U, B>(self, other: U) -> Ap<Self, U, B>
       where Self: Sized,
             Self::Item: FnOnce(U::Item) -> B,
             U: Event { ... }
    fn run_in_start_time(self) -> RunInStartTime<Self>
       where Self: Sized { ... }
    fn run_in_start_time_by(
        self,
        including_current_events: bool,
    ) -> RunInStartTime<Self>
       where Self: Sized { ... }
    fn run_in_stop_time(self) -> RunInStopTime<Self>
       where Self: Sized { ... }
    fn run_in_stop_time_by(
        self,
        including_current_events: bool,
    ) -> RunInStopTime<Self>
       where Self: Sized { ... }
    fn into_boxed(self) -> EventBox<Self::Item>
       where Self: Sized + 'static { ... }
}

Expand description

The computation synchronized with the event queue.

Required Associated Types§

type Item

The type of the item that is returned in the current modeling time.

Provided Methods§

fn into_process(self) -> EventIntoProcess<Self>
where Self: Sized,

Convert to the Process computation.

fn into_composite(self) -> EventIntoComposite<Self>
where Self: Sized,

Convert to the Composite computation.

fn and_then<U, F>(self, f: F) -> AndThen<Self, U, F>
where Self: Sized, U: Event, F: FnOnce(Self::Item) -> U,

Bind the current computation with its continuation within the resulting computation.

fn map<B, F>(self, f: F) -> Map<Self, B, F>
where Self: Sized, F: FnOnce(Self::Item) -> B,

Map the current computation using the specified transform.

fn zip<U>(self, other: U) -> Zip<Self, U>
where Self: Sized, U: Event,

Zip the current computation with another one within the resulting computation.

fn ap<U, B>(self, other: U) -> Ap<Self, U, B>
where Self: Sized, Self::Item: FnOnce(U::Item) -> B, U: Event,

The function application.

fn run_in_start_time(self) -> RunInStartTime<Self>
where Self: Sized,

Run the computation in the start time.

fn run_in_start_time_by( self, including_current_events: bool, ) -> RunInStartTime<Self>
where Self: Sized,

Run the computation in the start time by processing the current events or not.

fn run_in_stop_time(self) -> RunInStopTime<Self>
where Self: Sized,

Run the computation in the stop time.

fn run_in_stop_time_by( self, including_current_events: bool, ) -> RunInStopTime<Self>
where Self: Sized,

Run the computation in the stop time by processing the current events or not.

fn into_boxed(self) -> EventBox<Self::Item>
where Self: Sized + 'static,

Convert into a boxed value.

Implementors§

impl Event for NewInIntegTimes

type Item = ObservableBox<f64>

impl Event for NewInStartTime

type Item = ObservableBox<f64>

impl Event for NewInStopTime

type Item = ObservableBox<f64>

impl Event for NewSourceInIntegTimes

type Item = Grc<ObservableSource<f64>>

impl Event for NewSourceInStartTime

type Item = Grc<ObservableSource<f64>>

impl Event for NewSourceInStopTime

type Item = Grc<ObservableSource<f64>>

impl Event for CancelById

type Item = ()

impl Event for Interrupt

type Item = ()

impl Event for InterruptionTime

type Item = Option<f64>

impl Event for IsInterrupted

type Item = bool

impl Event for IsPassivated

type Item = bool

impl Event for Reactivate

type Item = ()

impl Event for ReactivateImmediately

type Item = ()

impl Event for DisposableEventRepr

Available on crate feature cons_mode only.

type Item = DisposableRepr

impl Event for Enqueue

type Item = ()

impl Event for EnqueueIO

type Item = ()

impl Event for EnqueueIOWithPriority

type Item = ()

impl Event for EnqueueWithPriority

type Item = ()

impl Event for EventRepr

Available on crate feature cons_mode only.

type Item = ()

impl Event for Priority

type Item = isize

impl Event for Time

type Item = f64

impl<D> Event for DisposableEvent<D>
where D: Disposable,

type Item = ()

impl<F> Event for EnqueueIOWithIntegTimes<F>
where F: Fn() -> EventBox<()> + 'static,

type Item = ()

impl<F> Event for EnqueueWithIntegTimes<F>
where F: Fn() -> EventBox<()> + 'static,

type Item = ()

impl<F, M> Event for Delay<F, M>
where F: FnOnce() -> M, M: Event,

type Item = <M as Event>::Item

impl<F, T> Event for Cons<F, T>
where F: FnOnce(&Point<'_>) -> Result<T>,

type Item = T

impl<I> Event for ReactivateManyImmediately<I>
where I: Iterator<Item = Grc<ProcessId>> + 'static,

type Item = ()

impl<I, M> Event for Sequence<I, M>
where I: Iterator<Item = M>, M: Event,

type Item = Vec<<M as Event>::Item>

impl<I, M> Event for Sequence_<I, M>
where I: Iterator<Item = M>, M: Event,

type Item = ()

impl<M> Event for Run_<M>
where M: Composite,

type Item = <M as Composite>::Item

impl<M> Event for Trigger<M>

type Item = ()

impl<M> Event for ParameterIntoEvent<M>
where M: Parameter,

type Item = <M as Parameter>::Item

impl<M> Event for dvcompute_cons::simulation::process::Run<M>
where M: Process<Item = ()>,

type Item = <M as Process>::Item

impl<M> Event for SimulationIntoEvent<M>
where M: Simulation,

type Item = <M as Simulation>::Item

impl<M> Event for Trace<M>
where M: Event,

type Item = <M as Event>::Item

impl<M> Event for Yield<M>
where M: Event<Item = ()> + 'static,

type Item = ()

impl<M, B, F> Event for Map<M, B, F>
where M: Event, F: FnOnce(M::Item) -> B,

type Item = B

impl<M, D> Event for dvcompute_cons::simulation::composite::Run<M, D>
where M: Composite, D: Disposable + 'static,

type Item = (<M as Composite>::Item, DisposableBox)

impl<M, U> Event for Zip<M, U>
where M: Event, U: Event,

type Item = (<M as Event>::Item, <U as Event>::Item)

impl<M, U, B> Event for Ap<M, U, B>
where M: Event, U: Event, M::Item: FnOnce(U::Item) -> B,

type Item = B

impl<M, U, F> Event for AndThen<M, U, F>
where M: Event, U: Event, F: FnOnce(M::Item) -> U,

type Item = <U as Event>::Item

impl<S> Event for NewResource<S>
where S: QueueStrategy,

type Item = Resource<S>

impl<S> Event for dvcompute_cons::simulation::resource::stats::ReleaseWithinEvent<S>
where S: QueueStrategy,

type Item = ()

impl<S> Event for dvcompute_cons::simulation::resource::stats::TryRequestWithinEvent<S>
where S: QueueStrategy,

type Item = bool

impl<S> Event for dvcompute_cons::simulation::resource::ReleaseWithinEvent<S>
where S: QueueStrategy,

type Item = ()

impl<S> Event for dvcompute_cons::simulation::resource::TryRequestWithinEvent<S>
where S: QueueStrategy,

type Item = bool

impl<SI, SM, SO, T> Event for dvcompute_cons::simulation::queue::stats::NewQueue<SI, SM, SO, T>
where SI: QueueStrategy + 'static, SM: QueueStrategy, SO: QueueStrategy + 'static, T: 'static,

type Item = Queue<SI, SM, SO, T>

impl<SI, SM, SO, T> Event for dvcompute_cons::simulation::queue::NewQueue<SI, SM, SO, T>
where SI: QueueStrategy + 'static, SM: QueueStrategy, SO: QueueStrategy + 'static, T: 'static,

type Item = Queue<SI, SM, SO, T>

impl<SM, SO, T> Event for dvcompute_cons::simulation::queue::unbounded::stats::NewQueue<SM, SO, T>
where SM: QueueStrategy, SO: QueueStrategy + 'static, T: 'static,

type Item = Queue<SM, SO, T>

impl<SM, SO, T> Event for dvcompute_cons::simulation::queue::unbounded::NewQueue<SM, SO, T>
where SM: QueueStrategy, SO: QueueStrategy + 'static, T: 'static,

type Item = Queue<SM, SO, T>

impl<T> Event for EnqueueMessage<T>
where T: Serialize,

type Item = ()

impl<T> Event for SendMessage<T>
where T: Serialize,

type Item = ()

impl<T> Event for Swap<T>

type Item = T

impl<T> Event for Write<T>

type Item = ()

impl<T> Event for EventBox<T>

type Item = T

impl<T> Event for Return<T>

type Item = T

impl<T, F> Event for Modify<T, F>
where F: FnOnce(&T) -> T, T: Clone,

type Item = ()

impl<T: Clone> Event for Read<T>

type Item = T