nio 0.1.4

Async runtime for Rust
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

use crate::rt::context::LocalContext;

use super::*;
use std::{
    pin::Pin,
    task::{Context, Poll},
};

pub struct Sleep {
    pub(crate) timer: RcTimer,
}

impl Sleep {
    pub fn at(deadline: Instant) -> Sleep {
        LocalContext::with(|ctx| unsafe { ctx.timers(|timers| timers.sleep_at(deadline)) })
    }

    #[inline]
    pub fn deadline(&self) -> Instant {
        self.timer.deadline()
    }

    #[inline]
    pub fn is_elapsed(&self) -> bool {
        self.timer.as_ref().rc.get() == 1
    }

    pub fn reset_at(&mut self, deadline: Instant) {
        LocalContext::with(|ctx| unsafe {
            ctx.timers(|timers| timers.reset_at(&self.timer, deadline))
        })
    }

    pub fn reset(&mut self, duration: Duration) {
        LocalContext::with(|ctx| unsafe {
            ctx.timers(|timers| timers.reset_at(&self.timer, timers.clock.current() + duration))
        })
    }
}

#[inline]
#[must_use]
pub fn sleep(duration: Duration) -> Sleep {
    LocalContext::with(|ctx| unsafe {
        ctx.timers(|timers| timers.sleep_at(timers.clock.current() + duration))
    })
}

impl Future for Sleep {
    type Output = ();
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        if self.is_elapsed() {
            return Poll::Ready(());
        }
        self.timer.as_ref().waker.register(cx);
        Poll::Pending
    }
}

impl Drop for Sleep {
    fn drop(&mut self) {
        if self.is_elapsed() {
            return; // already droped
        }
        LocalContext::with(|ctx| unsafe { ctx.timers(|timers| timers.remove(&self.timer)) })
    }
}

impl fmt::Debug for Sleep {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(self.timer.as_ref(), f)
    }
}