rtc-interval 0.1.0

Wall clock synchronized interval timers
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

#[cfg(feature = "async")]
pub use async_interval::AsyncRtcInterval;

use std::time::Duration;

use bma_ts::Timestamp;

pub struct RtcInterval {
    interval: rtsc::time::Interval,
    d: Duration,
    tick_prev: u64,
}

impl RtcInterval {
    pub fn new(d: Duration) -> Self {
        let mut interval = rtsc::time::interval(if d >= Duration::from_secs(1) {
            Duration::from_millis(200)
        } else {
            d
        });
        interval = interval.set_missing_tick_behavior(rtsc::time::MissedTickBehavior::Skip);
        Self {
            interval,
            d,
            tick_prev: 0,
        }
    }
    pub fn tick(&mut self) -> Timestamp {
        if self.d >= Duration::from_secs(1) {
            loop {
                self.interval.tick();
                let t_secs = Timestamp::now().as_secs();
                if t_secs.is_multiple_of(self.d.as_secs()) && t_secs != self.tick_prev {
                    self.tick_prev = t_secs;
                    break Timestamp::from_secs(t_secs);
                }
            }
        } else {
            self.interval.tick();
            Timestamp::now()
        }
    }
}

#[cfg(feature = "async")]
mod async_interval {
    use std::time::Duration;

    use bma_ts::Timestamp;

    pub struct AsyncRtcInterval {
        interval: tokio::time::Interval,
        d: Duration,
        tick_prev: u64,
    }

    impl AsyncRtcInterval {
        pub fn new(d: Duration) -> Self {
            let mut interval = tokio::time::interval(if d >= Duration::from_secs(1) {
                Duration::from_millis(200)
            } else {
                d
            });
            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
            Self {
                interval,
                d,
                tick_prev: 0,
            }
        }
        pub async fn tick(&mut self) -> Timestamp {
            if self.d >= Duration::from_secs(1) {
                loop {
                    self.interval.tick().await;
                    let t_secs = Timestamp::now().as_secs();
                    if t_secs.is_multiple_of(self.d.as_secs()) && t_secs != self.tick_prev {
                        self.tick_prev = t_secs;
                        break Timestamp::from_secs(t_secs);
                    }
                }
            } else {
                self.interval.tick().await;
                Timestamp::now()
            }
        }
    }
}