From 3a6eb83da6ff1a56fa66bea03b434367da8ae4f0 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sun, 31 Aug 2014 20:44:19 -0700 Subject: [PATCH] typarameterize Serializer --- serde_macros/src/lib.rs | 29 +------ src/bench_log.rs | 96 ++++++++--------------- src/json/mod.rs | 128 +++++++++++++++++-------------- src/ser.rs | 166 ++++++++++++++++++++-------------------- 4 files changed, 187 insertions(+), 232 deletions(-) diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs index db7fd60d..3755cf82 100644 --- a/serde_macros/src/lib.rs +++ b/serde_macros/src/lib.rs @@ -72,15 +72,10 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt, let trait_def = TraitDef { span: sp, attributes: vec!(), - path: Path::new(vec!("serde", "ser", "Serializable")), - /* path: Path::new_(vec!("serde", "ser", "Serializable"), None, vec!(box Literal(Path::new_local("__S")), box Literal(Path::new_local("__E"))), true), - */ additional_bounds: Vec::new(), - generics: LifetimeBounds::empty(), - /* generics: LifetimeBounds { lifetimes: Vec::new(), bounds: vec!(("__S", None, vec!(Path::new_( @@ -88,32 +83,10 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt, vec!(box Literal(Path::new_local("__E"))), true))), ("__E", None, vec!())) }, - */ methods: vec!( MethodDef { name: "serialize", - generics: LifetimeBounds { - lifetimes: Vec::new(), - bounds: vec!( - ( - "__S", - None, - vec!( - Path::new_( - vec!("serde", "ser", "Serializer"), - None, - vec!(box Literal(Path::new_local("__E"))), - true - ) - ), - ), - ( - "__E", - None, - vec!(), - ), - ) - }, + generics: LifetimeBounds::empty(), explicit_self: borrowed_explicit_self(), args: vec!(Ptr(box Literal(Path::new_local("__S")), Borrowed(None, MutMutable))), diff --git a/src/bench_log.rs b/src/bench_log.rs index bb49be18..3a913698 100644 --- a/src/bench_log.rs +++ b/src/bench_log.rs @@ -35,12 +35,9 @@ enum HttpProtocol { HTTP11, } -impl ser::Serializable for HttpProtocol { +impl, E> ser::Serializable for HttpProtocol { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -67,12 +64,9 @@ enum HttpMethod { PATCH, } -impl ser::Serializable for HttpMethod { +impl, E> ser::Serializable for HttpMethod { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -92,12 +86,9 @@ enum CacheStatus { Hit, } -impl ser::Serializable for CacheStatus { +impl, E> ser::Serializable for CacheStatus { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -126,12 +117,9 @@ enum OriginProtocol { HTTPS, } -impl ser::Serializable for OriginProtocol { +impl, E> ser::Serializable for OriginProtocol { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -152,12 +140,9 @@ enum ZonePlan { ENT, } -impl ser::Serializable for ZonePlan { +impl, E> ser::Serializable for ZonePlan { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -429,12 +414,9 @@ enum Country { ZW, } -impl ser::Serializable for Country { +impl, E> ser::Serializable for Country { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_uint(*self as uint) } } @@ -799,12 +781,10 @@ fn bench_serializer_mem_writer(b: &mut Bencher) { b.iter(|| { //let _json = json::to_str(&log).unwrap(); - let mut wr = MemWriter::with_capacity(1024); - { - let mut serializer = json::Serializer::new(wr.by_ref()); - log.serialize(&mut serializer).unwrap(); - } - let _json = wr.unwrap(); + let wr = MemWriter::with_capacity(1024); + let mut serializer = json::Serializer::new(wr); + log.serialize(&mut serializer).unwrap(); + let _json = serializer.unwrap().unwrap(); }); } @@ -816,12 +796,10 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) { b.iter(|| { //let _json = json::to_str(&log).unwrap(); - let mut wr = MyMemWriter0::with_capacity(1024); - { - let mut serializer = json::Serializer::new(wr.by_ref()); - log.serialize(&mut serializer).unwrap(); - } - let _json = wr.unwrap(); + let wr = MyMemWriter0::with_capacity(1024); + let mut serializer = json::Serializer::new(wr); + log.serialize(&mut serializer).unwrap(); + let _json = serializer.unwrap().unwrap(); }); } @@ -833,12 +811,10 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) { b.iter(|| { //let _json = json::to_str(&log).unwrap(); - let mut wr = MyMemWriter1::with_capacity(1024); - { - let mut serializer = json::Serializer::new(wr.by_ref()); - log.serialize(&mut serializer).unwrap(); - } - let _json = wr.unwrap(); + let wr = MyMemWriter1::with_capacity(1024); + let mut serializer = json::Serializer::new(wr); + log.serialize(&mut serializer).unwrap(); + let _json = serializer.unwrap().unwrap(); }); } @@ -850,12 +826,10 @@ fn bench_serializer_my_mem_writer2(b: &mut Bencher) { b.iter(|| { //let _json = json::to_str(&log).unwrap(); - let mut wr = MyMemWriter2::with_capacity(1024); - { - let mut serializer = json::Serializer::new(wr.by_ref()); - log.serialize(&mut serializer).unwrap(); - } - let _json = wr.unwrap(); + let wr = MyMemWriter2::with_capacity(1024); + let mut serializer = json::Serializer::new(wr); + log.serialize(&mut serializer).unwrap(); + let _json = serializer.unwrap().unwrap(); }); } @@ -867,12 +841,10 @@ fn bench_serializer_my_mem_writer3(b: &mut Bencher) { b.iter(|| { //let _json = json::to_str(&log).unwrap(); - let mut wr = MyMemWriter3::with_capacity(1024); - { - let mut serializer = json::Serializer::new(wr.by_ref()); - log.serialize(&mut serializer).unwrap(); - } - let _json = wr.unwrap(); + let wr = MyMemWriter3::with_capacity(1024); + let mut serializer = json::Serializer::new(wr); + log.serialize(&mut serializer).unwrap(); + let _json = serializer.unwrap().unwrap(); }); } @@ -1256,10 +1228,10 @@ fn bench_manual_my_mem_writer3_escape(b: &mut Bencher) { }); } -fn direct(mut wr: W, log: &Log) { +fn direct(wr: W, log: &Log) { use ser::Serializer; - let mut serializer = json::Serializer::new(wr.by_ref()); + let mut serializer = json::Serializer::new(wr); serializer.serialize_struct_start("Log", 12).unwrap(); serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap(); diff --git a/src/json/mod.rs b/src/json/mod.rs index 7e2a2415..9647602d 100644 --- a/src/json/mod.rs +++ b/src/json/mod.rs @@ -489,12 +489,9 @@ impl fmt::Show for Json { } } -impl ser::Serializable for Json { +impl, E> ser::Serializable for Json { #[inline] - fn serialize< - S: ser::Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { match *self { Null => { ().serialize(s) @@ -913,6 +910,11 @@ impl Serializer { first: true, } } + + /// Unwrap the Writer from the Serializer. + pub fn unwrap(self) -> W { + self.wr + } } impl ser::Serializer for Serializer { @@ -1008,7 +1010,7 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_tuple_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, value: &T) -> IoResult<()> { if self.first { self.first = false; @@ -1031,7 +1033,7 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_struct_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, name: &str, value: &T) -> IoResult<()> { if self.first { self.first = false; @@ -1058,7 +1060,7 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_enum_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, value: &T) -> IoResult<()> { if self.first { self.first = false; @@ -1075,7 +1077,7 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_option< - T: Serializable + T: Serializable, io::IoError> >(&mut self, v: &Option) -> IoResult<()> { match *v { Some(ref v) => { @@ -1089,7 +1091,7 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_seq< - T: Serializable, + T: Serializable, io::IoError>, Iter: Iterator >(&mut self, mut iter: Iter) -> IoResult<()> { try!(self.wr.write_str("[")); @@ -1108,8 +1110,8 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_map< - K: Serializable, - V: Serializable, + K: Serializable, io::IoError>, + V: Serializable, io::IoError>, Iter: Iterator<(K, V)> >(&mut self, mut iter: Iter) -> IoResult<()> { try!(self.wr.write_str("{")); @@ -1147,6 +1149,11 @@ impl PrettySerializer { } } + /// Unwrap the Writer from the Serializer. + pub fn unwrap(self) -> W { + self.wr + } + #[inline] fn serialize_sep(&mut self) -> IoResult<()> { if self.first { @@ -1267,7 +1274,7 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_tuple_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, value: &T) -> IoResult<()> { try!(self.serialize_sep()); value.serialize(self) @@ -1286,7 +1293,7 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_struct_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, name: &str, value: &T) -> IoResult<()> { try!(self.serialize_sep()); try!(self.serialize_str(name)); @@ -1311,7 +1318,7 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_enum_elt< - T: Serializable + T: Serializable, io::IoError> >(&mut self, value: &T) -> IoResult<()> { try!(self.serialize_sep()); value.serialize(self) @@ -1325,7 +1332,7 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_option< - T: Serializable + T: Serializable, io::IoError> >(&mut self, v: &Option) -> IoResult<()> { match *v { Some(ref v) => { @@ -1339,7 +1346,7 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_seq< - T: Serializable, + T: Serializable, io::IoError>, Iter: Iterator >(&mut self, mut iter: Iter) -> IoResult<()> { try!(self.wr.write_str("[")); @@ -1355,8 +1362,8 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_map< - K: Serializable, - V: Serializable, + K: Serializable, io::IoError>, + V: Serializable, io::IoError>, Iter: Iterator<(K, V)> >(&mut self, mut iter: Iter) -> IoResult<()> { try!(self.wr.write_str("{")); @@ -1375,36 +1382,40 @@ impl ser::Serializer for PrettySerializer { /// Encode the specified struct into a json `[u8]` buffer. #[inline] -pub fn to_vec(value: &T) -> Vec { - let mut wr = MemWriter::with_capacity(1024); - { - let mut serializer = Serializer::new(wr.by_ref()); - // We are writing to a MemWriter, which doesn't fail. So we can ignore - // the error. - value.serialize(&mut serializer).unwrap(); - } - wr.unwrap() +pub fn to_vec< + T: ser::Serializable, io::IoError> +>(value: &T) -> Vec { + let wr = MemWriter::with_capacity(1024); + let mut serializer = Serializer::new(wr); + // We are writing to a MemWriter, which doesn't fail. So we can ignore + // the error. + value.serialize(&mut serializer).unwrap(); + serializer.unwrap().unwrap() } /// Encode the specified struct into a json `String` buffer. #[inline] -pub fn to_string(value: &T) -> Result> { +pub fn to_string< + T: ser::Serializable, io::IoError> +>(value: &T) -> Result> { let buf = to_vec(value); String::from_utf8(buf) } /// Encode the specified struct into a json `[u8]` buffer. -pub fn to_pretty_vec(value: &T) -> Vec { - let mut wr = MemWriter::new(); - { - let mut serializer = PrettySerializer::new(wr.by_ref()); - value.serialize(&mut serializer).unwrap(); - } - wr.unwrap() +pub fn to_pretty_vec< + T: ser::Serializable, io::IoError> +>(value: &T) -> Vec { + let wr = MemWriter::new(); + let mut serializer = PrettySerializer::new(wr); + value.serialize(&mut serializer).unwrap(); + serializer.unwrap().unwrap() } /// Encode the specified struct into a json `String` buffer. -pub fn to_pretty_string(value: &T) -> Result> { +pub fn to_pretty_string< + T: ser::Serializable, io::IoError> +>(value: &T) -> Result> { let buf = to_pretty_vec(value); String::from_utf8(buf) } @@ -2302,6 +2313,7 @@ impl ToJson for Option { #[cfg(test)] mod tests { use std::fmt::Show; + use std::io; use std::str; use std::collections::TreeMap; @@ -2321,7 +2333,7 @@ mod tests { SyntaxError, }; use de; - use ser::Serializable; + use ser::{Serializable, Serializer}; use ser; macro_rules! treemap { @@ -2400,7 +2412,7 @@ mod tests { } fn test_encode_ok< - T: PartialEq + Show + ToJson + ser::Serializable + T: PartialEq + Show + ToJson + ser::Serializable, io::IoError> >(errors: &[(T, &str)]) { for &(ref value, out) in errors.iter() { let out = out.to_string(); @@ -2414,7 +2426,7 @@ mod tests { } fn test_pretty_encode_ok< - T: PartialEq + Show + ToJson + ser::Serializable + T: PartialEq + Show + ToJson + ser::Serializable, io::IoError> >(errors: &[(T, &str)]) { for &(ref value, out) in errors.iter() { let out = out.to_string(); @@ -3460,7 +3472,7 @@ mod tests { "{\"a\": 3}", box [ (ObjectStart, box []), - (NumberValue(3.0), box [Key("a")]), + (F64Value(3.0), box [Key("a")]), (ObjectEnd, box []), ] ); @@ -3477,7 +3489,7 @@ mod tests { "{\"a\" : 1.0 ,\"b\": [ true ]}", box [ (ObjectStart, box []), - (NumberValue(1.0), box [Key("a")]), + (F64Value(1.0), box [Key("a")]), (ListStart, box [Key("b")]), (BooleanValue(true),box [Key("b"), Index(0)]), (ListEnd, box [Key("b")]), @@ -3495,7 +3507,7 @@ mod tests { }"#, ~[ (ObjectStart, ~[]), - (NumberValue(1.0), ~[Key("a")]), + (F64Value(1.0), ~[Key("a")]), (ListStart, ~[Key("b")]), (BooleanValue(true), ~[Key("b"), Index(0)]), (StringValue("foo\nbar".to_string()), ~[Key("b"), Index(1)]), @@ -3554,8 +3566,8 @@ mod tests { "[3, 1]", box [ (ListStart, box []), - (NumberValue(3.0), box [Index(0)]), - (NumberValue(1.0), box [Index(1)]), + (F64Value(3.0), box [Index(0)]), + (F64Value(1.0), box [Index(1)]), (ListEnd, box []), ] ); @@ -3563,8 +3575,8 @@ mod tests { "\n[3, 2]\n", box [ (ListStart, box []), - (NumberValue(3.0), box [Index(0)]), - (NumberValue(2.0), box [Index(1)]), + (F64Value(3.0), box [Index(0)]), + (F64Value(2.0), box [Index(1)]), (ListEnd, box []), ] ); @@ -3572,10 +3584,10 @@ mod tests { "[2, [4, 1]]", box [ (ListStart, box []), - (NumberValue(2.0), box [Index(0)]), + (F64Value(2.0), box [Index(0)]), (ListStart, box [Index(1)]), - (NumberValue(4.0), box [Index(1), Index(0)]), - (NumberValue(1.0), box [Index(1), Index(1)]), + (F64Value(4.0), box [Index(1), Index(0)]), + (F64Value(1.0), box [Index(1), Index(1)]), (ListEnd, box [Index(1)]), (ListEnd, box []), ] @@ -3731,12 +3743,12 @@ mod bench { list.push(json::Object(treemap!( "a".to_string() => json::Boolean(true), "b".to_string() => json::Null, - "c".to_string() => json::Number(3.1415), + "c".to_string() => json::F64(3.1415), "d".to_string() => json::String("Hello world".to_string()), "e".to_string() => json::List(vec!( - json::Number(1f64), - json::Number(2f64), - json::Number(3f64) + json::U64(1), + json::U64(2), + json::U64(3) )) ))); } @@ -3832,7 +3844,7 @@ mod bench { assert_eq!(parser.next(), Some(json::NullValue)); assert_eq!(parser.stack().top(), Some(json::Key("b"))); - assert_eq!(parser.next(), Some(json::NumberValue(3.1415))); + assert_eq!(parser.next(), Some(json::F64Value(3.1415))); assert_eq!(parser.stack().top(), Some(json::Key("c"))); assert_eq!(parser.next(), Some(json::StringValue("Hello world".to_string()))); @@ -3840,9 +3852,9 @@ mod bench { assert_eq!(parser.next(), Some(json::ListStart)); assert_eq!(parser.stack().top(), Some(json::Key("e"))); - assert_eq!(parser.next(), Some(json::NumberValue(1f64))); - assert_eq!(parser.next(), Some(json::NumberValue(2f64))); - assert_eq!(parser.next(), Some(json::NumberValue(3f64))); + assert_eq!(parser.next(), Some(json::U64Value(1))); + assert_eq!(parser.next(), Some(json::U64Value(2))); + assert_eq!(parser.next(), Some(json::U64Value(3))); assert_eq!(parser.next(), Some(json::ListEnd)); assert_eq!(parser.next(), Some(json::ObjectEnd)); diff --git a/src/ser.rs b/src/ser.rs index fc17de89..29ae3d8d 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -79,47 +79,52 @@ pub trait Serializer { fn serialize_str(&mut self, v: &str) -> Result<(), E>; fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>; - fn serialize_tuple_elt(&mut self, v: &T) -> Result<(), E>; + fn serialize_tuple_elt< + T: Serializable + >(&mut self, v: &T) -> Result<(), E>; fn serialize_tuple_end(&mut self) -> Result<(), E>; fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>; - fn serialize_struct_elt(&mut self, name: &str, v: &T) -> Result<(), E>; + fn serialize_struct_elt< + T: Serializable + >(&mut self, name: &str, v: &T) -> Result<(), E>; fn serialize_struct_end(&mut self) -> Result<(), E>; fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>; - fn serialize_enum_elt(&mut self, v: &T) -> Result<(), E>; + fn serialize_enum_elt< + T: Serializable + >(&mut self, v: &T) -> Result<(), E>; fn serialize_enum_end(&mut self) -> Result<(), E>; - fn serialize_option(&mut self, v: &Option) -> Result<(), E>; + fn serialize_option< + T: Serializable + >(&mut self, v: &Option) -> Result<(), E>; fn serialize_seq< - T: Serializable, + T: Serializable, Iter: Iterator >(&mut self, iter: Iter) -> Result<(), E>; fn serialize_map< - K: Serializable, - V: Serializable, + K: Serializable, + V: Serializable, Iter: Iterator<(K, V)> >(&mut self, iter: Iter) -> Result<(), E>; } ////////////////////////////////////////////////////////////////////////////// -pub trait Serializable { - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E>; +pub trait Serializable, E> { + fn serialize(&self, s: &mut S) -> Result<(), E>; } ////////////////////////////////////////////////////////////////////////////// macro_rules! impl_serializable { ($ty:ty, $method:ident) => { - impl Serializable for $ty { + impl, E> Serializable for $ty { #[inline] - fn serialize, E>(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.$method(*self) } } @@ -143,22 +148,16 @@ impl_serializable!(char, serialize_char) ////////////////////////////////////////////////////////////////////////////// -impl<'a> Serializable for &'a str { +impl<'a, S: Serializer, E> Serializable for &'a str { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_str(*self) } } -impl Serializable for String { +impl, E> Serializable for String { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { self.as_slice().serialize(s) } } @@ -167,9 +166,14 @@ impl Serializable for String { macro_rules! impl_serializable_box { ($ty:ty) => { - impl<'a, T: Serializable> Serializable for $ty { + impl< + 'a, + S: Serializer, + E, + T: Serializable + > Serializable for $ty { #[inline] - fn serialize, E>(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { (**self).serialize(s) } } @@ -181,9 +185,13 @@ impl_serializable_box!(Box) impl_serializable_box!(Gc) impl_serializable_box!(Rc) -impl Serializable for Arc { +impl< + S: Serializer, + E, + T: Serializable + Send + Sync +> Serializable for Arc { #[inline] - fn serialize, E>(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { (**self).serialize(s) } } @@ -191,13 +199,12 @@ impl Serializable for Arc { ////////////////////////////////////////////////////////////////////////////// impl< - T: Serializable -> Serializable for Option { + S: Serializer, + E, + T: Serializable +> Serializable for Option { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_option(self) } } @@ -205,13 +212,12 @@ impl< ////////////////////////////////////////////////////////////////////////////// impl< - T: Serializable -> Serializable for Vec { + S: Serializer, + E, + T: Serializable +> Serializable for Vec { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_seq(self.iter()) } } @@ -219,27 +225,25 @@ impl< ////////////////////////////////////////////////////////////////////////////// impl< - K: Serializable + Eq + Hash, - V: Serializable -> Serializable for HashMap { + S: Serializer, + E, + K: Serializable + Eq + Hash, + V: Serializable +> Serializable for HashMap { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_map(self.iter()) } } impl< - K: Serializable + Ord, - V: Serializable -> Serializable for TreeMap { + S: Serializer, + E, + K: Serializable + Ord, + V: Serializable +> Serializable for TreeMap { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_map(self.iter()) } } @@ -247,25 +251,23 @@ impl< ////////////////////////////////////////////////////////////////////////////// impl< - T: Serializable + Eq + Hash -> Serializable for HashSet { + S: Serializer, + E, + T: Serializable + Eq + Hash +> Serializable for HashSet { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_seq(self.iter()) } } impl< - T: Serializable + Ord -> Serializable for TreeSet { + S: Serializer, + E, + T: Serializable + Ord +> Serializable for TreeSet { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_seq(self.iter()) } } @@ -278,26 +280,22 @@ macro_rules! peel { macro_rules! impl_serialize_tuple { () => { - impl Serializable for () { + impl, E> Serializable for () { #[inline] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { s.serialize_null() } } }; ( $($name:ident,)+ ) => { impl< - $($name:Serializable),* - > Serializable for ($($name,)*) { + S: Serializer, + E, + $($name:Serializable),+ + > Serializable for ($($name,)+) { #[inline] #[allow(uppercase_variables)] - fn serialize< - S: Serializer, - E - >(&self, s: &mut S) -> Result<(), E> { + fn serialize(&self, s: &mut S) -> Result<(), E> { // FIXME: how can we count macro args? let mut len = 0; $({ let $name = 1; len += $name; })*; @@ -495,7 +493,7 @@ mod tests { } fn serialize_tuple_elt< - T: Serializable + T: Serializable, Error> >(&mut self, value: &T) -> Result<(), Error> { try!(self.serialize(TupleSep)); value.serialize(self) @@ -510,7 +508,7 @@ mod tests { } fn serialize_struct_elt< - T: Serializable + T: Serializable, Error> >(&mut self, name: &str, value: &T) -> Result<(), Error> { try!(self.serialize(StructSep(name))); value.serialize(self) @@ -525,7 +523,7 @@ mod tests { } fn serialize_enum_elt< - T: Serializable + T: Serializable, Error> >(&mut self, value: &T) -> Result<(), Error> { try!(self.serialize(EnumSep)); value.serialize(self) @@ -536,7 +534,7 @@ mod tests { } fn serialize_option< - T: Serializable + T: Serializable, Error> >(&mut self, v: &Option) -> Result<(), Error> { match *v { Some(ref v) => { @@ -550,7 +548,7 @@ mod tests { } fn serialize_seq< - T: Serializable, + T: Serializable, Error>, SeqIter: Iterator >(&mut self, mut iter: SeqIter) -> Result<(), Error> { let (len, _) = iter.size_hint(); @@ -562,8 +560,8 @@ mod tests { } fn serialize_map< - K: Serializable, - V: Serializable, + K: Serializable, Error>, + V: Serializable, Error>, MapIter: Iterator<(K, V)> >(&mut self, mut iter: MapIter) -> Result<(), Error> { let (len, _) = iter.size_hint();