timer_utils/
typed.rs

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

timer_utils/
typed.rs
