fast-clock 0.2.0

Low-overhead timing without hiding the details from you
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 crate::{Clock, DurationCalibration, InherentlyCalibrated, Time};
use core::cmp::Ordering;
use std::time::{Duration, Instant, SystemTime};

/// [`Time`] implementation for [`std::time::Instant`].
///
/// [`instant_sub`](Time::instant_sub) panics if `a < b` because [`Duration`] cannot
/// represent negative values. Use [`Time::instant_cmp`] to compare instants.
pub struct InstantTime;
impl Time for InstantTime {
    type Instant = std::time::Instant;

    type Duration = Duration;

    #[inline]
    fn instant_sub(a: Self::Instant, b: Self::Instant) -> Self::Duration {
        a.checked_duration_since(b)
            .expect("instant_sub: a is earlier than b; Duration cannot represent negative values")
    }

    #[inline]
    fn duration_sub(a: Self::Duration, b: Self::Duration) -> Self::Duration {
        a - b
    }

    #[inline]
    fn duration_add(a: Self::Duration, b: Self::Duration) -> Self::Duration {
        a + b
    }

    #[inline]
    fn mixed_sub(a: Self::Instant, b: Self::Duration) -> Self::Instant {
        a - b
    }

    #[inline]
    fn mixed_add(a: Self::Instant, b: Self::Duration) -> Self::Instant {
        a + b
    }

    #[inline]
    fn instant_cmp(a: Self::Instant, b: Self::Instant) -> Ordering {
        a.cmp(&b)
    }
}

/// [`Time`] implementation for [`std::time::SystemTime`].
///
/// [`instant_sub`](Time::instant_sub) panics if `a < b` because [`Duration`] cannot
/// represent negative values. Use [`Time::instant_cmp`] to compare instants.
pub struct SystemTimeTime;

impl Time for SystemTimeTime {
    type Instant = SystemTime;
    type Duration = Duration;

    #[inline]
    fn instant_sub(a: SystemTime, b: SystemTime) -> Duration {
        a.duration_since(b)
            .expect("instant_sub: a is earlier than b; Duration cannot represent negative values")
    }

    #[inline]
    fn duration_sub(a: Duration, b: Duration) -> Duration {
        a - b
    }

    #[inline]
    fn duration_add(a: Duration, b: Duration) -> Duration {
        a + b
    }

    #[inline]
    fn mixed_sub(a: SystemTime, b: Duration) -> SystemTime {
        a - b
    }

    #[inline]
    fn mixed_add(a: SystemTime, b: Duration) -> SystemTime {
        a + b
    }

    #[inline]
    fn instant_cmp(a: Self::Instant, b: Self::Instant) -> Ordering {
        a.cmp(&b)
    }
}

macro_rules! std_clock {
    ($(#[$meta:meta])* $Instant:ty, $Clock:ident, $TimeType:ty) => {
        $(#[$meta])*
        #[derive(Clone, Copy, Debug)]
        pub struct $Clock;

        impl Clock for $Clock {
            type Time = $TimeType;
            type Calibration = InherentlyCalibrated;

            fn now(&self) -> $Instant {
                <$Instant>::now()
            }
        }
    };
}

std_clock!(
    /// A [`Clock`] that reads [`std::time::Instant::now`].
    Instant, InstantClock, InstantTime
);
std_clock!(
    /// A [`Clock`] that reads [`std::time::SystemTime::now`].
    SystemTime, SystemClock, SystemTimeTime
);

impl DurationCalibration<Duration> for InherentlyCalibrated {
    #[inline]
    fn convert_to_ns(&self, d: Duration) -> u64 {
        d.as_nanos()
            .try_into()
            .expect("duration exceeds u64::MAX nanoseconds (~584 years)")
    }

    #[inline]
    fn convert_from_ns(&self, ns: u64) -> Duration {
        Duration::from_nanos(ns)
    }
}