Impl serde::Serialize and serde::Deserialize for TimeDelta

src/time_delta.rs

@@ -638,6 +638,54 @@ impl arbitrary::Arbitrary<'_> for TimeDelta {
     }
 }
 
+#[cfg(feature = "serde")]
+mod serde {
+    use super::{TimeDelta, MAX, MIN};
+    use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
+
+    impl Serialize for TimeDelta {
+        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+            <(i64, i32) as Serialize>::serialize(&(self.secs, self.nanos), serializer)
+        }
+    }
+
+    impl<'de> Deserialize<'de> for TimeDelta {
+        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+            let (secs, nanos) = <(i64, i32) as Deserialize>::deserialize(deserializer)?;
+            if !(MIN.secs..=MAX.secs).contains(&secs)
+                || nanos >= 1_000_000_000
+                || (secs == MAX.secs && nanos > MAX.nanos)
+                || (secs == MIN.secs && nanos < MIN.nanos)
+            {
+                return Err(Error::custom("TimeDelta out of bounds"));
+            }
+            Ok(TimeDelta { secs, nanos })
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::{TimeDelta, MAX};
+
+        #[test]
+        fn test_serde() {
+            let duration = TimeDelta::new(123, 456).unwrap();
+            assert_eq!(
+                serde_json::from_value::<TimeDelta>(serde_json::to_value(duration).unwrap())
+                    .unwrap(),
+                duration
+            );
+        }
+
+        #[test]
+        #[should_panic(expected = "TimeDelta out of bounds")]
+        fn test_serde_oob_panic() {
+            let _ =
+                serde_json::from_value::<TimeDelta>(serde_json::json!([MAX.secs + 1, 0])).unwrap();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::OutOfRangeError;