alone_ee 1.2.3

Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#![allow(clippy::type_complexity)]
#![allow(dead_code)]

pub mod event;
pub mod event_emitter;
pub mod listener;
pub mod observer;
pub mod subscription;

#[cfg(test)]
mod tests {
    use crate::event_emitter::EventEmitter;
    use std::cell::RefCell;
    use std::rc::Rc;
    use std::sync::Arc;

    #[test]
    fn test_ee() {
        #[derive(Debug, PartialEq)]
        struct SomeEvent {
            pub ev: u32,
            pub txt: &'static str,
        }

        let mut ee = EventEmitter::<Rc<SomeEvent>>::new();

        let fired_ev: Rc<RefCell<Option<Rc<SomeEvent>>>> = Rc::new(RefCell::new(Option::None));

        let subs1 = {
            let fired_ev_clone = fired_ev.clone();

            ee.on(Box::new(move |ev| {
                *fired_ev_clone.borrow_mut() = Option::Some(Rc::clone(ev.data()));
                Ok(())
            }))
        };

        let subs2 = {
            let fired_ev_clone = fired_ev.clone();

            ee.on(Box::new(move |ev| {
                *fired_ev_clone.borrow_mut() = Option::Some(Rc::clone(ev.data()));
                Ok(())
            }))
        };

        assert!(fired_ev.borrow().is_none());

        ee.emit(Rc::new(SomeEvent { ev: 123, txt: "hello" })).unwrap();

        assert!(fired_ev.borrow().is_some());

        assert_eq!(ee.len(), 2);

        drop(subs1);

        assert_eq!(ee.len(), 2);

        ee.cleanup();

        assert_eq!(ee.len(), 1);

        if let Some(ev) = fired_ev.borrow().clone() {
            assert_eq!(ev.ev, 123);
        }

        ee.emit(Rc::new(SomeEvent { ev: 333, txt: "world" })).unwrap();

        if let Some(ev) = fired_ev.borrow().clone() {
            assert_eq!(ev.ev, 333);
        }

        let subs3 = {
            let fired_ev_clone = fired_ev.clone();
            ee.once(Box::new(move |ev| {
                *fired_ev_clone.borrow_mut() = Option::Some(ev.data().clone());
                Ok(())
            }))
        };

        assert_eq!(ee.len(), 2);

        ee.emit(Rc::new(SomeEvent { ev: 444, txt: "world" })).unwrap();

        if let Some(ev) = fired_ev.borrow().clone() {
            assert_eq!(ev.ev, 444);
        }

        drop(subs2);

        ee.emit(Rc::new(SomeEvent { ev: 555, txt: "world" })).unwrap();

        if let Some(ev) = fired_ev.borrow().clone() {
            assert_eq!(ev.ev, 444);
        }

        assert_eq!(ee.len(), 0);

        ee.reset();

        assert_eq!(ee.len(), 0);

        drop(ee);

        drop(subs3);
    }
}