Crate karyon_eventemitter

karyon-eventemitter

A lightweight, asynchronous event emitter for Rust. It provides a flexible pub-sub (publish-subscribe) mechanism, enabling decoupled communication between components via strongly typed events, organized by topics and event types.

This crate is similar to the EventEmitter in Node.js and can also be used as a Message Dispatcher. See the examples for more details.

Example

 use karyon_eventemitter::{EventEmitter, EventTopic, 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 EventTopic 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();

     // ....
  };

Re-exports

pub use eventemitter::AsEventValue;

pub use eventemitter::Event;

pub use eventemitter::EventEmitter;

pub use eventemitter::EventListener;

pub use eventemitter::EventListenerID;

pub use eventemitter::EventTopic;

pub use error::Error;

pub use error::Result;

Modules

error

eventemitter

Derive Macros

EventValue

Derive macro for the AsEventValue trait