Struct EventEmitter

pub struct EventEmitter<T> {
    listeners: Mutex<HashMap<T, HashMap<String, HashMap<EventListenerID, Sender<Event>>>>>,
    listener_buffer_size: usize,
}

EventEmitter asynchronous event emitter.

Allows components to communicate through events organized by topics.

Example

use karyon_eventemitter::{EventEmitter, AsEventTopic, EventValue};

 async {
    let event_emitter = EventEmitter::new();

    #[derive(Hash, PartialEq, Eq, Debug, Clone)]
    enum Topic {
        TopicA,
        TopicB,
    }

    #[derive(Clone, Debug, PartialEq, EventValue)]
    struct A(usize);

    #[derive(Clone, Debug, PartialEq, EventValue)]
    struct B(usize);

    impl AsEventTopic for B {
        type Topic = Topic;
        fn topic() -> Self::Topic{
            Topic::TopicB
        }
    }

    #[derive(Clone, Debug, PartialEq, EventValue)]
    struct C(usize);

    let a_listener = event_emitter.register::<A>(&Topic::TopicA);
    let b_listener = event_emitter.register::<B>(&Topic::TopicB);
    // This also listens to Topic B
    let c_listener = event_emitter.register::<C>(&Topic::TopicB);

    event_emitter.emit_by_topic(&Topic::TopicA, &A(3)) .await;
    event_emitter.emit(&B(3)) .await;
    event_emitter.emit_by_topic(&Topic::TopicB, &C(3)) .await;

    let msg: A = a_listener.recv().await.unwrap();
    let msg: B = b_listener.recv().await.unwrap();
    let msg: C = c_listener.recv().await.unwrap();

    // ....
 };

Fields

listeners: Mutex<HashMap<T, HashMap<String, HashMap<EventListenerID, Sender<Event>>>>>

listener_buffer_size: usize

Implementations

impl<T> EventEmitter<T>

where T: Hash + Eq + Debug + Clone,

pub fn new() -> Arc<EventEmitter<T>>

Creates a new EventEmitter

pub fn with_buffer_size(size: usize) -> Arc<EventEmitter<T>>

Creates a new EventEmitter with the provided buffer size for the EventListener channel.

This is important to control the memory used by the listener channel. If the consumer for the event listener can’t keep up with the new events coming, then the channel buffer will fill with new events, and if the buffer is full, the emit function will block until the listener starts to consume the buffered events.

If size is zero, this function will panic.

pub async fn emit<E: AsEventTopic<Topic = T> + Clone>( &self, value: &E, ) -> Result<()>

Emits an event to the listeners.

The event must implement the AsEventTopic trait to indicate the topic of the event. Otherwise, you can use emit_by_topic().

pub async fn emit_by_topic<E: AsEventValue + Clone>( &self, topic: &T, value: &E, ) -> Result<()>

Emits an event to the listeners.

pub fn register<E: AsEventValue + Clone>( self: &Arc<Self>, topic: &T, ) -> EventListener<T, E>

Registers a new event listener for the given topic.

pub fn clear(self: &Arc<Self>)

Removes all topics and event listeners.

This effectively resets the EventEmitter to its initial state.

pub fn unregister_topic(self: &Arc<Self>, topic: &T)

Unregisters all event listeners for the given topic.

async fn send<E: AsEventValue + Clone>( &self, topic: &T, value: &E, ) -> Result<FuturesUnordered<impl Future<Output = (EventListenerID, Result<(), SendError<Event>>)> + use<'_, T, E>>>

Internal method that handles the actual sending of events to listeners.

fn remove(&self, topic: &T, event_id: &str, listener_ids: &[EventListenerID])

Internal method to remove the event listener attached to the given topic.