Enum State

pub enum State {
    Ready,
    Blocked,
    Waiting,
    Running,
    Completed,
}

State represents the possible states it is possible for a function to be in

Variants

Ready

Ready - Function will be in Ready state when all of it’s inputs are full and there are no inputs it sends to that are full (unless that input is it’s own)

Blocked

Blocked - Function is in Blocked state when there is at least one input it sends to that is full (unless that input is it’s own, as then it will be emptied when the function runs)

Waiting

Waiting - Function is in Blocked state when at least one of it’s inputs is not full

Running

Running - Function is in Running state when it has been picked from the Ready list for execution using the next() function

Completed

Completed - Function has indicated that it no longer wants to be run, so it’s execution has completed.

Trait Implementations

impl Debug for State

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for State

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for State

fn eq(&self, other: &State) -> 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 Serialize for State

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for State

impl StructuralPartialEq for State