Skip to main content

rusting_core/
events.rs

1use bevy_ecs::prelude::Resource;
2
3/// A typed event channel whose visible events live for exactly one frame.
4#[derive(Resource)]
5pub struct EventQueue<T: Send + Sync + 'static> {
6    current: Vec<T>,
7    pending: Vec<T>,
8}
9
10impl<T: Send + Sync + 'static> Default for EventQueue<T> {
11    fn default() -> Self {
12        Self {
13            current: Vec::new(),
14            pending: Vec::new(),
15        }
16    }
17}
18
19impl<T: Send + Sync + 'static> EventQueue<T> {
20    pub fn send(&mut self, event: T) {
21        self.pending.push(event);
22    }
23
24    pub fn iter(&self) -> impl ExactSizeIterator<Item = &T> {
25        self.current.iter()
26    }
27
28    #[must_use]
29    pub fn is_empty(&self) -> bool {
30        self.current.is_empty()
31    }
32
33    #[must_use]
34    pub fn len(&self) -> usize {
35        self.current.len()
36    }
37
38    /// Expires the currently visible events and promotes pending events.
39    ///
40    /// Runtime integrations must call this exactly once at the start of each
41    /// frame, before event consumers run. This is runtime integration API,
42    /// not application API.
43    #[doc(hidden)]
44    pub fn begin_frame(&mut self) {
45        self.current.clear();
46        std::mem::swap(&mut self.current, &mut self.pending);
47    }
48}
49
50#[cfg(test)]
51mod tests {
52    use super::EventQueue;
53    use bevy_ecs::prelude::Resource;
54
55    struct NoDefault;
56
57    #[test]
58    fn default_does_not_require_the_event_type_to_implement_default() {
59        let mut events = EventQueue::<NoDefault>::default();
60
61        assert!(events.is_empty());
62        events.send(NoDefault);
63        events.begin_frame();
64        assert_eq!(events.len(), 1);
65    }
66
67    #[test]
68    fn pending_events_are_invisible() {
69        let mut events = EventQueue::default();
70
71        events.send(1);
72
73        assert!(events.is_empty());
74        assert_eq!(events.len(), 0);
75        assert_eq!(
76            events.iter().copied().collect::<Vec<_>>(),
77            Vec::<i32>::new()
78        );
79    }
80
81    #[test]
82    fn events_keep_insertion_order_on_the_next_frame() {
83        let mut events = EventQueue::default();
84        events.send("first");
85        events.send("second");
86        events.send("third");
87
88        events.begin_frame();
89
90        assert_eq!(
91            events.iter().copied().collect::<Vec<_>>(),
92            vec!["first", "second", "third"]
93        );
94    }
95
96    #[test]
97    fn visible_events_expire_after_one_frame() {
98        let mut events = EventQueue::default();
99        events.send(1);
100        events.begin_frame();
101        assert_eq!(events.iter().copied().collect::<Vec<_>>(), vec![1]);
102
103        events.begin_frame();
104
105        assert!(events.is_empty());
106    }
107
108    #[test]
109    fn sends_while_current_is_visible_are_deferred() {
110        let mut events = EventQueue::default();
111        events.send("current");
112        events.begin_frame();
113
114        events.send("next");
115
116        assert_eq!(events.iter().copied().collect::<Vec<_>>(), vec!["current"]);
117        events.begin_frame();
118        assert_eq!(events.iter().copied().collect::<Vec<_>>(), vec!["next"]);
119    }
120
121    #[test]
122    fn event_queue_is_an_ecs_resource() {
123        fn assert_resource<T: Resource>() {}
124
125        assert_resource::<EventQueue<u32>>();
126    }
127}