Struct Time 

pub struct Time<T: TimeScale> { /* private fields */ }

An instant in time in a given TimeScale, relative to J2000.

Time supports femtosecond precision, but be aware that many algorithms operating on Times are not accurate to this level of precision.

Implementations

impl<T: TimeScale> Time<T>

pub const fn new(scale: T, seconds: i64, subsecond: Subsecond) -> Self

Instantiates a Time in the given TimeScale from the count of seconds since J2000, subdivided into integral seconds and Subsecond.

pub fn from_date_and_time( scale: T, date: Date, time: TimeOfDay, ) -> Result<Self, TimeError>

Instantiates a Time in the given TimeScale from a Date and a TimeOfDay.

Errors

• Returns TimeError::LeapSecondsOutsideUtc if time is a leap second, since leap seconds cannot be unambiguously represented by a continuous time format.

pub fn from_iso(scale: T, iso: &str) -> Result<Self, TimeError>

Instantiates a Time in the given TimeScale from an ISO 8601 string.

Errors

• Returns TimeError::InvalidIsoString if iso is not a valid ISO 8601 timestamp.

pub const fn from_delta(scale: T, delta: TimeDelta) -> Self

Instantiates a Time in the given TimeScale and a TimeDelta relative to J2000.

pub const fn from_epoch(scale: T, epoch: Epoch) -> Self

Returns the Time at epoch in the given TimeScale.

Since Time is defined relative to J2000, this is equivalent to the delta between J2000 and epoch.

pub fn from_julian_date(scale: T, julian_date: Days, epoch: Epoch) -> Self

Given a Julian date, instantiates a Time in the specified TimeScale, relative to epoch.

pub fn from_two_part_julian_date(scale: T, jd1: Days, jd2: Days) -> Self

Instantiates a Time from a two-part Julian date jd1 + jd2 in days.

pub fn builder_with_scale(scale: T) -> TimeBuilder<T>

Returns a TimeBuilder for constructing a new Time in the given TimeScale.

pub fn scale(&self) -> T

where T: Copy,

Returns the timescale

pub fn with_scale<S: TimeScale>(&self, scale: S) -> Time<S>

Returns a new Time with the delta of self but time scale scale.

Note that the underlying delta is simply copied – no time scale transformation takes place.

pub fn try_to_scale<S, P>( &self, scale: S, provider: &P, ) -> Result<Time<S>, P::Error>

where T: Copy, S: TimeScale + Copy, P: TryOffset<T, S> + ?Sized,

Converts this time to scale using the given offset provider.

pub fn to_scale<S>(&self, scale: S) -> Time<S>

where T: Copy, S: TimeScale + Copy, DefaultOffsetProvider: Offset<T, S>,

Converts this time to scale using the default offset provider.

pub fn with_scale_and_delta<S: TimeScale>( &self, scale: S, delta: TimeDelta, ) -> Time<S>

Returns a new Time with the delta of self adjusted by delta, and time scale scale.

Note that no time scale transformation takes place beyond the adjustment specified by delta.

pub fn jd0(scale: T) -> Self

Returns the Julian epoch as a Time in the given TimeScale.

pub fn mjd0(scale: T) -> Self

Returns the modified Julian epoch as a Time in the given TimeScale.

pub fn j1950(scale: T) -> Self

Returns the J1950 epoch as a Time in the given TimeScale.

pub fn j2000(scale: T) -> Self

Returns the J2000 epoch as a Time in the given TimeScale.

pub fn as_seconds_and_subsecond(&self) -> Option<(i64, Subsecond)>

Returns the seconds and subsecond components, or None if the delta is non-finite.

pub fn seconds(&self) -> Option<i64>

Returns the number of whole seconds since J2000.

pub fn subsecond(&self) -> Option<f64>

Returns the fraction of a second from the last whole second as an f64.

impl<T: TimeScale + Into<DynTimeScale>> Time<T>

pub fn into_dyn(self) -> DynTime

Converts this time into a DynTime with a runtime time scale.

Trait Implementations

impl<T: TimeScale> Add<TimeDelta> for Time<T>

type Output = Time<T>

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> Self::Output

Performs the + operation.

impl<T: TimeScale + Debug> ApproxEq for Time<T>

fn approx_eq(&self, rhs: &Self, atol: f64, rtol: f64) -> ApproxEqResults

Compares self with rhs for approximate equality.

impl<T: TimeScale> CalendarDate for Time<T>

fn date(&self) -> Date

Returns the date component.

fn year(&self) -> i64

Returns the year.

fn month(&self) -> u8

Returns the month (1–12).

fn day(&self) -> u8

Returns the day of the month (1–31).

fn day_of_year(&self) -> u16

Returns the day number within the year (1–366).

