agera 0.1.19

Agera SDK API
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
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::sync::{Arc, RwLock};
use crate::common::*;

type EventListenerList<T> = Arc<RwLock<Vec<EventListener<T>>>>;

/// An event emitter.
///
/// `EventEmitter` consists of a sequence of listeners whose function is invoked
/// when an event is emitted with a single data value.
/// 
/// Event listeners to an event emitter are created through the `listener` method.
pub struct EventEmitter<T: Clone> {
    listener_list: EventListenerList<T>,
}

impl<T: Clone> EventEmitter<T> {
    pub fn new() -> Self {
        Self {
            listener_list: Arc::new(RwLock::new(vec![])),
        }
    }

    /// Adds a listener to an event emitter.
    pub fn listener<F>(&self, function: F) -> EventListener<T>
        where F: Fn(T) + Send + Sync + 'static
    {
        let listener = EventListener::new(Arc::clone(&self.listener_list), function);
        listener.add();
        listener
    }

    /// Emits a single data value.
    pub fn emit(&self, data: T) {
        let mut list_2 = vec![];
        for listener in &*self.listener_list.read().unwrap() {
            list_2.push(listener.clone());
        }
        for listener in list_2 {
            (listener.inner.function)(data.clone());
        }
    }
}

/*
/// Creates an event listener to an event emitter, returning `EventListener<T>`.
/// 
/// # Syntax
/// 
/// ```ignore
/// use agera::common::*;
///
/// let listener = event_listener!(event_emitter, |data| {
///     // Action
/// });
/// ```
pub macro event_listener {
    ($emitter:expr, $function:expr) => {
        let emitter: EventEmitter<_> = $emitter;
        emitter.add_listener(Box::new($function))
    },
}
*/

pub struct EventListener<T: Clone> {
    inner: Arc<EventListenerInner<T>>,
}

impl<T: Clone> PartialEq for EventListener<T> {
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.inner, &other.inner)
    }
}

impl<T: Clone> Eq for EventListener<T> {}

impl<T: Clone> Clone for EventListener<T> {
    fn clone(&self) -> Self {
        Self {
            inner: Arc::clone(&self.inner),
        }
    }
}

impl<T: Clone> EventListener<T> {
    pub fn new<F: Fn(T) + Send + Sync + 'static>(listener_list: EventListenerList<T>, function: F) -> Self {
        Self {
            inner: Arc::new(EventListenerInner {
                listener_list,
                function: Box::new(function),
            }),
        }
    }

    /// Adds the event listener to the end of the sequence of listeners if it was previously
    /// removed by the `remove` method. If the event listener is already attached
    /// to the sequence, it is moved to the end of the sequence.
    pub fn add(&self) {
        self.remove();
        let list = &self.inner.listener_list;
        list.write().unwrap().push(self.clone());
    }

    /// Indicates whether the event listener is attached to the sequence of listeners,
    /// that is, whether it was not removed from the sequence.
    pub fn is_active(&self) -> bool {
        let list = &self.inner.listener_list;
        list.read().unwrap().contains(self)
    }

    /// Removes the event listener from the sequence of listeners.
    pub fn remove(&self) {
        let list = &self.inner.listener_list;
        list.write().unwrap().remove_equals(self);
    }
}

struct EventListenerInner<T: Clone> {
    listener_list: EventListenerList<T>,
    function: Box<dyn Fn(T) + Send + Sync + 'static>,
}