From 87ca3f3edbdd301710824c70b497b4a91e9e09d5 Mon Sep 17 00:00:00 2001 From: Cameron Jordan Date: Fri, 28 Aug 2015 17:50:18 -0700 Subject: [PATCH 1/3] Preliminary support for encoding structs as maps --- rmp-serde/src/encode.rs | 22 +++++++++++++++++++++- rmp-serde/tests/deserializer.rs | 30 ++++++++++++++++++++++++++++++ rmp-serde/tests/serializer.rs | 27 +++++++++++++++++++++++++++ 3 files changed, 78 insertions(+), 1 deletion(-) diff --git a/rmp-serde/src/encode.rs b/rmp-serde/src/encode.rs index 1f49cf0d..e45224c0 100644 --- a/rmp-serde/src/encode.rs +++ b/rmp-serde/src/encode.rs @@ -72,6 +72,7 @@ impl From for Error { // TODO: Docs. Examples. pub struct Serializer<'a> { wr: &'a mut Write, + verbose: bool, } impl<'a> Serializer<'a> { @@ -79,6 +80,16 @@ impl<'a> Serializer<'a> { 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(&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) } diff --git a/rmp-serde/tests/deserializer.rs b/rmp-serde/tests/deserializer.rs index be880716..89e31179 100644 --- a/rmp-serde/tests/deserializer.rs +++ b/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() { diff --git a/rmp-serde/tests/serializer.rs b/rmp-serde/tests/serializer.rs index c20fdfed..150d59e7 100644 --- a/rmp-serde/tests/serializer.rs +++ b/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() { From 12960379fbc81bf9e9122e30ddc4cad4b64ee7d8 Mon Sep 17 00:00:00 2001 From: Cameron Jordan Date: Sat, 29 Aug 2015 18:28:55 -0700 Subject: [PATCH 2/3] Static dispatch to VariantWriter impl via generics --- rmp-serde/src/encode.rs | 60 ++++++++++++++++++++-- rmp-serde/src/lib.rs | 2 +- rmp-serde/tests/deserializer.rs | 30 +++++++++++ rmp-serde/tests/serializer.rs | 88 ++++++++++++++++++++++----------- 4 files changed, 145 insertions(+), 35 deletions(-) diff --git a/rmp-serde/src/encode.rs b/rmp-serde/src/encode.rs index 1f49cf0d..4891f93d 100644 --- a/rmp-serde/src/encode.rs +++ b/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 for Error { } } +pub trait VariantWriter { + fn write_struct_len(&self, wr: &mut W, len: u32) -> Result where W: Write; + fn write_field_name(&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(&self, wr: &mut W, len: u32) -> Result + where W: Write + { + write_array_len(wr, len) + } + + /// This implementation does not write field names + #[allow(unused_variables)] + fn write_field_name(&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(&self, wr: &mut W, len: u32) -> Result + where W: Write + { + write_map_len(wr, len) + } + + fn write_field_name(&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 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(&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) } diff --git a/rmp-serde/src/lib.rs b/rmp-serde/src/lib.rs index a30ef374..c84ff354 100644 --- a/rmp-serde/src/lib.rs +++ b/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}; diff --git a/rmp-serde/tests/deserializer.rs b/rmp-serde/tests/deserializer.rs index be880716..89e31179 100644 --- a/rmp-serde/tests/deserializer.rs +++ b/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() { diff --git a/rmp-serde/tests/serializer.rs b/rmp-serde/tests/serializer.rs index c20fdfed..ada520ef 100644 --- a/rmp-serde/tests/serializer.rs +++ b/rmp-serde/tests/serializer.rs @@ -8,15 +8,18 @@ use std::io::Cursor; use serde::Serialize; -use rmp_serde::Serializer; +use rmp_serde::new_default_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 Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xc0], buf); } @@ -27,7 +30,7 @@ fn fail_null() { let val = (); - match val.serialize(&mut Serializer::new(&mut &mut buf[..])) { + match val.serialize(&mut new_default_serializer(&mut &mut buf[..])) { Err(Error::InvalidFixedValueWrite(..)) => (), other => panic!("unexpected result: {:?}", other) } @@ -40,7 +43,7 @@ fn pass_bool() { { let mut cur = Cursor::new(&mut buf[..]); - let mut encoder = Serializer::new(&mut cur); + let mut encoder = new_default_serializer(&mut cur); let val = true; val.serialize(&mut encoder).ok().unwrap(); @@ -56,7 +59,7 @@ fn pass_usize() { let mut buf = [0x00, 0x00]; let val = 255usize; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xcc, 0xff], buf); } @@ -66,7 +69,7 @@ fn pass_u8() { let mut buf = [0x00, 0x00]; let val = 255u8; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xcc, 0xff], buf); } @@ -76,7 +79,7 @@ fn pass_u16() { let mut buf = [0x00, 0x00, 0x00]; let val = 65535u16; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xcd, 0xff, 0xff], buf); } @@ -86,7 +89,7 @@ fn pass_u32() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00]; let val = 4294967295u32; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xce, 0xff, 0xff, 0xff, 0xff], buf); } @@ -96,7 +99,7 @@ fn pass_u64() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; let val = 18446744073709551615u64; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], buf); } @@ -106,7 +109,7 @@ fn pass_isize() { let mut buf = [0x00, 0x00]; let val = -128isize; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xd0, 0x80], buf); } @@ -116,7 +119,7 @@ fn pass_i8() { let mut buf = [0x00, 0x00]; let val = -128i8; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xd0, 0x80], buf); } @@ -126,7 +129,7 @@ fn pass_i16() { let mut buf = [0x00, 0x00, 0x00]; let val = -32768i16; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xd1, 0x80, 0x00], buf); } @@ -136,7 +139,7 @@ fn pass_i32() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00]; let val = -2147483648i32; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xd2, 0x80, 0x00, 0x00, 0x00], buf); } @@ -146,7 +149,7 @@ fn pass_i64() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; let val = -9223372036854775808i64; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf); } @@ -156,7 +159,7 @@ fn pass_f32() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00]; let val = 3.4028234e38_f32; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xca, 0x7f, 0x7f, 0xff, 0xff], buf); } @@ -166,7 +169,7 @@ fn pass_f64() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; let val = 42f64; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xcb, 0x40, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf); } @@ -176,7 +179,7 @@ fn pass_char() { let mut buf = [0x00, 0x00]; let val = '!'; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xa1, 0x21], buf); } @@ -187,7 +190,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 Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65], buf); } @@ -201,7 +204,7 @@ fn pass_struct() { struct Decoded { id: u32, value: u32 } let val = Decoded { id: 42, value: 100500 }; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94], buf); } @@ -211,7 +214,7 @@ fn pass_tuple() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; let val = (42u32, 100500u32); - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0x92, 0x2a, 0xce, 0x0, 0x1, 0x88, 0x94], buf); } @@ -221,7 +224,7 @@ fn pass_option_some() { let mut buf = [0x00]; let val = Some(100u32); - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0x64], buf); } @@ -231,7 +234,7 @@ fn pass_option_none() { let mut buf = [0x00]; let val: Option = None; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0xc0], buf); } @@ -241,7 +244,7 @@ fn pass_seq() { let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; let val = vec!["le", "shit"]; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); assert_eq!([0x92, 0xa2, 0x6c, 0x65, 0xa4, 0x73, 0x68, 0x69, 0x74], buf); } @@ -255,7 +258,7 @@ fn pass_map() { let mut val = BTreeMap::new(); val.insert(0u8, "le"); val.insert(1u8, "shit"); - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); let out = [ 0x82, // 2 (size) @@ -267,6 +270,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(&mut &mut buf[..], StructMapWriter)).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() { @@ -282,7 +312,7 @@ fn pass_enum() { let mut buf = [0x00; 3]; let val = Custom::Second; - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); let out = [0x92, 0x01, 0x90]; assert_eq!(out, buf); @@ -301,7 +331,7 @@ fn pass_enum_variant_with_arg() { let mut buf = [0x00; 4]; let val = Custom::Second(42); - val.serialize(&mut Serializer::new(&mut &mut buf[..])).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut &mut buf[..])).ok().unwrap(); let out = [0x92, 0x01, 0x91, 0x2a]; assert_eq!(out, buf); @@ -313,7 +343,7 @@ fn pass_encodong_struct_into_vec() { let mut buf: Vec = Vec::new(); - val.serialize(&mut Serializer::new(&mut buf)).unwrap(); + val.serialize(&mut new_default_serializer(&mut buf)).unwrap(); assert_eq!(vec![0x92, 0x2a, 0xaa, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72], buf); } @@ -329,7 +359,7 @@ fn encode_struct_with_string_using_vec() { let mut buf = Vec::new(); let val = Custom { data: "le message".to_string() }; - val.serialize(&mut Serializer::new(&mut buf)).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut buf)).ok().unwrap(); let out = vec![0x91, 0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65]; assert_eq!(out, buf); @@ -343,7 +373,7 @@ fn pass_bin() { let vec = vec![0xcc, 0x80]; let val = Bytes::from(&vec); - val.serialize(&mut Serializer::new(&mut buf)).ok().unwrap(); + val.serialize(&mut new_default_serializer(&mut buf)).ok().unwrap(); assert_eq!(vec![0xc4, 0x02, 0xcc, 0x80], buf); } From 46b3d5dd13ed2134e338e40951209bf5cc314b6d Mon Sep 17 00:00:00 2001 From: Evgeny Safronov Date: Sun, 30 Aug 2015 12:57:10 +0300 Subject: [PATCH 3/3] Serializer: refactoring. - Returned back `Serializer` instantiation using `new` function. - Added `with` function to instantiate `Serializer` with specified struct encoder. --- rmp-serde/src/encode.rs | 36 +++++---------- rmp-serde/src/lib.rs | 2 +- rmp-serde/tests/serializer.rs | 85 +++++++++++++++++++++-------------- 3 files changed, 65 insertions(+), 58 deletions(-) diff --git a/rmp-serde/src/encode.rs b/rmp-serde/src/encode.rs index 4891f93d..ad2801d1 100644 --- a/rmp-serde/src/encode.rs +++ b/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(&self, wr: &mut W, len: u32) -> Result - where W: Write - { - write_map_len(wr, len) - } - - fn write_field_name(&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, } } } diff --git a/rmp-serde/src/lib.rs b/rmp-serde/src/lib.rs index c84ff354..a30ef374 100644 --- a/rmp-serde/src/lib.rs +++ b/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; diff --git a/rmp-serde/tests/serializer.rs b/rmp-serde/tests/serializer.rs index ada520ef..65cc1279 100644 --- a/rmp-serde/tests/serializer.rs +++ b/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 = 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(&self, wr: &mut W, len: u32) -> Result + where W: Write + { + write_map_len(wr, len) + } + + fn write_field_name(&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 = 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); }