Add TimestampSerde for serde impl

Author: junderw

rmp-serde/src/decode.rs

@@ -21,7 +21,7 @@ use rmp::decode::{self, DecodeStringError, MarkerReadError, NumValueReadError, R
 use rmp::Marker;
 
 use crate::config::{BinaryConfig, DefaultConfig, HumanReadableConfig, SerializerConfig};
-use crate::MSGPACK_EXT_STRUCT_NAME;
+use crate::{MSGPACK_EXT_STRUCT_NAME, MSGPACK_TIMESTAMP_STRUCT_NAME};
 
 /// Enum representing errors that can occur while decoding MessagePack data.
 #[derive(Debug)]
@@ -698,6 +698,11 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
             return visitor.visit_newtype_struct(ext_de);
         }
 
+        if name == MSGPACK_TIMESTAMP_STRUCT_NAME {
+            let ts_de = TimestampDeserializer::new(&mut self.rd);
+            return ts_de.deserialize_any(visitor);
+        }
+
         visitor.visit_newtype_struct(self)
     }
 
@@ -1191,3 +1196,34 @@ where
     let mut de = Deserializer::from_read_ref(rd);
     Deserialize::deserialize(&mut de)
 }
+
+#[derive(Debug)]
+pub(crate) struct TimestampDeserializer<'a, R> {
+    rd: &'a mut R,
+}
+
+impl<'a, R: Read> TimestampDeserializer<'a, R> {
+    pub(crate) fn new(rd: &'a mut R) -> Self {
+        Self {
+            rd,
+        }
+    }
+}
+
+impl<'de, 'a, R: Read> de::Deserializer<'de> for TimestampDeserializer<'a, R> {
+    type Error = Error;
+
+    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de> {
+        let ts = rmp::decode::read_timestamp(&mut self.rd)?;
+
+        visitor.visit_u128(ts.into_u128())
+    }
+
+    forward_to_deserialize_any! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
+        seq bytes byte_buf map unit_struct newtype_struct
+        struct identifier tuple enum ignored_any tuple_struct
+    }
+}

rmp-serde/src/encode.rs

@@ -20,7 +20,7 @@ use rmp::{encode, Marker};
 use crate::config::{
     BinaryConfig, DefaultConfig, HumanReadableConfig, RuntimeConfig, SerializerConfig, StructMapConfig, StructTupleConfig
 };
-use crate::MSGPACK_EXT_STRUCT_NAME;
+use crate::{MSGPACK_EXT_STRUCT_NAME, MSGPACK_TIMESTAMP_STRUCT_NAME};
 
 /// This type represents all possible errors that can occur when serializing or
 /// deserializing MessagePack data.
@@ -685,6 +685,13 @@ where
             return ext_se.end();
         }
 
+        if name == MSGPACK_TIMESTAMP_STRUCT_NAME {
+            let mut ts_se = TimestampSerializer::new(&mut self.wr);
+            value.serialize(&mut ts_se)?;
+
+            return Ok(());
+        }
+
         // Encode as if it's inner type.
         value.serialize(self)
     }
@@ -1269,3 +1276,186 @@ impl Write for FallibleWriter {
         Ok(())
     }
 }
+
+struct TimestampSerializer<'a, W> {
+    wr: &'a mut W
+}
+
+impl<'a, W: Write> TimestampSerializer<'a, W> {
+    fn new(wr: &'a mut W) -> Self {
+        Self { wr }
+    }
+}
+
+impl<'a, W: Write> serde::Serializer for &'a mut TimestampSerializer<'a, W> {
+    type Ok = ();
+
+    type Error = Error;
+
+    type SerializeSeq = serde::ser::Impossible<(), Error>;
+    type SerializeTuple = serde::ser::Impossible<(), Error>;
+    type SerializeTupleStruct = serde::ser::Impossible<(), Error>;
+    type SerializeTupleVariant = serde::ser::Impossible<(), Error>;
+    type SerializeMap = serde::ser::Impossible<(), Error>;
+    type SerializeStruct = serde::ser::Impossible<(), Error>;
+    type SerializeStructVariant = serde::ser::Impossible<(), Error>;
+
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        let ts = rmp::Timestamp::from_u128(v).ok_or_else(|| Error::Syntax(format!("Not a valid Timestamp")))?;
+        rmp::encode::write_timestamp(self.wr, ts).map_err(|_| Error::Syntax(format!("Not a valid Timestamp")))?;
+        Ok(())
+    }
+
+    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_newtype_struct<T>(
+        self,
+        _name: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        Err(Error::InvalidDataModel("expected u128"))
+    }
+}

