Struct TimePoint 

pub struct TimePoint<Scale: ?Sized> { /* private fields */ }

A TimePoint identifies a specific instant in time. It is templated on a Representation and Period, which the define the characteristics of the Duration type used to represent the time elapsed since the epoch of the underlying time scale Scale.

Implementations

impl<Scale: ?Sized> TimePoint<Scale>

pub const fn from_time_since_epoch(time_since_epoch: Duration) -> Self

Constructs a new TimePoint from a known time since epoch.

pub const fn time_since_epoch(&self) -> Duration

Returns the time elapsed since the epoch of the time scale associated with this instant.

pub const fn count(&self) -> i128

Returns the raw underlying representation of this time point.

pub fn round<Target>(self) -> TimePoint<Scale>

where Target: UnitRatio,

Converts towards a different time unit, rounding towards the nearest whole unit.

pub fn ceil<Target>(self) -> TimePoint<Scale>

where Target: UnitRatio,

Converts towards a different time unit, rounding towards positive infinity if the unit is not entirely commensurate with the present unit.

pub fn floor<Target>(self) -> TimePoint<Scale>

where Target: UnitRatio,

Converts towards a different time unit, rounding towards negative infinity if the unit is not entirely commensurate with the present unit.

pub fn from_historic_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, ) -> Result<Self, InvalidHistoricDateTime<<Self as FromDateTime>::Error>>

where Self: FromDateTime,

Constructs a TimePoint in the given time scale, based on a historic date-time.

pub fn from_gregorian_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, ) -> Result<Self, InvalidGregorianDateTime<<Self as FromDateTime>::Error>>

where Self: FromDateTime,

Constructs a TimePoint in the given time scale, based on a Gregorian date-time.

pub fn from_julian_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, ) -> Result<Self, InvalidJulianDateTime<<Self as FromDateTime>::Error>>

where Self: FromDateTime,

Constructs a TimePoint in the given time scale, based on a Julian date-time.

impl<Scale> TimePoint<Scale>

where Scale: UniformDateTimeScale + ?Sized,

pub fn from_modified_julian_date(mjd: ModifiedJulianDate) -> Self

Constructs a time point from a modified Julian date, expressed in the resulting time scale itself. The modified Julian date uses 17 November, 1858 (historic calendar) as epoch, or 2400000.5 days less than the Julian day.

Conversions from modified Julian days into TimePoints are supported only for uniform date time scales. For non-uniform time scales, leap second days result in ambiguous and difficult to implement interpretations of the fractional part of a day. Based on the “Resolution B1 on the use of Julian Dates” of the IAU, it is also not recommended to use such Julian date expressions: hence, we do not support it.

impl<Scale> TimePoint<Scale>

where Scale: AbsoluteTimeScale + ?Sized,

pub fn into_modified_julian_date(&self) -> ModifiedJulianDate

Converts this time point into the equivalent Julian day representation.

impl<Scale> TimePoint<Scale>

where Self: FromFineDateTime, TimePoint<Scale>: FromDateTime, Scale: ?Sized,

pub fn from_fine_historic_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, subseconds: Duration, ) -> Result<Self, InvalidHistoricDateTime<<Self as FromFineDateTime>::Error>>

Constructs a TimePoint in the given time scale, based on a subsecond-accuracy historic date-time.

pub fn from_fine_gregorian_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, subseconds: Duration, ) -> Result<Self, InvalidGregorianDateTime<<Self as FromFineDateTime>::Error>>

Constructs a TimePoint in the given time scale, based on a subsecond-accuracy Gregorian date-time.

pub fn from_fine_julian_datetime( year: i32, month: Month, day: u8, hour: u8, minute: u8, second: u8, subseconds: Duration, ) -> Result<Self, InvalidJulianDateTime<<Self as FromFineDateTime>::Error>>

Constructs a TimePoint in the given time scale, based on a subsecond-accuracy Julian date-time.

impl<Scale: ?Sized> TimePoint<Scale>

where Self: IntoDateTime,

pub fn into_historic_datetime(self) -> (HistoricDate, u8, u8, u8)

Maps a TimePoint towards the corresponding historic date and time-of-day.

pub fn into_gregorian_datetime(self) -> (GregorianDate, u8, u8, u8)

