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: 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, R> From<EncodedTime<S, R>> for Time<S>

where R: InfallibleRepresentationForScale<S>,

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

Converts to this type from the input type.

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

where R: InfallibleRepresentationForScale<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<S: Scale> Copy for Time<S>