moku 0.4.0

A library for creating hierarchical state machines (HSM)
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

use std::collections::VecDeque;

use hunter::*;
use moku::*;

#[state_machine]
mod hunter {
    use moku::*;

    #[machine_module]
    mod machine {}
    pub use machine::*;

    pub enum Event {
        StomachGrumbled,
        PreyCaught,
        MeatCooked,
    }

    impl StateMachineEvent for Event {}

    pub struct Top;

    impl TopState for Top {
        fn handle_event(&mut self, event: &Self::Event) -> impl Into<Next<Self::State>> {
            match event {
                Event::StomachGrumbled => Next::Target(State::Hunting),
                Event::PreyCaught => Next::Target(State::Cooking),
                _ => Next::None,
            }
        }
    }

    struct Hunting;

    impl Substate<Top> for Hunting {
        // by default, states will defer all events
    }

    struct Cooking;

    impl Substate<Top> for Cooking {
        fn handle_event(
            &mut self,
            _ctx: &mut Self::Context<'_>,
            event: &Self::Event,
        ) -> impl Into<Response<Self::State>> {
            match event {
                Event::MeatCooked => Response::Next(Next::Target(State::Top)),
                // ignore Top state's logic to start hunting when stomach grumbles
                Event::StomachGrumbled => Response::Drop,
                // defer other events to superstates
                _ => Response::Next(Next::None),
            }
        }
    }
}

fn main() {
    let mut machine = Builder::new(Top).build();
    let mut events = VecDeque::new();

    // generate events
    events.push_back(Event::StomachGrumbled);
    events.push_back(Event::PreyCaught);
    events.push_back(Event::MeatCooked);

    for event in events {
        machine.handle_event(&event);
    }
}