timer_utils/
generic.rs

1use object_collection::ObjectList;
2use std::collections::vec_deque::{Iter, IterMut};
3use std::collections::VecDeque;
4use std::ffi::c_void;
5
6#[derive(Debug, PartialEq, Eq)]
7pub struct TimerObjectEntry {
8    time: u64,
9    inner: ObjectList,
10}
11
12impl TimerObjectEntry {
13    pub fn new(time: u64) -> Self {
14        TimerObjectEntry {
15            time,
16            inner: ObjectList::new(),
17        }
18    }
19
20    pub fn len(&self) -> usize {
21        self.inner.len()
22    }
23
24    pub fn is_empty(&self) -> bool {
25        self.inner.is_empty()
26    }
27
28    pub fn get_time(&self) -> u64 {
29        self.time
30    }
31
32    pub fn pop_front_raw(&mut self) -> Option<*mut c_void> {
33        self.inner.pop_front_raw()
34    }
35
36    pub fn push_back<T>(&mut self, t: T) {
37        self.inner.push_back(t)
38    }
39
40    pub fn remove_raw(&mut self, pointer: *mut c_void) -> Option<*mut c_void> {
41        self.inner.remove_raw(pointer)
42    }
43
44    pub fn push_back_raw(&mut self, ptr: *mut c_void) {
45        self.inner.push_back_raw(ptr)
46    }
47
48    pub fn iter_mut(&mut self) -> IterMut<'_, *mut c_void> {
49        self.inner.iter_mut()
50    }
51
52    pub fn iter(&self) -> Iter<'_, *mut c_void> {
53        self.inner.iter()
54    }
55}
56
57#[repr(C)]
58#[derive(Debug, PartialEq, Eq)]
59pub struct TimerObjectList {
60    dequeue: VecDeque<TimerObjectEntry>,
61}
62
63impl TimerObjectList {
64    pub fn new() -> Self {
65        TimerObjectList {
66            dequeue: VecDeque::new(),
67        }
68    }
69
70    pub fn len(&self) -> usize {
71        self.dequeue.len()
72    }
73
74    pub fn insert<T>(&mut self, time: u64, t: T) {
75        let ptr = Box::leak(Box::new(t));
76        self.insert_raw(time, ptr as *mut _ as *mut c_void)
77    }
78
79    pub fn insert_raw(&mut self, time: u64, ptr: *mut c_void) {
80        let index = self
81            .dequeue
82            .binary_search_by(|x| x.time.cmp(&time))
83            .unwrap_or_else(|x| x);
84        match self.dequeue.get_mut(index) {
85            Some(entry) => {
86                entry.push_back_raw(ptr);
87            }
88            None => {
89                let mut entry = TimerObjectEntry::new(time);
90                entry.push_back_raw(ptr);
91                self.dequeue.insert(index, entry);
92            }
93        }
94    }
95
96    pub fn front(&self) -> Option<&TimerObjectEntry> {
97        self.dequeue.front()
98    }
99
100    pub fn pop_front(&mut self) -> Option<TimerObjectEntry> {
101        self.dequeue.pop_front()
102    }
103
104    pub fn is_empty(&self) -> bool {
105        self.dequeue.is_empty()
106    }
107
108    pub fn get_entry(&mut self, time: u64) -> Option<&mut TimerObjectEntry> {
109        let index = self
110            .dequeue
111            .binary_search_by(|x| x.time.cmp(&time))
112            .unwrap_or_else(|x| x);
113        self.dequeue.get_mut(index)
114    }
115
116    pub fn iter_mut(&mut self) -> IterMut<'_, TimerObjectEntry> {
117        self.dequeue.iter_mut()
118    }
119
120    pub fn iter(&self) -> Iter<'_, TimerObjectEntry> {
121        self.dequeue.iter()
122    }
123}
124
125impl Default for TimerObjectList {
126    fn default() -> Self {
127        Self::new()
128    }
129}
130
131#[cfg(test)]
132mod tests {
133    use super::TimerObjectList;
134
135    #[test]
136    fn timer_object_list() {
137        let mut list = TimerObjectList::new();
138        assert_eq!(list.len(), 0);
139        list.insert(1, String::from("data can be everything"));
140        assert_eq!(list.len(), 1);
141
142        let mut entry = list.pop_front().unwrap();
143        assert_eq!(entry.len(), 1);
144        let pointer = entry.pop_front_raw().unwrap() as *mut _ as *mut String;
145        unsafe {
146            assert_eq!(String::from("data can be everything"), *pointer);
147        }
148    }
149}
timer_utils/generic.rs

timer_utils/
generic.rs
