Struct EncodedTime 

pub struct EncodedTime<S: Scale, R: TimeRepresentation> { /* private fields */ }

A typed external representation of a Time<S> instant.

Implementations

impl<S: Scale, R: TimeRepresentation> EncodedTime<S, R>

pub const fn new_unchecked(raw: Quantity<R::Unit>) -> Self

Construct from a raw quantity, bypassing the finite check.

Passing a non-finite value yields an instant whose behaviour is unspecified. Prefer Self::try_new for user-supplied data; use this only when the value is known to be finite (e.g. compile-time constants).

pub const fn raw(self) -> Quantity<R::Unit>

Return the underlying typed quantity.

pub const fn quantity(self) -> Quantity<R::Unit>

Alias for Self::raw.

impl<S: Scale, R> EncodedTime<S, R>

where R: RepresentationForScale<S>,

pub fn try_new(raw: Quantity<R::Unit>) -> Result<Self, ConversionError>

Construct a typed encoded instant from its raw quantity.

pub fn try_to_time(self) -> Result<Time<S>, ConversionError>

Convert this encoded instant to the canonical Time<S> model.

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

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

Convert this encoded instant to the canonical Time<S> model using an explicit context.

impl<S: Scale, R> EncodedTime<S, R>

where R: InfallibleRepresentationForScale<S>,

pub fn to_time(self) -> Time<S>

Infallible conversion to the canonical Time<S> model.

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

where T: InfallibleConversionTarget<S>,

Unified infallible conversion to a target scale or encoded format.

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

where T: ConversionTarget<S>,

Unified fallible conversion to a target scale or encoded format.

impl<S: Scale, R> EncodedTime<S, R>

where R: RepresentationForScale<S>,

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

where T: ContextConversionTarget<S>,

Unified context-backed conversion to a target scale or encoded format.

impl<S: Scale, R> EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

pub fn min(self, other: Self) -> Self

Earlier of self and other.

Equivalent to if self <= other { self } else { other }.

pub fn max(self, other: Self) -> Self

Later of self and other.

pub fn mean(self, other: Self) -> Self

Midpoint between self and other.

impl<S: CoordinateScale> EncodedTime<S, JD>

pub const JULIAN_YEAR: Day

Length of a Julian year in days (365.25 d).

pub const JULIAN_CENTURY: Day

Length of a Julian century in days (36 525 d).

pub fn new(jd: f64) -> Self

Construct from a raw Julian Day value without validation.

Prefer Self::try_new for untrusted input.

pub fn jd_value(self) -> f64

Raw Julian Day value as f64 (days since noon 1 January 4713 BC JD).

pub fn julian_centuries(self) -> f64

Julian centuries since J2000.0: T = (JD − 2 451 545.0) / 36 525.

pub fn julian_millennias(self) -> f64

Julian millennia since J2000.0: T = (JD − 2 451 545.0) / 365 250.

impl EncodedTime<TT, JD>

pub const J2000: Self = J2000_TT

J2000.0 epoch as a TT-scale Julian Date (JD(TT) = 2 451 545.0).

pub fn tt_to_tdb(self) -> JulianDate<TDB>

Convert this TT Julian Date to the TDB scale.

Uses the Fairhead-Bretagnon periodic correction stored in the scale conversion layer. The result is on the TDB coordinate time axis, still expressed as a Julian Date.

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

Build a TT Julian Date from a chrono::DateTime<Utc>.

Converts UTC → TAI → TT internally. Panics if the UTC time data is unavailable for the supplied instant; use Time::<UTC>::try_from_chrono for a fallible path.

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

Convert this TT Julian Date to a chrono::DateTime<Utc>.

Returns None if the value is outside the supported UTC range.

impl<S: CoordinateScale> EncodedTime<S, MJD>

pub fn new(mjd: f64) -> Self

Construct from a raw Modified Julian Day value without validation.

Prefer Self::try_new for untrusted input.

pub fn mjd_value(self) -> f64

Raw Modified Julian Day value as f64 (days since midnight 17 November 1858).

impl EncodedTime<TT, MJD>

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

Build a TT Modified Julian Date from a chrono::DateTime<Utc>.

Converts UTC → TAI → TT internally. Panics if UTC time data is unavailable; use Time::<UTC>::try_from_chrono for a fallible path.

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

Convert this TT Modified Julian Date to a chrono::DateTime<Utc>.

Returns None if the value is outside the supported UTC range.

Trait Implementations

impl<S: Scale, R> Add<Quantity<Day>> for EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

type Output = EncodedTime<S, R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Scale, R> AddAssign<Quantity<Day>> for EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

fn add_assign(&mut self, rhs: Day)

Performs the += operation.

impl<S: Scale, R: TimeRepresentation> Clone for EncodedTime<S, R>

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, R: TimeRepresentation> Debug for EncodedTime<S, R>

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

Formats the value using the given formatter.

impl<S: Scale, R: TimeRepresentation> Display for EncodedTime<S, R>

where Quantity<R::Unit>: Display,

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

Formats the value using the given formatter.

impl<S: CoordinateScale> From<EncodedTime<S, JD>> for ModifiedJulianDate<S>

fn from(jd: JulianDate<S>) -> Self

Convert a Julian Date to a Modified Julian Date on the same scale.

impl<S: CoordinateScale> From<EncodedTime<S, MJD>> for JulianDate<S>

fn from(mjd: ModifiedJulianDate<S>) -> Self

Convert a Modified Julian Date to a Julian Date on the same scale.

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, R: TimeRepresentation> LowerExp for EncodedTime<S, R>

where Quantity<R::Unit>: LowerExp,

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

Formats the value using the given formatter.

impl<S: Scale, R: TimeRepresentation> PartialEq for EncodedTime<S, R>

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, R: TimeRepresentation> PartialOrd for EncodedTime<S, R>

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: Scale, R> Sub<Quantity<Day>> for EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

type Output = EncodedTime<S, R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Scale, R> Sub for EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

b - a returns the signed offset in days: positive when b is later.

type Output = Quantity<Day>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Scale, R> SubAssign<Quantity<Day>> for EncodedTime<S, R>

where R: TimeRepresentation<Unit = Day>,

fn sub_assign(&mut self, rhs: Day)

Performs the -= operation.

impl<S: Scale, R: TimeRepresentation> UpperExp for EncodedTime<S, R>

where Quantity<R::Unit>: UpperExp,

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

Formats the value using the given formatter.

impl<S: Scale, R: TimeRepresentation> Copy for EncodedTime<S, R>