temporal_core 0.0.1

An Intl-first date time 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
128
129
130
131

use std::time::{SystemTime, Duration, UNIX_EPOCH};

use crate::iso;

#[derive(Default)]
pub struct NominalDuration {
    is_negative: bool,
    years: u32,
    months: u32,
    weeks: u32,
    days: u32,
    hours: u32,
    minutes: u32,
    seconds: u32,
    milli_seconds: u32,
    micro_seconds: u32,
    nano_seconds: u32,
}

impl NominalDuration {
    fn signum(&self) -> i32 {
        if self.is_negative {
            -1
        } else {
            1
        }
    }

    pub fn from_years(years: i32) -> Self {
        Self {
            years: years.abs().try_into().unwrap(),
            ..Self::default()
        }
    }

    pub fn years(&self) -> i32 {
        self.years as i32 * self.signum()
    }
    pub fn months(&self) -> i32 {
        self.months as i32 * self.signum()
    }
    pub fn weeks(&self) -> i32 {
        self.weeks as i32 * self.signum()
    }
    pub fn days(&self) -> i32 {
        self.days as i32 * self.signum()
    }
}

pub struct SignedDuration {
    secs: i64,
    nanos: u32, // Always 0 <= nanos < NANOS_PER_SEC
}

impl TryFrom<SignedDuration> for Duration {
    type Error = <i64 as TryFrom<u64>>::Error;

    fn try_from(value: SignedDuration) -> Result<Self, Self::Error> {
        Ok(Self::new(value.as_secs().try_into()?, value.subsec_nanos()))
    }
}

impl TryFrom<Duration> for SignedDuration {
    type Error = <i64 as TryFrom<u64>>::Error;

    fn try_from(value: Duration) -> Result<Self, Self::Error> {
        Ok(Self::new_unchecked(value.as_secs().try_into()?, value.subsec_nanos()))
    }
}

impl SignedDuration {
    pub fn now() -> Self {
        let now = SystemTime::now();
        Self::from_system_time_since_unix(now)
    }

    pub(crate) fn new_unchecked(secs: i64, nanos: u32) -> Self {
        Self { secs, nanos }
    }

    pub fn new(mut secs: i64, nanos: i32) -> Self {
        secs += nanos.div_euclid(1000_000_000) as i64;
        Self {
            secs,
            nanos: nanos.rem_euclid(1000_000_000) as u32,
        }
    }

    pub fn from_iso_string(s: &str) -> Option<Self> {
        let i = iso::parse(s)?;
        let offset_secs = match i.timezone_offset? {
            iso::IsoOffset::Z => 0,
            iso::IsoOffset::Numeric(x) => x.to_seconds() as i64,
        };
        let time_secs = if let Some(x) = i.time {
            x.to_second().into()
        } else {
            0
        };
        let secs = i.date.to_epoch_second() + time_secs + offset_secs;
        Some(Self::new(secs, 0))
    }

    pub(crate) fn from_system_time_since_unix(s: SystemTime) -> Self {
        match s.duration_since(UNIX_EPOCH) {
            Ok(d) => SignedDuration {
                secs: d.as_secs() as i64,
                nanos: d.subsec_nanos(),
            },
            Err(e) => {
                let d = e.duration();
                SignedDuration {
                    secs: -(d.as_secs() as i64),
                    nanos: d.subsec_nanos(),
                }
            }
        }
    }

    pub fn from_secs(secs: i64) -> Self {
        Self { secs, nanos: 0 }
    }

    pub fn as_secs(&self) -> i64 {
        self.secs
    }

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