Struct stateright::QuickMachine

pub struct QuickMachine<State, Action> {
    pub init_states: fn() -> Vec<State>,
    pub actions: fn(_: &State, _: &mut Vec<Action>),
    pub next_state: fn(_: &State, _: &Action) -> Option<State>,
}

A convenience structure for succinctly describing a throwaway StateMachine.

Fields

init_states: fn() -> Vec<State>

Returns the initial possible states.

actions: fn(_: &State, _: &mut Vec<Action>)

Collects the subsequent possible actions based on a previous state.

next_state: fn(_: &State, _: &Action) -> Option<State>

Converts a previous state and action to a resulting state. None indicates that the action does not change the state.

Trait Implementations

impl<State: Clone, Action: Clone> Clone for QuickMachine<State, Action>

fn clone(&self) -> QuickMachine<State, Action>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State, Action> StateMachine for QuickMachine<State, Action>

type State = State

The type of state upon which this machine operates.

type Action = Action

The type of action that transitions between states.

fn init_states(&self) -> Vec<Self::State>

Returns the initial possible states.

fn actions(&self, state: &Self::State, actions: &mut Vec<Self::Action>)

Collects the subsequent possible actions based on a previous state.

fn next_state(
    &self,
    last_state: &Self::State,
    action: &Self::Action
) -> Option<Self::State>

Converts a previous state and action to a resulting state. None indicates that the action does not change the state.

fn display_outcome(
    &self,
    last_state: &Self::State,
    action: &Self::Action
) -> Option<String> where
    Self::State: Debug, 

Summarizes the outcome of taking a step.

fn next_steps(
    &self,
    last_state: &Self::State
) -> Vec<(Self::Action, Self::State)> where
    Self::State: Hash, 

Indicates the steps (action-state pairs) that follow a particular state.

fn next_states(&self, last_state: &Self::State) -> Vec<Self::State>

Indicates the states that follow a particular state. Slightly more efficient than calling next_steps and projecting out the states.

fn follow_fingerprints(
    &self,
    init_states: Vec<Self::State>,
    fingerprints: Vec<Fingerprint>
) -> Option<Self::State> where
    Self::State: Hash, 

Determines the final state associated with a particular fingerprint path.