Static dispatch to VariantWriter impl via generics

Author: cameronism

rmp-serde/src/encode.rs

@@ -3,6 +3,7 @@ use serde;
 use std::fmt;
 use std::io::Write;
 
+use rmp::Marker;
 use rmp::encode::{
     write_nil,
     write_bool,
@@ -58,6 +59,52 @@ impl From<ValueWriteError> for Error {
     }
 }
 
+pub trait VariantWriter {
+    fn write_struct_len<W>(&self, wr: &mut W, len: u32) -> Result<Marker, ValueWriteError> where W: Write;
+    fn write_field_name<W>(&self, wr: &mut W, _key: &str) -> Result<(), ValueWriteError> where W: Write;
+}
+
+/// Writes struct as MessagePack array with no field names
+pub struct StructArrayWriter;
+
+impl VariantWriter for StructArrayWriter {
+    fn write_struct_len<W>(&self, wr: &mut W, len: u32) -> Result<Marker, ValueWriteError>
+        where W: Write
+    {
+        write_array_len(wr, len)
+    }
+
+    /// This implementation does not write field names
+    #[allow(unused_variables)]
+    fn write_field_name<W>(&self, wr: &mut W, _key: &str) -> Result<(), ValueWriteError>
+        where W: Write
+    {
+        Ok(())
+    }
+}
+
+/// Writes struct as MessagePack map including field names
+pub struct StructMapWriter;
+
+impl VariantWriter for StructMapWriter {
+    fn write_struct_len<W>(&self, wr: &mut W, len: u32) -> Result<Marker, ValueWriteError>
+        where W: Write
+    {
+        write_map_len(wr, len)
+    }
+
+    fn write_field_name<W>(&self, wr: &mut W, _key: &str) -> Result<(), ValueWriteError>
+        where W: Write
+    {
+        write_str(wr, _key)
+    }
+}
+
+/// Creates a new MessagePack encoder with default variant options
+pub fn new_default_serializer<'a>(wr: &'a mut Write) -> Serializer<'a, StructArrayWriter> {
+    Serializer::new(wr, StructArrayWriter)
+}
+
 /// Represents MessagePack serialization implementation.
 ///
 /// # Note
@@ -70,20 +117,22 @@ impl From<ValueWriteError> for Error {
 /// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
 /// operation is retried.
 // TODO: Docs. Examples.
-pub struct Serializer<'a> {
+pub struct Serializer<'a, W: VariantWriter> {
     wr: &'a mut Write,
+    vw: W,
 }
 
-impl<'a> Serializer<'a> {
+impl<'a, W: VariantWriter> Serializer<'a, W> {
     /// Creates a new MessagePack encoder whose output will be written to the writer specified.
-    pub fn new(wr: &'a mut Write) -> Serializer<'a> {
+    pub fn new(wr: &'a mut Write, variant_writer: W) -> Serializer<'a, W> {
         Serializer {
             wr: wr,
+            vw: variant_writer,
         }
     }
 }
 
-impl<'a> serde::Serializer for Serializer<'a> {
+impl<'a, W: VariantWriter> serde::Serializer for Serializer<'a, W> {
     type Error = Error;
 
     fn visit_unit(&mut self) -> Result<(), Error> {
@@ -276,7 +325,7 @@ impl<'a> serde::Serializer for Serializer<'a> {
             None => panic!("do not know how to serialize a sequence with no length"),
         };
 
-        try!(write_array_len(&mut self.wr, len as u32));
+        try!(self.vw.write_struct_len(&mut self.wr, len as u32));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
@@ -286,6 +335,7 @@ impl<'a> serde::Serializer for Serializer<'a> {
     fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> Result<(), Error>
         where V: serde::Serialize,
     {
+        try!(self.vw.write_field_name(&mut self.wr, _key));
         value.serialize(self)
     }
 

rmp-serde/src/lib.rs

@@ -5,4 +5,4 @@ pub mod decode;
 pub mod encode;
 
 pub use decode::Deserializer;
-pub use encode::Serializer;
+pub use encode::{Serializer, new_default_serializer, StructArrayWriter, StructMapWriter};

rmp-serde/tests/deserializer.rs

@@ -340,6 +340,36 @@ fn pass_map() {
     assert_eq!(expected, actual);
 }
 
+#[cfg(feature = "serde_macros")]
+#[test]
+fn pass_struct_map() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct Custom {
+        et: String,
+        le: u8,
+        shit: u8,
+    }
+
+    let buf = [
+        0x83, // 3 (size)
+        0xa2, 0x65, 0x74, // "et"
+        0xa5, 0x76, 0x6f, 0x69, 0x6c, 0x61, // "voila"
+        0xa2, 0x6c, 0x65, // "le"
+        0x00, // 0
+        0xa4, 0x73, 0x68, 0x69, 0x74, // "shit"
+        0x01, // 1
+    ];
+    let cur = Cursor::new(&buf[..]);
+
+    // it appears no special behavior is needed for deserializing structs encoded as maps
+    let mut deserializer = Deserializer::new(cur);
+    let actual: Custom = Deserialize::deserialize(&mut deserializer).unwrap();
+    let voila = "voila".to_string(); // so the next line looks more funny
+    let expected = Custom { et: voila, le: 0, shit: 1 };
+
+    assert_eq!(expected, actual);
+}
+
 #[cfg(feature = "serde_macros")]
 #[test]
 fn pass_enum() {