Struct EventBus 

pub struct EventBus<E, V> { /* private fields */ }

An event bus that can be cloned and shared across threads. If you do not need to share the bus across threads use unsync::EventBus which is more efficient in terms of performance since it doens’t need to hold locks on resources

Example

use tram::{prelude::*, sync::EventBus};
use std::{cell::RefCell, rc::Rc};

#[derive(PartialEq, Eq, Hash)]
enum EventType {
    Start,
    Stop
}

#[derive(Debug, PartialEq)]
enum Status {
    Stopped,
    Started
}

let bus: EventBus<EventType, ()> = EventBus::unbound();
let status = Rc::new(RefCell::new(Status::Stopped));
let status_closure = Rc::clone(&status);

bus.on(EventType::Start, move |_bus, _| {
    *status_closure.borrow_mut() = Status::Started;
})
.expect("Failed to listen for this event");

bus.emit(EventType::Start).expect("Failed to emit");

assert_eq!(*status.borrow(), Status::Started);
assert_eq!(bus.event_count(), 1);

Implementations

impl<E, V> EventBus<E, V>

pub fn unbound() -> Self

Creates an unbound bus that can emit any number of events

pub fn bound(limit: usize) -> Self

Creates a bound bus that can emit up to limit events

pub fn disconnected(&self) -> bool

Returns true if this bus has exausted its allowed max number of emits

pub fn event_count(&self) -> usize

Trait Implementations

impl<E, V> Clone for EventBus<E, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, V> EventEmitter<E, V> for EventBus<E, V>

where E: Eq + Hash,

fn on<F>(&self, event: E, f: F) -> Result<(), Error>

where F: Fn(&BusRef<E, V>, Option<&V>) + 'static,

Adds a listener f for and event

fn emit(&self, event: E) -> Result<(), Error>

Emits an event, firing all listeners connected to it via on.

fn emit_with_value(&self, event: E, value: Option<&V>) -> Result<(), Error>

Emits an event with a value associated to it, firing all listeners connected to it via on.

impl<E, V> Send for EventBus<E, V>

where E: Send,

impl<E, V> Sync for EventBus<E, V>

where E: Send,