time/interop/
utcdatetime_systemtime.rs

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
use core::cmp::Ordering;
use core::ops::Sub;
use std::time::SystemTime;

use crate::{Duration, UtcDateTime};

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

    /// # Panics
    ///
    /// This may panic if an overflow occurs.
    fn sub(self, rhs: SystemTime) -> Self::Output {
        self - Self::from(rhs)
    }
}

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

    /// # Panics
    ///
    /// This may panic if an overflow occurs.
    fn sub(self, rhs: UtcDateTime) -> Self::Output {
        UtcDateTime::from(self) - rhs
    }
}

impl PartialEq<SystemTime> for UtcDateTime {
    fn eq(&self, rhs: &SystemTime) -> bool {
        self == &Self::from(*rhs)
    }
}

impl PartialEq<UtcDateTime> for SystemTime {
    fn eq(&self, rhs: &UtcDateTime) -> bool {
        &UtcDateTime::from(*self) == rhs
    }
}

impl PartialOrd<SystemTime> for UtcDateTime {
    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
        self.partial_cmp(&Self::from(*other))
    }
}

impl PartialOrd<UtcDateTime> for SystemTime {
    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
        UtcDateTime::from(*self).partial_cmp(other)
    }
}

impl From<SystemTime> for UtcDateTime {
    fn from(system_time: SystemTime) -> Self {
        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
            Ok(duration) => Self::UNIX_EPOCH + duration,
            Err(err) => Self::UNIX_EPOCH - err.duration(),
        }
    }
}

impl From<UtcDateTime> for SystemTime {
    fn from(datetime: UtcDateTime) -> Self {
        let duration = datetime - UtcDateTime::UNIX_EPOCH;

        if duration.is_zero() {
            Self::UNIX_EPOCH
        } else if duration.is_positive() {
            Self::UNIX_EPOCH + duration.unsigned_abs()
        } else {
            debug_assert!(duration.is_negative());
            Self::UNIX_EPOCH - duration.unsigned_abs()
        }
    }
}