Struct EventEmitter

Source

pub struct EventEmitter { /* private fields */ }

Expand description

The EventEmitter struct is the core of the event handling system. It allows registration of event handlers and emits events to these handlers.

§Examples

use async_events_emitter::{EventEmitter, Event, EventHandler};
use async_trait::async_trait;
 
#[derive(Debug, Clone)]
pub struct MyCustomEvent;

#[derive(Debug, Clone)]
pub struct MyEventHandler;
 
impl Event for MyCustomEvent {};

#[async_trait]
impl EventHandler<MyCustomEvent> for MyEventHandler {
    async fn handle_event(&mut self, event: MyCustomEvent) {
        // Handle event data here..
        println!("{:?}", event)
    }
}
 
// Create a new EventEmitter
let mut event_emitter = EventEmitter::new();
let my_event_handler = MyEventHandler;

// Register event handlers
event_emitter.on::<MyCustomEvent>(my_event_handler);

// Emit an event
event_emitter.emit(MyCustomEvent);

Implementations§

Source §

impl EventEmitter

Source

pub fn new() -> Self

Creates a new instance of the EventEmitter.

This function initializes the EventEmitter with empty event handlers. It’s ideal for starting an event-driven application where you’ll be adding handlers dynamically.

Source

pub fn with_capacity(capacity: usize) -> Self

Creates a new instance of the EventEmitter with a specified capacity.

This variant of the constructor allows you to specify an initial capacity for event listeners, which can be useful for performance optimization in scenarios where a large number of listeners are expected.

§Arguments

capacity: The initial capacity for storing event listeners.

§Examples

let mut event_emitter = EventEmitter::with_capacity(100);

Source

pub fn on<E: Event + 'static>( &mut self, handler: impl EventHandler<E> + 'static, ) -> ListenerId

Registers a handler for a specific event type.

The on method allows you to register a handler that will be called every time an event of a specific type is emitted. This is useful for setting up listeners that should persist and handle all occurrences of an event.

§Type Parameters

E: The type of the event to listen for. This type must implement the Event trait.

§Arguments

handler: An implementation of the EventHandler trait. This handler will be called for every emitted event of type E.

§Returns

Returns a ListenerId which can be used to remove the listener at a later time with the off method.

§Examples

use async_events_emitter::*;
 
#[derive(Debug, Clone)]
struct MyCustomEvent;
 
let mut event_emitter = EventEmitter::new();
event_emitter.on::<MyCustomEvent>(my_event_handler);

Source

pub fn once<E: Event + 'static>( &mut self, handler: impl EventHandler<E> + 'static, ) -> ListenerId

Registers a handler for a specific event type, but only for the next occurrence.

This method is similar to on, but the handler will be automatically unregistered after it handles an event once.

§Type Parameters

E: The type of the event to listen for.

§Arguments

handler: The handler for the event, which will be called only once.

§Returns

Returns a ListenerId, which can be used to prematurely remove the listener if needed.

§Examples

use async_events_emitter::*;
 
#[derive(Debug, Clone)]
struct MyCustomEvent;
 
let mut event_emitter = EventEmitter::new();
event_emitter.once::<MyCustomEvent>(my_event_handler);

Source