Maps a TimePoint towards the corresponding proleptic Gregorian date and time-of-day.

pub fn into_julian_datetime(self) -> (JulianDate, u8, u8, u8)

Maps a TimePoint towards the corresponding Julian date and time-of-day.

impl<Scale: ?Sized> TimePoint<Scale>

where Self: IntoFineDateTime,

pub fn into_fine_historic_datetime(self) -> (HistoricDate, u8, u8, u8, Duration)

pub fn into_fine_gregorian_datetime( self, ) -> (GregorianDate, u8, u8, u8, Duration)

pub fn into_fine_julian_datetime(self) -> (JulianDate, u8, u8, u8, Duration)

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_bdt(time_point: BeiDouTime) -> Self

where Self: FromTimeScale<Bdt>,

pub fn into_bdt(self) -> BeiDouTime

where Self: IntoTimeScale<Bdt>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_glonasst(time_point: GlonassTime) -> Self

where Self: FromTimeScale<Glonasst>,

pub fn into_glonasst(self) -> GlonassTime

where Self: IntoTimeScale<Glonasst>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_gpst(time_point: GpsTime) -> Self

where Self: FromTimeScale<Gpst>,

pub fn into_gpst(self) -> GpsTime

where Self: IntoTimeScale<Gpst>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_gst(time_point: GalileoTime) -> Self

where Self: FromTimeScale<Gst>,

pub fn into_gst(self) -> GalileoTime

where Self: IntoTimeScale<Gst>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_qzsst(time_point: QzssTime) -> Self

where Self: FromTimeScale<Qzsst>,

pub fn into_qzsst(self) -> QzssTime

where Self: IntoTimeScale<Qzsst>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_tai(time_point: TaiTime) -> Self

where Self: FromTimeScale<Tai>,

pub fn into_tai(self) -> TaiTime

where Self: IntoTimeScale<Tai>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_tcg(time_point: TcgTime) -> Self

where Self: FromTimeScale<Tcg>,

pub fn into_tcg(self) -> TcgTime

where Self: IntoTimeScale<Tcg>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_tcb(time_point: TcbTime) -> Self

where Self: FromTimeScale<Tcb>,

pub fn into_tcb(self) -> TcbTime

where Self: IntoTimeScale<Tcb>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_tdb(time_point: TdbTime) -> Self

where Self: FromTimeScale<Tdb>,

pub fn into_tdb(self) -> TdbTime

where Self: IntoTimeScale<Tdb>,

impl TimePoint<Tt>

pub fn approximate_tdb(self) -> TdbTime

Approximates Barycentric Dynamical Time (BDT) from TT using a simplified expression following the IAU SOFA estimate TDB = TT + 0.001657 * sin(g) where g is an estimate of the Earth’s mean anomaly. The resulting estimate is accurate to 50 microseconds from 1980 to 2100.

See “SOFA Time Scale and Calendar Tools”, 2023 May 31, version for the C programming language. Section 4.3.4 “TDB minus TT”.

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_tt(time_point: TtTime) -> Self

where Self: FromTimeScale<Tt>,

pub fn into_tt(self) -> TtTime

where Self: IntoTimeScale<Tt>,

impl<Scale: ?Sized> TimePoint<Scale>

pub fn from_utc(time_point: UtcTime) -> Self

where Self: FromTimeScale<Utc>,

pub fn into_utc(self) -> UtcTime

where Self: IntoTimeScale<Utc>,

Trait Implementations

impl<Scale> Add<Duration> for TimePoint<Scale>

where Scale: ?Sized,

type Output = TimePoint<Scale>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Scale> AddAssign<Duration> for TimePoint<Scale>

where Scale: ?Sized,

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl<Scale> Bounded for TimePoint<Scale>

where Scale: ?Sized,

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<Scale: ?Sized> Clone for TimePoint<Scale>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Scale: ?Sized> Debug for TimePoint<Scale>

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

Formats the value using the given formatter.

impl<'de, Scale> Deserialize<'de> for TimePoint<Scale>

where Self: FromStr, <Self as FromStr>::Err: Display, Scale: ?Sized,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Scale> Display for TimePoint<Scale>

