Move interop between datetime types to single mod

Author: jhpratt

time/src/duration.rs

@@ -5,6 +5,8 @@ use core::fmt;
 use core::iter::Sum;
 use core::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 use core::time::Duration as StdDuration;
+#[cfg(feature = "std")]
+use std::time::SystemTime;
 
 use deranged::RangedI32;
 use num_conv::prelude::*;
@@ -17,6 +19,8 @@ use crate::internal_macros::{
 #[cfg(feature = "std")]
 #[allow(deprecated)]
 use crate::Instant;
+#[cfg(feature = "std")]
+use crate::OffsetDateTime;
 
 /// By explicitly inserting this enum where padding is expected, the compiler is able to better
 /// perform niche value optimization.
@@ -1558,3 +1562,32 @@ impl<'a> Sum<&'a Self> for Duration {
         iter.copied().sum()
     }
 }
+
+#[cfg(feature = "std")]
+impl Add<Duration> for SystemTime {
+    type Output = Self;
+
+    fn add(self, duration: Duration) -> Self::Output {
+        if duration.is_zero() {
+            self
+        } else if duration.is_positive() {
+            self + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            self - duration.unsigned_abs()
+        }
+    }
+}
+
+impl_add_assign!(SystemTime: #[cfg(feature = "std")] Duration);
+
+#[cfg(feature = "std")]
+impl Sub<Duration> for SystemTime {
+    type Output = Self;
+
+    fn sub(self, duration: Duration) -> Self::Output {
+        (OffsetDateTime::from(self) - duration).into()
+    }
+}
+
+impl_sub_assign!(SystemTime: #[cfg(feature = "std")] Duration);

time/src/interop/js_sys_date_offsetdatetime.rs

@@ -0,0 +1,27 @@
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::OffsetDateTime;
+
+impl From<js_sys::Date> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if the timestamp can not be represented.
+    fn from(js_date: js_sys::Date) -> Self {
+        // get_time() returns milliseconds
+        let timestamp_nanos = js_date.get_time() as i128
+            * Nanosecond::per(Millisecond).cast_signed().extend::<i128>();
+        Self::from_unix_timestamp_nanos(timestamp_nanos)
+            .expect("invalid timestamp: Timestamp cannot fit in range")
+    }
+}
+
+impl From<OffsetDateTime> for js_sys::Date {
+    fn from(datetime: OffsetDateTime) -> Self {
+        // new Date() takes milliseconds
+        let timestamp = (datetime.unix_timestamp_nanos()
+            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            as f64;
+        Self::new(&timestamp.into())
+    }
+}

time/src/interop/js_sys_date_utcdatetime.rs

@@ -0,0 +1,26 @@
+use num_conv::prelude::*;
+
+use crate::convert::*;
+use crate::UtcDateTime;
+
+impl From<js_sys::Date> for UtcDateTime {
+    /// # Panics
+    ///
+    /// This may panic if the timestamp can not be represented.
+    fn from(js_date: js_sys::Date) -> Self {
+        // get_time() returns milliseconds
+        let timestamp_nanos = (js_date.get_time() * Nanosecond::per(Millisecond) as f64) as i128;
+        Self::from_unix_timestamp_nanos(timestamp_nanos)
+            .expect("invalid timestamp: Timestamp cannot fit in range")
+    }
+}
+
+impl From<UtcDateTime> for js_sys::Date {
+    fn from(datetime: UtcDateTime) -> Self {
+        // new Date() takes milliseconds
+        let timestamp = (datetime.unix_timestamp_nanos()
+            / Nanosecond::per(Millisecond).cast_signed().extend::<i128>())
+            as f64;
+        Self::new(&timestamp.into())
+    }
+}

time/src/interop/mod.rs

@@ -0,0 +1,28 @@
+//! Comparison, arithmetic, and conversion between various types in `time` and the standard library.
+//!
+//! Currently, full interoperability is present between [`OffsetDateTime`](crate::OffsetDateTime),
+//! [`UtcDateTime`](crate::UtcDateTime), and [`SystemTime`](std::time::SystemTime). Partial
+//! interoperability is present with [`js_sys::Date`]. Note that
+//! [`PrimitiveDateTime`](crate::PrimitiveDateTime) is not interoperable with any of these types due
+//! to the lack of an associated UTC offset.
+
+// Module names should have the two types sorted in alphabetical order. This avoids any question
+// of which type should be the "primary" type in the module name.
+
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+mod js_sys_date_offsetdatetime;
+#[cfg(all(
+    target_family = "wasm",
+    not(any(target_os = "emscripten", target_os = "wasi")),
+    feature = "wasm-bindgen"
+))]
+mod js_sys_date_utcdatetime;
+#[cfg(feature = "std")]
+mod offsetdatetime_systemtime;
+mod offsetdatetime_utcdatetime;
+#[cfg(feature = "std")]
+mod utcdatetime_systemtime;

time/src/interop/offsetdatetime_systemtime.rs

