statig 0.4.1

Hierarchical state machines for designing event-driven systems
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

#[cfg(test)]
#[cfg(feature = "async")]
#[allow(unused)]
mod tests {

    use statig::prelude::*;

    enum Event {
        Tick,
    }

    #[derive(Default)]
    struct FooBar {
        before_dispatch: bool,
        after_dispatch: bool,
        before_transition: bool,
        after_transition: bool,
    }

    #[state_machine(
        initial = "State::foo()",
        before_dispatch = "Self::before_dispatch",
        after_dispatch = "Self::after_dispatch",
        before_transition = "Self::before_transition",
        after_transition = "Self::after_transition"
    )]
    impl FooBar {
        #[state]
        async fn foo(event: &Event) -> Outcome<State> {
            Transition(State::bar())
        }

        #[state]
        async fn bar(event: &Event) -> Outcome<State> {
            Transition(State::foo())
        }
    }

    impl FooBar {
        async fn before_dispatch(
            &mut self,
            state_or_superstate: StateOrSuperstate<'_, State, Superstate>,
            event: &Event,
        ) {
            self.before_dispatch = true;
        }

        async fn after_dispatch(
            &mut self,
            state_or_superstate: StateOrSuperstate<'_, State, Superstate>,
            event: &Event,
            _context: &mut (),
        ) {
            self.after_dispatch = true;
        }

        async fn before_transition(&mut self, source: &State, target: &State) {
            self.before_transition = true;
        }

        async fn after_transition(&mut self, source: &State, target: &State, _context: &mut ()) {
            self.after_transition = true;
        }
    }

    #[test]
    fn async_hooks() {
        let mut foo_bar = FooBar::default().state_machine();

        futures::executor::block_on(async {
            foo_bar.handle(&Event::Tick).await;
        });

        assert_eq!(foo_bar.inner().before_dispatch, true);
        assert_eq!(foo_bar.inner().after_dispatch, true);
        assert_eq!(foo_bar.inner().before_transition, true);
        assert_eq!(foo_bar.inner().after_transition, true);
    }
}