hyperlane_broadcast/broadcast_map/
impl.rs

1use crate::*;
2
3impl<T: Clone + Debug> BroadcastMapTrait for T {}
4
5impl<T: BroadcastMapTrait> Default for BroadcastMap<T> {
6    fn default() -> Self {
7        Self(DashMap::new())
8    }
9}
10
11impl<T: BroadcastMapTrait> BroadcastMap<T> {
12    pub fn new() -> Self {
13        Self::default()
14    }
15
16    fn get(&self) -> &DashMapStringBroadcast<T> {
17        &self.0
18    }
19
20    pub fn insert<K>(&self, key: K, capacity: Capacity) -> OptionBroadcast<T>
21    where
22        K: ToString,
23    {
24        let key_string: String = key.to_string();
25        let broadcast: Broadcast<T> = Broadcast::new(capacity);
26        self.get().insert(key_string, broadcast)
27    }
28
29    pub fn receiver_count<K>(&self, key: K) -> OptionReceiverCount
30    where
31        K: ToString,
32    {
33        self.get()
34            .get(&key.to_string())
35            .map(|receiver| receiver.receiver_count())
36    }
37
38    pub fn subscribe<K>(&self, key: K) -> OptionBroadcastMapReceiver<T>
39    where
40        K: ToString,
41    {
42        self.get()
43            .get(&key.to_string())
44            .map(|receiver| receiver.subscribe())
45    }
46
47    pub fn subscribe_or_insert<K>(&self, key: K, capacity: Capacity) -> BroadcastMapReceiver<T>
48    where
49        K: ToString,
50    {
51        let key_string: String = key.to_string();
52        match self.get().get(&key_string) {
53            Some(sender) => sender.subscribe(),
54            None => {
55                self.insert(key, capacity);
56                self.subscribe_or_insert(key_string, capacity)
57            }
58        }
59    }
60
61    pub fn send<K: ToString>(&self, key: K, data: T) -> BroadcastMapSendResult<T>
62    where
63        K: ToString,
64    {
65        match self.get().get(&key.to_string()) {
66            Some(sender) => sender.send(data).map(|result| Some(result)),
67            None => Ok(None),
68        }
69    }
70}