use std::panic::{AssertUnwindSafe, catch_unwind};
use crate::events::event::ObjectEvent;
use crate::events::event_type::EventType;
use crate::events::subscription::SubscriptionId;
pub(crate) struct Listener {
id: SubscriptionId,
filter: Option<EventType>,
callback: Box<dyn FnMut(&ObjectEvent) + Send + Sync>,
}
impl Listener {
fn matches(&self, event_type: EventType) -> bool {
self.filter.is_none_or(|filter| filter == event_type)
}
pub(crate) fn run(&mut self, event: &ObjectEvent) {
if self.matches(event.event_type) {
(self.callback)(event);
}
}
}
pub(crate) fn run_listeners(listeners: &mut Vec<Listener>, event: &ObjectEvent) {
let mut index = 0;
while index < listeners.len() {
let result = catch_unwind(AssertUnwindSafe(|| listeners[index].run(event)));
if result.is_err() {
listeners.remove(index);
} else {
index += 1;
}
}
}
pub struct EventBus {
next_id: usize,
listeners: Vec<Listener>,
detached: bool,
pending_removals: Vec<SubscriptionId>,
}
impl Default for EventBus {
fn default() -> Self {
Self {
next_id: 1,
listeners: Vec::new(),
detached: false,
pending_removals: Vec::new(),
}
}
}
impl EventBus {
pub fn new() -> Self {
Self::default()
}
pub fn subscribe(
&mut self,
filter: impl Into<Option<EventType>>,
callback: impl FnMut(&ObjectEvent) + Send + Sync + 'static,
) -> SubscriptionId {
let id = SubscriptionId::new(self.next_id);
self.next_id = self.next_id.saturating_add(1);
self.listeners.push(Listener {
id,
filter: filter.into(),
callback: Box::new(callback),
});
id
}
pub fn unsubscribe(&mut self, id: SubscriptionId) {
if self.detached {
self.pending_removals.push(id);
return;
}
self.listeners.retain(|listener| listener.id != id);
}
pub fn dispatch(&mut self, event: &ObjectEvent) {
let mut current = std::mem::take(&mut self.listeners);
run_listeners(&mut current, event);
self.listeners.extend(current);
}
pub(crate) fn detach_listeners(&mut self) -> Vec<Listener> {
self.detached = true;
std::mem::take(&mut self.listeners)
}
pub(crate) fn reattach_listeners(&mut self, listeners: Vec<Listener>) {
let mut batch = listeners;
for id in self.pending_removals.drain(..) {
batch.retain(|listener| listener.id != id);
}
let mut ordered = batch;
ordered.append(&mut self.listeners);
self.listeners = ordered;
self.detached = false;
}
pub fn listener_count(&self) -> usize {
self.listeners.len()
}
}