Struct TimeScaleConversion 

pub struct TimeScaleConversion {
    pub source: TimeScale,
    pub target: TimeScale,
    pub offset_seconds: f64,
}

A caller-supplied time-scale conversion policy.

The conversion stores the source and target time scales plus the explicit target - source offset in SI seconds. It does not model Delta T, leap seconds, DUT1, or relativistic TDB terms itself; it only packages the caller’s chosen rule so an instant can be retagged explicitly and reproducibly. Its compact summary renders the structured field names explicitly so release-facing diagnostics do not have to infer which side of the conversion the offset applies to.

Example

use pleiades_types::{Instant, JulianDay, TimeScale, TimeScaleConversion};

let policy = TimeScaleConversion::new(TimeScale::Ut1, TimeScale::Tt, 64.184);
let instant = Instant::new(JulianDay::from_days(2_451_545.0), TimeScale::Ut1);
let converted = policy.apply(instant).expect("UT1-tagged instant");

assert_eq!(policy.summary_line(), "source=UT1; target=TT; offset_seconds=64.184 s");
assert_eq!(converted.scale, TimeScale::Tt);

use pleiades_types::{Instant, JulianDay, TimeScale, TimeScaleConversion};

let policy = TimeScaleConversion::new(TimeScale::Tdb, TimeScale::Tt, -0.001_657);
let instant = Instant::new(JulianDay::from_days(2_451_545.0), TimeScale::Tdb);

assert!(policy.validate(instant).is_ok());
assert_eq!(policy.summary_line(), "source=TDB; target=TT; offset_seconds=-0.001657 s");
assert_eq!(policy.validated_summary_line(instant).unwrap(), policy.summary_line());

Fields

source: TimeScale

The source time scale expected by the policy.

target: TimeScale

The target time scale produced by the policy.

offset_seconds: f64

The explicit target - source offset in SI seconds.

Implementations

impl TimeScaleConversion

pub const fn new( source: TimeScale, target: TimeScale, offset_seconds: f64, ) -> TimeScaleConversion

Creates a new caller-supplied time-scale conversion policy.

pub fn summary_line(&self) -> String

Returns a compact one-line rendering of the caller-supplied policy.

pub fn validated_summary_line( &self, instant: Instant, ) -> Result<String, TimeScaleConversionError>

Returns the compact summary line after validating the policy.

This keeps the fail-closed rendering path co-located with the explicit conversion contract when a caller wants to report the policy before mutating the instant.

pub fn validate(self, instant: Instant) -> Result<(), TimeScaleConversionError>

Validates the policy against a specific instant without retagging it.

This is useful when a caller wants to preflight the explicit conversion contract before mutating the instant itself. The source scale must match the instant’s current scale, and the offset must be finite.

pub fn apply( self, instant: Instant, ) -> Result<Instant, TimeScaleConversionError>

Applies the policy to an instant.

This is the mutating counterpart to TimeScaleConversion::validate. The source scale must match the instant’s current scale, and the offset must be finite. Otherwise the conversion fails with the same structured time-scale error used by the lower-level helpers.

Trait Implementations

impl Clone for TimeScaleConversion

fn clone(&self) -> TimeScaleConversion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TimeScaleConversion

impl Debug for TimeScaleConversion

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TimeScaleConversion

fn deserialize<__D>( __deserializer: __D, ) -> Result<TimeScaleConversion, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TimeScaleConversion

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

Formats the value using the given formatter.

impl PartialEq for TimeScaleConversion

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TimeScaleConversion

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TimeScaleConversion