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| {
56 let f = Arc::clone(&f);
57 async move {
58 let result = tokio::task::spawn_blocking(move || {
59 struct Reset;
61 impl Drop for Reset {
62 fn drop(&mut self) {
63 crate::client::IN_HANDLER_THREAD.with(|flag| flag.set(false));
64 }
65 }
66 crate::client::IN_HANDLER_THREAD.with(|flag| flag.set(true));
67 let _reset = Reset;
68 f(arg, client);
69 })
70 .await;
71 if let Err(err) = result {
72 if err.is_panic() {
73 tracing::error!("an event handler panicked");
74 }
75 }
76 }
77 .boxed()
78 })
79 }
80}
81
82#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
84pub struct ListenerId(u64);
85
86struct Entry<A> {
87 id: ListenerId,
88 handler: BoxHandler<A>,
89 once: bool,
90}
91
92impl<A> Clone for Entry<A> {
93 fn clone(&self) -> Self {
94 Entry {
95 id: self.id,
96 handler: Arc::clone(&self.handler),
97 once: self.once,
98 }
99 }
100}
101
102pub(crate) struct Handlers {
104 next_id: u64,
105 events: HashMap<String, Vec<Entry<crate::Event>>>,
106 any: Vec<Entry<crate::Event>>,
107 state: Vec<Entry<crate::ConnectionState>>,
108}
109
110impl fmt::Debug for Handlers {
111 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
112 f.debug_struct("Handlers")
113 .field("events", &self.events.keys().collect::<Vec<_>>())
114 .field("any", &self.any.len())
115 .field("state", &self.state.len())
116 .finish()
117 }
118}
119
120impl Default for Handlers {
121 fn default() -> Self {
122 Handlers {
123 next_id: 1,
124 events: HashMap::new(),
125 any: Vec::new(),
126 state: Vec::new(),
127 }
128 }
129}
130
131impl Handlers {
132 fn id(&mut self) -> ListenerId {
133 self.next_id += 1;
134 ListenerId(self.next_id)
135 }
136
137 pub(crate) fn on(
138 &mut self,
139 event: String,
140 handler: BoxHandler<crate::Event>,
141 once: bool,
142 ) -> ListenerId {
143 let id = self.id();
144 self.events
145 .entry(event)
146 .or_default()
147 .push(Entry { id, handler, once });
148 id
149 }
150
151 pub(crate) fn on_any(&mut self, handler: BoxHandler<crate::Event>) -> ListenerId {
152 let id = self.id();
153 self.any.push(Entry {
154 id,
155 handler,
156 once: false,
157 });
158 id
159 }
160
161 pub(crate) fn on_state(&mut self, handler: BoxHandler<crate::ConnectionState>) -> ListenerId {
162 let id = self.id();
163 self.state.push(Entry {
164 id,
165 handler,
166 once: false,
167 });
168 id
169 }
170
171 pub(crate) fn off(&mut self, event: &str) -> usize {
173 self.events.remove(event).map_or(0, |v| v.len())
174 }
175
176 pub(crate) fn off_any(&mut self) -> usize {
177 std::mem::take(&mut self.any).len()
178 }
179
180 pub(crate) fn off_listener(&mut self, id: ListenerId) -> bool {
181 let mut removed = false;
182 for list in self.events.values_mut() {
183 let before = list.len();
184 list.retain(|e| e.id != id);
185 removed |= list.len() != before;
186 }
187 self.events.retain(|_, list| !list.is_empty());
188 let before = self.any.len();
189 self.any.retain(|e| e.id != id);
190 removed |= self.any.len() != before;
191 let before = self.state.len();
192 self.state.retain(|e| e.id != id);
193 removed | (self.state.len() != before)
194 }
195
196 pub(crate) fn listener_count(&self, event: &str) -> usize {
197 self.events.get(event).map_or(0, Vec::len)
198 }
199
200 pub(crate) fn take_for_event(&mut self, event: &str) -> Vec<BoxHandler<crate::Event>> {
203 let mut out: Vec<_> = self.any.iter().map(|e| Arc::clone(&e.handler)).collect();
204 if let Some(list) = self.events.get_mut(event) {
205 out.extend(list.iter().map(|e| Arc::clone(&e.handler)));
206 list.retain(|e| !e.once);
207 if list.is_empty() {
208 self.events.remove(event);
209 }
210 }
211 out
212 }
213
214 pub(crate) fn state_handlers(&self) -> Vec<BoxHandler<crate::ConnectionState>> {
215 self.state.iter().map(|e| Arc::clone(&e.handler)).collect()
216 }
217}