Preliminary support for encoding structs as maps

Author: cameronism

rmp-serde/src/encode.rs

@@ -72,13 +72,24 @@ impl From<ValueWriteError> for Error {
 // TODO: Docs. Examples.
 pub struct Serializer<'a> {
     wr: &'a mut Write,
+    verbose: bool,
 }
 
 impl<'a> Serializer<'a> {
     /// Creates a new MessagePack encoder whose output will be written to the writer specified.
     pub fn new(wr: &'a mut Write) -> Serializer<'a> {
         Serializer {
             wr: wr,
+            verbose: false,
+        }
+    }
+
+    /// Creates a new MessagePack encoder whose output will be written to the writer specified.
+    /// structs will be written as maps in MessagePack
+    pub fn new_verbose(wr: &'a mut Write) -> Serializer<'a> {
+        Serializer {
+            wr: wr,
+            verbose: true,
         }
     }
 }
@@ -276,7 +287,11 @@ 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));
+        if self.verbose {
+            try!(write_map_len(&mut self.wr, len as u32));
+        } else {
+            try!(write_array_len(&mut self.wr, len as u32));
+        }
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
@@ -286,6 +301,11 @@ impl<'a> serde::Serializer for Serializer<'a> {
     fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> Result<(), Error>
         where V: serde::Serialize,
     {
+        if self.verbose {
+            if let Err(e) = write_str(&mut self.wr, _key).map_err(From::from) {
+                return Err(e);
+            }
+        }
         value.serialize(self)
     }
 

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() {

rmp-serde/tests/serializer.rs

@@ -267,6 +267,33 @@ fn pass_map() {
     assert_eq!(out, buf);
 }
 
+#[cfg(feature = "serde_macros")]
+#[test]
+fn pass_struct_map() {
+    #[derive(Debug, PartialEq, Serialize)]
+    struct Custom<'a> {
+        et: &'a str,
+        le: u8,
+        shit: u8,
+    }
+
+    let mut buf = [0x00; 20];
+
+    let val = Custom { et: "voila", le: 0, shit: 1 };
+    val.serialize(&mut Serializer::new_verbose(&mut &mut buf[..])).ok().unwrap();
+
+    let out = [
+        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
+    ];
+    assert_eq!(out, buf);
+}
+
 #[cfg(feature = "serde_macros")]
 #[test]
 fn pass_enum() {