Struct EventManager

Source

pub struct EventManager { /* private fields */ }

Implementations§

Source §

impl EventManager

Source

pub fn on<S, F, T, Fut>(&self, event: S, callback: F) -> EventHandler
where S: Into<String>, T: 'static + Send + Sync + Clone, F: FnMut(T) -> Fut + Send + 'static, Fut: Future<Output = Result<(), Error>> + Send + 'static,

Register event handler for a specific event name.

§Parameters

event - The event name (any type that matches an Into<String>)
callback - An async moved callback that accepts a single parameter as an argument. The argument can be anything that might be both Send + Sync. You can trick multiple parameters by turning them in a single tuple.

§Return

Returns an EventHandler that can be used by the unregister() method.

§Errors

If the event handler does not match the expected emitted event exactly it will fail silently. That means if the tuple gave in the callback parameter does not exactly match the emit one no handler will be called.

§Example

use hermes_five::utils::EventManager;
use hermes_five::pause;

#[hermes_five::runtime]
async fn main() {
    // Instantiate an EventManager
    let events: EventManager = Default::default();

    // Register various handlers for the same event.
    events.on("ready", |name: String| async move { Ok(()) });
    events.on("ready", |age: u8| async move { Ok(()) });
    events.on("ready", |whatever: Vec<[u8;4]>| async move { Ok(()) });
    events.on("ready", |(name, age): (&str, u8)| async move {
        println!("Event handler with parameters: {} {}.", name, age);
        pause!(1000);
        println!("Event handler done");
        Ok(())
    });

    // Invoke handlers for "ready" event.
    events.emit("ready", ("foo", 69u8));

    // None matching handler (because of parameters) will never be called.
    events.emit("ready", ("bar"));
}

Source

pub fn emit<S, T>(&self, event: S, payload: T)
where S: Into<String>, T: 'static + Send + Sync,

Invoke all event handlers registered for a specific event name. Only the callback registered by the on() method and whose payload matches the declared callback type will be called. All others will be silently skipped.

§Parameters

event: The event name (any type that matches an Into<String>)
payload: The event payload (must be 'static + Send + Sync) The payload can be anything that might be both Send + Sync. You can trick multiple parameters by turning them in a single tuple.

§Example

use hermes_five::utils::EventManager;

#[hermes_five::runtime]
async fn main() {
    // Instantiate an EventManager
    let events: EventManager = Default::default();

    // Register various handlers for the same event.
    events.on("ready", |name: &str| async move {
        println!("Callback 1");
        Ok(())
    });
    events.on("ready", |age: u8| async move {
        println!("Callback 2");
        Ok(())
    });

    // Invoke handlers for "ready" event matching &str parameter.
    events.emit("ready", "foo");
    // Invoke handlers for "ready" event matching u8 parameter.
    events.emit("ready", 42);

    // No event registered for "nothing" event.
    events.emit("nothing", ());
}

Source

pub fn unregister(&self, handler: EventHandler)

Unregister a given handler if found.

§Example

use hermes_five::utils::EventManager;

#[hermes_five::runtime]
async fn main() {
    // Instantiate an EventManager
    let events: EventManager = Default::default();

    // Register various handlers for the same event.
    let handler1 = events.on("ready", |age: u8| async move {
        println!("Callback 1");
        Ok(())
    });
    let handler2 = events.on("ready", |age: u8| async move {
        println!("Callback 2");
        Ok(())
    });

    // Unregister handler 1.
    events.unregister(handler1);

    // Invoke handlers for "ready" event matching u8 parameter.
    // Only the callback2 remains to be called here.
    events.emit("ready", 42);
}