impl<T: TimeScale> CivilTime for Time<T>

fn time(&self) -> TimeOfDay

Returns the time-of-day component.

fn hour(&self) -> u8

Returns the hour (0–23).

fn minute(&self) -> u8

Returns the minute (0–59).

fn second(&self) -> u8

Returns the second (0–60, where 60 represents a leap second).

fn as_seconds_f64(&self) -> f64

Returns the second including the subsecond fraction as an f64.

fn millisecond(&self) -> u32

Returns the millisecond component (0–999).

fn microsecond(&self) -> u32

Returns the microsecond component (0–999).

fn nanosecond(&self) -> u32

Returns the nanosecond component (0–999).

fn picosecond(&self) -> u32

Returns the picosecond component (0–999).

fn femtosecond(&self) -> u32

Returns the femtosecond component (0–999).

impl<T: Clone + TimeScale> Clone for Time<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TimeScale> Debug for Time<T>

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

Formats the value using the given formatter.

impl<T: Default + TimeScale> Default for Time<T>

fn default() -> Time<T>

Returns the “default value” for a type.

impl<T: TimeScale> Display for Time<T>

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

Formats the value using the given formatter.

impl FromStr for Time<Tai>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for Time<Tcb>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for Time<Tcg>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for Time<Tdb>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for Time<Tt>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl FromStr for Time<Ut1>

type Err = TimeError

The associated error which can be returned from parsing.

fn from_str(iso: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T: TimeScale> JulianDate for Time<T>

fn julian_date(&self, epoch: Epoch, unit: Unit) -> f64

Expresses self as a Julian date in the specified Unit, relative to the given Epoch.

fn two_part_julian_date(&self) -> (f64, f64)

Expresses self as a two-part Julian date in the specified Unit, relative to the given Epoch.

fn seconds_since_julian_epoch(&self) -> f64

Returns the number of seconds since the Julian epoch as an f64.

fn seconds_since_modified_julian_epoch(&self) -> f64

Returns the number of seconds since the Modified Julian epoch as an f64.

fn seconds_since_j1950(&self) -> f64

Returns the number of seconds since J1950 as an f64.

fn seconds_since_j2000(&self) -> f64

Returns the number of seconds since J2000 as an f64.

fn days_since_julian_epoch(&self) -> f64

Returns the number of days since the Julian epoch as an f64.

fn days_since_modified_julian_epoch(&self) -> f64

Returns the number of days since the Modified Julian epoch as an f64.

fn days_since_j1950(&self) -> f64

Returns the number of days since J1950 as an f64.

fn days_since_j2000(&self) -> f64

Returns the number of days since J2000 as an f64.

fn years_since_julian_epoch(&self) -> f64

Returns the number of years since the Julian epoch as an f64.

fn years_since_modified_julian_epoch(&self) -> f64

Returns the number of years since the Modified Julian epoch as an f64.

fn years_since_j1950(&self) -> f64

Returns the number of years since J1950 as an f64.

fn years_since_j2000(&self) -> f64

Returns the number of years since J2000 as an f64.

fn centuries_since_julian_epoch(&self) -> f64

Returns the number of centuries since the Julian epoch as an f64.

fn centuries_since_modified_julian_epoch(&self) -> f64

Returns the number of centuries since the Modified Julian epoch as an f64.

fn centuries_since_j1950(&self) -> f64

Returns the number of centuries since J1950 as an f64.

fn centuries_since_j2000(&self) -> f64

Returns the number of centuries since J2000 as an f64.

impl<T: Ord + TimeScale> Ord for Time<T>

fn cmp(&self, other: &Time<T>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + TimeScale> PartialEq for Time<T>

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

fn partial_cmp(&self, other: &Time<T>) -> 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<T: TimeScale> Sub<TimeDelta> for Time<T>

type Output = Time<T>

The resulting type after applying the - operator.

fn sub(self, rhs: TimeDelta) -> Self::Output

Performs the - operation.

impl<T: TimeScale> Sub for Time<T>

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: Time<T>) -> Self::Output

Performs the - operation.

impl<T: TimeScale> ToDelta for Time<T>

fn to_delta(&self) -> TimeDelta

Transforms the value into a TimeDelta.

impl<T> ToUtc for Time<T>

where T: TimeScale + Copy, DefaultOffsetProvider: Offset<T, Tai>,

fn to_utc_with_provider(&self, provider: &impl LeapSecondsProvider) -> Utc

Converts to UTC using the given leap-seconds provider.

fn to_utc(&self) -> Utc

Converts to UTC using the built-in leap-seconds table.

impl<T: Copy + TimeScale> Copy for Time<T>

impl<T: Eq + TimeScale> Eq for Time<T>

impl<T: TimeScale> StructuralPartialEq for Time<T>