rmp-serde/src/lib.rs

@@ -40,6 +40,7 @@ pub mod encode;
 ///            Value::Ext(2, vec![5]));
 /// ```
 pub const MSGPACK_EXT_STRUCT_NAME: &str = "_ExtStruct";
+pub(crate) const MSGPACK_TIMESTAMP_STRUCT_NAME: &str = "_TimestampForInternalUseOnly";
 
 /// Helper that allows both to encode and decode strings no matter whether they contain valid or
 /// invalid UTF-8.
@@ -335,3 +336,50 @@ impl<'de> Deserialize<'de> for RawRef<'de> {
         de.deserialize_any(RawRefVisitor)
     }
 }
+
+/// This is a wrapper for `rmp::Timestamp` which is only used for serde.
+///
+/// This maps to the serde data model as follows:
+///
+/// `struct _TimestampForInternalUseOnly(u128);`
+///
+/// This will encode enough information for the Serializer and Deserializer
+/// to properly manage the data to and from the msgpack format.
+///
+/// This wrapper should ONLY be used with the msgpack Serializer and Deserializer
+/// from this library.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TimestampSerde(pub rmp::Timestamp);
+
+impl Serialize for TimestampSerde {
+    fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        se.serialize_newtype_struct(MSGPACK_TIMESTAMP_STRUCT_NAME, &self.0.into_u128())
+    }
+}
+
+impl<'de> Deserialize<'de> for TimestampSerde {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        struct TimestampVisitor;
+
+        impl de::Visitor<'_> for TimestampVisitor {
+            type Value = TimestampSerde;
+            
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("A valid TimestampSerde")
+            }
+            
+            fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+                where
+                    E: de::Error, {
+                    Ok(TimestampSerde(rmp::Timestamp::from_u128(v).ok_or_else(|| de::Error::custom("invalid TimestampSerde"))?))
+            }
+        }
+        deserializer.deserialize_newtype_struct(MSGPACK_TIMESTAMP_STRUCT_NAME, TimestampVisitor)
+    }
+}

rmp-serde/tests/decode_derive.rs

@@ -3,7 +3,7 @@ use std::io::Cursor;
 use serde::Deserialize;
 
 use rmp_serde::decode::Error;
-use rmp_serde::Deserializer;
+use rmp_serde::{Deserializer, TimestampSerde};
 
 #[test]
 fn pass_newtype() {
@@ -66,6 +66,24 @@ fn pass_struct() {
     assert_eq!(Decoded { id: 42, value: 100500 }, actual);
 }
 
+#[test]
+fn pass_timestamp() {
+    let buf = [0x93, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94, 0xd6, 0xff, 0x0, 0x0, 0x0, 0x7];
+    let cur = Cursor::new(&buf[..]);
+
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct Decoded {
+        id: u32,
+        value: u32,
+        ts: TimestampSerde,
+    }
+
+    let mut de = Deserializer::new(cur);
+    let actual: Decoded = Deserialize::deserialize(&mut de).unwrap();
+
+    assert_eq!(Decoded { id: 42, value: 100500, ts: TimestampSerde(rmp::Timestamp::from_32(7)) }, actual);
+}
+
 #[test]
 fn pass_struct_from_map() {
     #[derive(Debug, PartialEq, Deserialize)]

rmp-serde/tests/encode_derive.rs

@@ -1,4 +1,4 @@
-use rmp_serde::Serializer;
+use rmp_serde::{Serializer, TimestampSerde};
 use serde::Serialize;
 
 #[test]
@@ -129,6 +129,27 @@ fn pass_struct() {
     assert_eq!(vec![0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94], buf);
 }
 
+#[test]
+fn pass_timestamp() {
+    #[derive(Serialize)]
+    struct Struct {
+        f1: u32,
+        f2: u32,
+        ts: TimestampSerde,
+    }
+
+    let val = Struct {
+        f1: 42,
+        f2: 100500,
+        ts: TimestampSerde(rmp::Timestamp::from_32(9))
+    };
+    let mut buf = Vec::new();
+    val.serialize(&mut Serializer::new(&mut buf)).unwrap();
+
+    // Expect: [42, 100500, 4 byte Timestamp].
+    assert_eq!(vec![0x93, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94, 0xd6, 0xff, 0x0, 0x0, 0x0, 0x9], buf);
+}
+
 #[test]
 fn serialize_struct_variant() {
     #[derive(Serialize)]