timeout_trait/
std_impls.rs

1use super::{
2    TickDuration,
3    fugit::{KilohertzU32, RateExtU32},
4    prelude::*,
5};
6use std::time::{Duration, Instant};
7
8#[derive(Clone)]
9pub struct StdTickInstant(Instant);
10
11impl TickInstant for StdTickInstant {
12    #[inline]
13    fn frequency() -> KilohertzU32 {
14        1.MHz()
15    }
16
17    #[inline]
18    fn now() -> Self {
19        StdTickInstant(Instant::now())
20    }
21
22    #[inline]
23    fn elapsed(&mut self) -> TickDuration<Self> {
24        let ticks = Instant::now().duration_since(self.0).as_micros() as u64;
25        TickDuration::from_ticks(ticks)
26    }
27
28    #[inline]
29    fn move_forward(&mut self, dur: &TickDuration<Self>) {
30        self.0 = self
31            .0
32            .checked_add(Duration::from_micros(dur.ticks()))
33            .unwrap();
34    }
35}
36
37#[cfg(test)]
38mod tests {
39    use crate::TickTimeout;
40
41    use super::*;
42    use std::{thread::sleep, time::Duration};
43
44    struct UseTimeout<T: TickInstant> {
45        interval: TickTimeout<T>,
46    }
47
48    fn test_timeout<T: TickInstant>() {
49        let mut t = TickTimeout::<T>::from_millis(500);
50        assert!(!t.timeout());
51        sleep(Duration::from_millis(260));
52        assert!(!t.timeout());
53        sleep(Duration::from_millis(260));
54        assert!(t.timeout());
55        assert!(!t.timeout());
56
57        t.restart();
58        assert!(!t.timeout());
59        sleep(Duration::from_millis(260));
60        assert!(!t.timeout());
61        sleep(Duration::from_millis(260));
62        assert!(t.timeout());
63        assert!(!t.timeout());
64
65        let dur = TickDuration::<T>::from_nanos(100);
66        assert!(T::now().timeout_with(&dur, || {
67            sleep(Duration::from_nanos(1));
68            true
69        }));
70
71        let mut u = UseTimeout {
72            interval: TickTimeout::<T>::from_millis(1),
73        };
74        u.interval.timeout();
75    }
76
77    #[test]
78    fn tick_timeout() {
79        test_timeout::<StdTickInstant>();
80    }
81
82    #[test]
83    fn tick_instant() {
84        let mut now = StdTickInstant::now();
85        sleep(Duration::from_millis(200));
86        assert!(now.elapsed().ticks() - 200_000 < 1000);
87    }
88}