ato 2.0.3

A very minimal no-std async runtime
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

use core::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
    time::Duration,
};

/// A structure that ticks at regular intervals.
#[derive(Debug)]
pub struct Interval {
    next_tick: Duration,
    period: Duration,
    time_fn: fn() -> Duration,
}

impl Interval {
    /// Creates a new `Interval` that ticks at the specified `period`.
    ///
    /// The first tick completes immediately (burst strategy), similar to Tokio.
    pub fn new(period: Duration, time_fn: fn() -> Duration) -> Self {
        let now = time_fn();
        Self {
            next_tick: now,
            period,
            time_fn,
        }
    }

    /// Creates a future that completes when the next interval is reached.
    ///
    /// The returned future borrows the interval, allowing the `Interval` to
    /// track state across multiple calls.
    pub fn tick(&mut self) -> IntervalTick<'_> {
        IntervalTick { interval: self }
    }

    /// Resets the interval to start ticking from the current instant.
    ///
    /// This is useful if the system was paused or lagged significantly and
    /// you want to skip the "burst" of missed ticks.
    pub fn reset(&mut self) {
        self.next_tick = (self.time_fn)();
    }
}

/// A future returned by `Interval::tick`.
pub struct IntervalTick<'a> {
    interval: &'a mut Interval,
}

impl Future for IntervalTick<'_> {
    type Output = ();

    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
        let now = (this.interval.time_fn)();

        if now >= this.interval.next_tick {
            this.interval.next_tick += this.interval.period;
            Poll::Ready(())
        } else {
            Poll::Pending
        }
    }
}