1use std::collections::HashMap;
4use std::fmt;
5use std::future::Future;
6use std::sync::Arc;
7
8use futures_util::FutureExt;
9use futures_util::future::BoxFuture;
10
11use crate::Client;
12
13pub(crate) type BoxHandler<A> = Arc<dyn Fn(A, Client) -> BoxFuture<'static, ()> + Send + Sync>;
15
16pub trait Handler<A, M>: Send + Sync + 'static {
26 #[doc(hidden)]
27 fn into_boxed(self) -> BoxHandler<A>;
28}
29
30#[doc(hidden)]
31#[derive(Debug)]
32pub enum AsyncHandler {}
33#[doc(hidden)]
34#[derive(Debug)]
35pub enum SyncHandler {}
36
37impl<A, F, Fut> Handler<A, (AsyncHandler, Fut)> for F
38where
39 A: Send + 'static,
40 F: Fn(A, Client) -> Fut + Send + Sync + 'static,
41 Fut: Future<Output = ()> + Send + 'static,
42{
43 fn into_boxed(self) -> BoxHandler<A> {
44 Arc::new(move |arg, client| self(arg, client).boxed())
45 }
46}
47
48impl<A, F> Handler<A, SyncHandler> for F
49where
50 A: Send + 'static,
51 F: Fn(A, Client) + Send + Sync + 'static,
52{
53 fn into_boxed(self) -> BoxHandler<A> {
54 let f = Arc::new(self);
55 Arc::new(move |arg, client: Client| {
56 let f = Arc::clone(&f);
57 async move {
58 let key = client.key();
59 let result = tokio::task::spawn_blocking(move || {
60 struct Reset;
62 impl Drop for Reset {
63 fn drop(&mut self) {
64 crate::client::IN_HANDLER_THREAD.with(|k| k.set(0));
65 }
66 }
67 crate::client::IN_HANDLER_THREAD.with(|k| k.set(key));
68 let _reset = Reset;
69 f(arg, client);
70 })
71 .await;
72 if let Err(err) = result {
73 if err.is_panic() {
74 tracing::error!("an event handler panicked");
75 }
76 }
77 }
78 .boxed()
79 })
80 }
81}
82
83#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
85pub struct ListenerId(u64);
86
87struct Entry<A> {
88 id: ListenerId,
89 handler: BoxHandler<A>,
90 once: bool,
91}
92
93impl<A> Clone for Entry<A> {
94 fn clone(&self) -> Self {
95 Entry {
96 id: self.id,
97 handler: Arc::clone(&self.handler),
98 once: self.once,
99 }
100 }
101}
102
103pub(crate) struct Handlers {
105 next_id: u64,
106 events: HashMap<String, Vec<Entry<crate::Event>>>,
107 any: Vec<Entry<crate::Event>>,
108 state: Vec<Entry<crate::ConnectionState>>,
109}
110
111impl fmt::Debug for Handlers {
112 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
113 f.debug_struct("Handlers")
114 .field("events", &self.events.keys().collect::<Vec<_>>())
115 .field("any", &self.any.len())
116 .field("state", &self.state.len())
117 .finish()
118 }
119}
120
121impl Default for Handlers {
122 fn default() -> Self {
123 Handlers {
124 next_id: 1,
125 events: HashMap::new(),
126 any: Vec::new(),
127 state: Vec::new(),
128 }
129 }
130}
131
132impl Handlers {
133 fn id(&mut self) -> ListenerId {
134 self.next_id += 1;
135 ListenerId(self.next_id)
136 }
137
138 pub(crate) fn on(
139 &mut self,
140 event: String,
141 handler: BoxHandler<crate::Event>,
142 once: bool,
143 ) -> ListenerId {
144 let id = self.id();
145 self.events
146 .entry(event)
147 .or_default()
148 .push(Entry { id, handler, once });
149 id
150 }
151
152 pub(crate) fn on_any(&mut self, handler: BoxHandler<crate::Event>) -> ListenerId {
153 let id = self.id();
154 self.any.push(Entry {
155 id,
156 handler,
157 once: false,
158 });
159 id
160 }
161
162 pub(crate) fn on_state(&mut self, handler: BoxHandler<crate::ConnectionState>) -> ListenerId {
163 let id = self.id();
164 self.state.push(Entry {
165 id,
166 handler,
167 once: false,
168 });
169 id
170 }
171
172 pub(crate) fn off(&mut self, event: &str) -> usize {
174 self.events.remove(event).map_or(0, |v| v.len())
175 }
176
177 pub(crate) fn off_any(&mut self) -> usize {
178 std::mem::take(&mut self.any).len()
179 }
180
181 pub(crate) fn off_listener(&mut self, id: ListenerId) -> bool {
182 let mut removed = false;
183 for list in self.events.values_mut() {
184 let before = list.len();
185 list.retain(|e| e.id != id);
186 removed |= list.len() != before;
187 }
188 self.events.retain(|_, list| !list.is_empty());
189 let before = self.any.len();
190 self.any.retain(|e| e.id != id);
191 removed |= self.any.len() != before;
192 let before = self.state.len();
193 self.state.retain(|e| e.id != id);
194 removed | (self.state.len() != before)
195 }
196
197 pub(crate) fn listener_count(&self, event: &str) -> usize {
198 self.events.get(event).map_or(0, Vec::len)
199 }
200
201 pub(crate) fn take_for_event(&mut self, event: &str) -> Vec<BoxHandler<crate::Event>> {
204 let mut out: Vec<_> = self.any.iter().map(|e| Arc::clone(&e.handler)).collect();
205 if let Some(list) = self.events.get_mut(event) {
206 out.extend(list.iter().map(|e| Arc::clone(&e.handler)));
207 list.retain(|e| !e.once);
208 if list.is_empty() {
209 self.events.remove(event);
210 }
211 }
212 out
213 }
214
215 pub(crate) fn state_handlers(&self) -> Vec<BoxHandler<crate::ConnectionState>> {
216 self.state.iter().map(|e| Arc::clone(&e.handler)).collect()
217 }
218}