Struct EventEmitter

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

EventEmitter emits events to registered listeners based on topics.

Example

use karyon_core::event::{EventEmitter, EventValueTopic, EventValue};

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

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

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

   impl EventValue for A {
        fn id() -> &'static str {
            "A"
        }
    }

    let listener = event_emitter.register::<A>(&Topic::TopicA).await;

    event_emitter.emit_by_topic(&Topic::TopicA, &A(3)) .await;
    let msg: A = listener.recv().await.unwrap();

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

    impl EventValue for B {
        fn id() -> &'static str {
            "B"
        }
    }

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

    let listener = event_emitter.register::<B>(&Topic::TopicB).await;

    event_emitter.emit(&B(3)) .await;
    let msg: B = 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: EventValueTopic<Topic = T> + Clone>( &self, value: &E, ) -> Result<()>

Emits an event to the listeners.

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

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

Emits an event to the listeners.

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

Registers a new event listener for the given topic.

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

Remove all topics and event listeners

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

Unregisters all event listeners for the given topic.

async fn remove(&self, topic: &T, event_id: &str, listener_id: &EventListenerID)

Removes the event listener attached to the given topic.