Struct EventDispatcher 

pub struct EventDispatcher { /* private fields */ }

Global event dispatcher.

The dispatcher maintains a registry of listeners for each event type. When an event is dispatched, all registered listeners are called in priority order.

Implementations

impl EventDispatcher

pub fn new() -> EventDispatcher

Create a new event dispatcher.

pub fn listen<E, L>(&self, listener: L)

where E: Event, L: Listener<E>,

Register a listener for an event type.

Example

use ferro_events::{EventDispatcher, Event, Listener, Error, async_trait};

#[derive(Clone)]
struct MyEvent;
impl Event for MyEvent {
    fn name(&self) -> &'static str { "MyEvent" }
}

struct MyListener;

#[async_trait]
impl Listener<MyEvent> for MyListener {
    async fn handle(&self, _event: &MyEvent) -> Result<(), Error> {
        Ok(())
    }
}

let dispatcher = EventDispatcher::new();
dispatcher.listen(MyListener);

pub fn listen_with_priority<E, L>(&self, listener: L, priority: i32)

where E: Event, L: Listener<E>,

Register a listener with a specific priority.

Higher priority listeners are called first.

pub fn on<E, F, Fut>(&self, handler: F)

where E: Event, F: Fn(E) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), Error>> + Send + 'static,

Register a closure as a listener.

Example

use ferro_events::{EventDispatcher, Event, Error};

#[derive(Clone)]
struct UserCreated { id: i64 }
impl Event for UserCreated {
    fn name(&self) -> &'static str { "UserCreated" }
}

let dispatcher = EventDispatcher::new();
dispatcher.on(|event: UserCreated| async move {
    println!("User {} created", event.id);
    Ok::<(), Error>(())
});

pub async fn dispatch<E>(&self, event: E) -> Result<(), Error>

where E: Event,

Dispatch an event to all registered listeners.

Returns Ok(()) if all listeners succeeded, or the first error encountered.

pub fn dispatch_async<E>(&self, event: E)

where E: Event + 'static,

Dispatch an event without waiting for listeners to complete.

This spawns the event handling as a background task.

pub fn has_listeners<E>(&self) -> bool

where E: Event,

Check if any listeners are registered for an event type.

pub fn forget<E>(&self)

where E: Event,

Remove all listeners for an event type.

pub fn flush(&self)

Remove all listeners.

Trait Implementations

impl Default for EventDispatcher

fn default() -> EventDispatcher

Returns the “default value” for a type.