finite-state-machine 0.2.0

A type and trait based finite state machine macro
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#![no_std]
pub use paste::paste;
#[macro_export]
macro_rules! state_machine {
    (
        $name:ident($data:ident$(<$($lt:lifetime),*>)?);
        $(
            $state_name:ident {
                $($event:ident => $possible_target_state:ident),*
            }
        ),*
    ) => {
        $crate::paste!{
        mod [<$name:snake>] {
            use super::*;
            #[derive(Debug, Default)]
            pub enum State {
                #[default]
            $(
                $state_name,
            )*
                Invalid(&'static str),
                End
            }
            #[cfg_attr(feature = "verbose", derive(Debug))]
            #[cfg_attr(feature = "derive_default", derive(Default))]
            pub struct $name$(<$($lt),*>)? {
                pub state: State,
                pub data: $data$(<$($lt),*>)?,
            }
            enum Events {
            $(
                $([<$state_name $event>],)*
            )*
            }

            $(
                pub enum [<$state_name Events>] {
                    $($event,)*
                    Illegal(&'static str)
                }
            )*
            pub trait Deciders {
            $(
                fn [<$state_name:snake>](&self) -> [<$state_name Events>];
            )*
            }
            $(
                pub trait [<$state_name Transitions>] {
                    $(fn [<$event:snake>](&mut self) -> Result<(),&'static str>;)*
                    fn illegal(&mut self);
                }
            )*
            impl$(<$($lt),*>)? $name$(<$($lt),*>)? {
                pub fn run_to_end(&mut self) -> Result<(), &'static str> {
                    loop {
                        #[cfg(feature = "verbose")]
                        println!("Debug: {:?}", self.data);
                        match &self.state {
                            $(State::$state_name => match self.[<$state_name:snake>]() {
                                $([<$state_name Events>]::$event => {
                                    match [<$state_name Transitions>]::[<$event:snake>](self) {
                                        Ok(_) => {
                                            #[cfg(feature = "verbose")]
                                            println!("{} + {} -> {}", stringify!($state_name), stringify!($event), stringify!($possible_target_state));
                                            self.state = State::$possible_target_state
                                        },
                                        Err(message) => {
                                            #[cfg(feature = "verbose")]
                                            println!("{} + {} + error({}) -> {}", stringify!($state_name), stringify!($event), message, stringify!(Invalid));
                                            self.state = State::Invalid(message)
                                        }
                                    }

                                },)*
                                [<$state_name Events>]::Illegal(message) => {
                                    [<$state_name Transitions>]::illegal(self);
                                    #[cfg(feature = "verbose")]
                                    println!("{} + illegal -> invalid({})", stringify!($state_name), stringify!(message));
                                    self.state = State::Invalid(message);
                                }
                            } ,)*
                            State::End => return Ok(()),
                            State::Invalid(message) => return Err(message),
                        };
                    };
                }
            }
        }
        }
    };
}