Enum Blocked 

pub enum Blocked {
    Idle,
    Sleeping {
        next_wakeup: Instant,
    },
    Deadlock(Vec<SendBlock>),
    Breakpoint(Name, Effect),
    Busy {
        external_effects: usize,
        stages: Vec<Name>,
    },
    Terminated(Name),
}

Classification of why SimulationRunning::run_until_blocked has stopped.

Variants

Idle

All stages are suspended on Effect::Receive.

Sleeping

The simulation is waiting for a wakeup with no external effects pending.

Fields

next_wakeup: Instant

Deadlock(Vec<SendBlock>)

All stages are suspended on either Effect::Receive or Effect::Send.

Breakpoint(Name, Effect)

The given breakpoint was hit.

Busy

The given stages are suspended on effects other than Effect::Receive while none are suspended on Effect::Send. The given number of external effects are currently unresolved.

Fields

external_effects: usize

stages: Vec<Name>

Terminated(Name)

The given stage has terminated.

Implementations

impl Blocked

pub fn assert_idle(&self)

Assert that the blocking reason is Idle.

pub fn assert_sleeping(&self) -> Instant

Assert that the blocking reason is Sleeping.

pub fn assert_sleeping_until(&self, until: Instant)

Assert that the blocking reason is Sleeping until the given instant.

pub fn assert_deadlock( &self, names: impl IntoIterator<Item = impl AsRef<str> + Debug>, )

Assert that the blocking reason is Deadlock by at least the given stages.

pub fn assert_busy( &self, names: impl IntoIterator<Item = impl AsRef<str> + Debug>, ) -> &Self

Assert that the blocking reason is Busy by at least the given stages.

pub fn assert_external_effects(&self, effects: usize)

pub fn assert_breakpoint(self, name: impl AsRef<str>) -> Effect

Assert that the blocking reason is Breakpoint by the given name.

pub fn assert_terminated(self, name: impl AsRef<str>)

Assert that the blocking reason is Terminated by the given name.

Trait Implementations

impl Debug for Blocked

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Blocked

fn eq(&self, other: &Blocked) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Blocked