Enum State 

pub enum State<C: ?Sized + Config> {
    Born,
    Idle,
    Busy,
    Next(<C::Plan as Scheduler>::State),
    Done(ExitStatus),
    Gone(ExitStatus),
}

Represents the state of a Continuation throughout its lifecycle.

A Continuation starts in the Born state without references to shared data or its future, as provided by its owning Job or Agent. After binding pinned references to it, the Continuation moves to the Idle state, indicating it is unscheduled.

From the Idle state, the Continuation can be scheduled by inserting it into the event calendar at a specific model time, transitioning it to the Next state. When the model time reaches this point and the Continuation is activated, it enters the Busy state.

Upon completion, the Continuation transitions to the Done state, indicating that a return value is available for extraction. At any point before normal termination, the Continuation can be aborted, moving it to the Gone state and dropping its bound future. The Gone state is the final state in a Continuation’s lifecycle.

--- title: State Transition Diagram --- flowchart LR Born{{Born}}-->Idle{{Idle}} Born{{Born}}-->Gone{{Gone}} Idle{{Idle}}-->Next{{Next}} Idle{{Idle}}-->Gone{{Gone}} Busy{{Busy}}-->Idle{{Idle}} Busy{{Busy}}-->Done{{Done}} Next{{Next}}-->Idle{{Idle}} Next{{Next}}-->Busy{{Busy}} Done{{Done}}-->Gone{{Gone}}

Variants

Born

State of a continuation signifying a non-bound future and shared data.

Idle

State of a continuation that is waiting for external reactivation.

Busy

State of the continuation that is currently active. At most one continuation may be in this state during a simulation run at any time.

Next(<C::Plan as Scheduler>::State)

State of a continuation that is managed by the calendar.

Done(ExitStatus)

State of a completed continuation with a result available for extraction.

Gone(ExitStatus)

State of a continuation that cannot be scheduled anymore.

Implementations

impl<C: ?Sized + Config> State<C>

pub const fn is_born(&self) -> bool

Returns true if the current state is Self::Born and false otherwise.

pub const fn is_idle(&self) -> bool

Returns true if the current state is Self::Idle and false otherwise.

pub const fn is_busy(&self) -> bool

Returns true if the current state is Self::Busy and false otherwise.

pub const fn is_next(&self) -> bool

Returns true if the current state is Self::Next and false otherwise.

pub const fn is_done(&self) -> bool

Returns true if the current state is Self::Done and false otherwise.

pub const fn is_gone(&self) -> bool

Returns true if the current state is Self::Gone and false otherwise.

pub const fn is_init(&self) -> bool

Returns true if the current state is Self::Idle or Self::Busy or Self::Next or Self::Done or Self::Gone and false otherwise.

pub const fn is_term(&self) -> bool

Returns true if the current state is Self::Done or Self::Gone and false otherwise.

Trait Implementations

impl<C: ?Sized + Config> Debug for State<C>

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

Formats the value using the given formatter.

impl<C: ?Sized + Config> Default for State<C>

fn default() -> State<C>

Returns the “default value” for a type.

impl<C: ?Sized + Config> FSM for State<C>

type Token<'brand> = State<'brand>

Type of generically branded token.

type Erased = State

Type of the stateless enumeration of all possible states.

fn token<'brand>( this: &Self, once: Ephemeral<'brand>, _: Private, ) -> Self::Token<'brand>

Private trait function to convert a branded Ephemeral into an equally branded machine-specific token type.

fn erased(&self) -> Self::Erased

Erases the configuration-specific payloads from the enumeration, returning a type-erased version.

fn label(&self) -> &'static str

Returns the name of the current state as a string.

impl<'b, C: ?Sized + Config> Transition<'b, Born<'b>, Born<'b>> for State<C>

