finny 0.2.0

Finite State Machines with a procedural builder-style API and compile time transition checks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! The public Finite State Machine traits. The derive macros will implement these for your particular
//! state machines.

mod events;
mod fsm_impl;
mod fsm_factory;
mod queue;
mod states;
mod transitions;
mod tests_fsm;
mod dispatch;
mod timers;
mod inspect;

pub use self::events::*;
pub use self::fsm_factory::*;
pub use self::fsm_impl::*;
pub use self::queue::*;
pub use self::states::*;
pub use self::transitions::*;
pub use self::inspect::*;
pub use self::dispatch::*;
pub use self::timers::*;

use crate::lib::*;

pub type FsmResult<T> = Result<T, FsmError>;

/// The lib-level error type.
#[derive(Debug, PartialEq)]
pub enum FsmError {
    NoTransition,
    QueueOverCapacity,
    NotSupported,
    TimerNotStarted
}

pub type FsmDispatchResult = FsmResult<()>;

/// Finite State Machine backend. Handles the dispatching, the types are
/// defined by the code generator.
pub trait FsmBackend where Self: Sized + Debug {
    /// The machine's context that is shared between its constructors and actions.
    type Context;
    /// The type that holds the states of the machine.
    type States: FsmStates<Self>;
    /// A tagged union type with all the supported events. This type has to support cloning to facilitate
    /// the dispatch into sub-machines and into multiple regions.
    type Events: AsRef<str> + Clone;
    /// An enum with variants for all the possible timer instances, with support for submachines.
    type Timers: Debug + Clone + PartialEq + AllVariants;

    fn dispatch_event<Q, I, T>(ctx: DispatchContext<Self, Q, I, T>, event: FsmEvent<Self::Events, Self::Timers>) -> FsmDispatchResult
        where Q: FsmEventQueue<Self>, I: Inspect, T: FsmTimers<Self>;
}

/// Enumerates all the possible variants of a simple enum.
pub trait AllVariants where Self: Sized
{
    type Iter: Iterator<Item=Self>;

    fn iter() -> Self::Iter;
}