A simple event bus that can be cloned and shared across threads.

Emit inside `on` blocks

To re-emit events inside on closures do not clone the original bus, use the bus reference provided to the closure instead.

Example

```rust use tram::prelude::*;

[derive(PartialEq, Eq, Hash)]

enum EventType { Start, Stop, }

[derive(Debug, PartialEq)]

enum Status { Stopped, Started, }

let bus: EventBus = EventBus::unbound();

let status = Rc::new(RefCell::new(Status::Stopped)); let statusclosure = Rc::clone(&status); let statusclosure_2 = Rc::clone(&status);

bus.on(EventType::Start, move |bus, _| { *statusclosure.borrow_mut() = Status::Started; }) .unwrap();

bus.on(EventType::Stop, move |bus, _| { *statusclosure2.borrowmut() = Status::Stopped; }) .unwrap();

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

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

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

asserteq!(*status.borrow(), Status::Stopped); asserteq!(bus.event_count(), 2); ```

Using it in threads

```rust let bus: EventBus

let status = Arc::new(Mutex::new(Status::Stopped)); let final_status = Arc::clone(&status);

let t1 = std::thread::spawn(move || { bus.on(EventType::Start, move |bus, _| { let mut statuslock = status.lock().unwrap(); *status_lock = Status::Started; }).unwrap(); });

let t2 = std::thread::spawn(move || { bus_clone.emit(EventType::Start).unwrap(); });

t1.join().unwrap(); t2.join().unwrap();

let finalstatuslock = finalstatus.lock().unwrap(); asserteq!(*finalstatuslock, Status::Started) ```

Passing data to events

```rust let bus: EventBus = EventBus::unbound(); let status: Rc>> = Rc::new(RefCell::new(None)); let status_closure = Rc::clone(&status);

bus.on(EventType::Start, move |bus, startupdata| { status_closure.borrow_mut() = Some(startup_data.unwrap()); }) .unwrap();

bus.emitwithvalue(EventType::Start, Some(&123)).expect("Failed to emit");