bincode support

Author: divi255

Cargo.toml

@@ -16,6 +16,7 @@ features = ["full"]
 features = ["full"]
 
 [dependencies]
+bincode = { version = "2.0.1", optional = true }
 chrono = { version = "0.4", optional = true }
 dateparser = { version = "0.2", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
@@ -32,5 +33,7 @@ web-time = "1.1"
 [features]
 #default = [ "full" ]
 chrono = ["dep:chrono", "dateparser"]
-full = [ "chrono", "serde", "sqlx" ]
+full = [ "chrono", "serde", "bincode", "sqlx" ]
 as-float-secs = []
+serde = ["dep:serde"]
+bincode = ["dep:bincode"]

src/impl_bincode.rs

@@ -0,0 +1,93 @@
+use bincode::{Decode, Encode};
+
+use crate::{Monotonic, Timestamp};
+
+//
+// Timestamp
+//
+#[cfg(not(feature = "as-float-secs"))]
+impl Encode for Timestamp {
+    fn encode<E: bincode::enc::Encoder>(
+        &self,
+        encoder: &mut E,
+    ) -> Result<(), bincode::error::EncodeError> {
+        let nanos: u64 = self.as_nanos().try_into().unwrap();
+        nanos.encode(encoder)
+    }
+}
+
+#[cfg(feature = "as-float-secs")]
+impl Encode for Timestamp {
+    fn encode<E: bincode::enc::Encoder>(
+        &self,
+        encoder: &mut E,
+    ) -> Result<(), bincode::error::EncodeError> {
+        let secs = self.as_secs_f64();
+        secs.encode(encoder)
+    }
+}
+
+#[cfg(not(feature = "as-float-secs"))]
+impl<C> Decode<C> for Timestamp {
+    fn decode<D: bincode::de::Decoder<Context = C>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        let nanos = u64::decode(decoder)?;
+        Ok(nanos.into())
+    }
+}
+
+#[cfg(feature = "as-float-secs")]
+impl<C> Decode<C> for Timestamp {
+    fn decode<D: bincode::de::Decoder<Context = C>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        let secs = f64::decode(decoder)?;
+        Ok(Timestamp::from_secs_f64(secs))
+    }
+}
+
+//
+// Monotonic
+//
+impl Encode for Monotonic {
+    fn encode<E: bincode::enc::Encoder>(
+        &self,
+        encoder: &mut E,
+    ) -> Result<(), bincode::error::EncodeError> {
+        let nanos: u64 = self.as_nanos().try_into().unwrap();
+        nanos.encode(encoder)
+    }
+}
+
+impl<C> Decode<C> for Monotonic {
+    fn decode<D: bincode::de::Decoder<Context = C>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        let nanos = u64::decode(decoder)?;
+        Ok(nanos.into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Monotonic, Timestamp};
+
+    #[test]
+    fn test_timestamp_bincode() {
+        let ts = Timestamp::from_nanos(1_500_000_000);
+        let encoded = bincode::encode_to_vec(ts, bincode::config::standard()).unwrap();
+        let (decoded, _) =
+            bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
+        assert_eq!(ts, decoded);
+    }
+
+    #[test]
+    fn test_monotonic_bincode() {
+        let mono = Monotonic::from_nanos(2_500_000_000);
+        let encoded = bincode::encode_to_vec(mono, bincode::config::standard()).unwrap();
+        let (decoded, _) =
+            bincode::decode_from_slice(&encoded, bincode::config::standard()).unwrap();
+        assert_eq!(mono, decoded);
+    }
+}

src/lib.rs

@@ -6,6 +6,8 @@ pub use timestamp::Timestamp;
 mod common;
 mod convert;
 mod error;
+#[cfg(feature = "bincode")]
+mod impl_bincode;
 #[cfg(feature = "chrono")]
 mod impl_chrono;
 #[cfg(feature = "serde")]