time 0.3.50

Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std].
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

use core::cmp::Ordering;
use core::ops::Sub;
use std::time::SystemTime;

#[allow(unused_imports)] // MSRV of 1.87
use num_conv::prelude::*;

use crate::ext::SystemTimeExt;
use crate::unit::*;
use crate::{Duration, Timestamp};

impl Sub<SystemTime> for Timestamp {
    type Output = Duration;

    #[inline]
    fn sub(self, rhs: SystemTime) -> Self::Output {
        let lhs_duration = self - Self::UNIX_EPOCH;
        match rhs.duration_since(SystemTime::UNIX_EPOCH) {
            Ok(duration) => lhs_duration - duration,
            Err(err) => lhs_duration + err.duration(),
        }
    }
}

impl Sub<Timestamp> for SystemTime {
    type Output = Duration;

    #[inline]
    fn sub(self, rhs: Timestamp) -> Self::Output {
        let rhs_duration = rhs - Timestamp::UNIX_EPOCH;

        match self.duration_since(Self::UNIX_EPOCH) {
            Ok(lhs) => lhs - rhs_duration,
            Err(err) => -(err.duration() + rhs_duration),
        }
    }
}

impl PartialEq<SystemTime> for Timestamp {
    #[inline]
    fn eq(&self, other: &SystemTime) -> bool {
        *self - Self::UNIX_EPOCH == other.signed_duration_since(SystemTime::UNIX_EPOCH)
    }
}

impl PartialEq<Timestamp> for SystemTime {
    #[inline]
    fn eq(&self, other: &Timestamp) -> bool {
        other == self
    }
}

impl PartialOrd<SystemTime> for Timestamp {
    #[inline]
    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
        (*self - Self::UNIX_EPOCH).partial_cmp(&other.signed_duration_since(SystemTime::UNIX_EPOCH))
    }
}

impl PartialOrd<Timestamp> for SystemTime {
    #[inline]
    fn partial_cmp(&self, other: &Timestamp) -> Option<Ordering> {
        other.partial_cmp(self).map(Ordering::reverse)
    }
}

impl From<SystemTime> for Timestamp {
    /// # Panics
    ///
    /// This may panic if an overflow occurs.
    #[inline]
    #[track_caller]
    fn from(datetime: SystemTime) -> Self {
        let duration = datetime.signed_duration_since(SystemTime::UNIX_EPOCH);
        let mut seconds = duration.whole_seconds();
        let mut nanoseconds = duration.subsec_nanoseconds();

        if nanoseconds < 0 {
            seconds -= 1;
            nanoseconds += Nanosecond::per_t::<i32>(Second);
        }

        Self::new(seconds, nanoseconds.cast_unsigned())
            .expect("SystemTime value is out of valid range")
    }
}

impl From<Timestamp> for SystemTime {
    /// # Panics
    ///
    /// This may panic if an overflow occurs.
    #[inline]
    #[track_caller]
    fn from(timestamp: Timestamp) -> Self {
        Self::UNIX_EPOCH + (timestamp - Timestamp::UNIX_EPOCH)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::ext::NumericalDuration;

    #[test]
    fn systime_to_timestamp() -> crate::Result<()> {
        let ts = Timestamp::from(SystemTime::UNIX_EPOCH + 5.seconds());
        assert_eq!(ts, Timestamp::from_seconds(5)?);

        let ts = Timestamp::from(SystemTime::UNIX_EPOCH - 5.seconds());
        assert_eq!(ts, Timestamp::from_seconds(-5)?);

        let ts = Timestamp::from(SystemTime::UNIX_EPOCH + 5.seconds() + 1.milliseconds());
        assert_eq!(ts, Timestamp::from_milliseconds(5_001)?);

        let ts = Timestamp::from(SystemTime::UNIX_EPOCH - 5.seconds() - 1.milliseconds());
        assert_eq!(ts, Timestamp::from_milliseconds(-5_001)?);

        Ok(())
    }
}