dispatchers 0.3.0

Message dispatchers
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

use std::collections::HashMap;
use thiserror::Error;

/// Error type for dispatchers
///
/// An error can be raised when sending or receiving a message across thread/coroutines.
#[derive(Error, Debug)]
pub enum DispatcherError {
    /// Error while sending a message
    #[error("error while sending message: {0}")]
    SendError(String),
    /// Error while receiving a message
    #[error("error while receinging message: {0}")]
    RecvError(String),
}

/// A trait for messages that can be dispatched
pub trait MessageType {
    /// Return the message type
    ///
    /// This is used to identify the type of a message and the callbacks to trigger
    fn message_type(&self) -> &str;
}

/// An observer is a type that can handle a message.
///
/// It is a callback that is called when a message is dispatched.
pub trait Observer<M> {
    fn call(&self, message: &M);
}

/// A reference to an observer for the same thread/coroutine
pub type LocalObserverRef<'a, M> = Box<dyn Observer<M> + 'a>;

/// A reference to an observer
pub type ObserverRef<M> = Box<dyn Observer<M> + Send + Sync>;

/// A local dispatcher
///
/// This dispatcher only works on the same thread/coroutine.
/// A dispatcher is a type that can dispatch messages to observers.
/// Observers are registered by message type and a tag.
/// A message can be dispatched to all observers that are registered for the message type.
#[derive(Default)]
pub struct LocalDispatcher<'a, M> {
    handlers: HashMap<String, HashMap<String, LocalObserverRef<'a, M>>>,
}

/// A dispatcher
///
/// A dispatcher is a type that can dispatch messages to observers.
/// Observers are registered by message type and a tag.
/// A message can be dispatched to all observers that are registered for the message type.
#[derive(Default)]
pub struct Dispatcher<M> {
    handlers: HashMap<String, HashMap<String, ObserverRef<M>>>,
}

impl<'a, M> LocalDispatcher<'a, M>
where
    M: MessageType,
{
    pub fn register_handler(
        &mut self,
        message_type: &str,
        observer: LocalObserverRef<'a, M>,
        tag: &str,
    ) {
        match self.handlers.get_mut(message_type) {
            Some(observers) => {
                observers.insert(tag.to_owned(), observer);
            }
            None => {
                let mut observers = HashMap::new();
                observers.insert(tag.to_owned(), observer);
                self.handlers.insert(message_type.to_owned(), observers);
            }
        }
    }

    pub fn unregister_handler(&mut self, message_type: &str, tag: &str) {
        if let Some(observers) = self.handlers.get_mut(message_type) {
            observers.remove(tag);
        }
    }

    /// Dispatch method
    ///
    /// Trigger callbacks for registered observers for the given message type
    pub fn dispatch(&self, message: &M) -> Result<usize, DispatcherError> {
        let message_type = message.message_type();
        if let Some(observers) = self.handlers.get(message_type) {
            for observer in observers.values() {
                observer.call(message);
            }
            return Ok(observers.len());
        }
        Ok(0usize)
    }
}

impl<M> Dispatcher<M>
where
    M: MessageType,
{
    pub fn register_handler(&mut self, message_type: &str, observer: ObserverRef<M>, tag: &str) {
        match self.handlers.get_mut(message_type) {
            Some(observers) => {
                observers.insert(tag.to_owned(), observer);
            }
            None => {
                let mut observers = HashMap::new();
                observers.insert(tag.to_owned(), observer);
                self.handlers.insert(message_type.to_owned(), observers);
            }
        }
    }

    pub fn unregister_handler(&mut self, message_type: &str, tag: &str) {
        if let Some(observers) = self.handlers.get_mut(message_type) {
            observers.remove(tag);
        }
    }

    /// Dispatch method
    ///
    /// Trigger callbacks for registered observers for the given message type
    pub fn dispatch(&self, message: &M) -> Result<usize, DispatcherError> {
        let message_type = message.message_type();
        if let Some(observers) = self.handlers.get(message_type) {
            for observer in observers.values() {
                observer.call(message);
            }
            return Ok(observers.len());
        }
        Ok(0usize)
    }
}