waiter-trait 0.9.2

Traits used to wait and timeout.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use super::*;
use core::marker::PhantomData;
use fugit::MicrosDurationU32;

/// [`Waiter`] implementation for embedded system.
///
/// The difference from [`TickWaiter`] is that it supports setting timeout at `start()`.
///
/// # Examples
///
/// ```
/// use std::time::{Duration, Instant};
/// use waiter_trait::{prelude::*, TimedTickWaiter, StdInterval};
///
/// let w = TimedTickWaiter::<Instant, _>::new(
///     StdInterval::new(Duration::from_millis(400)),
///     Duration::from_secs(1).as_nanos() as u32,
/// );
///
/// let mut t = w.start(500.millis());
/// assert!(!t.timeout());
/// assert!(!t.timeout());
/// assert!(t.timeout());
///
/// let mut t = w.start(500.millis());
/// assert!(!t.timeout());
/// assert!(!t.timeout());
/// t.restart();
/// assert!(!t.timeout());
/// assert!(!t.timeout());
/// assert!(t.timeout());
/// ```
pub struct TimedTickWaiter<T, I> {
    frequency: u32,
    interval: I,
    _t: PhantomData<T>,
}

impl<T, I> TimedTickWaiter<T, I>
where
    T: TickInstant,
    I: Interval,
{
    pub fn new(interval: I, frequency: u32) -> Self {
        assert_eq!(frequency % 1_000_000, 0);
        Self {
            frequency,
            interval,
            _t: PhantomData,
        }
    }
}

impl<T, I> TimedWaiter for TimedTickWaiter<T, I>
where
    T: TickInstant,
    I: Interval,
{
    fn start(&self, timeout: MicrosDurationU32) -> impl WaiterStatus {
        TimedTickWaiterStatus::<T, I> {
            tick: T::now(),
            timeout_tick: timeout
                .ticks()
                .checked_mul(self.frequency / 1_000_000)
                .unwrap(),
            elapsed_tick: 0,
            waiter: self,
        }
    }
}

pub struct TimedTickWaiterStatus<'a, T: TickInstant, I: Interval> {
    tick: T,
    timeout_tick: u32,
    elapsed_tick: u32,
    waiter: &'a TimedTickWaiter<T, I>,
}

impl<'a, T, I> WaiterStatus for TimedTickWaiterStatus<'a, T, I>
where
    T: TickInstant,
    I: Interval,
{
    /// Can be reused without calling `restart()`.
    #[inline]
    fn timeout(&mut self) -> bool {
        let now = T::now();
        self.elapsed_tick = self.elapsed_tick.add_u32(now.tick_since(self.tick));
        self.tick = now;

        if self.elapsed_tick >= self.timeout_tick {
            self.elapsed_tick -= self.timeout_tick;
            true
        } else {
            self.waiter.interval.interval();
            false
        }
    }

    #[inline(always)]
    fn restart(&mut self) {
        self.tick = T::now();
        self.elapsed_tick = 0;
    }
}