Struct Time 

pub struct Time<S: Scale> { /* private fields */ }

A point in time on scale S.

Internally, Time<S> stores a compensated (hi, lo) pair of seconds since J2000 TT on the scale’s coordinate axis. The pair sums to the exact value represented by the instance, while keeping the low-order remainder small enough to retain much better precision than a single f64.

Time<S> is intentionally modeled as an affine point, not as a raw scalar: subtracting two instants yields a duration, while adding or subtracting a duration shifts an instant. Internally this is represented with affn::SplitPoint1, which preserves the same point-vs-displacement semantics used elsewhere in the codebase.

The split representation exists because astronomical epochs are large values, while important corrections are often tiny. A single f64 would discard low-order precision too aggressively once epoch-sized values are combined with sub-second or microsecond-scale offsets, so Time<S> keeps the large component in hi and the residual correction in lo.

UTC remains special: it stores a continuous instant on the same internal axis used by TAI, but its civil interpretation still comes from the active UTC-TAI table. Raw JD/MJD/J2000-second helpers and second-based arithmetic operate on that stored instant axis; use the civil API when you need leap-second-labelled UTC values.

Implementations

impl Time<UTC>

pub fn try_from_chrono_with( dt: DateTime<Utc>, ctx: &TimeContext, ) -> Result<Self, ConversionError>

Build a UTC instant from a chrono::DateTime<Utc> using the context’s captured time-data bundle.

pub fn try_from_chrono(dt: DateTime<Utc>) -> Result<Self, ConversionError>

Build a UTC instant from a chrono::DateTime<Utc>.

Snapshots the active time-data bundle at call time via TimeContext::new. For reproducible pipelines, prefer try_from_chrono_with with an explicit context.

pub fn from_chrono_with(dt: DateTime<Utc>, ctx: &TimeContext) -> Self

Convenience panicking wrapper over try_from_chrono_with.

pub fn from_chrono(dt: DateTime<Utc>) -> Self

Convenience panicking wrapper over try_from_chrono.

Snapshots the active time-data bundle at call time via TimeContext::new. For reproducible pipelines, prefer from_chrono_with.

pub fn try_to_chrono_with( self, ctx: &TimeContext, ) -> Result<DateTime<Utc>, ConversionError>

Convert to a chrono::DateTime<Utc>, preserving leap-second labels, using the context’s captured time-data bundle.

pub fn try_to_chrono(self) -> Result<DateTime<Utc>, ConversionError>

Convert to a chrono::DateTime<Utc>, preserving leap-second labels.

Snapshots the active time-data bundle at call time via TimeContext::new. For reproducible pipelines, prefer try_to_chrono_with with an explicit context.

pub fn to_chrono_with(self, ctx: &TimeContext) -> Option<DateTime<Utc>>

Convenience non-fallible wrapper (returns None on error) using the context’s captured time-data bundle.

pub fn to_chrono(self) -> Option<DateTime<Utc>>

Convenience non-fallible wrapper (returns None on error).

Snapshots the active time-data bundle at call time via TimeContext::new. For reproducible pipelines, prefer to_chrono_with.

pub fn is_leap_second_with(self, ctx: &TimeContext) -> bool

Returns true if this instant falls inside a positive leap second in UTC (e.g. 23:59:60) using the context’s captured time-data bundle.

pub fn is_leap_second(self) -> bool

Returns true if this instant falls inside a positive leap second in UTC (e.g. 23:59:60).

Snapshots the active time-data bundle at call time via TimeContext::new. For reproducible pipelines, prefer is_leap_second_with.

impl<S: Scale> Time<S>

pub fn raw_seconds_pair(self) -> (Second, Second)

Raw internal storage pair in J2000-TT seconds on the instance scale.

impl<S: CoordinateScale> Time<S>

pub fn try_from_raw_j2000_seconds_split( hi: Second, lo: Second, ) -> Result<Self, ConversionError>

Build from a split J2000-second pair on the scale’s coordinate axis.

This is the public constructor for FFI and wrapper layers that need to preserve the compensated (hi, lo) representation instead of flattening it to one scalar.

impl<S: Scale> Time<S>

pub fn to<T>(self) -> T::Output

where T: InfallibleConversionTarget<S>,

Unified infallible conversion to a scale/view target.

pub fn try_to<T>(self) -> Result<T::Output, ConversionError>

where T: ConversionTarget<S>,

Unified fallible conversion to a scale/view target.

pub fn to_with<T>(self, ctx: &TimeContext) -> Result<T::Output, ConversionError>

where T: ContextConversionTarget<S>,

Unified context-backed conversion to a scale/view target.

pub fn to_scale<S2: Scale>(self) -> Time<S2>

where S: InfallibleScaleConvert<S2>,

Infallible scale conversion. Compiles only for pairs with a closed-form, context-free conversion.

pub fn to_scale_with<S2: Scale>( self, ctx: &TimeContext, ) -> Result<Time<S2>, ConversionError>

where S: ContextScaleConvert<S2>,

Context-required scale conversion (UT1 routes).

Trait Implementations

impl<S: CoordinateScale> Add<Quantity<Second>> for Time<S>

type Output = Time<S>

The resulting type after applying the + operator.

fn add(self, rhs: Second) -> Self

Performs the + operation.

impl<S: CoordinateScale> AddAssign<Quantity<Second>> for Time<S>

fn add_assign(&mut self, rhs: Second)

Performs the += operation.

impl<S: Scale> Clone for Time<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Scale> Debug for Time<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Scale> Display for Time<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Scale, F> From<EncodedTime<S, F>> for Time<S>

where F: InfallibleFormatForScale<S>,

fn from(value: EncodedTime<S, F>) -> Self

Converts to this type from the input type.

impl<S: Scale, F> From<Time<S>> for EncodedTime<S, F>

where F: InfallibleFormatForScale<S>,

fn from(value: Time<S>) -> Self

Converts to this type from the input type.

impl<S: Scale> PartialEq for Time<S>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Scale> PartialOrd for Time<S>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S: CoordinateScale> Sub<Quantity<Second>> for Time<S>

type Output = Time<S>

The resulting type after applying the - operator.

fn sub(self, rhs: Second) -> Self

Performs the - operation.

impl<S: CoordinateScale> Sub for Time<S>

type Output = Quantity<Second>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Second

Performs the - operation.

impl<S: CoordinateScale> SubAssign<Quantity<Second>> for Time<S>

fn sub_assign(&mut self, rhs: Second)

Performs the -= operation.

impl TimeInstant for Time<TT>

type Duration = Quantity<Second>

Duration type produced by subtracting two instants.

fn difference(&self, other: &Self) -> Second

Signed duration from other to self (self − other).

fn add_duration(&self, dur: Second) -> Self

Shift this instant forward by duration.

impl<S: Scale> Copy for Time<S>