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

use std::fmt::Debug;
use std::collections::HashSet;

use crate::event::*;
use crate::sender::*;

pub trait Handler: Sender + Send + Debug {
    type Sig: IsSig<Sig = Self::Sig> + Debug;

    /// Get a mutable reference to the event handler component.
    fn get_handler_component_mut(&mut self) -> &mut HandlerComponent<Self::Sig>;

    /// Get a immutable reference to the event handler component.
    fn get_handler_component(&self) -> &HandlerComponent<Self::Sig>;

    /// Lifecycle method that is called when the event handler is attached
    /// to the commutator.
    fn on_attach(&mut self) {}

    /// Lifecycle method that is called when the event handler is detached from
    /// the commutator.
    fn on_detach(&mut self) {}

    /// Init method that is called when the commutator starts running, or if
    /// the commutator is already running right when the event handler is attached.
    fn init(&mut self) {}

    /// Handle event
    fn handle(&mut self, _event: &Self::Event) {}

    /// Get the initial subscriptions of the event handler.
    fn get_init_subscriptions(&self) -> Vec<Self::Sig> {
        Vec::new()
    }

    /// Get the id of the event handler.
    fn get_id(&self) -> Option<usize> {
        self.get_handler_component().id
    }

    /// Set the id of the event handler.
    fn set_id(&mut self, id: usize) {
        self.get_handler_component_mut().id = Some(id);
    }

    /// Set the subscriptions of the event handler.
    fn set_subscriptions(&mut self, subscriptions: Vec<Self::Sig>) {
        for sig in subscriptions {
            self.get_handler_component_mut().subscriptions.insert(sig);
        }  
    }

    /// Attach event senders to the event handler. As a result, calling 
    /// `post_to_self()` from the event sender will send the event only to
    /// this event handler.
    fn attach(&self, sender: &mut dyn Sender<Event = Self::Event>) {
        let id = self.get_id().expect(
            "Event sender itself must be attached in order to attach event senders to it.");
        sender.set_sender(self.get_sender().clone());
        sender.set_associated_handler_id(id);
    }

}

#[derive(Debug)]
pub struct HandlerComponent<S>
where
S: IsSig<Sig = S> {
    id: Option<usize>,
    subscriptions: HashSet<S>
}

impl<S> Default for HandlerComponent<S>
where
S: IsSig<Sig = S> {

    fn default() -> Self {
        Self {
            id: None,
            subscriptions: HashSet::new()
        }
    }

}

impl<S> Clone for HandlerComponent<S>
where
S: IsSig<Sig = S> {

    fn clone(&self) -> Self {
        Self {
            id: None,
            subscriptions: self.subscriptions.clone()
        }
    }

}