Struct aper::StateMachineContainerProgram

pub struct StateMachineContainerProgram<SM: StateMachine>(pub SM);

A StateProgram implementation that can be built from any StateMachine. Transitions are stripped of their metadata and passed down to the underlying state machine.

Tuple Fields

0: SM

Trait Implementations

impl<SM: Clone + StateMachine> Clone for StateMachineContainerProgram<SM>

fn clone(&self) -> StateMachineContainerProgram<SM>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<SM: Debug + StateMachine> Debug for StateMachineContainerProgram<SM>

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

Formats the value using the given formatter.

impl<SM: Default + StateMachine> Default for StateMachineContainerProgram<SM>

fn default() -> StateMachineContainerProgram<SM>

Returns the “default value” for a type.

impl<'de, SM: StateMachine> Deserialize<'de> for StateMachineContainerProgram<SM>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<SM: StateMachine> Serialize for StateMachineContainerProgram<SM>

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

Serialize this value into the given Serde serializer.

impl<SM: StateMachine> StateMachine for StateMachineContainerProgram<SM>

type Transition = TransitionEvent<SM::Transition>

The StateMachine::Transition type associates another type with this state machine as its transitions.

fn apply(&mut self, transition: Self::Transition)

Update the state machine according to the given Transition. This method must be deterministic: calling it on a clone of the state with a clone of the Transition must result in the same state, even at a different time and on a different machine. This is the requirement that allows Aper to keep the state in sync across multiple machines.

impl<SM: StateMachine + Default> StateProgram for StateMachineContainerProgram<SM>

type T = SM::Transition

fn new(_init_value: &str) -> Self

fn suspended_event(&self) -> Option<TransitionEvent<Self::T>>

A state machine may “suspend” an event which occurs at a specific time in the future. This is useful for ensuring that the state is updated at a future time regardless of a user-initiated state change before then. State machines that only change state as a result of user-initiated events can ignore this method, as the default implementation is to never suspend an event.