Struct dvcompute_branch::simulation::queue::unbounded::stats::NewQueue

pub struct NewQueue<SM, SO, T> { /* private fields */ }

Computation that creates a new Queue.

Trait Implementations

impl<SM: Clone, SO: Clone, T: Clone> Clone for NewQueue<SM, SO, T>

fn clone(&self) -> NewQueue<SM, SO, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<SM, SO, T> Event for NewQueue<SM, SO, T> where
    SM: QueueStrategy,
    SO: QueueStrategy,
    T: Clone + 'static, 

type Item = Queue<SM, SO, T>

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

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 flat_map<U, F>(self, f: F) -> FlatMap<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 + Clone + 'static, 

Convert into a boxed value.