fn transition( this: &mut Self, token: Born<'b>, _data: Self::Data, _: Private, ) -> Born<'b>

Updates the state of Born, requiring a Born-token and returning it.

type Data = ()

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Born<'b>, Gone<'b>> for State<C>

fn transition( this: &mut Self, token: Born<'b>, data: Self::Data, p: Private, ) -> Gone<'b>

Performs the transition between Born and Gone, requiring a Born-token and returning the resulting Gone-token.

type Data = <State<C> as Transition<'b, Gone<'b>, Gone<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Born<'b>, Idle<'b>> for State<C>

fn transition( this: &mut Self, token: Born<'b>, data: Self::Data, p: Private, ) -> Idle<'b>

Performs the transition between Born and Idle, requiring a Born-token and returning the resulting Idle-token.

type Data = <State<C> as Transition<'b, Idle<'b>, Idle<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Busy<'b>, Busy<'b>> for State<C>

fn transition( this: &mut Self, token: Busy<'b>, _data: Self::Data, _: Private, ) -> Busy<'b>

Updates the state of Busy, requiring a Busy-token and returning it.

type Data = ()

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Busy<'b>, Done<'b>> for State<C>

fn transition( this: &mut Self, token: Busy<'b>, data: Self::Data, p: Private, ) -> Done<'b>

Performs the transition between Busy and Done, requiring a Busy-token and returning the resulting Done-token.

type Data = <State<C> as Transition<'b, Done<'b>, Done<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Busy<'b>, Idle<'b>> for State<C>

fn transition( this: &mut Self, token: Busy<'b>, data: Self::Data, p: Private, ) -> Idle<'b>

Performs the transition between Busy and Idle, requiring a Busy-token and returning the resulting Idle-token.

type Data = <State<C> as Transition<'b, Idle<'b>, Idle<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Done<'b>, Done<'b>> for State<C>

fn transition( this: &mut Self, token: Done<'b>, _data: Self::Data, _: Private, ) -> Done<'b>

Updates the state of Done, requiring a Done-token and returning it.

type Data = Result<Success, Failure>

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Done<'b>, Gone<'b>> for State<C>

fn transition( this: &mut Self, token: Done<'b>, data: Self::Data, p: Private, ) -> Gone<'b>

Performs the transition between Done and Gone, requiring a Done-token and returning the resulting Gone-token.

type Data = <State<C> as Transition<'b, Gone<'b>, Gone<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Gone<'b>, Gone<'b>> for State<C>

fn transition( this: &mut Self, token: Gone<'b>, _data: Self::Data, _: Private, ) -> Gone<'b>

Updates the state of Gone, requiring a Gone-token and returning it.

type Data = Result<Success, Failure>

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Idle<'b>, Gone<'b>> for State<C>

fn transition( this: &mut Self, token: Idle<'b>, data: Self::Data, p: Private, ) -> Gone<'b>

Performs the transition between Idle and Gone, requiring a Idle-token and returning the resulting Gone-token.

type Data = <State<C> as Transition<'b, Gone<'b>, Gone<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Idle<'b>, Idle<'b>> for State<C>

fn transition( this: &mut Self, token: Idle<'b>, _data: Self::Data, _: Private, ) -> Idle<'b>

Updates the state of Idle, requiring a Idle-token and returning it.

type Data = ()

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Idle<'b>, Next<'b>> for State<C>

fn transition( this: &mut Self, token: Idle<'b>, data: Self::Data, p: Private, ) -> Next<'b>

Performs the transition between Idle and Next, requiring a Idle-token and returning the resulting Next-token.

type Data = <State<C> as Transition<'b, Next<'b>, Next<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Next<'b>, Busy<'b>> for State<C>

fn transition( this: &mut Self, token: Next<'b>, data: Self::Data, p: Private, ) -> Busy<'b>

Performs the transition between Next and Busy, requiring a Next-token and returning the resulting Busy-token.

type Data = <State<C> as Transition<'b, Busy<'b>, Busy<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Next<'b>, Idle<'b>> for State<C>

fn transition( this: &mut Self, token: Next<'b>, data: Self::Data, p: Private, ) -> Idle<'b>

Performs the transition between Next and Idle, requiring a Next-token and returning the resulting Idle-token.

type Data = <State<C> as Transition<'b, Idle<'b>, Idle<'b>>>::Data

Associated type specifying the payload of the destination state V.

impl<'b, C: ?Sized + Config> Transition<'b, Next<'b>, Next<'b>> for State<C>

fn transition( this: &mut Self, token: Next<'b>, _data: Self::Data, _: Private, ) -> Next<'b>

Updates the state of Next, requiring a Next-token and returning it.

type Data = <<C as Config>::Plan as Scheduler>::State

Associated type specifying the payload of the destination state V.