armature 0.1.1

An event-driven stateful actor framework for Rust.
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

#[cfg(test)]
mod tests {

use std::sync::Arc;
use async_std::task::block_on;
use armature::{Commutator, Store};

extern crate armature_macro;
use armature_macro::{event, stator};

#[event]
pub enum Event {
    PositionUpdate(Arc<Position>)
}

#[derive(Default, Debug, Clone)]
pub struct Position {
    x: isize,
    y: isize
}

#[stator]
pub mod joystick {

    use super::*;

    #[stator_struct]
    #[derive(Clone, Default, Debug)]
    pub struct Joystick {
        #[sender]
        pub position: Store<Position, Event>,
    }

    #[stator_states]
    impl Joystick {

        const INIT: State<Self, Event> = Self::read;

        fn read(&mut self, event: &Event) -> Response<Self, Event> {
            match event {
                Event::OnEntry => {
                    let position = Position {
                        x: 11,
                        y: -54
                    };
                    self.position.mutate(position);
                    self.publish(Event::Detach(self.get_id().unwrap()));
                    Response::Handled
                }
                _ => Response::Handled
            }
        }
    }

    #[stator_lifecycle]
    impl Joystick {

        fn on_attach(&mut self) {
            self.position.on_mutate = |this| {
                this.publish(Event::PositionUpdate(Arc::new(this.value.clone())))
            }
        }
    }
}

#[stator]
pub mod cursor {

    use armature::Response;

    use super::*;

    #[stator_struct]
    #[derive(Clone, Default, Debug)]
    pub struct Cursor {
        pub position: Arc<Position>
    }

    #[stator_states]
    impl Cursor {

        const INIT: State<Self, Event> = Self::draw;

        fn draw(&mut self, event: &Event) -> Response<Self, Event> {
            match event {
                Event::PositionUpdate(position) => {
                    self.position = Arc::clone(position);
                    println!("{:#?}", &self.position);
                    self.publish(Event::Detach(self.get_id().unwrap()));
                    Response::Handled
                }
                _ => Response::Handled
            }
        }
    }
}

#[test]
fn store_mutation() {

    let joystick = joystick::Joystick::default();
    let cursor = cursor::Cursor::default();

    let mut commutator = Commutator::new();

    commutator.attach(Box::new(joystick));
    commutator.attach(Box::new(cursor));

    let timeout = std::time::Duration::from_millis(1000);

    assert!(block_on(async_std::future::timeout(timeout, commutator.run())).is_ok());
    assert!(commutator.drain().len() == 0);
}

}