lox-time 0.1.0-alpha.22

Time modelling tools for the Lox ecosystem
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

// SPDX-FileCopyrightText: 2026 Helge Eichhorn <git@helgeeichhorn.de>
//
// SPDX-License-Identifier: MPL-2.0

use chrono::{DateTime, Utc};
use lox_core::time::deltas::ToDelta;

pub use lox_core::time::chrono::ChronoError;

use crate::utc::transformations::ToUtc;
use crate::{Time, time_scales::Tai, utc::UtcError};

impl TryFrom<Time<Tai>> for DateTime<Utc> {
    type Error = ChronoError;

    fn try_from(time: Time<Tai>) -> Result<Self, Self::Error> {
        let utc = time.to_utc();
        utc.to_delta().try_into()
    }
}

impl From<DateTime<Utc>> for Time<Tai> {
    fn from(dt: DateTime<Utc>) -> Self {
        crate::utc::Utc::from_delta(dt.into())
            .expect("chrono::DateTime always produces a finite TimeDelta")
            .to_time()
    }
}

impl TryFrom<crate::utc::Utc> for DateTime<Utc> {
    type Error = ChronoError;

    fn try_from(utc: crate::utc::Utc) -> Result<Self, Self::Error> {
        utc.to_delta().try_into()
    }
}

impl TryFrom<DateTime<Utc>> for crate::utc::Utc {
    type Error = UtcError;

    fn try_from(dt: DateTime<Utc>) -> Result<Self, Self::Error> {
        crate::utc::Utc::from_delta(dt.into())
    }
}

#[cfg(test)]
mod tests {
    use lox_core::time::{constants::UNIX_EPOCH, deltas::TimeDelta};
    use rstest::rstest;

    use super::*;

    // Post-1972 delta where TAI-UTC offset is an exact integer, ensuring
    // lossless roundtrip through chrono's nanosecond precision.
    const POST_1972_DELTA: TimeDelta = TimeDelta::from_seconds(-86400);

    #[rstest]
    #[case(POST_1972_DELTA)]
    #[case(TimeDelta::default())]
    #[case(TimeDelta::from_seconds_f64(0.123456))]
    #[should_panic(expected = "NaN TimeDelta cannot be converted to UTC")]
    #[case(TimeDelta::NaN)]
    fn test_chrono_time_roundtrip(#[case] delta: TimeDelta) {
        let exp = Time::from_delta(Tai, delta);
        let dt: DateTime<Utc> = exp.try_into().unwrap();
        let act: Time<Tai> = dt.into();
        assert_eq!(act, exp)
    }

    #[rstest]
    #[case(UNIX_EPOCH)]
    #[case(TimeDelta::default())]
    #[case(TimeDelta::from_seconds_f64(0.123456))]
    fn test_chrono_utc_roundtrip(#[case] delta: TimeDelta) {
        let exp = crate::utc::Utc::from_delta(delta).unwrap();
        let dt: DateTime<Utc> = exp.try_into().unwrap();
        let act: crate::utc::Utc = dt.try_into().unwrap();
        assert_eq!(act, exp)
    }
}