gears 0.1.7

Gears core implementation
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

use std::collections::HashMap;

use crate::runtime::actiondispatch::dispatchable::Dispatchable;
use crate::structure::xflow::{XFlowNode, XFlowNodeType};
use super::xfstate::XFState;

type Receivers<'a> = HashMap<XFlowNodeType, Box<Dispatchable + 'a>>;

pub struct Dispatcher<'a> {
    receivers: Receivers<'a>,
}

impl<'a> Dispatcher<'a> {
    pub fn register_receiver<T: Dispatchable + 'a>(
        &mut self,
        xflow_node_type: XFlowNodeType,
        receiver: T,
    ) -> () {
        let receiver_box = Box::new(receiver);
        self.receivers.insert(
            xflow_node_type.to_owned(),
            receiver_box,
        );
    }

    pub fn dispatch(&self, xfnode: &XFlowNode, xfstate: &mut XFState) -> Result<(), String> {
        debug!("Nodetype {:?}, action {}", xfnode.nodetype, xfnode.action);

        if let Some(receiver) = self.receivers.get(&xfnode.nodetype) {
            match receiver.dispatch(xfnode, xfstate) {
                Ok(()) => Ok(()),
                Err(()) => {
                    let msg = "An error has occurred dispatching, but this is currently not handled".to_owned();
                    error!("{}", msg);
                    Err(msg)
                }
            }
        } else {
            let msg = format!(
                "No dispatcher found for {:?}/{}!",
                xfnode.nodetype,
                xfnode.action
            );
            error!("{}", msg);
            Err(msg)
        }

    }
}

impl<'a> Default for Dispatcher<'a> {
    fn default() -> Dispatcher<'a> {
        let receivers: Receivers = HashMap::new();

        Dispatcher { receivers: receivers }
    }
}