Struct finny::FsmFrontend

pub struct FsmFrontend<F, Q, I, T> where
    F: FsmBackend,
    Q: FsmEventQueue<F>,
    I: Inspect,
    T: FsmTimers<F>,  {
    pub backend: FsmBackendImpl<F>,
    pub queue: Q,
    pub inspect: I,
    pub timers: T,
}

The frontend of a state machine which also includes environmental services like queues and inspection. The usual way to use the FSM.

Fields

backend: FsmBackendImpl<F>

queue: Q

inspect: I

timers: T

Implementations

impl<F, Q, I, T> FsmFrontend<F, Q, I, T> where
    F: FsmBackend,
    Q: FsmEventQueue<F>,
    I: Inspect,
    T: FsmTimers<F>, 

pub fn start(&mut self) -> FsmResult<()>

Start the FSM, initiates the transition to the initial state.

pub fn dispatch_timer_events(&mut self) -> FsmResult<()>

Dispatch any pending timer events into the queue, then run all the events from the queue until completition.

pub fn dispatch<E>(&mut self, event: E) -> FsmResult<()> where
    E: Into<<F as FsmBackend>::Events>, 

Dispatch this event and run it to completition.

pub fn dispatch_single_event(
    &mut self,
    event: FsmEvent<<F as FsmBackend>::Events, <F as FsmBackend>::Timers>
) -> FsmResult<()>

Dispatch only this event, do not run it to completition.

pub fn dispatch_queue(&mut self) -> FsmResult<()>

Dispatch the entire event queue and run it to completition.

Methods from Deref<Target = FsmBackendImpl<F>>

pub fn get_context(&self) -> &<F as FsmBackend>::Context

pub fn get_current_states(
    &self
) -> <<F as FsmBackend>::States as FsmStates<F>>::CurrentState

pub fn get_state<S>(&self) -> &S where
    <F as FsmBackend>::States: AsRef<S>, 

Trait Implementations

impl<F, Q, I, T> Deref for FsmFrontend<F, Q, I, T> where
    F: FsmBackend,
    Q: FsmEventQueue<F>,
    I: Inspect,
    T: FsmTimers<F>, 

type Target = FsmBackendImpl<F>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F, Q, I, T> DerefMut for FsmFrontend<F, Q, I, T> where
    F: FsmBackend,
    Q: FsmEventQueue<F>,
    I: Inspect,
    T: FsmTimers<F>, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.