Serializer: refactoring.

 - Returned back `Serializer` instantiation using `new` function.
 - Added `with` function to instantiate `Serializer` with specified
   struct encoder.

Author: 3Hren

rmp-serde/src/encode.rs

@@ -83,28 +83,6 @@ impl VariantWriter for StructArrayWriter {
     }
 }
 
-/// 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
@@ -122,12 +100,22 @@ pub struct Serializer<'a, W: VariantWriter> {
     vw: W,
 }
 
+impl<'a> Serializer<'a, StructArrayWriter> {
+    /// Creates a new MessagePack encoder whose output will be written to the writer specified.
+    pub fn new(wr: &'a mut Write) -> Serializer<'a, StructArrayWriter> {
+        Serializer {
+            wr: wr,
+            vw: StructArrayWriter,
+        }
+    }
+}
+
 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, variant_writer: W) -> Serializer<'a, W> {
+    pub fn with(wr: &'a mut Write, vw: W) -> Serializer<'a, W> {
         Serializer {
             wr: wr,
-            vw: variant_writer,
+            vw: vw,
         }
     }
 }

rmp-serde/src/lib.rs

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

rmp-serde/tests/serializer.rs

@@ -2,24 +2,22 @@
 #![cfg_attr(feature = "serde_macros", plugin(serde_macros))]
 
 extern crate serde;
+extern crate rmp;
 extern crate rmp_serde;
 
 use std::io::Cursor;
 
 use serde::Serialize;
 
-use rmp_serde::new_default_serializer;
+use rmp_serde::Serializer;
 use rmp_serde::encode::Error;
 
-#[cfg(feature = "serde_macros")]
-use rmp_serde::{Serializer, StructMapWriter};
-
 #[test]
 fn pass_null() {
     let mut buf = [0x00];
 
     let val = ();
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xc0], buf);
 }
@@ -30,7 +28,7 @@ fn fail_null() {
 
     let val = ();
 
-    match val.serialize(&mut new_default_serializer(&mut &mut buf[..])) {
+    match val.serialize(&mut Serializer::new(&mut &mut buf[..])) {
         Err(Error::InvalidFixedValueWrite(..)) => (),
         other => panic!("unexpected result: {:?}", other)
     }
@@ -43,7 +41,7 @@ fn pass_bool() {
     {
         let mut cur = Cursor::new(&mut buf[..]);
 
-        let mut encoder = new_default_serializer(&mut cur);
+        let mut encoder = Serializer::new(&mut cur);
 
         let val = true;
         val.serialize(&mut encoder).ok().unwrap();
@@ -59,7 +57,7 @@ fn pass_usize() {
     let mut buf = [0x00, 0x00];
 
     let val = 255usize;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xcc, 0xff], buf);
 }
@@ -69,7 +67,7 @@ fn pass_u8() {
     let mut buf = [0x00, 0x00];
 
     let val = 255u8;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xcc, 0xff], buf);
 }
@@ -79,7 +77,7 @@ fn pass_u16() {
     let mut buf = [0x00, 0x00, 0x00];
 
     let val = 65535u16;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xcd, 0xff, 0xff], buf);
 }
@@ -89,7 +87,7 @@ fn pass_u32() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = 4294967295u32;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xce, 0xff, 0xff, 0xff, 0xff], buf);
 }
@@ -99,7 +97,7 @@ fn pass_u64() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = 18446744073709551615u64;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], buf);
 }
@@ -109,7 +107,7 @@ fn pass_isize() {
     let mut buf = [0x00, 0x00];
 
     let val = -128isize;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xd0, 0x80], buf);
 }
@@ -119,7 +117,7 @@ fn pass_i8() {
     let mut buf = [0x00, 0x00];
 
     let val = -128i8;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xd0, 0x80], buf);
 }
@@ -129,7 +127,7 @@ fn pass_i16() {
     let mut buf = [0x00, 0x00, 0x00];
 
     let val = -32768i16;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xd1, 0x80, 0x00], buf);
 }
@@ -139,7 +137,7 @@ fn pass_i32() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = -2147483648i32;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xd2, 0x80, 0x00, 0x00, 0x00], buf);
 }
@@ -149,7 +147,7 @@ fn pass_i64() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = -9223372036854775808i64;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf);
 }
