Trait dvcompute::simulation::event::Event[−][src]

pub trait Event {
    type Item;
    fn into_process(self) -> EventIntoProcess<Self>
    where
        Self: Sized,
    { ... }

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

    fn flat_map<U, F>(self, f: F) -> FlatMap<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.

Associated Types

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

Provided methods

Convert to the Process computation.

Convert to the Composite computation.

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

Map the current computation using the specified transform.

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

The function application.

Run the computation in the start time.

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

Run the computation in the stop time.

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

Convert into a boxed value.

Implementors