where Scale: ?Sized + TimeScale, Duration: Zero, Self: IntoFineDateTime,

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

Formats the value using the given formatter.

impl<Scale> FromDateTime for TimePoint<Scale>

where Scale: ?Sized + UniformDateTimeScale,

type Error = InvalidTimeOfDay

This error may be returned whenever some input date-time is not valid. This may be the case when the time-of-day is not valid, but also when some date-time does not occur in a chosen time scale, for example due to leap seconds deletions or daylight saving time switches.

fn from_datetime( date: Date, hour: u8, minute: u8, second: u8, ) -> Result<Self, Self::Error>

Maps a given combination of date and time-of-day to an instant on this time scale. May return an error if the input does not represent a valid combination of date and time-of-day.

impl<Scale> FromFineDateTime for TimePoint<Scale>

where Scale: ?Sized, TimePoint<Scale>: FromDateTime,

type Error = <TimePoint<Scale> as FromDateTime>::Error

fn from_fine_datetime( date: Date, hour: u8, minute: u8, second: u8, subseconds: Duration, ) -> Result<Self, Self::Error>

Maps a given combination of date and fine time-of-day to an instant on this time scale. May return an error if the input does not represent a valid combination of date and time-of-day.

impl<Scale> FromStr for TimePoint<Scale>

where Self: FromFineDateTime, Scale: TimeScale,

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

Parses a TimePoint based on some ISO 8610 date and time of day string. Note that time shifts are explicitly not supported: those are already included in the choice of Scale for a type. Additionally, we only support the extended calendar date and time of day formats (see section 5.4.2.1 of ISO 8610). Finally, because the extended format is used (which explicitly delimits time point components), any number of digits is allowed in the year component, such that its range can be extended beyond the 0000..=9999 allowed by ISO 8601.

type Err = TimePointParsingError<<TimePoint<Scale> as FromFineDateTime>::Error>

The associated error which can be returned from parsing.

impl<ScaleFrom, ScaleInto> FromTimeScale<ScaleFrom> for TimePoint<ScaleInto>

where ScaleFrom: TerrestrialTime, ScaleInto: TerrestrialTime,

fn from_time_scale(time_point: TimePoint<ScaleFrom>) -> Self

Constructs a time point from an instant expressed in another scale.

impl<Scale: ?Sized> Hash for TimePoint<Scale>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Scale> IntoDateTime for TimePoint<Scale>

where Scale: ?Sized + UniformDateTimeScale,

fn into_datetime(self) -> (Date, u8, u8, u8)

Maps a time point back to the date and time-of-day that it represents. Returns a tuple of date, hour, minute, and second. This function shall not fail, unless overflow occurs in the underlying integer arithmetic.

impl<Scale> IntoFineDateTime for TimePoint<Scale>

where Scale: ?Sized, Self: IntoDateTime,

fn into_fine_datetime(self) -> (Date, u8, u8, u8, Duration)

Convenience function that maps from a “fine” (subsecond-accuracy) time point to a date-time according to this time scale. Returns a tuple of date, hour, minute, second, and subsecond. Shall not fail, unless overflow occurs in the underlying integer arithmetic.

impl<S1, S2> IntoTimeScale<S1> for TimePoint<S2>

where TimePoint<S1>: FromTimeScale<S2>,

fn into_time_scale(self) -> TimePoint<S1>

Constructs a time point from an instant expressed in another scale.

impl<Scale: ?Sized> Ord for TimePoint<Scale>

fn cmp(&self, other: &Self) -> 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<Scale: ?Sized> PartialEq for TimePoint<Scale>

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<Scale: ?Sized> PartialOrd for TimePoint<Scale>

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<Scale> Serialize for TimePoint<Scale>

where Self: ToString, Scale: ?Sized,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Scale> Sub<Duration> for TimePoint<Scale>

where Scale: ?Sized,

type Output = TimePoint<Scale>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Scale> Sub for TimePoint<Scale>

where Scale: ?Sized,

type Output = Duration

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Scale> SubAssign<Duration> for TimePoint<Scale>

where Scale: ?Sized,

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl<Scale: ?Sized> Copy for TimePoint<Scale>

impl<Scale: ?Sized> Eq for TimePoint<Scale>