@@ -159,7 +157,7 @@ fn pass_f32() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = 3.4028234e38_f32;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xca, 0x7f, 0x7f, 0xff, 0xff], buf);
 }
@@ -169,7 +167,7 @@ fn pass_f64() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = 42f64;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xcb, 0x40, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf);
 }
@@ -179,7 +177,7 @@ fn pass_char() {
     let mut buf = [0x00, 0x00];
 
     let val = '!';
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xa1, 0x21], buf);
 }
@@ -190,7 +188,7 @@ fn pass_string() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = "le message";
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65], buf);
 }
@@ -204,7 +202,7 @@ fn pass_struct() {
     struct Decoded { id: u32, value: u32 }
 
     let val = Decoded { id: 42, value: 100500 };
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94], buf);
 }
@@ -214,7 +212,7 @@ fn pass_tuple() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = (42u32, 100500u32);
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94], buf);
 }
@@ -224,7 +222,7 @@ fn pass_option_some() {
     let mut buf = [0x00];
 
     let val = Some(100u32);
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0x64], buf);
 }
@@ -234,7 +232,7 @@ fn pass_option_none() {
     let mut buf = [0x00];
 
     let val: Option<u32> = None;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0xc0], buf);
 }
@@ -244,7 +242,7 @@ fn pass_seq() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
     let val = vec!["le", "shit"];
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     assert_eq!([0x92, 0xa2, 0x6c, 0x65, 0xa4, 0x73, 0x68, 0x69, 0x74], buf);
 }
@@ -258,7 +256,7 @@ fn pass_map() {
     let mut val = BTreeMap::new();
     val.insert(0u8, "le");
     val.insert(1u8, "shit");
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     let out = [
         0x82, // 2 (size)
@@ -273,6 +271,27 @@ fn pass_map() {
 #[cfg(feature = "serde_macros")]
 #[test]
 fn pass_struct_map() {
+    use std::io::Write;
+    use rmp::Marker;
+    use rmp::encode::{ValueWriteError, write_map_len, write_str};
+    use rmp_serde::encode::VariantWriter;
+
+    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)
+        }
+    }
+
     #[derive(Debug, PartialEq, Serialize)]
     struct Custom<'a> {
         et: &'a str,
@@ -283,7 +302,7 @@ fn pass_struct_map() {
     let mut buf = [0x00; 20];
 
     let val = Custom { et: "voila", le: 0, shit: 1 };
-    val.serialize(&mut Serializer::new(&mut &mut buf[..], StructMapWriter)).ok().unwrap();
+    val.serialize(&mut Serializer::with(&mut &mut buf[..], StructMapWriter)).ok().unwrap();
 
     let out = [
         0x83, // 3 (size)
@@ -312,7 +331,7 @@ fn pass_enum() {
     let mut buf = [0x00; 3];
 
     let val = Custom::Second;
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     let out = [0x92, 0x01, 0x90];
     assert_eq!(out, buf);
@@ -331,7 +350,7 @@ fn pass_enum_variant_with_arg() {
     let mut buf = [0x00; 4];
 
     let val = Custom::Second(42);
-    val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap();
 
     let out = [0x92, 0x01, 0x91, 0x2a];
     assert_eq!(out, buf);
@@ -343,7 +362,7 @@ fn pass_encodong_struct_into_vec() {
 
     let mut buf: Vec<u8> = Vec::new();
 
-    val.serialize(&mut new_default_serializer(&mut buf)).unwrap();
+    val.serialize(&mut Serializer::new(&mut buf)).unwrap();
 
     assert_eq!(vec![0x92, 0x2a, 0xaa, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72], buf);
 }
@@ -359,7 +378,7 @@ fn encode_struct_with_string_using_vec() {
     let mut buf = Vec::new();
 
     let val = Custom { data: "le message".to_string() };
-    val.serialize(&mut new_default_serializer(&mut buf)).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut buf)).ok().unwrap();
 
     let out = vec![0x91, 0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
     assert_eq!(out, buf);
@@ -373,7 +392,7 @@ fn pass_bin() {
     let vec = vec![0xcc, 0x80];
     let val = Bytes::from(&vec);
 
-    val.serialize(&mut new_default_serializer(&mut buf)).ok().unwrap();
+    val.serialize(&mut Serializer::new(&mut buf)).ok().unwrap();
 
     assert_eq!(vec![0xc4, 0x02, 0xcc, 0x80], buf);
 }