From e56756d5e4e60f7f5361c8b50a44c2ff779f1cdd Mon Sep 17 00:00:00 2001
From: Fabian Braun <fabian-braun@users.noreply.github.com>
Date: Wed, 18 Oct 2023 14:54:21 +0200
Subject: [PATCH] Implement Debug for Time

---
 src/lib.rs | 171 +++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 132 insertions(+), 39 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 75629cf..8a4ec17 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -42,7 +42,7 @@ use std::cmp::max;
 use std::cmp::min;
 use std::cmp::Ordering;
 use std::error::Error;
-use std::fmt::Debug;
+use std::fmt::{Debug, Formatter};
 use std::fmt::Display;
 use std::ops::Add;
 use std::ops::AddAssign;
@@ -73,7 +73,7 @@ use serde::Serialize;
 ///
 /// Low overhead time representation. Internally represented as milliseconds.
 #[derive(
-    Eq, PartialEq, Hash, Ord, PartialOrd, Copy, Clone, Debug, Default, Serialize, Deref, From, Into,
+Eq, PartialEq, Hash, Ord, PartialOrd, Copy, Clone, Default, Serialize, Deref, From, Into,
 )]
 pub struct Time(i64);
 impl Time {
@@ -132,7 +132,7 @@ impl Time {
         // casting to u32 is safe here because it is guaranteed that the value is in
         // 0..1_000_000_000
         #[allow(clippy::cast_possible_truncation)]
-        let nanos = if nanos.is_negative() {
+            let nanos = if nanos.is_negative() {
             1_000_000_000 - nanos.unsigned_abs()
         } else {
             nanos.unsigned_abs()
@@ -263,8 +263,8 @@ impl Display for Time {
 /// Allows deserializing from RFC 3339 strings and unsigned integers.
 impl<'de> Deserialize<'de> for Time {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
+        where
+            D: serde::Deserializer<'de>,
     {
         deserializer.deserialize_any(TimeVisitor)
     }
@@ -279,15 +279,15 @@ impl<'de> Visitor<'de> for TimeVisitor {
     }
 
     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
+        where
+            E: serde::de::Error,
     {
         Time::parse_from_rfc3339(v).map_err(|e| E::custom(e.to_string()))
     }
 
     fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
+        where
+            E: serde::de::Error,
     {
         i64::try_from(v)
             .map_err(|e| E::custom(e.to_string()))
@@ -295,8 +295,8 @@ impl<'de> Visitor<'de> for TimeVisitor {
     }
 
     fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
+        where
+            D: serde::Deserializer<'de>,
     {
         // expecting an unsigned integer inside the newtype struct, but technically also
         // allowing strings
@@ -317,6 +317,40 @@ impl From<Time> for std::time::SystemTime {
     }
 }
 
+impl Debug for Time {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let positive = self.0 >= 0;
+        let mut total = if self.0 == i64::MIN {
+            9223372036854775808usize
+        } else {
+            self.0.abs() as usize
+        };
+        let millis_part = total % 1000;
+        total -= millis_part;
+        let seconds_part = (total % (1000 * 60)) / 1000;
+        total -= seconds_part;
+        let minutes_part = (total % (1000 * 60 * 60)) / (1000 * 60);
+        total -= minutes_part;
+        let hours_part = total / (1000 * 60 * 60);
+        if !positive {
+            f.write_str("-")?;
+        }
+        write!(f, "{:02}:", hours_part)?;
+        write!(f, "{:02}:", minutes_part)?;
+        write!(f, "{:02}", seconds_part)?;
+        if millis_part > 0 {
+            write!(f, ".{}", millis_part)?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum TimeWindowError {
+    #[error("time window start is after end")]
+    StartAfterEnd,
+}
+
 /// An interval or range of time: `[start,end)`.
 #[derive(Clone, Debug, Eq, PartialEq, Default, Copy, Serialize, Deserialize, From, Into, Hash)]
 pub struct TimeWindow {
@@ -738,21 +772,21 @@ impl TimeWindow {
 /// Duration can be negative. Internally duration is represented as
 /// milliseconds.
 #[derive(
-    Eq,
-    PartialEq,
-    Ord,
-    PartialOrd,
-    Copy,
-    Clone,
-    Debug,
-    Default,
-    Hash,
-    Serialize,
-    Deref,
-    From,
-    Into,
-    Sum,
-    Neg,
+Eq,
+PartialEq,
+Ord,
+PartialOrd,
+Copy,
+Clone,
+Debug,
+Default,
+Hash,
+Serialize,
+Deref,
+From,
+Into,
+Sum,
+Neg,
 )]
 pub struct Duration(i64);
 
@@ -838,8 +872,8 @@ impl Duration {
 /// Allows deserializing from strings, unsigned integers, and signed integers.
 impl<'de> Deserialize<'de> for Duration {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
+        where
+            D: serde::Deserializer<'de>,
     {
         deserializer.deserialize_any(DurationVisitor)
     }
@@ -868,15 +902,15 @@ impl<'de> Visitor<'de> for DurationVisitor {
     }
 
     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
+        where
+            E: serde::de::Error,
     {
         Duration::from_str(v).map_err(|e| E::custom(e.to_string()))
     }
 
     fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
+        where
+            E: serde::de::Error,
     {
         i64::try_from(v)
             .map_err(|e| E::custom(e.to_string()))
@@ -884,15 +918,15 @@ impl<'de> Visitor<'de> for DurationVisitor {
     }
 
     fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
+        where
+            E: serde::de::Error,
     {
         Ok(Duration::millis(v))
     }
 
     fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
+        where
+            D: serde::Deserializer<'de>,
     {
         // expecting a signed integer inside the newtype struct, but technically also
         // allowing strings and signed integers
@@ -1189,11 +1223,11 @@ impl From<Duration> for std::time::Duration {
             "Negative Duration {input} cannot be converted to std::time::Duration"
         );
         #[allow(clippy::cast_sign_loss)] // caught by the debug_assert above
-        let secs = (input.0 / 1000) as u64;
+            let secs = (input.0 / 1000) as u64;
         // casting to u32 is safe here because it is guaranteed that the value is in
         // 0..1_000_000_000. The sign loss is caught by the debug_assert above.
         #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-        let nanos = ((input.0 % 1000) * 1_000_000) as u32;
+            let nanos = ((input.0 % 1000) * 1_000_000) as u32;
         std::time::Duration::new(secs, nanos)
     }
 }
@@ -1352,6 +1386,65 @@ mod time_test {
         }
     }
 
+    #[test]
+    fn test_debug() {
+        struct TestCase {
+            name: &'static str,
+            input: Time,
+            expected: String,
+        }
+        let tests = vec![
+            TestCase {
+                name: "EPOCH",
+                input: Time::EPOCH,
+                expected: "00:00:00".to_string(),
+            },
+            TestCase {
+                name: "i16::MAX + 1",
+                input: Time::seconds(i64::from(i16::MAX) + 1),
+                expected: "09:06:08".to_string(),
+            },
+            TestCase {
+                name: "i32::MAX + 1",
+                input: Time::seconds(i64::from(i32::MAX) + 1),
+                expected: "596523:14:08".to_string(),
+            },
+            TestCase {
+                name: "u32::MAX + 1",
+                input: Time::seconds(i64::from(u32::MAX) + 1),
+                expected: "1193046:28:16".to_string(),
+            },
+            TestCase {
+                name: "very large",
+                input: Time::seconds(i64::from(i32::MAX) * 3500),
+                expected: "2087831323:28:20".to_string(),
+            },
+            TestCase {
+                name: "MAX",
+                input: Time::MAX,
+                expected: "2562047788015:12:55.807".to_string(),
+            },
+            TestCase {
+                name: "i16::MIN",
+                input: Time::seconds(i64::from(i16::MIN)),
+                expected: "-09:06:08".to_string(),
+            },
+            TestCase {
+                name: "i64::MIN",
+                input: Time::millis(i64::MIN),
+                expected: "-2562047788015:12:55.808".to_string(),
+            },
+        ];
+        for test in tests {
+            assert_eq!(
+                test.expected,
+                format!("{:?}", test.input),
+                "test '{}' failed",
+                test.name
+            );
+        }
+    }
+
     #[test]
     fn deserialize_time() {
         // strings
@@ -1432,7 +1525,7 @@ mod duration_test {
                 + Duration::minutes(3)
                 + Duration::seconds(4)
                 + Duration::millis(5))
-            .to_string()
+                .to_string()
         );
 
         assert_eq!("0ms", Duration::ZERO.to_string());