rust_asio 0.5.3

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::mem;
use std::time::{Duration, SystemTime, Instant};

#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
#[doc(hidden)]
pub struct Expiry(Duration);

impl Expiry {
    pub fn now() -> Expiry {
        Instant::now().into_expiry()
    }

    pub fn as_secs(&self) -> u64 {
        self.0.as_secs()
    }

    pub fn subsec_nanos(&self) -> u32 {
        self.0.subsec_nanos()
    }
}

impl Default for Expiry {
    fn default() -> Expiry {
        Expiry(Duration::new(i64::max_value() as u64, 0))
    }
}

#[doc(hidden)]
pub trait IntoExpiry {
    fn into_expiry(self) -> Expiry;
}

impl IntoExpiry for Instant {
    fn into_expiry(self) -> Expiry {
        Expiry(self.duration_since(unsafe { mem::zeroed() }))
    }
}

impl IntoExpiry for SystemTime {
    fn into_expiry(self) -> Expiry {
        Expiry(Expiry::now().0 + self.elapsed().unwrap())
    }
}


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

    type TimePoint;

    #[doc(hidden)]
    fn expires_at(timepoint: Self::TimePoint) -> Expiry;

    #[doc(hidden)]
    fn expires_from(duration: Self::Duration) -> Expiry;

    #[doc(hidden)]
    fn elapsed_at(timepoint: Self::TimePoint) -> Duration;

    #[doc(hidden)]
    fn elapsed_from(duration: Self::Duration) -> Duration;
}

/// Provides a monotonic clock.
pub struct SteadyClock;

impl Clock for SteadyClock {
    type Duration = Duration;

    type TimePoint = Instant;

    #[doc(hidden)]
    fn expires_at(timepoint: Self::TimePoint) -> Expiry {
        timepoint.into_expiry()
    }

    #[doc(hidden)]
    fn expires_from(duration: Self::Duration) -> Expiry {
        (Instant::now() + duration).into_expiry()
    }

    #[doc(hidden)]
    fn elapsed_at(timepoint: Self::TimePoint) -> Duration {
        timepoint.elapsed()
    }

    #[doc(hidden)]
    fn elapsed_from(duration: Self::Duration) -> Duration {
        duration
    }
}

/// Provides a real-time clock.
pub struct SystemClock;

impl Clock for SystemClock {
    type Duration = Duration;

    type TimePoint = SystemTime;

    #[doc(hidden)]
    fn expires_at(timepoint: Self::TimePoint) -> Expiry {
        timepoint.into_expiry()
    }

    #[doc(hidden)]
    fn expires_from(duration: Self::Duration) -> Expiry {
        (Instant::now() + duration).into_expiry()
    }

    #[doc(hidden)]
    fn elapsed_at(timepoint: Self::TimePoint) -> Duration {
        timepoint.elapsed().unwrap()
    }

    #[doc(hidden)]
    fn elapsed_from(duration: Self::Duration) -> Duration {
        duration
    }
}

#[test]
fn test_expiry() {
    let a = Instant::now().into_expiry();
    let b = SystemTime::now().into_expiry();
    assert!((a.0.as_secs() - b.0.as_secs()) <= 1);
}