edfsm 0.12.0

Event Driven Finite State Machine library
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// Declare our state, commands and events

use edfsm::{impl_fsm, Fsm, Input};

struct Idle;
struct Running;
enum State {
    Idle(Idle),
    Running(Running),
}

struct Start;
struct Stop;
enum Command {
    Start(Start),
    Stop(Stop),
}

struct Started;
struct Stopped;
enum Event {
    Started(Started),
    Stopped(Stopped),
}

// Declare an object to handle effects as we step through the FSM

struct EffectHandlers {
    started: u32,
    stopped: u32,
    transitioned_stopped_to_started: u32,
}

impl EffectHandlers {
    pub fn start_something(&mut self) {
        self.started += 1;
    }

    pub fn stop_something(&mut self) {
        self.stopped += 1;
    }

    pub fn enter_running(&mut self) {
        self.transitioned_stopped_to_started += 1;
    }
}

// Declare the FSM itself

struct MyFsm;

#[impl_fsm]
impl Fsm for MyFsm {
    type S = State;
    type C = Command;
    type E = Event;
    type SE = EffectHandlers;

    state!(Running / entry);

    command!(Idle    => Start => Started => Running);
    command!(Running => Stop  => Stopped => Idle);

    ignore_command!(Idle    => Stop);
    ignore_command!(Running => Start);
}

impl MyFsm {
    fn on_entry_running(_to_s: &Running, se: &mut EffectHandlers) {
        se.enter_running()
    }

    fn for_running_stop(_s: &Running, _c: Stop, se: &mut EffectHandlers) -> Option<Stopped> {
        se.stop_something();
        Some(Stopped)
    }

    fn on_running_stopped(_s: &Running, _e: &Stopped) -> Option<Idle> {
        Some(Idle)
    }

    fn for_idle_start(_s: &Idle, _c: Start, se: &mut EffectHandlers) -> Option<Started> {
        se.start_something();
        Some(Started)
    }

    fn on_idle_started(_s: &Idle, _e: &Started) -> Option<Running> {
        Some(Running)
    }
}

#[test]
fn main() {
    // Initialize our effect handlers

    let mut se = EffectHandlers {
        started: 0,
        stopped: 0,
        transitioned_stopped_to_started: 0,
    };

    // Finally, test the FSM by stepping through various states

    let e = MyFsm::step(
        &mut State::Idle(Idle),
        Input::Command(Command::Start(Start)),
        &mut se,
    );
    assert!(matches!(e, Some(Event::Started(Started))));
    assert_eq!(se.started, 1);
    assert_eq!(se.stopped, 0);
    assert_eq!(se.transitioned_stopped_to_started, 1);

    let e = MyFsm::step(
        &mut State::Running(Running),
        Input::Command(Command::Start(Start)),
        &mut se,
    );
    assert!(e.is_none());
    assert_eq!(se.started, 1);
    assert_eq!(se.stopped, 0);
    assert_eq!(se.transitioned_stopped_to_started, 1);

    let e = MyFsm::step(
        &mut State::Running(Running),
        Input::Command(Command::Stop(Stop)),
        &mut se,
    );
    assert!(matches!(e, Some(Event::Stopped(Stopped))));
    assert_eq!(se.started, 1);
    assert_eq!(se.stopped, 1);
    assert_eq!(se.transitioned_stopped_to_started, 1);

    let e = MyFsm::step(
        &mut State::Idle(Idle),
        Input::Command(Command::Stop(Stop)),
        &mut se,
    );
    assert!(e.is_none());
    assert_eq!(se.started, 1);
    assert_eq!(se.stopped, 1);
    assert_eq!(se.transitioned_stopped_to_started, 1);
}