statechart 0.0.8

statecharts: hierarchical, reactive state machines
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

#[cfg(test)]

use std::rc::Rc;

extern crate env_logger;
extern crate statechart;
use statechart::*;

#[test]
fn pingpong() {
    let _ = env_logger::init();
    let sc = states!{ root {
        initial_label: Some("init".to_string()),
        substates: [
            state!{ init {
                on_entry: [
                    action_assign!(key: "i", value: Value::Int(0)),
                    action_raise!(topic: "ping", contents: Value::Int(1))],
                transitions: [goto!(target: ping)]}},
            state!{ ping {
                transitions: [
                    goto!(target: pong, topics: ["ping"],
                        cond: cond_fn!(|it: &Interpreter| {
                            match it.get_var("i") {
                                Some(&Value::Int(i)) => i < 10,
                                _ => false,
                            }}),
                        actions: [
                            action_raise!(topic: "pong"),
                            action_fn!(Rc::new(|it: &mut Interpreter| {
                                let i = match it.get_var("i") {
                                    Some(&Value::Int(i)) => i,
                                    _ => return Err(Fault::ActionError(
                                        "i: invalid or uninitialized value".to_string())),
                                };
                                it.set_var("i", Value::Int(i+1));
                                Ok(())
                            }))]),
                    goto!(target: end,
                        cond: cond_fn!(|it: &Interpreter| {
                            match it.get_var("i") {
                                Some(&Value::Int(i)) => i >= 10,
                                _ => false,
                            }
                        })),
                ],
                on_entry: [action_log!(message: "ping!")],
            }},
            state!{ pong {
                transitions: [goto!(target: ping, topics: ["pong"],
                                actions: [action_raise!(topic: "ping")])],
                on_entry: [action_log!(message: "pong!")],
            }},
            final_state!{ end {
                result: Output::ValueOf(ValueOfBuilder::default().key("i").build().unwrap()),
            }},
        ]}};
    let ctx = Context::new(sc);
    let mut it = Interpreter::new();
    let result = it.run(&ctx);
    assert!(result.is_ok(), "fault: {:?}", result.err().unwrap());
    assert_eq!(result.unwrap(), Value::Int(10));
}