Struct Bus 

pub struct Bus { /* private fields */ }

Implementations

impl Bus

pub fn new(capacity: usize) -> Self

Examples found in repository

examples/base.rs (line 22)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

pub fn bind<E: Event>( &self, listener: impl Listener<Event = E>, ) -> SubscribeHandle

pub fn bind_cancel<E: Event>( &self, cancel: CancellationToken, listener: impl Listener<Event = E>, ) -> SubscribeHandle

pub fn on<E: Event>( &self, listener: impl Listener<Event = E>, ) -> SubscribeHandle

Examples found in repository

examples/base.rs (lines 30-32)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

pub fn once<E: Event>( &self, listener: impl Listener<Event = E>, ) -> SubscribeHandle

Examples found in repository

examples/base.rs (lines 25-27)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

pub fn many<E: Event>( &self, times: usize, listener: impl Listener<Event = E>, ) -> SubscribeHandle

Examples found in repository

examples/base.rs (line 35)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

pub async fn emit<E: Event>(&self, event: E)

Examples found in repository

examples/base.rs (line 38)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

pub fn emitter<E: Event>(&self) -> Emitter<E>

pub async fn drain(self)

Examples found in repository

examples/base.rs (line 54)

async fn main() {
    let bus = Bus::new(2);

    // Register EventA listener
    bus.once::<EventA>(from_fn(|_| async {
        println!("Handled  Event A");
    }));

    // Register EventB listener
    let handle2 = bus.on(from_fn(|_: Rent<EventB>| async {
        println!("Handled  Event B");
    }));

    // Register EventC listener
    bus.many(3, from_fn(event_c_listener));

    // Emit events
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.emit(EventC).await;
    bus.emit(EventD).await;

    // Cancel EventB listener and register EventD listener
    handle2.cancel();
    tokio::time::sleep(Duration::from_millis(1)).await;
    bus.on(from_fn(|_: Rent<EventD>| async {
        println!("Handled  Event D");
    }));

    // Emit again
    bus.emit(EventA).await;
    bus.emit(EventB).await;
    bus.clone().emit(EventD).await;
    bus.drain().await;
}

Trait Implementations

impl Clone for Bus

fn clone(&self) -> Bus

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for Bus

fn drop(&mut self)

Executes the destructor for this type.