tempoch-core 0.6.0

Core astronomical time primitives for tempoch.
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

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Vallés Puig, Ramon

//! `chrono` convenience impls for TT-encoded instants whose format round-trips on TT
//! (e.g. [`JD`], [`MJD`], [`J2000s`] — not [`GPS`], which encodes TAI).

use crate::earth::context::TimeContext;
use crate::format::TimeFormat;
use crate::foundation::error::ConversionError;
use crate::model::scale::{TT, UTC};
use crate::model::target::InfallibleConversionTarget;
use crate::model::time::Time;
use crate::InfallibleFormatForScale;
use chrono::{DateTime, Utc};

impl<F: TimeFormat> Time<TT, F>
where
    F: InfallibleFormatForScale<TT> + InfallibleConversionTarget<TT, Output = Time<TT, F>>,
{
    /// Build a TT [`Time`] in format `F` from a UTC `chrono` timestamp.
    #[inline]
    pub fn try_from_chrono(dt: DateTime<Utc>) -> Result<Self, ConversionError> {
        Ok(Time::<UTC>::try_from_chrono(dt)?.to::<TT>().reinterpret())
    }

    /// Build a TT [`Time`] in format `F` from a UTC `chrono` timestamp.
    #[track_caller]
    #[inline]
    pub fn from_chrono(dt: DateTime<Utc>) -> Self {
        Self::try_from_chrono(dt).expect("UTC conversion failed; use try_from_chrono")
    }

    /// Like [`Self::try_from_chrono`], but uses an explicit [`TimeContext`].
    #[inline]
    pub fn try_from_chrono_with(
        dt: DateTime<Utc>,
        ctx: &TimeContext,
    ) -> Result<Self, ConversionError> {
        Ok(Time::<UTC>::try_from_chrono_with(dt, ctx)?
            .to::<TT>()
            .reinterpret())
    }

    /// Like [`Self::from_chrono`], but uses an explicit [`TimeContext`].
    #[track_caller]
    #[inline]
    pub fn from_chrono_with(dt: DateTime<Utc>, ctx: &TimeContext) -> Self {
        Self::try_from_chrono_with(dt, ctx)
            .expect("UTC conversion failed; use try_from_chrono_with")
    }

    /// Convert to a UTC `chrono` timestamp (TT → UTC using a default context).
    #[inline]
    pub fn try_to_chrono(self) -> Result<DateTime<Utc>, ConversionError> {
        self.to_j2000s().to::<UTC>().try_to_chrono()
    }

    /// Convert to a UTC `chrono` timestamp (TT → UTC using a default context).
    #[inline]
    pub fn to_chrono(self) -> Option<DateTime<Utc>> {
        self.try_to_chrono().ok()
    }

    /// Like [`Self::try_to_chrono`], but uses an explicit [`TimeContext`].
    #[inline]
    pub fn try_to_chrono_with(self, ctx: &TimeContext) -> Result<DateTime<Utc>, ConversionError> {
        self.to_j2000s().to::<UTC>().try_to_chrono_with(ctx)
    }

    /// Like [`Self::to_chrono`], but uses an explicit [`TimeContext`].
    #[inline]
    pub fn to_chrono_with(self, ctx: &TimeContext) -> Option<DateTime<Utc>> {
        self.try_to_chrono_with(ctx).ok()
    }
}

impl<F: TimeFormat> From<DateTime<Utc>> for Time<TT, F>
where
    F: InfallibleFormatForScale<TT> + InfallibleConversionTarget<TT, Output = Time<TT, F>>,
{
    #[inline]
    fn from(value: DateTime<Utc>) -> Self {
        Self::from_chrono(value)
    }
}