1 use crate::common::{GearId, Millis}; |
|
2 use std::{ |
|
3 cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd}, |
|
4 collections::BinaryHeap, |
|
5 }; |
|
6 |
|
7 pub type EventId = u16; |
|
8 |
|
9 struct TimeEvent { |
|
10 time: Millis, |
|
11 gear_id: GearId, |
|
12 event_id: EventId, |
|
13 } |
|
14 |
|
15 impl PartialOrd for TimeEvent { |
|
16 #[inline] |
|
17 fn partial_cmp(&self, other: &Self) -> Option<Ordering> { |
|
18 self.time.partial_cmp(&other.time) |
|
19 } |
|
20 } |
|
21 |
|
22 impl PartialEq for TimeEvent { |
|
23 #[inline] |
|
24 fn eq(&self, other: &Self) -> bool { |
|
25 self.time.eq(&other.time) |
|
26 } |
|
27 } |
|
28 |
|
29 impl Ord for TimeEvent { |
|
30 #[inline] |
|
31 fn cmp(&self, other: &Self) -> Ordering { |
|
32 self.time.cmp(&other.time) |
|
33 } |
|
34 } |
|
35 |
|
36 impl Eq for TimeEvent {} |
|
37 |
|
38 pub struct OccurredEvents { |
|
39 events: Vec<(GearId, EventId)>, |
|
40 } |
|
41 |
|
42 impl OccurredEvents { |
|
43 fn new() -> Self { |
|
44 Self { events: vec![] } |
|
45 } |
|
46 |
|
47 fn clear(&mut self) { |
|
48 self.events.clear() |
|
49 } |
|
50 } |
|
51 |
|
52 pub struct TimeProcessor { |
|
53 current_event_id: EventId, |
|
54 current_time: Millis, |
|
55 events: BinaryHeap<TimeEvent>, |
|
56 timeouts: OccurredEvents, |
|
57 } |
|
58 |
|
59 impl TimeProcessor { |
|
60 pub fn new() -> Self { |
|
61 Self { |
|
62 current_event_id: 0, |
|
63 current_time: Millis::new(0), |
|
64 events: BinaryHeap::with_capacity(1024), |
|
65 timeouts: OccurredEvents::new(), |
|
66 } |
|
67 } |
|
68 |
|
69 pub fn register(&mut self, gear_id: GearId, timeout: Millis) -> EventId { |
|
70 let event_id = self.current_event_id; |
|
71 self.current_event_id = self.current_event_id.wrapping_add(1); |
|
72 let event = TimeEvent { |
|
73 time: self.current_time + timeout, |
|
74 gear_id, |
|
75 event_id, |
|
76 }; |
|
77 self.events.push(event); |
|
78 event_id |
|
79 } |
|
80 |
|
81 fn remove_events<P>(&mut self, predicate: P) |
|
82 where |
|
83 P: Fn(&TimeEvent) -> bool, |
|
84 { |
|
85 let events = self.events.drain().filter(predicate).collect::<Vec<_>>(); |
|
86 self.events.extend(events); |
|
87 } |
|
88 |
|
89 pub fn cancel(&mut self, event_id: EventId) { |
|
90 //self.events.retain(|event| event.event_id != event_id) |
|
91 self.remove_events(|event| event.event_id != event_id) |
|
92 } |
|
93 |
|
94 pub fn cancel_all(&mut self, gear_id: GearId) { |
|
95 //self.events.retain(|event| event.gear_id != gear_id) |
|
96 self.remove_events(|event| event.gear_id != gear_id) |
|
97 } |
|
98 |
|
99 pub fn process(&mut self, time_step: Millis) -> &OccurredEvents { |
|
100 self.timeouts.clear(); |
|
101 self.current_time = self.current_time + time_step; |
|
102 while self |
|
103 .events |
|
104 .peek() |
|
105 .filter(|e| e.time <= self.current_time) |
|
106 .is_some() |
|
107 { |
|
108 let event = self.events.pop().unwrap(); |
|
109 self.timeouts.events.push((event.gear_id, event.event_id)) |
|
110 } |
|
111 &self.timeouts |
|
112 } |
|
113 } |
|