Struct Time 

pub struct Time<S>
where
    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<Time<UTC>, 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<Time<UTC>, 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) -> Time<UTC>

Convenience panicking wrapper over try_from_chrono_with.

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

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> Time<S>

where S: Scale,

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

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

impl<S> Time<S>

where S: Scale,

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

where T: InfallibleConversionTarget<S>,

Unified infallible conversion to a scale/view target.

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

where T: ConversionTarget<S>,

Unified fallible conversion to a scale/view target.

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

where T: ContextConversionTarget<S>,

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

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

where S2: Scale, S: InfallibleScaleConvert<S2>,

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

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

where S2: Scale, S: ContextScaleConvert<S2>,

Context-required scale conversion (UT1 routes).

Trait Implementations

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

where S: CoordinateScale,

type Output = Time<S>

The resulting type after applying the + operator.

fn add(self, rhs: Quantity<Second>) -> Time<S>

Performs the + operation.

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

where S: CoordinateScale,

fn add_assign(&mut self, rhs: Quantity<Second>)

Performs the += operation.

impl<S> Clone for Time<S>

where S: Scale,

fn clone(&self) -> Time<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Time<S>

where S: Scale,

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

Formats the value using the given formatter.

impl<S> Display for Time<S>

where S: Scale,

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

Formats the value using the given formatter.

impl<S, R> From<EncodedTime<S, R>> for Time<S>

where S: Scale, R: InfallibleRepresentationForScale<S>,

fn from(value: EncodedTime<S, R>) -> Time<S>

Converts to this type from the input type.

impl<S, R> From<Time<S>> for EncodedTime<S, R>

where S: Scale, R: InfallibleRepresentationForScale<S>,

fn from(value: Time<S>) -> EncodedTime<S, R>

Converts to this type from the input type.

impl<S> PartialEq for Time<S>

where S: Scale,

fn eq(&self, other: &Time<S>) -> 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> PartialOrd for Time<S>

where S: Scale,

fn partial_cmp(&self, other: &Time<S>) -> 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> Sub<Quantity<Second>> for Time<S>

where S: CoordinateScale,

type Output = Time<S>

The resulting type after applying the - operator.

fn sub(self, rhs: Quantity<Second>) -> Time<S>

Performs the - operation.

impl<S> Sub for Time<S>

where S: CoordinateScale,

type Output = Quantity<Second>

The resulting type after applying the - operator.

fn sub(self, rhs: Time<S>) -> Quantity<Second>

Performs the - operation.

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

where S: CoordinateScale,

fn sub_assign(&mut self, rhs: Quantity<Second>)

Performs the -= operation.

impl TimeInstant for Time<TT>

type Duration = Quantity<Second>

Duration type produced by subtracting two instants.

fn difference(&self, other: &Time<TT>) -> Quantity<Second>

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

fn add_duration(&self, dur: Quantity<Second>) -> Time<TT>

Shift this instant forward by duration.

impl<S> Copy for Time<S>

where S: Scale,