basu 0.1.9

Eventbus crate with sync and async features
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::{error::BasuError, event::Event, EventBus, Handle};

#[derive(Debug)]
struct Data {
    message: String,
}

struct HandlerA;
struct HandlerB;

impl Handle<Data> for HandlerA {
    fn handle(&self, event: &Event<Data>) -> Result<(), BasuError> {
        let data = event.get_data();
        println!("HandlerA: {}", data.message);

        Ok(())
    }
}

impl Handle<Data> for HandlerB {
    fn handle(&self, event: &Event<Data>) -> Result<(), BasuError> {
        let data = event.get_data();
        println!("HandlerB: {}", data.message);

        Ok(())
    }
}

const ECHO: &str = "echo";

#[test]
fn test() {
    let eventbus = EventBus::new();

    let handler_a_id = eventbus.subscribe(ECHO, Box::new(HandlerA)).unwrap();
    println!("HandlerA id: {:?}", handler_a_id);

    let event = Event::new(Data {
        message: "{data from event}".to_owned(),
    });

    eventbus.publish(ECHO, &event).unwrap();
    let event_types = eventbus.list().unwrap();
    assert_eq!(event_types, vec![ECHO.to_owned()]);

    let count = eventbus.get_handler_count(ECHO).unwrap();
    assert_eq!(count, 1);

    let handler_b_id = eventbus.subscribe(ECHO, Box::new(HandlerB)).unwrap();
    println!("HandlerB id: {:?}", handler_b_id);

    let count = eventbus.get_handler_count(ECHO).unwrap();
    assert_eq!(count, 2);
    eventbus.publish(ECHO, &event).unwrap();

    eventbus.unsubscribe(ECHO, &handler_a_id).unwrap();
    let count = eventbus.get_handler_count(ECHO).unwrap();
    assert_eq!(count, 1);

    eventbus.clear().unwrap();
    let event_types = eventbus.list().unwrap();
    assert_eq!(event_types.len(), 0);
}