@@ -0,0 +1,75 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+use std::time::SystemTime;
+
+use crate::{Duration, OffsetDateTime};
+
+impl Sub<SystemTime> for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: SystemTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl Sub<OffsetDateTime> for SystemTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
+        OffsetDateTime::from(self) - rhs
+    }
+}
+
+impl PartialEq<SystemTime> for OffsetDateTime {
+    fn eq(&self, rhs: &SystemTime) -> bool {
+        self == &Self::from(*rhs)
+    }
+}
+
+impl PartialEq<OffsetDateTime> for SystemTime {
+    fn eq(&self, rhs: &OffsetDateTime) -> bool {
+        &OffsetDateTime::from(*self) == rhs
+    }
+}
+
+impl PartialOrd<SystemTime> for OffsetDateTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl PartialOrd<OffsetDateTime> for SystemTime {
+    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
+        OffsetDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl From<SystemTime> for OffsetDateTime {
+    fn from(system_time: SystemTime) -> Self {
+        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(duration) => Self::UNIX_EPOCH + duration,
+            Err(err) => Self::UNIX_EPOCH - err.duration(),
+        }
+    }
+}
+
+impl From<OffsetDateTime> for SystemTime {
+    fn from(datetime: OffsetDateTime) -> Self {
+        let duration = datetime - OffsetDateTime::UNIX_EPOCH;
+
+        if duration.is_zero() {
+            Self::UNIX_EPOCH
+        } else if duration.is_positive() {
+            Self::UNIX_EPOCH + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            Self::UNIX_EPOCH - duration.unsigned_abs()
+        }
+    }
+}

time/src/interop/offsetdatetime_utcdatetime.rs

@@ -0,0 +1,68 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+
+use crate::{Duration, OffsetDateTime, UtcDateTime};
+
+impl Sub<OffsetDateTime> for UtcDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: OffsetDateTime) -> Self::Output {
+        OffsetDateTime::from(self) - rhs
+    }
+}
+
+impl Sub<UtcDateTime> for OffsetDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: UtcDateTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl PartialEq<OffsetDateTime> for UtcDateTime {
+    fn eq(&self, other: &OffsetDateTime) -> bool {
+        OffsetDateTime::from(*self) == *other
+    }
+}
+
+impl PartialEq<UtcDateTime> for OffsetDateTime {
+    fn eq(&self, other: &UtcDateTime) -> bool {
+        *self == Self::from(*other)
+    }
+}
+
+impl PartialOrd<OffsetDateTime> for UtcDateTime {
+    fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering> {
+        OffsetDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl PartialOrd<UtcDateTime> for OffsetDateTime {
+    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl From<OffsetDateTime> for UtcDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn from(datetime: OffsetDateTime) -> Self {
+        datetime.to_utc()
+    }
+}
+
+impl From<UtcDateTime> for OffsetDateTime {
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn from(datetime: UtcDateTime) -> Self {
+        datetime.as_primitive().assume_utc()
+    }
+}

time/src/interop/utcdatetime_systemtime.rs

@@ -0,0 +1,75 @@
+use core::cmp::Ordering;
+use core::ops::Sub;
+use std::time::SystemTime;
+
+use crate::{Duration, UtcDateTime};
+
+impl Sub<SystemTime> for UtcDateTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: SystemTime) -> Self::Output {
+        self - Self::from(rhs)
+    }
+}
+
+impl Sub<UtcDateTime> for SystemTime {
+    type Output = Duration;
+
+    /// # Panics
+    ///
+    /// This may panic if an overflow occurs.
+    fn sub(self, rhs: UtcDateTime) -> Self::Output {
+        UtcDateTime::from(self) - rhs
+    }
+}
+
+impl PartialEq<SystemTime> for UtcDateTime {
+    fn eq(&self, rhs: &SystemTime) -> bool {
+        self == &Self::from(*rhs)
+    }
+}
+
+impl PartialEq<UtcDateTime> for SystemTime {
+    fn eq(&self, rhs: &UtcDateTime) -> bool {
+        &UtcDateTime::from(*self) == rhs
+    }
+}
+
+impl PartialOrd<SystemTime> for UtcDateTime {
+    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
+        self.partial_cmp(&Self::from(*other))
+    }
+}
+
+impl PartialOrd<UtcDateTime> for SystemTime {
+    fn partial_cmp(&self, other: &UtcDateTime) -> Option<Ordering> {
+        UtcDateTime::from(*self).partial_cmp(other)
+    }
+}
+
+impl From<SystemTime> for UtcDateTime {
+    fn from(system_time: SystemTime) -> Self {
+        match system_time.duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(duration) => Self::UNIX_EPOCH + duration,
+            Err(err) => Self::UNIX_EPOCH - err.duration(),
+        }
+    }
+}
+
+impl From<UtcDateTime> for SystemTime {
+    fn from(datetime: UtcDateTime) -> Self {
+        let duration = datetime - UtcDateTime::UNIX_EPOCH;
+
+        if duration.is_zero() {
+            Self::UNIX_EPOCH
+        } else if duration.is_positive() {
+            Self::UNIX_EPOCH + duration.unsigned_abs()
+        } else {
+            debug_assert!(duration.is_negative());
+            Self::UNIX_EPOCH - duration.unsigned_abs()
+        }
+    }
+}

time/src/lib.rs

@@ -92,6 +92,7 @@ mod hint;
 #[cfg(feature = "std")]
 mod instant;
 mod internal_macros;
+mod interop;
 #[cfg(feature = "macros")]
 pub mod macros;
 mod month;