async-shared-timeout 0.2.2

Async timeout that can be reset and shared
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

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

/// async-io runtime implementation
#[derive(Copy, Clone, Default)]
#[cfg_attr(docsrs, doc(cfg(feature = "async-io")))]
pub struct Runtime {
    _private: (),
}

impl Runtime {
    /// Create a new async-io runtime object
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }
}

impl super::Runtime for Runtime {
    type Sleep = Timer;
    type Instant = Instant;
    fn create_sleep(&self, timeout: Duration) -> Self::Sleep {
        Timer::after(timeout)
    }
    fn now(&self) -> Self::Instant {
        Instant::now()
    }
}

impl super::Instant for Instant {
    fn duration_since(&self, earlier: &Self) -> Duration {
        self.duration_since(*earlier)
    }
}

impl super::Sleep for Timer {
    fn poll_sleep(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        self.poll(cx).map(|_| ())
    }
    fn reset(mut self: Pin<&mut Self>, timeout: Duration) {
        self.set_after(timeout);
    }
}