use crate::{scales, Time};
use chrono::TimeDelta;
use std::cmp::Ordering;
use std::ops::Sub;
#[derive(Debug, Clone)]
pub enum AnyTime {
GPST(Time<scales::GPST>),
TAI(Time<scales::TAI>),
TCG(Time<scales::TCG>),
TT(Time<scales::TT>),
UT1(Time<scales::UT1>),
UTC(Time<scales::UTC>),
}
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::GPST(lhs) => lhs.cmp(&other.clone().gpst()),
Self::TAI(lhs) => lhs.cmp(&other.clone().tai()),
Self::TCG(lhs) => lhs.cmp(&other.clone().tcg()),
Self::TT(lhs) => lhs.cmp(&other.clone().tt()),
Self::UT1(lhs) => lhs.cmp(&other.clone().ut1()),
Self::UTC(lhs) => lhs.cmp(&other.clone().utc()),
}
}
}
pub type AnyTimeVec = Vec<AnyTime>;
#[cfg(test)]
mod tests {
use super::*;
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::GPST(Time::<scales::GPST>::from_jd(2400000.5)),
any_time,
AnyTime::TCG(Time::<scales::TCG>::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_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::GPST(Time::<scales::GPST>::new(TimeDelta::seconds(100))),
AnyTime::TAI(Time::<scales::TAI>::new(TimeDelta::seconds(100))),
AnyTime::TCG(Time::<scales::TCG>::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);
}
}
}