use crate::{scales, Time, TimeScale};
use chrono::{NaiveDateTime, ParseError, TimeDelta};
use std::cmp::Ordering;
use std::ops::Sub;
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AnyTime {
BDT(Time<scales::BDT>),
GLONASST(Time<scales::GLONASST>),
GPST(Time<scales::GPST>),
GST(Time<scales::GST>),
QZZST(Time<scales::QZZST>),
TAI(Time<scales::TAI>),
TCB(Time<scales::TCB>),
TCG(Time<scales::TCG>),
TDB(Time<scales::TDB>),
TT(Time<scales::TT>),
UT1(Time<scales::UT1>),
UTC(Time<scales::UTC>),
}
impl AnyTime {
pub const fn scale(&self) -> TimeScale {
match self {
Self::BDT(_) => TimeScale::BDT,
Self::GLONASST(_) => TimeScale::GLONASST,
Self::GPST(_) => TimeScale::GPST,
Self::GST(_) => TimeScale::GST,
Self::QZZST(_) => TimeScale::QZZST,
Self::TAI(_) => TimeScale::TAI,
Self::TCB(_) => TimeScale::TCB,
Self::TCG(_) => TimeScale::TCG,
Self::TDB(_) => TimeScale::TDB,
Self::TT(_) => TimeScale::TT,
Self::UT1(_) => TimeScale::UT1,
Self::UTC(_) => TimeScale::UTC,
}
}
pub fn convert(self, scale: TimeScale) -> Self {
match scale {
TimeScale::BDT => self.bdt().into(),
TimeScale::GLONASST => self.glonasst().into(),
TimeScale::GPST => self.gpst().into(),
TimeScale::GST => self.gst().into(),
TimeScale::QZZST => self.qzzst().into(),
TimeScale::TAI => self.tai().into(),
TimeScale::TCB => self.tcb().into(),
TimeScale::TCG => self.tcg().into(),
TimeScale::TDB => self.tdb().into(),
TimeScale::TT => self.tt().into(),
TimeScale::UT1 => self.ut1().into(),
TimeScale::UTC => self.utc().into(),
}
}
pub fn from_datetime(datetime: NaiveDateTime, scale: TimeScale) -> Self {
match scale {
TimeScale::BDT => Time::<scales::BDT>::from_gregorian(datetime).into(),
TimeScale::GLONASST => Time::<scales::GLONASST>::from_gregorian(datetime).into(),
TimeScale::GPST => Time::<scales::GPST>::from_gregorian(datetime).into(),
TimeScale::GST => Time::<scales::GST>::from_gregorian(datetime).into(),
TimeScale::QZZST => Time::<scales::QZZST>::from_gregorian(datetime).into(),
TimeScale::TAI => Time::<scales::TAI>::from_gregorian(datetime).into(),
TimeScale::TCB => Time::<scales::TCB>::from_gregorian(datetime).into(),
TimeScale::TCG => Time::<scales::TCG>::from_gregorian(datetime).into(),
TimeScale::TDB => Time::<scales::TDB>::from_gregorian(datetime).into(),
TimeScale::TT => Time::<scales::TT>::from_gregorian(datetime).into(),
TimeScale::UT1 => Time::<scales::UT1>::from_gregorian(datetime).into(),
TimeScale::UTC => Time::<scales::UTC>::from_gregorian(datetime).into(),
}
}
pub fn from_jd(jd: f64, scale: TimeScale) -> Self {
match scale {
TimeScale::BDT => Time::<scales::BDT>::from_jd(jd).into(),
TimeScale::GLONASST => Time::<scales::GLONASST>::from_jd(jd).into(),
TimeScale::GPST => Time::<scales::GPST>::from_jd(jd).into(),
TimeScale::GST => Time::<scales::GST>::from_jd(jd).into(),
TimeScale::QZZST => Time::<scales::QZZST>::from_jd(jd).into(),
TimeScale::TAI => Time::<scales::TAI>::from_jd(jd).into(),
TimeScale::TCB => Time::<scales::TCB>::from_jd(jd).into(),
TimeScale::TCG => Time::<scales::TCG>::from_jd(jd).into(),
TimeScale::TDB => Time::<scales::TDB>::from_jd(jd).into(),
TimeScale::TT => Time::<scales::TT>::from_jd(jd).into(),
TimeScale::UT1 => Time::<scales::UT1>::from_jd(jd).into(),
TimeScale::UTC => Time::<scales::UTC>::from_jd(jd).into(),
}
}
pub fn from_mjd(mjd: f64, scale: TimeScale) -> Self {
match scale {
TimeScale::BDT => Time::<scales::BDT>::from_mjd(mjd).into(),
TimeScale::GLONASST => Time::<scales::GLONASST>::from_mjd(mjd).into(),
TimeScale::GPST => Time::<scales::GPST>::from_mjd(mjd).into(),
TimeScale::GST => Time::<scales::GST>::from_mjd(mjd).into(),
TimeScale::QZZST => Time::<scales::QZZST>::from_mjd(mjd).into(),
TimeScale::TAI => Time::<scales::TAI>::from_mjd(mjd).into(),
TimeScale::TCB => Time::<scales::TCB>::from_mjd(mjd).into(),
TimeScale::TCG => Time::<scales::TCG>::from_mjd(mjd).into(),
TimeScale::TDB => Time::<scales::TDB>::from_mjd(mjd).into(),
TimeScale::TT => Time::<scales::TT>::from_mjd(mjd).into(),
TimeScale::UT1 => Time::<scales::UT1>::from_mjd(mjd).into(),
TimeScale::UTC => Time::<scales::UTC>::from_mjd(mjd).into(),
}
}
pub fn from_split_jd(jd1: f64, jd2: f64, scale: TimeScale) -> Self {
match scale {
TimeScale::BDT => Time::<scales::BDT>::from_split_jd(jd1, jd2).into(),
TimeScale::GLONASST => Time::<scales::GLONASST>::from_split_jd(jd1, jd2).into(),
TimeScale::GPST => Time::<scales::GPST>::from_split_jd(jd1, jd2).into(),
TimeScale::GST => Time::<scales::GST>::from_split_jd(jd1, jd2).into(),
TimeScale::QZZST => Time::<scales::QZZST>::from_split_jd(jd1, jd2).into(),
TimeScale::TAI => Time::<scales::TAI>::from_split_jd(jd1, jd2).into(),
TimeScale::TCB => Time::<scales::TCB>::from_split_jd(jd1, jd2).into(),
TimeScale::TCG => Time::<scales::TCG>::from_split_jd(jd1, jd2).into(),
TimeScale::TDB => Time::<scales::TDB>::from_split_jd(jd1, jd2).into(),
TimeScale::TT => Time::<scales::TT>::from_split_jd(jd1, jd2).into(),
TimeScale::UT1 => Time::<scales::UT1>::from_split_jd(jd1, jd2).into(),
TimeScale::UTC => Time::<scales::UTC>::from_split_jd(jd1, jd2).into(),
}
}
pub fn from_isot_str(isot: &str, scale: TimeScale) -> Result<Self, ParseError> {
Self::from_str(isot, "%Y-%m-%dT%H:%M:%S%.f", scale)
}
pub fn from_iso_str(iso: &str, scale: TimeScale) -> Result<Self, ParseError> {
Self::from_str(iso, "%Y-%m-%d %H:%M:%S%.f", scale)
}
pub fn from_str(input: &str, format: &str, scale: TimeScale) -> Result<Self, ParseError> {
NaiveDateTime::parse_from_str(input, format)
.map(|datetime| Self::from_datetime(datetime, scale))
}
}
impl From<Time<scales::GPST>> for AnyTime {
fn from(time: Time<scales::GPST>) -> Self {
Self::GPST(time)
}
}
impl From<Time<scales::BDT>> for AnyTime {
fn from(time: Time<scales::BDT>) -> Self {
Self::BDT(time)
}
}
impl From<Time<scales::GLONASST>> for AnyTime {
fn from(time: Time<scales::GLONASST>) -> Self {
Self::GLONASST(time)
}
}
impl From<Time<scales::GST>> for AnyTime {
fn from(time: Time<scales::GST>) -> Self {
Self::GST(time)
}
}
impl From<Time<scales::QZZST>> for AnyTime {
fn from(time: Time<scales::QZZST>) -> Self {
Self::QZZST(time)
}
}
impl From<Time<scales::TAI>> for AnyTime {
fn from(time: Time<scales::TAI>) -> Self {
Self::TAI(time)
}
}
impl From<Time<scales::TCB>> for AnyTime {
fn from(time: Time<scales::TCB>) -> Self {
Self::TCB(time)
}
}
impl From<Time<scales::TCG>> for AnyTime {
fn from(time: Time<scales::TCG>) -> Self {
Self::TCG(time)
}
}
impl From<Time<scales::TDB>> for AnyTime {
fn from(time: Time<scales::TDB>) -> Self {
Self::TDB(time)
}
}
impl From<Time<scales::TT>> for AnyTime {
fn from(time: Time<scales::TT>) -> Self {
Self::TT(time)
}
}
impl From<Time<scales::UT1>> for AnyTime {
fn from(time: Time<scales::UT1>) -> Self {
Self::UT1(time)
}
}
impl From<Time<scales::UTC>> for AnyTime {
fn from(time: Time<scales::UTC>) -> Self {
Self::UTC(time)
}
}
impl Sub for AnyTime {
type Output = TimeDelta;
fn sub(self, other: AnyTime) -> TimeDelta {
let t1: Time<scales::TAI> = self.into();
let t2: Time<scales::TAI> = other.into();
t1 - t2
}
}
impl PartialEq for AnyTime {
fn eq(&self, other: &Self) -> bool {
self.cmp(other) == Ordering::Equal
}
}
impl Eq for AnyTime {}
impl PartialOrd for AnyTime {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for AnyTime {
fn cmp(&self, other: &Self) -> Ordering {
match self {
Self::BDT(lhs) => lhs.cmp(&other.clone().bdt()),
Self::GLONASST(lhs) => lhs.cmp(&other.clone().glonasst()),
Self::GPST(lhs) => lhs.cmp(&other.clone().gpst()),
Self::GST(lhs) => lhs.cmp(&other.clone().gst()),
Self::QZZST(lhs) => lhs.cmp(&other.clone().qzzst()),
Self::TAI(lhs) => lhs.cmp(&other.clone().tai()),
Self::TCB(lhs) => lhs.cmp(&other.clone().tcb()),
Self::TCG(lhs) => lhs.cmp(&other.clone().tcg()),
Self::TDB(lhs) => lhs.cmp(&other.clone().tdb()),
Self::TT(lhs) => lhs.cmp(&other.clone().tt()),
Self::UT1(lhs) => lhs.cmp(&other.clone().ut1()),
Self::UTC(lhs) => lhs.cmp(&other.clone().utc()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::NaiveDate;
use std::cmp::Ordering;
#[test]
fn test_into() {
let time_tai = Time::<scales::TAI>::from_jd(2400000.5);
let any_time = AnyTime::TAI(time_tai);
let _: Time<scales::UTC> = any_time.clone().into();
let variants = [
AnyTime::BDT(Time::<scales::BDT>::from_jd(2400000.5)),
AnyTime::GLONASST(Time::<scales::GLONASST>::from_jd(2400000.5)),
AnyTime::GPST(Time::<scales::GPST>::from_jd(2400000.5)),
AnyTime::GST(Time::<scales::GST>::from_jd(2400000.5)),
AnyTime::QZZST(Time::<scales::QZZST>::from_jd(2400000.5)),
any_time,
AnyTime::TCB(Time::<scales::TCB>::from_jd(2400000.5)),
AnyTime::TCG(Time::<scales::TCG>::from_jd(2400000.5)),
AnyTime::TDB(Time::<scales::TDB>::from_jd(2400000.5)),
AnyTime::TT(Time::<scales::TT>::from_jd(2400000.5)),
AnyTime::UT1(Time::<scales::UT1>::from_jd(2400000.5)),
AnyTime::UTC(Time::<scales::UTC>::from_jd(2400000.5)),
];
for variant in variants {
let _: Time<scales::TAI> = variant.into();
}
}
#[test]
fn test_constructors() {
let datetime = NaiveDate::from_ymd_opt(2000, 1, 1)
.unwrap()
.and_hms_nano_opt(12, 0, 0, 123_456_789)
.unwrap();
assert_eq!(
AnyTime::from_datetime(datetime, TimeScale::UTC),
AnyTime::UTC(Time::<scales::UTC>::from_gregorian(datetime))
);
assert_eq!(
AnyTime::from_jd(2_451_545.0, TimeScale::TAI),
AnyTime::TAI(Time::<scales::TAI>::from_jd(2_451_545.0))
);
assert_eq!(
AnyTime::from_mjd(51_544.5, TimeScale::TT),
AnyTime::TT(Time::<scales::TT>::from_mjd(51_544.5))
);
assert_eq!(
AnyTime::from_split_jd(2_451_545.0, 0.25, TimeScale::GPST),
AnyTime::GPST(Time::<scales::GPST>::from_split_jd(2_451_545.0, 0.25))
);
assert!(matches!(
AnyTime::from_jd(2_451_545.0, TimeScale::TCB),
AnyTime::TCB(_)
));
assert!(matches!(
AnyTime::from_jd(2_451_545.0, TimeScale::TCG),
AnyTime::TCG(_)
));
assert!(matches!(
AnyTime::from_jd(2_451_545.0, TimeScale::TDB),
AnyTime::TDB(_)
));
assert!(matches!(
AnyTime::from_jd(2_451_545.0, TimeScale::UT1),
AnyTime::UT1(_)
));
assert_eq!(
AnyTime::from_isot_str("2000-01-01T12:00:00.123456789", TimeScale::UTC).unwrap(),
AnyTime::from_datetime(datetime, TimeScale::UTC)
);
assert_eq!(
AnyTime::from_iso_str("2000-01-01 12:00:00.123456789", TimeScale::UTC).unwrap(),
AnyTime::from_datetime(datetime, TimeScale::UTC)
);
assert_eq!(
AnyTime::from_str(
"2000-01-01 12:00:00.123456789",
"%Y-%m-%d %H:%M:%S%.f",
TimeScale::UTC,
)
.unwrap(),
AnyTime::from_datetime(datetime, TimeScale::UTC)
);
assert_eq!(
AnyTime::from_str("00/01/01 12:00", "%y/%m/%d %H:%M", TimeScale::UTC).unwrap(),
AnyTime::from_datetime(
NaiveDate::from_ymd_opt(2000, 1, 1)
.unwrap()
.and_hms_opt(12, 0, 0)
.unwrap(),
TimeScale::UTC,
)
);
assert!(AnyTime::from_isot_str("not a datetime", TimeScale::UTC).is_err());
}
#[test]
fn test_gnss_constructors() {
let datetime = NaiveDate::from_ymd_opt(2000, 1, 1)
.unwrap()
.and_hms_nano_opt(12, 0, 0, 123_456_789)
.unwrap();
let scales = [
TimeScale::BDT,
TimeScale::GLONASST,
TimeScale::GPST,
TimeScale::GST,
TimeScale::QZZST,
];
for scale in scales {
assert_eq!(AnyTime::from_datetime(datetime, scale).scale(), scale);
assert_eq!(AnyTime::from_jd(2_451_545.0, scale).scale(), scale);
assert_eq!(AnyTime::from_mjd(51_544.5, scale).scale(), scale);
assert_eq!(
AnyTime::from_split_jd(2_451_545.0, 0.25, scale).scale(),
scale
);
}
}
#[test]
fn test_scale() {
let times = [
AnyTime::from_jd(2_451_545.0, TimeScale::BDT),
AnyTime::from_jd(2_451_545.0, TimeScale::GLONASST),
AnyTime::from_jd(2_451_545.0, TimeScale::GPST),
AnyTime::from_jd(2_451_545.0, TimeScale::GST),
AnyTime::from_jd(2_451_545.0, TimeScale::QZZST),
AnyTime::from_jd(2_451_545.0, TimeScale::TAI),
AnyTime::from_jd(2_451_545.0, TimeScale::TCB),
AnyTime::from_jd(2_451_545.0, TimeScale::TCG),
AnyTime::from_jd(2_451_545.0, TimeScale::TDB),
AnyTime::from_jd(2_451_545.0, TimeScale::TT),
AnyTime::from_jd(2_451_545.0, TimeScale::UT1),
AnyTime::from_jd(2_451_545.0, TimeScale::UTC),
];
let scales = [
TimeScale::BDT,
TimeScale::GLONASST,
TimeScale::GPST,
TimeScale::GST,
TimeScale::QZZST,
TimeScale::TAI,
TimeScale::TCB,
TimeScale::TCG,
TimeScale::TDB,
TimeScale::TT,
TimeScale::UT1,
TimeScale::UTC,
];
for (time, scale) in times.iter().zip(scales) {
assert_eq!(time.scale(), scale);
}
}
#[test]
fn test_convert() {
let time = AnyTime::from_jd(2_451_545.0, TimeScale::UTC);
let scales = [
TimeScale::BDT,
TimeScale::GLONASST,
TimeScale::GPST,
TimeScale::GST,
TimeScale::QZZST,
TimeScale::TAI,
TimeScale::TCB,
TimeScale::TCG,
TimeScale::TDB,
TimeScale::TT,
TimeScale::UT1,
TimeScale::UTC,
];
for scale in scales {
let converted = time.clone().convert(scale);
assert_eq!(converted.scale(), scale);
assert_eq!(converted, time);
}
}
#[test]
fn test_subtraction() {
let tai = Time::<scales::TAI>::new(TimeDelta::seconds(100));
let utc: Time<scales::UTC> = tai.clone().into();
assert_eq!(AnyTime::TAI(tai) - AnyTime::UTC(utc), TimeDelta::zero());
}
#[test]
fn test_comparison() {
let earlier_time = Time::<scales::TAI>::new(TimeDelta::seconds(100));
let same_time: Time<scales::TT> = earlier_time.clone().into();
let later_time = Time::<scales::TAI>::new(TimeDelta::seconds(101));
let earlier = AnyTime::TAI(earlier_time);
let same = AnyTime::TT(same_time);
let later = AnyTime::TAI(later_time);
assert_eq!(earlier, same);
assert_eq!(same, earlier);
assert!(earlier < later);
assert!(same < later);
assert!(later > same);
assert_eq!(earlier.cmp(&same), Ordering::Equal);
assert_eq!(same.cmp(&earlier), Ordering::Equal);
assert_eq!(earlier.cmp(&later), Ordering::Less);
assert_eq!(later.cmp(&same), Ordering::Greater);
let variants = [
AnyTime::BDT(Time::<scales::BDT>::new(TimeDelta::seconds(100))),
AnyTime::GLONASST(Time::<scales::GLONASST>::new(TimeDelta::seconds(100))),
AnyTime::GPST(Time::<scales::GPST>::new(TimeDelta::seconds(100))),
AnyTime::GST(Time::<scales::GST>::new(TimeDelta::seconds(100))),
AnyTime::QZZST(Time::<scales::QZZST>::new(TimeDelta::seconds(100))),
AnyTime::TAI(Time::<scales::TAI>::new(TimeDelta::seconds(100))),
AnyTime::TCB(Time::<scales::TCB>::new(TimeDelta::seconds(100))),
AnyTime::TCG(Time::<scales::TCG>::new(TimeDelta::seconds(100))),
AnyTime::TDB(Time::<scales::TDB>::new(TimeDelta::seconds(100))),
AnyTime::TT(Time::<scales::TT>::new(TimeDelta::seconds(100))),
AnyTime::UT1(Time::<scales::UT1>::new(TimeDelta::seconds(100))),
AnyTime::UTC(Time::<scales::UTC>::new(TimeDelta::seconds(100))),
];
for variant in variants {
assert_eq!(variant.cmp(&variant), Ordering::Equal);
}
}
#[cfg(feature = "serde")]
#[test]
fn serde_round_trip() {
let time = AnyTime::from_jd(2_451_545.0, TimeScale::UTC);
let json = serde_json::to_string(&time).unwrap();
assert_eq!(serde_json::from_str::<AnyTime>(&json).unwrap(), time);
}
}