rust_asio 0.3.1

Asynchronous I/O library
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
88
89
90
91
92
93
94
95
96
97

use std::io;
use std::time;
use std::ops::{Add, Sub};
use std::marker::PhantomData;
use time::{Duration, Timespec, SteadyTime, get_time};
use {IoObject, IoService, Handler};
use backbone::{WaitActor, AsWaitActor, sleep_for};
use backbone::ops::{async_wait, cancel_wait};
pub use backbone::{Expiry, ToExpiry};

pub trait ToStdDuration {
    fn to_std(&self) -> time::Duration;
}

impl ToStdDuration for Duration {
    fn to_std(&self) -> time::Duration {
        self.to_std().unwrap_or(time::Duration::new(0, 0))
    }
}

pub trait Clock : Send + 'static {
    type Duration : ToStdDuration + Clone;

    type TimePoint : ToExpiry
        + Add<Self::Duration, Output = Self::TimePoint>
        + Sub<Self::TimePoint, Output = Self::Duration>;

    fn now() -> Self::TimePoint;
}

pub struct WaitTimer<C> {
    wait: WaitActor,
    marker: PhantomData<C>,
}

impl<C: Clock> WaitTimer<C> {
    pub fn new<T: IoObject>(io: &T) -> WaitTimer<C> {
        WaitTimer {
            wait: WaitActor::new(io),
            marker: PhantomData,
        }
    }

    pub fn async_wait_at<F: Handler<()>>(&self, time: C::TimePoint, handler: F) {
        async_wait(self, time.to_expiry(), handler)
    }

    pub fn async_wait_for<F: Handler<()>>(&self, time: C::Duration, handler: F) {
        async_wait(self, (C::now() + time).to_expiry(), handler)
    }

    pub fn cancel(&self) {
        cancel_wait(self);
    }

    pub fn wait_at(&self, time: C::TimePoint) -> io::Result<()> {
        sleep_for((time - C::now()).to_std())
    }

    pub fn wait_for(&self, time: C::Duration) -> io::Result<()> {
        sleep_for(time.to_std())
    }
}

impl<C> IoObject for WaitTimer<C> {
    fn io_service(&self) -> &IoService {
        self.wait.io_service()
    }
}

impl<C: Clock> AsWaitActor for WaitTimer<C> {
    fn as_wait_actor(&self) -> &WaitActor {
        &self.wait
    }
}

pub struct SystemClock;

impl Clock for SystemClock {
    type Duration = Duration;
    type TimePoint = Timespec;

    fn now() -> Timespec {
        get_time()
    }
}

pub struct SteadyClock;

impl Clock for SteadyClock {
    type Duration = Duration;
    type TimePoint = SteadyTime;

    fn now() -> SteadyTime {
        SteadyTime::now()
    }
}