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 core::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
    time::Duration,
};
use tokio::time::{self, Instant, Sleep};

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

impl Runtime {
    /// Create a new Tokio runtime object. Current runtime will be used for sleeping. Launch
    /// [`Timeout::wait`](`crate::Timeout::wait`) in the correct context if necessary.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }
}

impl super::Runtime for Runtime {
    type Sleep = Sleep;
    type Instant = Instant;
    fn create_sleep(&self, timeout: Duration) -> Self::Sleep {
        time::sleep(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 Sleep {
    fn poll_sleep(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        self.poll(cx)
    }
    fn reset(self: Pin<&mut Self>, timeout: Duration) {
        self.reset(time::Instant::now() + timeout);
    }
}