From 99038b044ea512af7bac24f42ee54a6b0bf48214 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dawid=20Ci=C4=99=C5=BCarkiewicz?= Date: Sun, 10 Jul 2016 11:22:24 -0700 Subject: [PATCH 01/16] Eliminate `Visitor` pattern Visitor is "pull", while `MapSerializer` and `SeqSerializer` are "push" like the rest of the API. --- serde/src/ser/impls.rs | 274 ++++++++++------------------------------- serde/src/ser/mod.rs | 158 +++++++++--------------- 2 files changed, 124 insertions(+), 308 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index d0ac49bc..cd8e5964 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -64,8 +64,8 @@ use super::{ Error, Serialize, Serializer, - SeqVisitor, - MapVisitor, + SeqSerializer, + MapSerializer, }; /////////////////////////////////////////////////////////////////////////////// @@ -133,26 +133,6 @@ impl Serialize for Option where T: Serialize { } } -impl SeqVisitor for Option where T: Serialize { - #[inline] - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer, - { - match self.take() { - Some(value) => { - try!(serializer.serialize_seq_elt(value)); - Ok(Some(())) - } - None => Ok(None), - } - } - - #[inline] - fn len(&self) -> Option { - Some(if self.is_some() { 1 } else { 0 }) - } -} - /////////////////////////////////////////////////////////////////////////////// impl Serialize for PhantomData { @@ -164,69 +144,6 @@ impl Serialize for PhantomData { } } -/////////////////////////////////////////////////////////////////////////////// - -/// A `serde::Visitor` for sequence iterators. -/// -/// # Examples -/// -/// ``` -/// use serde::{Serialize, Serializer}; -/// use serde::ser::impls::SeqIteratorVisitor; -/// -/// struct Seq(Vec); -/// -/// impl Serialize for Seq { -/// fn serialize(&self, ser: &mut S) -> Result<(), S::Error> -/// where S: Serializer, -/// { -/// ser.serialize_seq(SeqIteratorVisitor::new( -/// self.0.iter(), -/// Some(self.0.len()), -/// )) -/// } -/// } -/// ``` -pub struct SeqIteratorVisitor { - iter: Iter, - len: Option, -} - -impl SeqIteratorVisitor - where Iter: Iterator -{ - /// Construct a new `SeqIteratorVisitor`. - #[inline] - pub fn new(iter: Iter, len: Option) -> SeqIteratorVisitor { - SeqIteratorVisitor { - iter: iter, - len: len, - } - } -} - -impl SeqVisitor for SeqIteratorVisitor - where T: Serialize, - Iter: Iterator, -{ - #[inline] - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer, - { - match self.iter.next() { - Some(value) => { - try!(serializer.serialize_seq_elt(value)); - Ok(Some(())) - } - None => Ok(None), - } - } - - #[inline] - fn len(&self) -> Option { - self.len - } -} /////////////////////////////////////////////////////////////////////////////// @@ -237,7 +154,12 @@ impl Serialize for [T] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -250,8 +172,11 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let visitor = SeqIteratorVisitor::new(self.iter(), Some($len)); - serializer.serialize_fixed_size_array(visitor) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } } @@ -301,7 +226,11 @@ impl Serialize for BinaryHeap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -313,7 +242,11 @@ impl Serialize for BTreeSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -325,7 +258,10 @@ impl Serialize for EnumSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } } } @@ -338,7 +274,11 @@ impl Serialize for HashSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -350,7 +290,11 @@ impl Serialize for LinkedList fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -361,10 +305,13 @@ impl Serialize for ops::Range { #[inline] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, + where S: Serialize, { - let len = iter::Step::steps_between(&self.start, &self.end, &A::one()); - serializer.serialize_seq(SeqIteratorVisitor::new(self.clone(), len)) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -384,7 +331,11 @@ impl Serialize for VecDeque where T: Serialize { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut seq_serializer = try!(serializer.serialize_seq()); + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } + Ok(()) } } @@ -406,6 +357,7 @@ macro_rules! e { ($e:expr) => { $e } } +/* TODO: FIX tuple magic macro_rules! tuple_impls { ($( $TupleVisitor:ident ($len:expr, $($T:ident),+) { @@ -413,51 +365,18 @@ macro_rules! tuple_impls { } )+) => { $( - /// A tuple visitor. - pub struct $TupleVisitor<'a, $($T: 'a),+> { - tuple: &'a ($($T,)+), - state: u8, - } - - impl<'a, $($T: 'a),+> $TupleVisitor<'a, $($T),+> { - /// Construct a new, empty `TupleVisitor`. - pub fn new(tuple: &'a ($($T,)+)) -> $TupleVisitor<'a, $($T),+> { - $TupleVisitor { - tuple: tuple, - state: 0, - } - } - } - - impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+> - where $($T: Serialize),+ - { - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer, - { - match self.state { - $( - $state => { - self.state += 1; - Ok(Some(try!(serializer.serialize_tuple_elt(&e!(self.tuple.$idx))))) - } - )+ - _ => { - Ok(None) - } - } - } - - fn len(&self) -> Option { - Some($len) - } - } - impl<$($T),+> Serialize for ($($T,)+) where $($T: Serialize),+ { #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer, + SS : SeqSerializer, + { + + for e in self.iter() { + try!(seq_serializer.serialize_elt(e)); + } serializer.serialize_tuple($TupleVisitor::new(self)) } } @@ -635,72 +554,7 @@ tuple_impls! { 15 => 15, } } - -/////////////////////////////////////////////////////////////////////////////// - -/// A `serde::Visitor` for (key, value) map iterators. -/// -/// # Examples -/// -/// ``` -/// use std::collections::HashMap; -/// use serde::{Serialize, Serializer}; -/// use serde::ser::impls::MapIteratorVisitor; -/// -/// struct Map(HashMap); -/// -/// impl Serialize for Map { -/// fn serialize(&self, ser: &mut S) -> Result<(), S::Error> -/// where S: Serializer, -/// { -/// ser.serialize_map(MapIteratorVisitor::new( -/// self.0.iter(), -/// Some(self.0.len()), -/// )) -/// } -/// } -/// ``` -pub struct MapIteratorVisitor { - iter: Iter, - len: Option, -} - -impl MapIteratorVisitor - where Iter: Iterator -{ - /// Construct a new `MapIteratorVisitor`. - #[inline] - pub fn new(iter: Iter, len: Option) -> MapIteratorVisitor { - MapIteratorVisitor { - iter: iter, - len: len, - } - } -} - -impl MapVisitor for MapIteratorVisitor - where K: Serialize, - V: Serialize, - I: Iterator, -{ - #[inline] - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer, - { - match self.iter.next() { - Some((key, value)) => { - try!(serializer.serialize_map_elt(key, value)); - Ok(Some(())) - } - None => Ok(None) - } - } - - #[inline] - fn len(&self) -> Option { - self.len - } -} +*/ /////////////////////////////////////////////////////////////////////////////// @@ -713,7 +567,11 @@ impl Serialize for BTreeMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut map_serializer = try!(serializer.serialize_map()); + for (k, v) in self.iter() { + try!(map_serializer.serialize_elt(k, v)); + } + Ok(()) } } @@ -727,7 +585,11 @@ impl Serialize for HashMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len()))) + let mut map_serializer = try!(serializer.serialize_map()); + for (k, v) in self.iter() { + try!(map_serializer.serialize_elt(k, v)); + } + Ok(()) } } diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 6040ea11..c42efe6e 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -38,6 +38,27 @@ pub trait Serialize { where S: Serializer; } +/// A trait that described a type that can serialize elements of a Map +pub trait MapSerializer : Sized { + /// The error type that can be returned if some error occurs during serialization. + type Error: Error; + + /// Serializes an element of a map (key-value pair). + fn serialize_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> + where K: Serialize, + V: Serialize; +} + +/// A trait that described a type that can serialize elements of a Sequence +pub trait SeqSerializer : Sized { + /// The error type that can be returned if some error occurs during serialization. + type Error: Error; + + /// Serializes an element of a sequence. + fn serialize_elt(&mut self, value: T) -> Result<(), Self::Error> + where T: Serialize; +} + /////////////////////////////////////////////////////////////////////////////// /// A trait that describes a type that can serialize a stream of values into the underlying format. @@ -45,6 +66,11 @@ pub trait Serializer { /// The error type that can be returned if some error occurs during serialization. type Error: Error; + /// A sub-type used to serialize sequences + type SeqSerializer : SeqSerializer; + /// A sub-type used to serialize maps + type MapSerializer : MapSerializer; + /// Serializes a `bool` value. fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error>; @@ -136,7 +162,11 @@ pub trait Serializer { /// byte slices separately from generic arrays. By default it serializes as a regular array. #[inline] fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - self.serialize_seq(impls::SeqIteratorVisitor::new(value.iter(), Some(value.len()))) + let mut seq_serializer = try!(self.serialize_seq()); + for b in value.iter() { + try!(seq_serializer.serialize_elt(b)); + } + Ok(()) } /// Serializes a `()` value. @@ -170,7 +200,7 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - self.serialize_tuple_struct(name, Some(value)) + self.serialize_tuple_struct(name).and_then(|mut s| s.serialize_elt(Some(value))) } /// Allows a variant with a single item to be more efficiently @@ -187,8 +217,7 @@ pub trait Serializer { self.serialize_tuple_variant( name, variant_index, - variant, - Some(value)) + variant).and_then(|mut s| s.serialize_elt(Some(value))) } /// Serializes a `None` value..serialize @@ -202,21 +231,15 @@ pub trait Serializer { /// /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item /// in the sequence. - fn serialize_seq(&mut self, visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor; - - /// Serializes a sequence element. - fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize; + fn serialize_seq(&mut self) -> Result; /// Serializes a tuple. /// /// By default this serializes a tuple as a sequence. #[inline] - fn serialize_tuple(&mut self, visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor, + fn serialize_tuple(&mut self) -> Result { - self.serialize_seq(visitor) + self.serialize_seq() } /// Serializes a tuple element. @@ -226,29 +249,30 @@ pub trait Serializer { fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize { - self.serialize_seq_elt(value) + self.serialize_seq().and_then(|mut s| s.serialize_elt(value)) } + /* + TODO: Fixed-sized visitor would kind of make sense here /// Serializes a fixed-size array. /// /// By default this serializes an array as a sequence. #[inline] - fn serialize_fixed_size_array(&mut self, visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor, + fn serialize_fixed_size_array(&mut self, visitor: V) -> Result<(), Self::Error> { self.serialize_seq(visitor) } + */ /// Serializes a tuple struct. /// /// By default, tuple structs are serialized as a tuple. #[inline] - fn serialize_tuple_struct(&mut self, + fn serialize_tuple_struct(&mut self, _name: &'static str, - visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor, + ) -> Result { - self.serialize_tuple(visitor) + self.serialize_tuple() } /// Serializes a tuple struct element. @@ -265,14 +289,13 @@ pub trait Serializer { /// /// By default, tuple variants are serialized as a tuple struct. #[inline] - fn serialize_tuple_variant(&mut self, + fn serialize_tuple_variant(&mut self, _name: &'static str, _variant_index: usize, variant: &'static str, - visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor, + ) -> Result { - self.serialize_tuple_struct(variant, visitor) + self.serialize_tuple_struct(variant) } /// Serializes a tuple element. @@ -285,99 +308,30 @@ pub trait Serializer { self.serialize_tuple_struct_elt(value) } - /// Serializes a map. - /// - /// Callees of this method need to construct a `MapVisitor`, which iterates through each item - /// in the map. - fn serialize_map(&mut self, visitor: V) -> Result<(), Self::Error> - where V: MapVisitor; - - /// Serializes a map element (key-value pair). - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> - where K: Serialize, - V: Serialize; + /// Serialize a map. + fn serialize_map(&mut self) -> Result; /// Serializes a struct. /// /// By default, structs are serialized as a map with the field name as the key. #[inline] - fn serialize_struct(&mut self, + fn serialize_struct(&mut self, _name: &'static str, - visitor: V) -> Result<(), Self::Error> - where V: MapVisitor, + ) -> Result { - self.serialize_map(visitor) - } - - /// Serializes an element of a struct. - /// - /// By default, struct elements are serialized as a map element with the field name as the key. - #[inline] - fn serialize_struct_elt(&mut self, - key: &'static str, - value: V) -> Result<(), Self::Error> - where V: Serialize, - { - self.serialize_map_elt(key, value) + self.serialize_map() } /// Serializes a struct variant. /// /// By default, struct variants are serialized as a struct. #[inline] - fn serialize_struct_variant(&mut self, + fn serialize_struct_variant(&mut self, _name: &'static str, _variant_index: usize, - variant: &'static str, - visitor: V) -> Result<(), Self::Error> - where V: MapVisitor, + variant: &'static str + ) -> Result { - self.serialize_struct(variant, visitor) - } - - /// Serializes an element of a struct variant. - /// - /// By default, struct variant elements are serialized as a struct element. - #[inline] - fn serialize_struct_variant_elt(&mut self, - key: &'static str, - value: V) -> Result<(), Self::Error> - where V: Serialize, - { - self.serialize_struct_elt(key, value) - } -} - -/// A trait that is used by a `Serialize` to iterate through a sequence. -#[cfg_attr(feature = "nightly-testing", allow(len_without_is_empty))] -pub trait SeqVisitor { - /// Serializes a sequence item in the serializer. - /// - /// This returns `Ok(Some(()))` when there are more items to serialize, or `Ok(None)` when - /// complete. - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer; - - /// Return the length of the sequence if known. - #[inline] - fn len(&self) -> Option { - None - } -} - -/// A trait that is used by a `Serialize` to iterate through a map. -#[cfg_attr(feature = "nightly-testing", allow(len_without_is_empty))] -pub trait MapVisitor { - /// Serializes a map item in the serializer. - /// - /// This returns `Ok(Some(()))` when there are more items to serialize, or `Ok(None)` when - /// complete. - fn visit(&mut self, serializer: &mut S) -> Result, S::Error> - where S: Serializer; - - /// Return the length of the map if known. - #[inline] - fn len(&self) -> Option { - None + self.serialize_struct(variant) } } From 3766633f4a27e2a79e3d47971568efed4596a78a Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 15:44:19 +0200 Subject: [PATCH 02/16] adjust codegen to work with the revamped map/seq serializer --- serde/src/ser/impls.rs | 61 +++-- serde/src/ser/mod.rs | 199 ++++++++++++---- serde_codegen/src/ser.rs | 361 +++++++----------------------- serde_test/src/de.rs | 13 +- serde_test/src/ser.rs | 251 +++++++++++---------- serde_test/src/token.rs | 8 +- testing/tests/test_annotations.rs | 70 +++--- testing/tests/test_bytes.rs | 50 ++++- testing/tests/test_de.rs | 40 ++-- testing/tests/test_macros.rs | 30 +-- testing/tests/test_ser.rs | 8 +- 11 files changed, 538 insertions(+), 553 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index cd8e5964..159ff1bc 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -64,8 +64,6 @@ use super::{ Error, Serialize, Serializer, - SeqSerializer, - MapSerializer, }; /////////////////////////////////////////////////////////////////////////////// @@ -155,11 +153,11 @@ impl Serialize for [T] where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -172,11 +170,11 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_fixed_size_array($len)); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } } @@ -226,11 +224,11 @@ impl Serialize for BinaryHeap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -242,11 +240,11 @@ impl Serialize for BTreeSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -258,7 +256,7 @@ impl Serialize for EnumSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } @@ -274,11 +272,11 @@ impl Serialize for HashSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -290,11 +288,11 @@ impl Serialize for LinkedList fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -307,11 +305,11 @@ impl Serialize for ops::Range fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serialize, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -331,11 +329,11 @@ impl Serialize for VecDeque where T: Serialize { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq()); + let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } - Ok(()) + seq_serializer.drop() } } @@ -357,7 +355,6 @@ macro_rules! e { ($e:expr) => { $e } } -/* TODO: FIX tuple magic macro_rules! tuple_impls { ($( $TupleVisitor:ident ($len:expr, $($T:ident),+) { @@ -369,15 +366,14 @@ macro_rules! tuple_impls { where $($T: Serialize),+ { #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - SS : SeqSerializer, + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer, { - - for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); - } - serializer.serialize_tuple($TupleVisitor::new(self)) + let mut ser = try!(serializer.serialize_tuple($len)); + $( + try!(ser.serialize_elt(&e!(self.$idx))); + )+ + ser.drop() } } )+ @@ -554,7 +550,6 @@ tuple_impls! { 15 => 15, } } -*/ /////////////////////////////////////////////////////////////////////////////// @@ -567,11 +562,11 @@ impl Serialize for BTreeMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut map_serializer = try!(serializer.serialize_map()); + let mut map_serializer = try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { try!(map_serializer.serialize_elt(k, v)); } - Ok(()) + map_serializer.drop() } } @@ -585,11 +580,11 @@ impl Serialize for HashMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut map_serializer = try!(serializer.serialize_map()); + let mut map_serializer = try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { try!(map_serializer.serialize_elt(k, v)); } - Ok(()) + map_serializer.drop() } } diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index c42efe6e..8cf626da 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -44,9 +44,14 @@ pub trait MapSerializer : Sized { type Error: Error; /// Serializes an element of a map (key-value pair). - fn serialize_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> + fn serialize_elt(&mut self, serializer: &mut S, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, - V: Serialize; + V: Serialize, + S: Serializer; + + /// Finish serializing the map + fn drop(self, serializer: &mut S) -> Result<(), Self::Error> + where S: Serializer; } /// A trait that described a type that can serialize elements of a Sequence @@ -55,8 +60,58 @@ pub trait SeqSerializer : Sized { type Error: Error; /// Serializes an element of a sequence. - fn serialize_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize; + fn serialize_elt(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error> + where T: Serialize, + S: Serializer; + + /// Finish serializing the map + fn drop(self, serializer: &mut S) -> Result<(), Self::Error> + where S: Serializer; +} + +/// A helper type for serializing maps. This is a workaround for HKL associated types +pub struct MapHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::MapSerializer); + +impl<'a, S: Serializer + 'a + ?Sized> MapHelper<'a, S> { + /// Create a new MapHelper + pub fn new(s: &'a mut S, ms: S::MapSerializer) -> Self { + MapHelper(s, ms) + } +} + +impl<'a, S: Serializer + ?Sized> MapHelper<'a, S> { + /// Serializes an element of a map (key-value pair). + pub fn serialize_elt(&mut self, key: K, value: V) -> Result<(), S::Error> + where K: Serialize, + V: Serialize { + self.1.serialize_elt(self.0, key, value) + } + /// Closes the sequence + pub fn drop(self) -> Result<(), S::Error> { + self.1.drop(self.0) + } +} + +/// A helper type for serializing sequences. This is a workaround for HKL associated types +pub struct SeqHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::SeqSerializer); + +impl<'a, S: Serializer + 'a + ?Sized> SeqHelper<'a, S> { + /// Create a new SeqHelper + pub fn new(s: &'a mut S, ms: S::SeqSerializer) -> Self { + SeqHelper(s, ms) + } +} + +impl<'a, S: Serializer + ?Sized> SeqHelper<'a, S> { + /// Serializes an element of a sequence. + pub fn serialize_elt(&mut self, value: V) -> Result<(), S::Error> + where V: Serialize { + self.1.serialize_elt(self.0, value) + } + /// Closes the sequence + pub fn drop(self) -> Result<(), S::Error> { + self.1.drop(self.0) + } } /////////////////////////////////////////////////////////////////////////////// @@ -162,11 +217,11 @@ pub trait Serializer { /// byte slices separately from generic arrays. By default it serializes as a regular array. #[inline] fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - let mut seq_serializer = try!(self.serialize_seq()); + let mut seq_serializer = try!(self.serialize_seq(Some(value.len()))); for b in value.iter() { try!(seq_serializer.serialize_elt(b)); } - Ok(()) + seq_serializer.drop() } /// Serializes a `()` value. @@ -200,7 +255,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - self.serialize_tuple_struct(name).and_then(|mut s| s.serialize_elt(Some(value))) + let mut ser = try!(self.serialize_tuple_struct(name, 1)); + try!(ser.serialize_elt((value,))); + ser.drop() } /// Allows a variant with a single item to be more efficiently @@ -214,10 +271,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - self.serialize_tuple_variant( - name, - variant_index, - variant).and_then(|mut s| s.serialize_elt(Some(value))) + let mut ser = try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); + try!(ser.serialize_elt((value,))); + ser.drop() } /// Serializes a `None` value..serialize @@ -231,15 +287,22 @@ pub trait Serializer { /// /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item /// in the sequence. - fn serialize_seq(&mut self) -> Result; + fn serialize_seq<'a>(&'a mut self, len: Option) -> Result, Self::Error>; + + /// Serializes a sequence element. + fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> + where T: Serialize; + + /// Finish serializing a sequence. + fn serialize_seq_end(&mut self) -> Result<(), Self::Error>; /// Serializes a tuple. /// /// By default this serializes a tuple as a sequence. #[inline] - fn serialize_tuple(&mut self) -> Result + fn serialize_tuple<'a>(&'a mut self, len: usize) -> Result, Self::Error> { - self.serialize_seq() + self.serialize_seq(Some(len)) } /// Serializes a tuple element. @@ -247,32 +310,37 @@ pub trait Serializer { /// By default, tuples are serialized as a sequence. #[inline] fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize - { - self.serialize_seq().and_then(|mut s| s.serialize_elt(value)) + where T: Serialize { + self.serialize_seq_elt(value) + } + + /// Finishes serialization of a tuple. + /// + /// By default, tuples are serialized as a sequence. + #[inline] + fn serialize_tuple_end(&mut self) -> Result<(), Self::Error> { + self.serialize_seq_end() } - /* - TODO: Fixed-sized visitor would kind of make sense here /// Serializes a fixed-size array. /// /// By default this serializes an array as a sequence. #[inline] - fn serialize_fixed_size_array(&mut self, visitor: V) -> Result<(), Self::Error> + fn serialize_fixed_size_array<'a>(&'a mut self, size: usize) -> Result, Self::Error> { - self.serialize_seq(visitor) + self.serialize_seq(Some(size)) } - */ /// Serializes a tuple struct. /// /// By default, tuple structs are serialized as a tuple. #[inline] - fn serialize_tuple_struct(&mut self, + fn serialize_tuple_struct<'a>(&'a mut self, _name: &'static str, - ) -> Result + len: usize, + ) -> Result, Self::Error> { - self.serialize_tuple() + self.serialize_tuple(len) } /// Serializes a tuple struct element. @@ -285,53 +353,106 @@ pub trait Serializer { self.serialize_tuple_elt(value) } + /// Finishes serialization of a tuple struct. + /// + /// By default, tuple structs are serialized as a sequence. + #[inline] + fn serialize_tuple_struct_end(&mut self) -> Result<(), Self::Error> { + self.serialize_tuple_end() + } + /// Serializes a tuple variant. /// /// By default, tuple variants are serialized as a tuple struct. #[inline] - fn serialize_tuple_variant(&mut self, + fn serialize_tuple_variant<'a>(&'a mut self, _name: &'static str, _variant_index: usize, variant: &'static str, - ) -> Result + len: usize, + ) -> Result, Self::Error> { - self.serialize_tuple_struct(variant) + self.serialize_tuple_struct(variant, len) } - /// Serializes a tuple element. + /// Serializes a tuple variant element. /// - /// By default, tuples are serialized as a sequence. + /// By default, tuple variants are serialized as tuples. #[inline] fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize { - self.serialize_tuple_struct_elt(value) + self.serialize_tuple_elt(value) + } + + /// Finishes serialization of a tuple variant. + /// + /// By default, tuple variants are serialized as tuples. + #[inline] + fn serialize_tuple_variant_end(&mut self) -> Result<(), Self::Error> { + self.serialize_tuple_end() } /// Serialize a map. - fn serialize_map(&mut self) -> Result; + fn serialize_map<'a>(&'a mut self, len: Option) -> Result, Self::Error>; + + /// Serialize a map element + fn serialize_map_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; + + /// Finishes serializing a map + fn serialize_map_end<'a>(&'a mut self) -> Result<(), Self::Error>; /// Serializes a struct. /// /// By default, structs are serialized as a map with the field name as the key. #[inline] - fn serialize_struct(&mut self, + fn serialize_struct<'a>(&'a mut self, _name: &'static str, - ) -> Result + len: usize, + ) -> Result, Self::Error> { - self.serialize_map() + self.serialize_map(Some(len)) + } + + /// Serialize a struct field + /// + /// By default, structs are serialized as a map with the field name as the key. + fn serialize_struct_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + self.serialize_map_elt(key, value) + } + + /// Finishes serializing a struct + /// + /// By default, structs are serialized as a map with the field name as the key. + fn serialize_struct_end<'a>(&'a mut self) -> Result<(), Self::Error> { + self.serialize_map_end() } /// Serializes a struct variant. /// /// By default, struct variants are serialized as a struct. #[inline] - fn serialize_struct_variant(&mut self, + fn serialize_struct_variant<'a>(&'a mut self, _name: &'static str, _variant_index: usize, - variant: &'static str - ) -> Result + variant: &'static str, + len: usize, + ) -> Result, Self::Error> { - self.serialize_struct(variant) + self.serialize_struct(variant, len) + } + + /// Serialize a struct variant element + /// + /// By default, structs are serialized as a map with the field name as the key. + fn serialize_struct_variant_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + self.serialize_struct_elt(key, value) + } + + /// Finishes serializing a struct variant + /// + /// By default, structs are serialized as a map with the field name as the key. + fn serialize_struct_variant_end<'a>(&'a mut self) -> Result<(), Self::Error> { + self.serialize_struct_end() } } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index 3f549c0f..231a5d55 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -216,30 +216,22 @@ fn serialize_tuple_struct( fields: &[Field], item_attrs: &attr::Item, ) -> P { - let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor( + let serialize_stmts = serialize_tuple_struct_visitor( cx, builder, ty.clone(), - builder.ty() - .ref_() - .lifetime("'__a") - .build_ty(ty.clone()), - builder.id("serialize_tuple_struct_elt"), fields, impl_generics, false, ); let type_name = name_expr(builder, item_attrs.name()); + let len = serialize_stmts.len(); quote_expr!(cx, { - $visitor_struct - $visitor_impl - _serializer.serialize_tuple_struct($type_name, Visitor { - value: self, - state: 0, - _structure_ty: ::std::marker::PhantomData::<&$ty>, - }) + let mut _seq_serializer = try!(_serializer.serialize_tuple_struct($type_name, $len)); + $serialize_stmts + _seq_serializer.drop() }) } @@ -251,30 +243,33 @@ fn serialize_struct( fields: &[Field], item_attrs: &attr::Item, ) -> P { - let (visitor_struct, visitor_impl) = serialize_struct_visitor( + let serialize_fields = serialize_struct_visitor( cx, builder, ty.clone(), - builder.ty() - .ref_() - .lifetime("'__a") - .build_ty(ty.clone()), - builder.id("serialize_struct_elt"), fields, impl_generics, false, ); let type_name = name_expr(builder, item_attrs.name()); + let len = fields.iter() + .filter(|&field| !field.attrs.skip_serializing()) + .map(|field| { + let ident = field.ident.expect("struct has unnamed fields"); + let field_expr = quote_expr!(cx, &self.$ident); + + match field.attrs.skip_serializing_if() { + Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }), + None => quote_expr!(cx, 1), + } + }) + .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - $visitor_struct - $visitor_impl - _serializer.serialize_struct($type_name, Visitor { - value: self, - state: 0, - _structure_ty: ::std::marker::PhantomData::<&$ty>, - }) + let mut _map_serializer = try!(_serializer.serialize_struct($type_name, $len)); + $serialize_fields + _map_serializer.drop() }) } @@ -377,7 +372,6 @@ fn serialize_variant( generics, ty, &variant.fields, - field_names, ); quote_arm!(cx, @@ -385,24 +379,16 @@ fn serialize_variant( ) } Style::Struct => { - let field_names: Vec<_> = (0 .. variant.fields.len()) - .map(|i| builder.id(format!("__field{}", i))) - .collect(); - let pat = builder.pat().struct_() .id(type_ident).id(variant_ident).build() - .with_pats( - field_names.iter() - .zip(variant.fields.iter()) - .map(|(id, field)| { - let name = match field.ident { - Some(name) => name, + .with_pats(variant.fields.iter() + .map(|field| { + match field.ident { + Some(name) => (name, builder.pat().ref_id(name)), None => { cx.span_bug(field.span, "struct variant has unnamed fields") } - }; - - (name, builder.pat().ref_id(id)) + } }) ) .build(); @@ -415,7 +401,6 @@ fn serialize_variant( generics, ty, &variant.fields, - field_names, item_attrs, ); @@ -462,46 +447,22 @@ fn serialize_tuple_variant( generics: &ast::Generics, structure_ty: P, fields: &[Field], - field_names: Vec, ) -> P { - let variant_ty = builder.ty().tuple() - .with_tys( - fields.iter().map(|field| { - builder.ty() - .ref_() - .lifetime("'__a") - .build_ty(field.ty.clone()) - }) - ) - .build(); - - let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor( + let serialize_stmts = serialize_tuple_struct_visitor( cx, builder, - structure_ty.clone(), - variant_ty, - builder.id("serialize_tuple_variant_elt"), + structure_ty, fields, generics, true, ); - let value_expr = builder.expr().tuple() - .with_exprs( - field_names.iter().map(|field| { - builder.expr().id(field) - }) - ) - .build(); + let len = serialize_stmts.len(); quote_expr!(cx, { - $visitor_struct - $visitor_impl - _serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, Visitor { - value: $value_expr, - state: 0, - _structure_ty: ::std::marker::PhantomData::<&$structure_ty>, - }) + let mut _seq_serializer = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); + $serialize_stmts + _seq_serializer.drop() }) } @@ -513,83 +474,41 @@ fn serialize_struct_variant( generics: &ast::Generics, ty: P, fields: &[Field], - field_names: Vec, item_attrs: &attr::Item, ) -> P { - let variant_generics = builder.generics() - .with(generics.clone()) - .add_lifetime_bound("'__serde_variant") - .lifetime_name("'__serde_variant") - .build(); - let variant_struct = builder.item().struct_("__VariantStruct") - .with_generics(variant_generics.clone()) - .with_fields( - fields.iter().map(|field| { - builder.struct_field(field.ident.expect("struct has unnamed fields")) - .ty() - .ref_() - .lifetime("'__serde_variant") - .build_ty(field.ty.clone()) - }) - ) - .field("__serde_container_ty") - .ty().phantom_data().build(ty.clone()) - .build(); - - let variant_expr = builder.expr().struct_id("__VariantStruct") - .with_id_exprs( - fields.iter() - .zip(field_names.iter()) - .map(|(field, field_name)| { - ( - field.ident.expect("struct has unnamed fields"), - builder.expr().id(field_name), - ) - }) - ) - .field("__serde_container_ty").path() - .global() - .id("std").id("marker") - .segment("PhantomData") - .with_ty(ty.clone()) - .build() - .build() - .build(); - - let variant_ty = builder.ty().path() - .segment("__VariantStruct") - .with_generics(variant_generics.clone()) - .build() - .build(); - - let (visitor_struct, visitor_impl) = serialize_struct_visitor( + let serialize_fields = serialize_struct_visitor( cx, builder, - variant_ty.clone(), - variant_ty.clone(), - builder.id("serialize_struct_variant_elt"), + ty.clone(), fields, - &variant_generics, + &generics, true, ); let item_name = name_expr(builder, item_attrs.name()); + let len = fields.iter() + .filter(|&field| !field.attrs.skip_serializing()) + .map(|field| { + let ident = field.ident.expect("struct has unnamed fields"); + let field_expr = quote_expr!(cx, $ident); + + match field.attrs.skip_serializing_if() { + Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }), + None => quote_expr!(cx, 1), + } + }) + .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - $variant_struct - $visitor_struct - $visitor_impl - _serializer.serialize_struct_variant( + let mut _map_serializer = try!(_serializer.serialize_struct_variant( $item_name, $variant_index, $variant_name, - Visitor { - value: $variant_expr, - state: 0, - _structure_ty: ::std::marker::PhantomData, - }, - ) + $len, + )); + $serialize_fields + _map_serializer.drop() }) } @@ -597,187 +516,73 @@ fn serialize_tuple_struct_visitor( cx: &ExtCtxt, builder: &aster::AstBuilder, structure_ty: P, - variant_ty: P, - serializer_method: ast::Ident, fields: &[Field], generics: &ast::Generics, is_enum: bool, -) -> (P, P) { - let arms: Vec<_> = fields.iter() +) -> Vec { + fields.iter() .enumerate() .map(|(i, field)| { - let mut field_expr = builder.expr().tup_field(i).field("value").self_(); - if !is_enum { - field_expr = quote_expr!(cx, &$field_expr); - } + let mut field_expr = if is_enum { + builder.expr().path().id(format!("__field{}", i)).build() + } else { + builder.expr().tup_field(i).ref_().self_() + }; - let continue_if_skip = field.attrs.skip_serializing_if() - .map(|path| quote_stmt!(cx, if $path($field_expr) { continue })); + let skip = field.attrs.skip_serializing_if() + .map(|path| quote_expr!(cx, $path($field_expr))) + .unwrap_or(quote_expr!(cx, false)); if let Some(path) = field.attrs.serialize_with() { field_expr = wrap_serialize_with(cx, builder, &structure_ty, generics, &field.ty, path, field_expr); } - quote_arm!(cx, - $i => { - self.state += 1; - $continue_if_skip - Ok(Some(try!(_serializer.$serializer_method($field_expr)))) + quote_stmt!(cx, + if !$skip { + try!(_seq_serializer.serialize_elt($field_expr)); } - ) + ).unwrap() }) - .collect(); - - let visitor_impl_generics = builder.from_generics(generics.clone()) - .add_lifetime_bound("'__a") - .lifetime_name("'__a") - .build(); - - let where_clause = &visitor_impl_generics.where_clause; - - let visitor_generics = builder.from_generics(visitor_impl_generics.clone()) - .strip_bounds() - .build(); - - let nfields = fields.len(); - - ( - quote_item!(cx, - struct Visitor $visitor_impl_generics $where_clause { - state: usize, - value: $variant_ty, - _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>, - } - ).unwrap(), - - quote_item!(cx, - impl $visitor_impl_generics _serde::ser::SeqVisitor - for Visitor $visitor_generics - $where_clause { - #[inline] - fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result, __S::Error> - where __S: _serde::ser::Serializer - { - match self.state { - $arms - _ => Ok(None) - } - } - - #[inline] - fn len(&self) -> Option { - Some($nfields) - } - } - ).unwrap(), - ) + .collect() } fn serialize_struct_visitor( cx: &ExtCtxt, builder: &aster::AstBuilder, structure_ty: P, - variant_ty: P, - serializer_method: ast::Ident, fields: &[Field], generics: &ast::Generics, is_enum: bool, -) -> (P, P) { - let arms: Vec = fields.iter() +) -> Vec { + fields.iter() .filter(|&field| !field.attrs.skip_serializing()) - .enumerate() - .map(|(i, field)| { + .map(|field| { let ident = field.ident.expect("struct has unnamed field"); - let mut field_expr = quote_expr!(cx, self.value.$ident); - if !is_enum { - field_expr = quote_expr!(cx, &$field_expr); - } + let mut field_expr = if is_enum { + quote_expr!(cx, $ident) + } else { + quote_expr!(cx, &self.$ident) + }; let key_expr = name_expr(builder, field.attrs.name()); - let continue_if_skip = field.attrs.skip_serializing_if() - .map(|path| quote_stmt!(cx, if $path($field_expr) { continue })); + let skip = field.attrs.skip_serializing_if() + .map(|path| quote_expr!(cx, $path($field_expr))) + .unwrap_or(quote_expr!(cx, false)); if let Some(path) = field.attrs.serialize_with() { field_expr = wrap_serialize_with(cx, builder, &structure_ty, generics, &field.ty, path, field_expr) } - let expr = quote_expr!(cx, - _serializer.$serializer_method($key_expr, $field_expr) - ); - - quote_arm!(cx, - $i => { - self.state += 1; - $continue_if_skip - return Ok(Some(try!($expr))); + quote_stmt!(cx, + if !$skip { + try!(_map_serializer.serialize_elt($key_expr, $field_expr)); } - ) + ).unwrap() }) - .collect(); - - let visitor_impl_generics = builder.from_generics(generics.clone()) - .add_lifetime_bound("'__a") - .lifetime_name("'__a") - .build(); - - let where_clause = &visitor_impl_generics.where_clause; - - let visitor_generics = builder.from_generics(visitor_impl_generics.clone()) - .strip_bounds() - .build(); - - let len = fields.iter() - .filter(|&field| !field.attrs.skip_serializing()) - .map(|field| { - let ident = field.ident.expect("struct has unnamed fields"); - let mut field_expr = quote_expr!(cx, self.value.$ident); - if !is_enum { - field_expr = quote_expr!(cx, &$field_expr); - } - - match field.attrs.skip_serializing_if() { - Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }), - None => quote_expr!(cx, 1), - } - }) - .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); - - ( - quote_item!(cx, - struct Visitor $visitor_impl_generics $where_clause { - state: usize, - value: $variant_ty, - _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>, - } - ).unwrap(), - - quote_item!(cx, - impl $visitor_impl_generics - _serde::ser::MapVisitor - for Visitor $visitor_generics - $where_clause { - #[inline] - fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result, __S::Error> - where __S: _serde::ser::Serializer, - { - loop { - match self.state { - $arms - _ => { return Ok(None); } - } - } - } - - #[inline] - fn len(&self) -> Option { - Some($len) - } - } - ).unwrap(), - ) + .collect() } fn wrap_serialize_with( diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index a2d4c3d7..24dabe19 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -135,15 +135,18 @@ impl de::Deserializer for Deserializer Some(Token::Option(true)) => visitor.visit_some(self), Some(Token::Unit) => visitor.visit_unit(), Some(Token::UnitStruct(name)) => visitor.visit_unit_struct(name), - Some(Token::SeqStart(len)) | Some(Token::TupleStructStart(_, len)) => { + Some(Token::SeqStart(len)) => { self.visit_seq(len, visitor) } - Some(Token::SeqArrayStart(len)) => { + Some(Token::SeqArrayStart(len))| Some(Token::TupleStructStart(_, len)) => { self.visit_seq(Some(len), visitor) } - Some(Token::MapStart(len)) | Some(Token::StructStart(_, len)) => { + Some(Token::MapStart(len)) => { self.visit_map(len, visitor) } + Some(Token::StructStart(_, len)) => { + self.visit_map(Some(len), visitor) + } Some(token) => Err(Error::UnexpectedToken(token)), None => Err(Error::EndOfStream), } @@ -745,7 +748,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I> where V: Visitor, { match self.de.tokens.peek() { - Some(&Token::EnumSeqStart(_, _, Some(enum_len))) => { + Some(&Token::EnumSeqStart(_, _, enum_len)) => { let token = self.de.tokens.next().unwrap(); if len == enum_len { @@ -776,7 +779,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I> where V: Visitor, { match self.de.tokens.peek() { - Some(&Token::EnumMapStart(_, _, Some(enum_len))) => { + Some(&Token::EnumMapStart(_, _, enum_len)) => { let token = self.de.tokens.next().unwrap(); if fields.len() == enum_len { diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index 2f028d3b..0411de1b 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -2,14 +2,73 @@ use std::marker::PhantomData; use serde::ser::{ self, - MapVisitor, - SeqVisitor, Serialize, + MapHelper, + SeqHelper, }; use error::Error; use token::Token; +pub enum MapSerializer { + Map, + Struct, + Enum, +} + +impl ser::MapSerializer for MapSerializer { + type Error = Error; + + fn serialize_elt(&mut self, serializer: &mut S, key: K, value: V) -> Result<(), Self::Error> + where K: Serialize, + V: Serialize, + S: ser::Serializer { + match *self { + MapSerializer::Map => serializer.serialize_map_elt(key, value), + MapSerializer::Struct => serializer.serialize_struct_elt(key, value), + MapSerializer::Enum => serializer.serialize_struct_variant_elt(key, value), + } + } + + fn drop(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer { + match self { + MapSerializer::Map => serializer.serialize_map_end(), + MapSerializer::Struct => serializer.serialize_struct_end(), + MapSerializer::Enum => serializer.serialize_struct_variant_end(), + } + } +} + +pub enum SeqSerializer { + Seq, + Tuple, + TupleStruct, + Enum, +} + +impl ser::SeqSerializer for SeqSerializer { + type Error = Error; + + fn serialize_elt(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error> + where T: Serialize, S: ser::Serializer { + match *self { + SeqSerializer::Seq => serializer.serialize_seq_elt(value), + SeqSerializer::Tuple => serializer.serialize_tuple_elt(value), + SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_elt(value), + SeqSerializer::Enum => serializer.serialize_tuple_variant_elt(value), + } + } + + fn drop(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer { + match self { + SeqSerializer::Seq => serializer.serialize_seq_end(), + SeqSerializer::Tuple => serializer.serialize_tuple_end(), + SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_end(), + SeqSerializer::Enum => serializer.serialize_tuple_variant_end(), + } + } +} + pub struct Serializer<'a, I> where I: Iterator>, { @@ -30,32 +89,14 @@ impl<'a, I> Serializer<'a, I> pub fn next_token(&mut self) -> Option<&'a Token<'a>> { self.tokens.next() } - - fn visit_seq(&mut self, mut visitor: V) -> Result<(), Error> - where V: SeqVisitor - { - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); - - Ok(()) - } - - fn visit_map(&mut self, mut visitor: V) -> Result<(), Error> - where V: MapVisitor - { - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); - - Ok(()) - } } impl<'a, I> ser::Serializer for Serializer<'a, I> where I: Iterator>, { type Error = Error; + type SeqSerializer = SeqSerializer; + type MapSerializer = MapSerializer; fn serialize_unit(&mut self) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::Unit)); @@ -174,25 +215,10 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - - fn serialize_seq(&mut self, visitor: V) -> Result<(), Error> - where V: SeqVisitor + fn serialize_seq<'b>(&'b mut self, len: Option) -> Result, Error> { - let len = visitor.len(); - assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len))); - - self.visit_seq(visitor) - } - - fn serialize_fixed_size_array(&mut self, visitor: V) -> Result<(), Error> - where V: SeqVisitor - { - let len = visitor.len().expect("arrays must have a length"); - - assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len))); - - self.visit_seq(visitor) + Ok(SeqHelper::new(self, SeqSerializer::Seq)) } fn serialize_seq_elt(&mut self, value: T) -> Result<(), Error> @@ -202,18 +228,22 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple(&mut self, mut visitor: V) -> Result<(), Error> - where V: SeqVisitor - { - let len = visitor.len().expect("arrays must have a length"); + fn serialize_seq_end(&mut self) -> Result<(), Error> { + assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); + Ok(()) + } + fn serialize_fixed_size_array<'b>(&'b mut self, len: usize) -> Result, Error> + { + assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len))); + Ok(SeqHelper::new(self, SeqSerializer::Seq)) + } + + fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result, Error> + { assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len))); - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); - - Ok(()) + Ok(SeqHelper::new(self, SeqSerializer::Tuple)) } fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Error> @@ -223,128 +253,117 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } + fn serialize_tuple_end(&mut self) -> Result<(), Error> { + assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); + Ok(()) + } + fn serialize_newtype_struct(&mut self, - name: &'static str, - value: T) -> Result<(), Error> + name: &'static str, + value: T) -> Result<(), Error> where T: Serialize, { assert_eq!(self.tokens.next(), Some(&Token::StructNewType(name))); value.serialize(self) } - fn serialize_tuple_struct(&mut self, name: &str, mut visitor: V) -> Result<(), Error> - where V: SeqVisitor + fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result, Error> { - let len = visitor.len(); - assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len))); - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); - - Ok(()) + Ok(SeqHelper::new(self, SeqSerializer::TupleStruct)) } fn serialize_tuple_struct_elt(&mut self, value: T) -> Result<(), Error> - where T: Serialize, + where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep)); value.serialize(self) } - fn serialize_tuple_variant(&mut self, - name: &str, - _variant_index: usize, - variant: &str, - mut visitor: V) -> Result<(), Error> - where V: SeqVisitor - { - let len = visitor.len(); - - assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len))); - - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); - + fn serialize_tuple_struct_end(&mut self) -> Result<(), Error> { + assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); Ok(()) } + fn serialize_tuple_variant<'b>(&'b mut self, + name: &str, + _variant_index: usize, + variant: &str, + len: usize) -> Result, Error> + { + assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len))); + + Ok(SeqHelper::new(self, SeqSerializer::Enum)) + } + fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Error> - where T: Serialize, + where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep)); value.serialize(self) } - fn serialize_map(&mut self, visitor: V) -> Result<(), Error> - where V: MapVisitor - { - let len = visitor.len(); + fn serialize_tuple_variant_end(&mut self) -> Result<(), Error> { + assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); + Ok(()) + } + fn serialize_map<'b>(&'b mut self, len: Option) -> Result, Error> + { assert_eq!(self.tokens.next(), Some(&Token::MapStart(len))); - self.visit_map(visitor) + Ok(MapHelper::new(self, MapSerializer::Map)) } - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Error> - where K: Serialize, - V: Serialize, - { + fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::MapSep)); - try!(key.serialize(self)); value.serialize(self) } - fn serialize_struct(&mut self, name: &str, mut visitor: V) -> Result<(), Error> - where V: MapVisitor - { - let len = visitor.len(); + fn serialize_map_end(&mut self) -> Result<(), Self::Error> { + assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); + Ok(()) + } + fn serialize_struct<'b>(&'b mut self, name: &str, len: usize) -> Result, Error> + { assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len))); - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); - - Ok(()) + Ok(MapHelper::new(self, MapSerializer::Struct)) } - fn serialize_struct_elt(&mut self, key: &'static str, value: T) -> Result<(), Error> - where T: Serialize, - { + fn serialize_struct_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::StructSep)); - try!(key.serialize(self)); value.serialize(self) } - fn serialize_struct_variant(&mut self, - name: &str, - _variant_index: usize, - variant: &str, - mut visitor: V) -> Result<(), Error> - where V: MapVisitor - { - let len = visitor.len(); + fn serialize_struct_end(&mut self) -> Result<(), Self::Error> { + assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); + Ok(()) + } + fn serialize_struct_variant<'b>(&'b mut self, + name: &str, + _variant_index: usize, + variant: &str, + len: usize) -> Result, Error> + { assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len))); - while let Some(()) = try!(visitor.visit(self)) { } - - assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); - - Ok(()) + Ok(MapHelper::new(self, MapSerializer::Enum)) } - fn serialize_struct_variant_elt(&mut self, key: &'static str, value: T) -> Result<(), Error> - where T: Serialize, - { + fn serialize_struct_variant_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep)); - try!(key.serialize(self)); value.serialize(self) } + + fn serialize_struct_variant_end(&mut self) -> Result<(), Self::Error> { + assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); + Ok(()) + } } diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs index dcb1137f..e4b3a825 100644 --- a/serde_test/src/token.rs +++ b/serde_test/src/token.rs @@ -38,7 +38,7 @@ pub enum Token<'a> { TupleSep, TupleEnd, - TupleStructStart(&'a str, Option), + TupleStructStart(&'a str, usize), TupleStructSep, TupleStructEnd, @@ -46,15 +46,15 @@ pub enum Token<'a> { MapSep, MapEnd, - StructStart(&'a str, Option), + StructStart(&'a str, usize), StructSep, StructEnd, - EnumSeqStart(&'a str, &'a str, Option), + EnumSeqStart(&'a str, &'a str, usize), EnumSeqSep, EnumSeqEnd, - EnumMapStart(&'a str, &'a str, Option), + EnumMapStart(&'a str, &'a str, usize), EnumMapSep, EnumMapEnd, } diff --git a/testing/tests/test_annotations.rs b/testing/tests/test_annotations.rs index a18a4b82..ba77f8f9 100644 --- a/testing/tests/test_annotations.rs +++ b/testing/tests/test_annotations.rs @@ -82,7 +82,7 @@ fn test_default_struct() { assert_de_tokens( &DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 }, &[ - Token::StructStart("DefaultStruct", Some(3)), + Token::StructStart("DefaultStruct", 3), Token::StructSep, Token::Str("a1"), @@ -111,7 +111,7 @@ fn test_default_struct() { assert_de_tokens( &DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 }, &[ - Token::StructStart("DefaultStruct", Some(1)), + Token::StructStart("DefaultStruct", 1), Token::StructSep, Token::Str("a1"), @@ -145,7 +145,7 @@ fn test_default_enum() { assert_de_tokens( &DefaultEnum::Struct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 }, &[ - Token::EnumMapStart("DefaultEnum", "Struct", Some(5)), + Token::EnumMapStart("DefaultEnum", "Struct", 5), Token::EnumMapSep, Token::Str("a1"), @@ -174,7 +174,7 @@ fn test_default_enum() { assert_de_tokens( &DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 }, &[ - Token::EnumMapStart("DefaultEnum", "Struct", Some(5)), + Token::EnumMapStart("DefaultEnum", "Struct", 5), Token::EnumMapSep, Token::Str("a1"), @@ -208,7 +208,7 @@ fn test_no_std_default() { assert_de_tokens( &ContainsNoStdDefault { a: NoStdDefault(123) }, &[ - Token::StructStart("ContainsNoStdDefault", Some(1)), + Token::StructStart("ContainsNoStdDefault", 1), Token::StructEnd, ] ); @@ -216,7 +216,7 @@ fn test_no_std_default() { assert_de_tokens( &ContainsNoStdDefault { a: NoStdDefault(8) }, &[ - Token::StructStart("ContainsNoStdDefault", Some(1)), + Token::StructStart("ContainsNoStdDefault", 1), Token::StructSep, Token::Str("a"), @@ -281,7 +281,7 @@ fn test_elt_not_deserialize() { e: NotDeserializeEnum::Trouble, }, &[ - Token::StructStart("ContainsNotDeserialize", Some(3)), + Token::StructStart("ContainsNotDeserialize", 3), Token::StructEnd, ] ); @@ -299,7 +299,7 @@ fn test_ignore_unknown() { assert_de_tokens( &DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 }, &[ - Token::StructStart("DefaultStruct", Some(5)), + Token::StructStart("DefaultStruct", 5), Token::StructSep, Token::Str("whoops1"), @@ -334,7 +334,7 @@ fn test_ignore_unknown() { assert_de_tokens_error::( &[ - Token::StructStart("DenyUnknown", Some(2)), + Token::StructStart("DenyUnknown", 2), Token::StructSep, Token::Str("a1"), @@ -368,7 +368,7 @@ fn test_rename_struct() { assert_tokens( &RenameStruct { a1: 1, a2: 2 }, &[ - Token::StructStart("Superhero", Some(2)), + Token::StructStart("Superhero", 2), Token::StructSep, Token::Str("a1"), @@ -385,7 +385,7 @@ fn test_rename_struct() { assert_ser_tokens( &RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &[ - Token::StructStart("SuperheroSer", Some(2)), + Token::StructStart("SuperheroSer", 2), Token::StructSep, Token::Str("a1"), @@ -402,7 +402,7 @@ fn test_rename_struct() { assert_de_tokens( &RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &[ - Token::StructStart("SuperheroDe", Some(2)), + Token::StructStart("SuperheroDe", 2), Token::StructSep, Token::Str("a1"), @@ -465,7 +465,7 @@ fn test_rename_enum() { assert_tokens( &RenameEnum::WonderWoman(0, 1), &[ - Token::EnumSeqStart("Superhero", "diana_prince", Some(2)), + Token::EnumSeqStart("Superhero", "diana_prince", 2), Token::EnumSeqSep, Token::I8(0), @@ -480,7 +480,7 @@ fn test_rename_enum() { assert_tokens( &RenameEnum::Flash { a: 1 }, &[ - Token::EnumMapStart("Superhero", "barry_allan", Some(1)), + Token::EnumMapStart("Superhero", "barry_allan", 1), Token::EnumMapSep, Token::Str("b"), @@ -496,7 +496,7 @@ fn test_rename_enum() { b: String::new(), }, &[ - Token::EnumMapStart("SuperheroSer", "dick_grayson", Some(2)), + Token::EnumMapStart("SuperheroSer", "dick_grayson", 2), Token::EnumMapSep, Token::Str("a"), @@ -516,7 +516,7 @@ fn test_rename_enum() { b: String::new(), }, &[ - Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)), + Token::EnumMapStart("SuperheroDe", "jason_todd", 2), Token::EnumMapSep, Token::Str("a"), @@ -550,7 +550,7 @@ fn test_skip_serializing_struct() { c: 3, }, &[ - Token::StructStart("SkipSerializingStruct", Some(2)), + Token::StructStart("SkipSerializingStruct", 2), Token::StructSep, Token::Str("a"), @@ -571,7 +571,7 @@ fn test_skip_serializing_struct() { c: 123, }, &[ - Token::StructStart("SkipSerializingStruct", Some(1)), + Token::StructStart("SkipSerializingStruct", 1), Token::StructSep, Token::Str("a"), @@ -603,7 +603,7 @@ fn test_skip_serializing_enum() { c: 3, }, &[ - Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)), + Token::EnumMapStart("SkipSerializingEnum", "Struct", 2), Token::EnumMapSep, Token::Str("a"), @@ -624,7 +624,7 @@ fn test_skip_serializing_enum() { c: 123, }, &[ - Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)), + Token::EnumMapStart("SkipSerializingEnum", "Struct", 1), Token::EnumMapSep, Token::Str("a"), @@ -671,7 +671,7 @@ fn test_elt_not_serialize() { d: NotSerializeEnum::Trouble, }, &[ - Token::StructStart("ContainsNotSerialize", Some(2)), + Token::StructStart("ContainsNotSerialize", 2), Token::StructSep, Token::Str("a"), @@ -703,7 +703,7 @@ fn test_serialize_with_struct() { b: 2, }, &[ - Token::StructStart("SerializeWithStruct", Some(2)), + Token::StructStart("SerializeWithStruct", 2), Token::StructSep, Token::Str("a"), @@ -723,7 +723,7 @@ fn test_serialize_with_struct() { b: 123, }, &[ - Token::StructStart("SerializeWithStruct", Some(2)), + Token::StructStart("SerializeWithStruct", 2), Token::StructSep, Token::Str("a"), @@ -756,7 +756,7 @@ fn test_serialize_with_enum() { b: 2, }, &[ - Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)), + Token::EnumMapStart("SerializeWithEnum", "Struct", 2), Token::EnumMapSep, Token::Str("a"), @@ -776,7 +776,7 @@ fn test_serialize_with_enum() { b: 123, }, &[ - Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)), + Token::EnumMapStart("SerializeWithEnum", "Struct", 2), Token::EnumMapSep, Token::Str("a"), @@ -806,7 +806,7 @@ fn test_deserialize_with_struct() { b: 2, }, &[ - Token::StructStart("DeserializeWithStruct", Some(2)), + Token::StructStart("DeserializeWithStruct", 2), Token::StructSep, Token::Str("a"), @@ -826,7 +826,7 @@ fn test_deserialize_with_struct() { b: 123, }, &[ - Token::StructStart("DeserializeWithStruct", Some(2)), + Token::StructStart("DeserializeWithStruct", 2), Token::StructSep, Token::Str("a"), @@ -858,7 +858,7 @@ fn test_deserialize_with_enum() { b: 2, }, &[ - Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)), + Token::EnumMapStart("DeserializeWithEnum", "Struct", 2), Token::EnumMapSep, Token::Str("a"), @@ -878,7 +878,7 @@ fn test_deserialize_with_enum() { b: 123, }, &[ - Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)), + Token::EnumMapStart("DeserializeWithEnum", "Struct", 2), Token::EnumMapSep, Token::Str("a"), @@ -897,7 +897,7 @@ fn test_deserialize_with_enum() { fn test_missing_renamed_field_struct() { assert_de_tokens_error::( &[ - Token::StructStart("Superhero", Some(2)), + Token::StructStart("Superhero", 2), Token::StructSep, Token::Str("a1"), @@ -910,7 +910,7 @@ fn test_missing_renamed_field_struct() { assert_de_tokens_error::( &[ - Token::StructStart("SuperheroDe", Some(2)), + Token::StructStart("SuperheroDe", 2), Token::StructSep, Token::Str("a1"), @@ -926,7 +926,7 @@ fn test_missing_renamed_field_struct() { fn test_missing_renamed_field_enum() { assert_de_tokens_error::( &[ - Token::EnumMapStart("Superhero", "barry_allan", Some(1)), + Token::EnumMapStart("Superhero", "barry_allan", 1), Token::EnumMapEnd, ], @@ -935,7 +935,7 @@ fn test_missing_renamed_field_enum() { assert_de_tokens_error::>( &[ - Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)), + Token::EnumMapStart("SuperheroDe", "jason_todd", 2), Token::EnumMapSep, Token::Str("a"), @@ -957,7 +957,7 @@ enum InvalidLengthEnum { fn test_invalid_length_enum() { assert_de_tokens_error::( &[ - Token::EnumSeqStart("InvalidLengthEnum", "A", Some(3)), + Token::EnumSeqStart("InvalidLengthEnum", "A", 3), Token::EnumSeqSep, Token::I32(1), Token::EnumSeqEnd, @@ -966,7 +966,7 @@ fn test_invalid_length_enum() { ); assert_de_tokens_error::( &[ - Token::EnumSeqStart("InvalidLengthEnum", "B", Some(3)), + Token::EnumSeqStart("InvalidLengthEnum", "B", 3), Token::EnumSeqSep, Token::I32(1), Token::EnumSeqEnd, diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index 7a9906a4..ab1db513 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -50,8 +50,42 @@ impl BytesSerializer { } } +struct SeqSerializer; + +impl serde::ser::SeqSerializer for SeqSerializer { + type Error = Error; + + fn serialize_elt(&mut self, _serializer: &mut S, _value: T) -> Result<(), Self::Error> + where T: Serialize, S: serde::ser::Serializer { + Err(Error) + } + + fn drop(self, _serializer: &mut S) -> Result<(), Self::Error> where S: serde::ser::Serializer { + Err(Error) + } +} + +struct MapSerializer; + +impl serde::ser::MapSerializer for MapSerializer { + type Error = Error; + + fn serialize_elt(&mut self, _serializer: &mut S, _key: K, _value: V) -> Result<(), Self::Error> + where K: Serialize, + V: Serialize, + S: serde::ser::Serializer { + Err(Error) + } + + fn drop(self, _serializer: &mut S) -> Result<(), Self::Error> where S: serde::ser::Serializer { + Err(Error) + } +} + impl serde::Serializer for BytesSerializer { type Error = Error; + type SeqSerializer = SeqSerializer; + type MapSerializer = MapSerializer; fn serialize_unit(&mut self) -> Result<(), Error> { Err(Error) @@ -95,8 +129,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_seq(&mut self, _visitor: V) -> Result<(), Error> - where V: serde::ser::SeqVisitor, + fn serialize_seq<'a>(&'a mut self, _len: Option) -> Result, Error> { Err(Error) } @@ -107,8 +140,12 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_map(&mut self, _visitor: V) -> Result<(), Error> - where V: serde::ser::MapVisitor, + fn serialize_seq_end(&mut self) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_map<'a>(&mut self, _: Option) -> Result, Error> { Err(Error) } @@ -120,6 +157,11 @@ impl serde::Serializer for BytesSerializer { Err(Error) } + fn serialize_map_end(&mut self) -> Result<(), Error> + { + Err(Error) + } + fn serialize_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> { assert_eq!(self.bytes, bytes); Ok(()) diff --git a/testing/tests/test_de.rs b/testing/tests/test_de.rs index fcd17448..08c06af6 100644 --- a/testing/tests/test_de.rs +++ b/testing/tests/test_de.rs @@ -81,9 +81,9 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token<'static>]) { struct IgnoreBase { a: i32, } - + let expected = IgnoreBase{a: 1}; - + // Embed the tokens to be ignored in the normal token // stream for an IgnoreBase type let concated_tokens : Vec> = vec![ @@ -91,7 +91,7 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token<'static>]) { Token::MapSep, Token::Str("a"), Token::I32(1), - + Token::MapSep, Token::Str("ignored") ] @@ -101,17 +101,17 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token<'static>]) { Token::MapEnd, ].into_iter()) .collect(); - + let mut de = serde_test::Deserializer::new(concated_tokens.into_iter()); let v: Result = Deserialize::deserialize(&mut de); - + // We run this test on every token stream for convenience, but // some token streams don't make sense embedded as a map value, // so we ignore those. SyntaxError is the real sign of trouble. if let Err(Error::UnexpectedToken(_)) = v { return; } - + assert_eq!(v.as_ref(), Ok(&expected)); assert_eq!(de.next_token(), None); } @@ -197,7 +197,7 @@ declare_tests! { Token::SeqEnd, ], () => &[ - Token::TupleStructStart("Anything", Some(0)), + Token::TupleStructStart("Anything", 0), Token::SeqEnd, ], } @@ -241,7 +241,7 @@ declare_tests! { Token::SeqEnd, ], TupleStruct(1, 2, 3) => &[ - Token::TupleStructStart("TupleStruct", Some(3)), + Token::TupleStructStart("TupleStruct", 3), Token::TupleStructSep, Token::I32(1), @@ -253,7 +253,7 @@ declare_tests! { Token::TupleStructEnd, ], TupleStruct(1, 2, 3) => &[ - Token::TupleStructStart("TupleStruct", None), + Token::TupleStructStart("TupleStruct", 3), Token::TupleStructSep, Token::I32(1), @@ -299,7 +299,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], BTreeSet::::new() => &[ - Token::TupleStructStart("Anything", Some(0)), + Token::TupleStructStart("Anything", 0), Token::SeqEnd, ], } @@ -327,7 +327,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], HashSet::::new() => &[ - Token::TupleStructStart("Anything", Some(0)), + Token::TupleStructStart("Anything", 0), Token::SeqEnd, ], hashset![FnvHasher @ 1, 2, 3] => &[ @@ -377,7 +377,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], Vec::::new() => &[ - Token::TupleStructStart("Anything", Some(0)), + Token::TupleStructStart("Anything", 0), Token::SeqEnd, ], } @@ -441,7 +441,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], [0; 0] => &[ - Token::TupleStructStart("Anything", Some(0)), + Token::TupleStructStart("Anything", 0), Token::SeqEnd, ], } @@ -533,7 +533,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], BTreeMap::::new() => &[ - Token::StructStart("Anything", Some(0)), + Token::StructStart("Anything", 0), Token::MapEnd, ], } @@ -587,7 +587,7 @@ declare_tests! { Token::UnitStruct("Anything"), ], HashMap::::new() => &[ - Token::StructStart("Anything", Some(0)), + Token::StructStart("Anything", 0), Token::MapEnd, ], hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[ @@ -615,7 +615,7 @@ declare_tests! { Token::MapEnd, ], Struct { a: 1, b: 2, c: 0 } => &[ - Token::StructStart("Struct", Some(3)), + Token::StructStart("Struct", 3), Token::StructSep, Token::Str("a"), Token::I32(1), @@ -656,7 +656,7 @@ declare_tests! { Token::MapEnd, ], Struct { a: 1, b: 2, c: 0 } => &[ - Token::StructStart("Struct", Some(3)), + Token::StructStart("Struct", 3), Token::StructSep, Token::Str("a"), Token::I32(1), @@ -688,7 +688,7 @@ declare_tests! { } test_enum_seq { Enum::Seq(1, 2, 3) => &[ - Token::EnumSeqStart("Enum", "Seq", Some(3)), + Token::EnumSeqStart("Enum", "Seq", 3), Token::EnumSeqSep, Token::I32(1), @@ -702,7 +702,7 @@ declare_tests! { } test_enum_map { Enum::Map { a: 1, b: 2, c: 3 } => &[ - Token::EnumMapStart("Enum", "Map", Some(3)), + Token::EnumMapStart("Enum", "Map", 3), Token::EnumMapSep, Token::Str("a"), Token::I32(1), @@ -803,7 +803,7 @@ declare_error_tests! { } test_duplicate_field_enum { &[ - Token::EnumMapStart("Enum", "Map", Some(3)), + Token::EnumMapStart("Enum", "Map", 3), Token::EnumMapSep, Token::Str("a"), Token::I32(1), diff --git a/testing/tests/test_macros.rs b/testing/tests/test_macros.rs index ca4dffaa..58ddfeab 100644 --- a/testing/tests/test_macros.rs +++ b/testing/tests/test_macros.rs @@ -174,7 +174,7 @@ fn test_ser_named_tuple() { assert_ser_tokens( &SerNamedTuple(&a, &mut b, c), &[ - Token::TupleStructStart("SerNamedTuple", Some(3)), + Token::TupleStructStart("SerNamedTuple", 3), Token::TupleStructSep, Token::I32(5), @@ -211,7 +211,7 @@ fn test_de_named_tuple() { assert_de_tokens( &DeNamedTuple(5, 6, 7), &[ - Token::TupleStructStart("DeNamedTuple", Some(3)), + Token::TupleStructStart("DeNamedTuple", 3), Token::TupleStructSep, Token::I32(5), @@ -239,7 +239,7 @@ fn test_ser_named_map() { c: c, }, &[ - Token::StructStart("SerNamedMap", Some(3)), + Token::StructStart("SerNamedMap", 3), Token::StructSep, Token::Str("a"), @@ -267,7 +267,7 @@ fn test_de_named_map() { c: 7, }, &[ - Token::StructStart("DeNamedMap", Some(3)), + Token::StructStart("DeNamedMap", 3), Token::StructSep, Token::Str("a"), @@ -315,7 +315,7 @@ fn test_ser_enum_seq() { //f, ), &[ - Token::EnumSeqStart("SerEnum", "Seq", Some(4)), + Token::EnumSeqStart("SerEnum", "Seq", 4), Token::EnumSeqSep, Token::I8(1), @@ -353,7 +353,7 @@ fn test_ser_enum_map() { //f: f, }, &[ - Token::EnumMapStart("SerEnum", "Map", Some(4)), + Token::EnumMapStart("SerEnum", "Map", 4), Token::EnumMapSep, Token::Str("a"), @@ -405,7 +405,7 @@ fn test_de_enum_seq() { //f, ), &[ - Token::EnumSeqStart("DeEnum", "Seq", Some(4)), + Token::EnumSeqStart("DeEnum", "Seq", 4), Token::EnumSeqSep, Token::I8(1), @@ -443,7 +443,7 @@ fn test_de_enum_map() { //f: f, }, &[ - Token::EnumMapStart("DeEnum", "Map", Some(4)), + Token::EnumMapStart("DeEnum", "Map", 4), Token::EnumMapSep, Token::Str("a"), @@ -489,7 +489,7 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::LifetimeMap { a: &value }, &[ - Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)), + Token::EnumMapStart("Lifetimes", "LifetimeMap", 1), Token::EnumMapSep, Token::Str("a"), @@ -502,7 +502,7 @@ fn test_lifetimes() { assert_ser_tokens( &Lifetimes::NoLifetimeMap { a: 5 }, &[ - Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)), + Token::EnumMapStart("Lifetimes", "NoLifetimeMap", 1), Token::EnumMapSep, Token::Str("a"), @@ -518,7 +518,7 @@ fn test_generic_struct() { assert_tokens( &GenericStruct { x: 5u32 }, &[ - Token::StructStart("GenericStruct", Some(1)), + Token::StructStart("GenericStruct", 1), Token::StructSep, Token::Str("x"), @@ -545,7 +545,7 @@ fn test_generic_tuple_struct() { assert_tokens( &GenericTupleStruct(5u32, 6u32), &[ - Token::TupleStructStart("GenericTupleStruct", Some(2)), + Token::TupleStructStart("GenericTupleStruct", 2), Token::TupleStructSep, Token::U32(5), @@ -584,7 +584,7 @@ fn test_generic_enum_seq() { assert_tokens( &GenericEnum::Seq::(5, 6), &[ - Token::EnumSeqStart("GenericEnum", "Seq", Some(2)), + Token::EnumSeqStart("GenericEnum", "Seq", 2), Token::EnumSeqSep, Token::U32(5), @@ -602,7 +602,7 @@ fn test_generic_enum_map() { assert_tokens( &GenericEnum::Map:: { x: 5, y: 6 }, &[ - Token::EnumMapStart("GenericEnum", "Map", Some(2)), + Token::EnumMapStart("GenericEnum", "Map", 2), Token::EnumMapSep, Token::Str("x"), @@ -622,7 +622,7 @@ fn test_default_ty_param() { assert_tokens( &DefaultTyParam:: { phantom: PhantomData }, &[ - Token::StructStart("DefaultTyParam", Some(1)), + Token::StructStart("DefaultTyParam", 1), Token::StructSep, Token::Str("phantom"), diff --git a/testing/tests/test_ser.rs b/testing/tests/test_ser.rs index 981ddb86..e772e05e 100644 --- a/testing/tests/test_ser.rs +++ b/testing/tests/test_ser.rs @@ -256,7 +256,7 @@ declare_ser_tests! { } test_tuple_struct { TupleStruct(1, 2, 3) => &[ - Token::TupleStructStart("TupleStruct", Some(3)), + Token::TupleStructStart("TupleStruct", 3), Token::TupleStructSep, Token::I32(1), @@ -270,7 +270,7 @@ declare_ser_tests! { } test_struct { Struct { a: 1, b: 2, c: 3 } => &[ - Token::StructStart("Struct", Some(3)), + Token::StructStart("Struct", 3), Token::StructSep, Token::Str("a"), Token::I32(1), @@ -289,7 +289,7 @@ declare_ser_tests! { Enum::Unit => &[Token::EnumUnit("Enum", "Unit")], Enum::One(42) => &[Token::EnumNewType("Enum", "One"), Token::I32(42)], Enum::Seq(1, 2) => &[ - Token::EnumSeqStart("Enum", "Seq", Some(2)), + Token::EnumSeqStart("Enum", "Seq", 2), Token::EnumSeqSep, Token::I32(1), @@ -298,7 +298,7 @@ declare_ser_tests! { Token::EnumSeqEnd, ], Enum::Map { a: 1, b: 2 } => &[ - Token::EnumMapStart("Enum", "Map", Some(2)), + Token::EnumMapStart("Enum", "Map", 2), Token::EnumMapSep, Token::Str("a"), Token::I32(1), From a6f8bd5aac19d196bd460f1c4a8cd405911de023 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 15:49:41 +0200 Subject: [PATCH 03/16] nightly --- serde/src/ser/impls.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 159ff1bc..7e9d8ce2 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -260,6 +260,7 @@ impl Serialize for EnumSet for e in self.iter() { try!(seq_serializer.serialize_elt(e)); } + seq_serializer.drop() } } From ee4e7413b0e22b0ec28c97ce457817b6c3567b0d Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 15:50:41 +0200 Subject: [PATCH 04/16] whoops --- serde/src/ser/impls.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 7e9d8ce2..a1e6e375 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -304,7 +304,7 @@ impl Serialize for ops::Range { #[inline] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serialize, + where S: Serializer, { let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { From fb575225bc7e4a536a2b6756acc75e26c54cc82f Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 16:16:48 +0200 Subject: [PATCH 05/16] simplify! --- serde/src/ser/impls.rs | 67 ++++++++-------- serde/src/ser/mod.rs | 147 ++++++++---------------------------- serde_codegen/src/ser.rs | 26 ++++--- serde_test/src/ser.rs | 96 ++++------------------- testing/tests/test_bytes.rs | 38 +--------- 5 files changed, 100 insertions(+), 274 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index a1e6e375..8f56d790 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -152,12 +152,11 @@ impl Serialize for [T] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -170,11 +169,11 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_fixed_size_array($len)); + try!(serializer.serialize_fixed_size_array($len)); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } } @@ -224,11 +223,11 @@ impl Serialize for BinaryHeap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -240,11 +239,11 @@ impl Serialize for BTreeSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -256,11 +255,11 @@ impl Serialize for EnumSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -273,11 +272,11 @@ impl Serialize for HashSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -289,11 +288,11 @@ impl Serialize for LinkedList fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -330,11 +329,11 @@ impl Serialize for VecDeque where T: Serialize { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end() } } @@ -370,11 +369,11 @@ macro_rules! tuple_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut ser = try!(serializer.serialize_tuple($len)); + try!(serializer.serialize_tuple($len)); $( - try!(ser.serialize_elt(&e!(self.$idx))); + try!(serializer.serialize_tuple_elt(&e!(self.$idx))); )+ - ser.drop() + serializer.serialize_tuple_end() } } )+ @@ -563,11 +562,11 @@ impl Serialize for BTreeMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut map_serializer = try!(serializer.serialize_map(Some(self.len()))); + try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { - try!(map_serializer.serialize_elt(k, v)); + try!(serializer.serialize_map_elt(k, v)); } - map_serializer.drop() + serializer.serialize_map_end() } } @@ -581,11 +580,11 @@ impl Serialize for HashMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut map_serializer = try!(serializer.serialize_map(Some(self.len()))); + try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { - try!(map_serializer.serialize_elt(k, v)); + try!(serializer.serialize_map_elt(k, v)); } - map_serializer.drop() + serializer.serialize_map_end() } } diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 8cf626da..742b9dd9 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -38,82 +38,6 @@ pub trait Serialize { where S: Serializer; } -/// A trait that described a type that can serialize elements of a Map -pub trait MapSerializer : Sized { - /// The error type that can be returned if some error occurs during serialization. - type Error: Error; - - /// Serializes an element of a map (key-value pair). - fn serialize_elt(&mut self, serializer: &mut S, key: K, value: V) -> Result<(), Self::Error> - where K: Serialize, - V: Serialize, - S: Serializer; - - /// Finish serializing the map - fn drop(self, serializer: &mut S) -> Result<(), Self::Error> - where S: Serializer; -} - -/// A trait that described a type that can serialize elements of a Sequence -pub trait SeqSerializer : Sized { - /// The error type that can be returned if some error occurs during serialization. - type Error: Error; - - /// Serializes an element of a sequence. - fn serialize_elt(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error> - where T: Serialize, - S: Serializer; - - /// Finish serializing the map - fn drop(self, serializer: &mut S) -> Result<(), Self::Error> - where S: Serializer; -} - -/// A helper type for serializing maps. This is a workaround for HKL associated types -pub struct MapHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::MapSerializer); - -impl<'a, S: Serializer + 'a + ?Sized> MapHelper<'a, S> { - /// Create a new MapHelper - pub fn new(s: &'a mut S, ms: S::MapSerializer) -> Self { - MapHelper(s, ms) - } -} - -impl<'a, S: Serializer + ?Sized> MapHelper<'a, S> { - /// Serializes an element of a map (key-value pair). - pub fn serialize_elt(&mut self, key: K, value: V) -> Result<(), S::Error> - where K: Serialize, - V: Serialize { - self.1.serialize_elt(self.0, key, value) - } - /// Closes the sequence - pub fn drop(self) -> Result<(), S::Error> { - self.1.drop(self.0) - } -} - -/// A helper type for serializing sequences. This is a workaround for HKL associated types -pub struct SeqHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::SeqSerializer); - -impl<'a, S: Serializer + 'a + ?Sized> SeqHelper<'a, S> { - /// Create a new SeqHelper - pub fn new(s: &'a mut S, ms: S::SeqSerializer) -> Self { - SeqHelper(s, ms) - } -} - -impl<'a, S: Serializer + ?Sized> SeqHelper<'a, S> { - /// Serializes an element of a sequence. - pub fn serialize_elt(&mut self, value: V) -> Result<(), S::Error> - where V: Serialize { - self.1.serialize_elt(self.0, value) - } - /// Closes the sequence - pub fn drop(self) -> Result<(), S::Error> { - self.1.drop(self.0) - } -} - /////////////////////////////////////////////////////////////////////////////// /// A trait that describes a type that can serialize a stream of values into the underlying format. @@ -121,11 +45,6 @@ pub trait Serializer { /// The error type that can be returned if some error occurs during serialization. type Error: Error; - /// A sub-type used to serialize sequences - type SeqSerializer : SeqSerializer; - /// A sub-type used to serialize maps - type MapSerializer : MapSerializer; - /// Serializes a `bool` value. fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error>; @@ -217,11 +136,11 @@ pub trait Serializer { /// byte slices separately from generic arrays. By default it serializes as a regular array. #[inline] fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - let mut seq_serializer = try!(self.serialize_seq(Some(value.len()))); + try!(self.serialize_seq(Some(value.len()))); for b in value.iter() { - try!(seq_serializer.serialize_elt(b)); + try!(self.serialize_seq_elt(b)); } - seq_serializer.drop() + self.serialize_seq_end() } /// Serializes a `()` value. @@ -255,9 +174,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - let mut ser = try!(self.serialize_tuple_struct(name, 1)); - try!(ser.serialize_elt((value,))); - ser.drop() + try!(self.serialize_tuple_struct(name, 1)); + try!(self.serialize_tuple_struct_elt(value)); + self.serialize_tuple_struct_end() } /// Allows a variant with a single item to be more efficiently @@ -271,9 +190,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - let mut ser = try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); - try!(ser.serialize_elt((value,))); - ser.drop() + try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); + try!(self.serialize_tuple_variant_elt(value)); + self.serialize_tuple_variant_end() } /// Serializes a `None` value..serialize @@ -287,7 +206,7 @@ pub trait Serializer { /// /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item /// in the sequence. - fn serialize_seq<'a>(&'a mut self, len: Option) -> Result, Self::Error>; + fn serialize_seq(&mut self, len: Option) -> Result<(), Self::Error>; /// Serializes a sequence element. fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> @@ -300,7 +219,7 @@ pub trait Serializer { /// /// By default this serializes a tuple as a sequence. #[inline] - fn serialize_tuple<'a>(&'a mut self, len: usize) -> Result, Self::Error> + fn serialize_tuple(&mut self, len: usize) -> Result<(), Self::Error> { self.serialize_seq(Some(len)) } @@ -326,7 +245,7 @@ pub trait Serializer { /// /// By default this serializes an array as a sequence. #[inline] - fn serialize_fixed_size_array<'a>(&'a mut self, size: usize) -> Result, Self::Error> + fn serialize_fixed_size_array(&mut self, size: usize) -> Result<(), Self::Error> { self.serialize_seq(Some(size)) } @@ -335,10 +254,10 @@ pub trait Serializer { /// /// By default, tuple structs are serialized as a tuple. #[inline] - fn serialize_tuple_struct<'a>(&'a mut self, - _name: &'static str, - len: usize, - ) -> Result, Self::Error> + fn serialize_tuple_struct(&mut self, + _name: &'static str, + len: usize, + ) -> Result<(), Self::Error> { self.serialize_tuple(len) } @@ -365,12 +284,12 @@ pub trait Serializer { /// /// By default, tuple variants are serialized as a tuple struct. #[inline] - fn serialize_tuple_variant<'a>(&'a mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - len: usize, - ) -> Result, Self::Error> + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str, + len: usize, + ) -> Result<(), Self::Error> { self.serialize_tuple_struct(variant, len) } @@ -394,22 +313,22 @@ pub trait Serializer { } /// Serialize a map. - fn serialize_map<'a>(&'a mut self, len: Option) -> Result, Self::Error>; + fn serialize_map(&mut self, len: Option) -> Result<(), Self::Error>; /// Serialize a map element - fn serialize_map_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; + fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; /// Finishes serializing a map - fn serialize_map_end<'a>(&'a mut self) -> Result<(), Self::Error>; + fn serialize_map_end(&mut self) -> Result<(), Self::Error>; /// Serializes a struct. /// /// By default, structs are serialized as a map with the field name as the key. #[inline] - fn serialize_struct<'a>(&'a mut self, + fn serialize_struct(&mut self, _name: &'static str, len: usize, - ) -> Result, Self::Error> + ) -> Result<(), Self::Error> { self.serialize_map(Some(len)) } @@ -417,14 +336,14 @@ pub trait Serializer { /// Serialize a struct field /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + fn serialize_struct_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { self.serialize_map_elt(key, value) } /// Finishes serializing a struct /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_end<'a>(&'a mut self) -> Result<(), Self::Error> { + fn serialize_struct_end(&mut self) -> Result<(), Self::Error> { self.serialize_map_end() } @@ -432,12 +351,12 @@ pub trait Serializer { /// /// By default, struct variants are serialized as a struct. #[inline] - fn serialize_struct_variant<'a>(&'a mut self, + fn serialize_struct_variant(&mut self, _name: &'static str, _variant_index: usize, variant: &'static str, len: usize, - ) -> Result, Self::Error> + ) -> Result<(), Self::Error> { self.serialize_struct(variant, len) } @@ -445,14 +364,14 @@ pub trait Serializer { /// Serialize a struct variant element /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_variant_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + fn serialize_struct_variant_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { self.serialize_struct_elt(key, value) } /// Finishes serializing a struct variant /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_variant_end<'a>(&'a mut self) -> Result<(), Self::Error> { + fn serialize_struct_variant_end(&mut self) -> Result<(), Self::Error> { self.serialize_struct_end() } } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index 231a5d55..24519785 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -223,15 +223,16 @@ fn serialize_tuple_struct( fields, impl_generics, false, + cx.ident_of("serialize_tuple_struct_elt"), ); let type_name = name_expr(builder, item_attrs.name()); let len = serialize_stmts.len(); quote_expr!(cx, { - let mut _seq_serializer = try!(_serializer.serialize_tuple_struct($type_name, $len)); + try!(_serializer.serialize_tuple_struct($type_name, $len)); $serialize_stmts - _seq_serializer.drop() + _serializer.serialize_tuple_struct_end() }) } @@ -250,6 +251,7 @@ fn serialize_struct( fields, impl_generics, false, + cx.ident_of("serialize_struct_elt"), ); let type_name = name_expr(builder, item_attrs.name()); @@ -267,9 +269,9 @@ fn serialize_struct( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - let mut _map_serializer = try!(_serializer.serialize_struct($type_name, $len)); + try!(_serializer.serialize_struct($type_name, $len)); $serialize_fields - _map_serializer.drop() + _serializer.serialize_struct_end() }) } @@ -455,14 +457,15 @@ fn serialize_tuple_variant( fields, generics, true, + cx.ident_of("serialize_tuple_variant_elt"), ); let len = serialize_stmts.len(); quote_expr!(cx, { - let mut _seq_serializer = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); + try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); $serialize_stmts - _seq_serializer.drop() + _serializer.serialize_tuple_variant_end() }) } @@ -484,6 +487,7 @@ fn serialize_struct_variant( fields, &generics, true, + cx.ident_of("serialize_struct_variant_elt"), ); let item_name = name_expr(builder, item_attrs.name()); @@ -501,14 +505,14 @@ fn serialize_struct_variant( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - let mut _map_serializer = try!(_serializer.serialize_struct_variant( + try!(_serializer.serialize_struct_variant( $item_name, $variant_index, $variant_name, $len, )); $serialize_fields - _map_serializer.drop() + _serializer.serialize_struct_variant_end() }) } @@ -519,6 +523,7 @@ fn serialize_tuple_struct_visitor( fields: &[Field], generics: &ast::Generics, is_enum: bool, + func: ast::Ident, ) -> Vec { fields.iter() .enumerate() @@ -540,7 +545,7 @@ fn serialize_tuple_struct_visitor( quote_stmt!(cx, if !$skip { - try!(_seq_serializer.serialize_elt($field_expr)); + try!(_serializer.$func($field_expr)); } ).unwrap() }) @@ -554,6 +559,7 @@ fn serialize_struct_visitor( fields: &[Field], generics: &ast::Generics, is_enum: bool, + func: ast::Ident, ) -> Vec { fields.iter() .filter(|&field| !field.attrs.skip_serializing()) @@ -578,7 +584,7 @@ fn serialize_struct_visitor( quote_stmt!(cx, if !$skip { - try!(_map_serializer.serialize_elt($key_expr, $field_expr)); + try!(_serializer.$func($key_expr, $field_expr)); } ).unwrap() }) diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index 0411de1b..8d07ecd7 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -3,72 +3,11 @@ use std::marker::PhantomData; use serde::ser::{ self, Serialize, - MapHelper, - SeqHelper, }; use error::Error; use token::Token; -pub enum MapSerializer { - Map, - Struct, - Enum, -} - -impl ser::MapSerializer for MapSerializer { - type Error = Error; - - fn serialize_elt(&mut self, serializer: &mut S, key: K, value: V) -> Result<(), Self::Error> - where K: Serialize, - V: Serialize, - S: ser::Serializer { - match *self { - MapSerializer::Map => serializer.serialize_map_elt(key, value), - MapSerializer::Struct => serializer.serialize_struct_elt(key, value), - MapSerializer::Enum => serializer.serialize_struct_variant_elt(key, value), - } - } - - fn drop(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer { - match self { - MapSerializer::Map => serializer.serialize_map_end(), - MapSerializer::Struct => serializer.serialize_struct_end(), - MapSerializer::Enum => serializer.serialize_struct_variant_end(), - } - } -} - -pub enum SeqSerializer { - Seq, - Tuple, - TupleStruct, - Enum, -} - -impl ser::SeqSerializer for SeqSerializer { - type Error = Error; - - fn serialize_elt(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error> - where T: Serialize, S: ser::Serializer { - match *self { - SeqSerializer::Seq => serializer.serialize_seq_elt(value), - SeqSerializer::Tuple => serializer.serialize_tuple_elt(value), - SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_elt(value), - SeqSerializer::Enum => serializer.serialize_tuple_variant_elt(value), - } - } - - fn drop(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer { - match self { - SeqSerializer::Seq => serializer.serialize_seq_end(), - SeqSerializer::Tuple => serializer.serialize_tuple_end(), - SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_end(), - SeqSerializer::Enum => serializer.serialize_tuple_variant_end(), - } - } -} - pub struct Serializer<'a, I> where I: Iterator>, { @@ -95,8 +34,6 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> where I: Iterator>, { type Error = Error; - type SeqSerializer = SeqSerializer; - type MapSerializer = MapSerializer; fn serialize_unit(&mut self) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::Unit)); @@ -215,10 +152,10 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_seq<'b>(&'b mut self, len: Option) -> Result, Error> + fn serialize_seq<'b>(&'b mut self, len: Option) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len))); - Ok(SeqHelper::new(self, SeqSerializer::Seq)) + Ok(()) } fn serialize_seq_elt(&mut self, value: T) -> Result<(), Error> @@ -233,17 +170,16 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_fixed_size_array<'b>(&'b mut self, len: usize) -> Result, Error> + fn serialize_fixed_size_array<'b>(&'b mut self, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len))); - Ok(SeqHelper::new(self, SeqSerializer::Seq)) + Ok(()) } - fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result, Error> + fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len))); - - Ok(SeqHelper::new(self, SeqSerializer::Tuple)) + Ok(()) } fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Error> @@ -267,11 +203,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result, Error> + fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len))); - Ok(SeqHelper::new(self, SeqSerializer::TupleStruct)) + Ok(()) } fn serialize_tuple_struct_elt(&mut self, value: T) -> Result<(), Error> @@ -290,11 +226,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> name: &str, _variant_index: usize, variant: &str, - len: usize) -> Result, Error> + len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len))); - Ok(SeqHelper::new(self, SeqSerializer::Enum)) + Ok(()) } fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Error> @@ -309,11 +245,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_map<'b>(&'b mut self, len: Option) -> Result, Error> + fn serialize_map<'b>(&'b mut self, len: Option) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::MapStart(len))); - Ok(MapHelper::new(self, MapSerializer::Map)) + Ok(()) } fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { @@ -327,11 +263,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_struct<'b>(&'b mut self, name: &str, len: usize) -> Result, Error> + fn serialize_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len))); - Ok(MapHelper::new(self, MapSerializer::Struct)) + Ok(()) } fn serialize_struct_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { @@ -349,11 +285,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> name: &str, _variant_index: usize, variant: &str, - len: usize) -> Result, Error> + len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len))); - Ok(MapHelper::new(self, MapSerializer::Enum)) + Ok(()) } fn serialize_struct_variant_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index ab1db513..1bcb0e9e 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -50,42 +50,8 @@ impl BytesSerializer { } } -struct SeqSerializer; - -impl serde::ser::SeqSerializer for SeqSerializer { - type Error = Error; - - fn serialize_elt(&mut self, _serializer: &mut S, _value: T) -> Result<(), Self::Error> - where T: Serialize, S: serde::ser::Serializer { - Err(Error) - } - - fn drop(self, _serializer: &mut S) -> Result<(), Self::Error> where S: serde::ser::Serializer { - Err(Error) - } -} - -struct MapSerializer; - -impl serde::ser::MapSerializer for MapSerializer { - type Error = Error; - - fn serialize_elt(&mut self, _serializer: &mut S, _key: K, _value: V) -> Result<(), Self::Error> - where K: Serialize, - V: Serialize, - S: serde::ser::Serializer { - Err(Error) - } - - fn drop(self, _serializer: &mut S) -> Result<(), Self::Error> where S: serde::ser::Serializer { - Err(Error) - } -} - impl serde::Serializer for BytesSerializer { type Error = Error; - type SeqSerializer = SeqSerializer; - type MapSerializer = MapSerializer; fn serialize_unit(&mut self) -> Result<(), Error> { Err(Error) @@ -129,7 +95,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_seq<'a>(&'a mut self, _len: Option) -> Result, Error> + fn serialize_seq<'a>(&'a mut self, _len: Option) -> Result<(), Error> { Err(Error) } @@ -145,7 +111,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_map<'a>(&mut self, _: Option) -> Result, Error> + fn serialize_map<'a>(&mut self, _: Option) -> Result<(), Error> { Err(Error) } From 6adcaa55e5896f1ffc4dcf4a372c7c24e1ee1347 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 16:53:20 +0200 Subject: [PATCH 06/16] json needs more info --- serde/src/ser/impls.rs | 22 +++++++-------- serde/src/ser/mod.rs | 54 ++++++++++++++++++++++++------------- serde_codegen/src/ser.rs | 19 ++++++++----- serde_test/src/ser.rs | 28 ++++++++++++------- testing/tests/test_bytes.rs | 8 +++--- 5 files changed, 81 insertions(+), 50 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 8f56d790..07d9d417 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -156,7 +156,7 @@ impl Serialize for [T] for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -173,7 +173,7 @@ macro_rules! array_impls { for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } } @@ -227,7 +227,7 @@ impl Serialize for BinaryHeap for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -243,7 +243,7 @@ impl Serialize for BTreeSet for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -259,7 +259,7 @@ impl Serialize for EnumSet for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -276,7 +276,7 @@ impl Serialize for HashSet for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -292,7 +292,7 @@ impl Serialize for LinkedList for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -333,7 +333,7 @@ impl Serialize for VecDeque where T: Serialize { for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end() + serializer.serialize_seq_end(Some(self.len())) } } @@ -373,7 +373,7 @@ macro_rules! tuple_impls { $( try!(serializer.serialize_tuple_elt(&e!(self.$idx))); )+ - serializer.serialize_tuple_end() + serializer.serialize_tuple_end($len) } } )+ @@ -566,7 +566,7 @@ impl Serialize for BTreeMap for (k, v) in self.iter() { try!(serializer.serialize_map_elt(k, v)); } - serializer.serialize_map_end() + serializer.serialize_map_end(Some(self.len())) } } @@ -584,7 +584,7 @@ impl Serialize for HashMap for (k, v) in self.iter() { try!(serializer.serialize_map_elt(k, v)); } - serializer.serialize_map_end() + serializer.serialize_map_end(Some(self.len())) } } diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 742b9dd9..682fe020 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -140,7 +140,7 @@ pub trait Serializer { for b in value.iter() { try!(self.serialize_seq_elt(b)); } - self.serialize_seq_end() + self.serialize_seq_end(Some(value.len())) } /// Serializes a `()` value. @@ -176,7 +176,7 @@ pub trait Serializer { { try!(self.serialize_tuple_struct(name, 1)); try!(self.serialize_tuple_struct_elt(value)); - self.serialize_tuple_struct_end() + self.serialize_tuple_struct_end(name, 1) } /// Allows a variant with a single item to be more efficiently @@ -192,7 +192,7 @@ pub trait Serializer { { try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); try!(self.serialize_tuple_variant_elt(value)); - self.serialize_tuple_variant_end() + self.serialize_tuple_variant_end(name, variant_index, variant, 1) } /// Serializes a `None` value..serialize @@ -213,7 +213,7 @@ pub trait Serializer { where T: Serialize; /// Finish serializing a sequence. - fn serialize_seq_end(&mut self) -> Result<(), Self::Error>; + fn serialize_seq_end(&mut self, len: Option) -> Result<(), Self::Error>; /// Serializes a tuple. /// @@ -237,8 +237,8 @@ pub trait Serializer { /// /// By default, tuples are serialized as a sequence. #[inline] - fn serialize_tuple_end(&mut self) -> Result<(), Self::Error> { - self.serialize_seq_end() + fn serialize_tuple_end(&mut self, len: usize) -> Result<(), Self::Error> { + self.serialize_seq_end(Some(len)) } /// Serializes a fixed-size array. @@ -276,8 +276,11 @@ pub trait Serializer { /// /// By default, tuple structs are serialized as a sequence. #[inline] - fn serialize_tuple_struct_end(&mut self) -> Result<(), Self::Error> { - self.serialize_tuple_end() + fn serialize_tuple_struct_end(&mut self, + _name: &'static str, + len: usize, + ) -> Result<(), Self::Error> { + self.serialize_tuple_end(len) } /// Serializes a tuple variant. @@ -301,15 +304,20 @@ pub trait Serializer { fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize { - self.serialize_tuple_elt(value) + self.serialize_tuple_struct_elt(value) } /// Finishes serialization of a tuple variant. /// /// By default, tuple variants are serialized as tuples. #[inline] - fn serialize_tuple_variant_end(&mut self) -> Result<(), Self::Error> { - self.serialize_tuple_end() + fn serialize_tuple_variant_end(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str, + len: usize, + ) -> Result<(), Self::Error> { + self.serialize_tuple_struct_end(variant, len) } /// Serialize a map. @@ -319,16 +327,16 @@ pub trait Serializer { fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; /// Finishes serializing a map - fn serialize_map_end(&mut self) -> Result<(), Self::Error>; + fn serialize_map_end(&mut self, len: Option) -> Result<(), Self::Error>; /// Serializes a struct. /// /// By default, structs are serialized as a map with the field name as the key. #[inline] fn serialize_struct(&mut self, - _name: &'static str, - len: usize, - ) -> Result<(), Self::Error> + _name: &'static str, + len: usize, + ) -> Result<(), Self::Error> { self.serialize_map(Some(len)) } @@ -343,8 +351,11 @@ pub trait Serializer { /// Finishes serializing a struct /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_end(&mut self) -> Result<(), Self::Error> { - self.serialize_map_end() + fn serialize_struct_end(&mut self, + _name: &'static str, + len: usize, + ) -> Result<(), Self::Error> { + self.serialize_map_end(Some(len)) } /// Serializes a struct variant. @@ -371,7 +382,12 @@ pub trait Serializer { /// Finishes serializing a struct variant /// /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_variant_end(&mut self) -> Result<(), Self::Error> { - self.serialize_struct_end() + fn serialize_struct_variant_end(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str, + len: usize, + ) -> Result<(), Self::Error> { + self.serialize_struct_end(variant, len) } } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index 24519785..fd68d048 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -232,7 +232,7 @@ fn serialize_tuple_struct( quote_expr!(cx, { try!(_serializer.serialize_tuple_struct($type_name, $len)); $serialize_stmts - _serializer.serialize_tuple_struct_end() + _serializer.serialize_tuple_struct_end($type_name, $len) }) } @@ -269,9 +269,10 @@ fn serialize_struct( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - try!(_serializer.serialize_struct($type_name, $len)); + let len = $len; + try!(_serializer.serialize_struct($type_name, len)); $serialize_fields - _serializer.serialize_struct_end() + _serializer.serialize_struct_end($type_name, len) }) } @@ -465,7 +466,7 @@ fn serialize_tuple_variant( quote_expr!(cx, { try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); $serialize_stmts - _serializer.serialize_tuple_variant_end() + _serializer.serialize_tuple_variant_end($type_name, $variant_index, $variant_name, $len) }) } @@ -505,14 +506,20 @@ fn serialize_struct_variant( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { + let len = $len; try!(_serializer.serialize_struct_variant( $item_name, $variant_index, $variant_name, - $len, + len, )); $serialize_fields - _serializer.serialize_struct_variant_end() + _serializer.serialize_struct_variant_end( + $item_name, + $variant_index, + $variant_name, + len, + ) }) } diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index 8d07ecd7..e2c73dd3 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -165,7 +165,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_seq_end(&mut self) -> Result<(), Error> { + fn serialize_seq_end(&mut self, _len: Option) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); Ok(()) } @@ -189,7 +189,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_end(&mut self) -> Result<(), Error> { + fn serialize_tuple_end(&mut self, _len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); Ok(()) } @@ -217,12 +217,12 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_struct_end(&mut self) -> Result<(), Error> { + fn serialize_tuple_struct_end(&mut self, _name: &str, _len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); Ok(()) } - fn serialize_tuple_variant<'b>(&'b mut self, + fn serialize_tuple_variant(&mut self, name: &str, _variant_index: usize, variant: &str, @@ -240,12 +240,16 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_variant_end(&mut self) -> Result<(), Error> { + fn serialize_tuple_variant_end(&mut self, + _name: &str, + _variant_index: usize, + _variant: &str, + _len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); Ok(()) } - fn serialize_map<'b>(&'b mut self, len: Option) -> Result<(), Error> + fn serialize_map(&mut self, len: Option) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::MapStart(len))); @@ -258,12 +262,12 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_map_end(&mut self) -> Result<(), Self::Error> { + fn serialize_map_end(&mut self, _len: Option) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); Ok(()) } - fn serialize_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<(), Error> + fn serialize_struct(&mut self, name: &str, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len))); @@ -276,7 +280,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_struct_end(&mut self) -> Result<(), Self::Error> { + fn serialize_struct_end(&mut self, _name: &str, _len: usize) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); Ok(()) } @@ -298,7 +302,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_struct_variant_end(&mut self) -> Result<(), Self::Error> { + fn serialize_struct_variant_end(&mut self, + _name: &str, + _variant_index: usize, + _variant: &str, + _len: usize) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); Ok(()) } diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index 1bcb0e9e..76977138 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -95,7 +95,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_seq<'a>(&'a mut self, _len: Option) -> Result<(), Error> + fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { Err(Error) } @@ -106,12 +106,12 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_seq_end(&mut self) -> Result<(), Error> + fn serialize_seq_end(&mut self, _: Option) -> Result<(), Error> { Err(Error) } - fn serialize_map<'a>(&mut self, _: Option) -> Result<(), Error> + fn serialize_map(&mut self, _: Option) -> Result<(), Error> { Err(Error) } @@ -123,7 +123,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_map_end(&mut self) -> Result<(), Error> + fn serialize_map_end(&mut self, _: Option) -> Result<(), Error> { Err(Error) } From 26528fbbb44803a2dd52008eb90d0c6719841d9c Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 12 Jul 2016 16:53:38 +0200 Subject: [PATCH 07/16] silence lint about `a: ref a` patterns --- serde_codegen/src/ser.rs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index fd68d048..2df9d9ef 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -382,19 +382,19 @@ fn serialize_variant( ) } Style::Struct => { - let pat = builder.pat().struct_() - .id(type_ident).id(variant_ident).build() - .with_pats(variant.fields.iter() - .map(|field| { - match field.ident { - Some(name) => (name, builder.pat().ref_id(name)), - None => { - cx.span_bug(field.span, "struct variant has unnamed fields") - } - } - }) - ) - .build(); + let mut pat = builder.pat().struct_().id(type_ident).id(variant_ident).build(); + for field in variant.fields.iter() { + let name = match field.ident { + Some(name) => name, + None => cx.span_bug(field.span, "struct variant has unnamed fields"), + }; + pat = pat.with_field_pat(ast::FieldPat { + ident: name, + pat: builder.pat().ref_id(name), + is_shorthand: true, + }); + } + let pat = pat.build(); let expr = serialize_struct_variant( cx, From 60938913b2037d2f6d23212922600ef8c5db38ab Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 13 Jul 2016 19:18:01 +0200 Subject: [PATCH 08/16] face -> palm --- serde_codegen/src/ser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index 2df9d9ef..c405d7fb 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -538,7 +538,7 @@ fn serialize_tuple_struct_visitor( let mut field_expr = if is_enum { builder.expr().path().id(format!("__field{}", i)).build() } else { - builder.expr().tup_field(i).ref_().self_() + builder.expr().ref_().tup_field(i).self_() }; let skip = field.attrs.skip_serializing_if() From 16ba32dbe12ec28d07eb18c16f710f9665338d1b Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 14 Jul 2016 15:36:47 +0200 Subject: [PATCH 09/16] stateful map/seq serialization --- serde/src/ser/impls.rs | 40 +++++++++++++-------------- serde/src/ser/mod.rs | 54 ++++++++++++++++++++++--------------- serde_codegen/src/ser.rs | 15 ++++++----- serde_test/src/ser.rs | 16 ++++++----- testing/tests/test_bytes.rs | 6 +++-- 5 files changed, 73 insertions(+), 58 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 07d9d417..a7f861eb 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -152,11 +152,11 @@ impl Serialize for [T] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -169,11 +169,11 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_fixed_size_array($len)); + let state = try!(serializer.serialize_fixed_size_array($len)); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } } @@ -223,11 +223,11 @@ impl Serialize for BinaryHeap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -239,11 +239,11 @@ impl Serialize for BTreeSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -272,11 +272,11 @@ impl Serialize for HashSet fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -288,11 +288,11 @@ impl Serialize for LinkedList fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -329,11 +329,11 @@ impl Serialize for VecDeque where T: Serialize { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_seq(Some(self.len()))); + let state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(self.len())) + serializer.serialize_seq_end(Some(self.len()), state) } } @@ -369,11 +369,11 @@ macro_rules! tuple_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_tuple($len)); + let state = try!(serializer.serialize_tuple($len)); $( try!(serializer.serialize_tuple_elt(&e!(self.$idx))); )+ - serializer.serialize_tuple_end($len) + serializer.serialize_tuple_end($len, state) } } )+ @@ -562,11 +562,11 @@ impl Serialize for BTreeMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_map(Some(self.len()))); + let state = try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { try!(serializer.serialize_map_elt(k, v)); } - serializer.serialize_map_end(Some(self.len())) + serializer.serialize_map_end(Some(self.len()), state) } } @@ -580,11 +580,11 @@ impl Serialize for HashMap fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - try!(serializer.serialize_map(Some(self.len()))); + let state = try!(serializer.serialize_map(Some(self.len()))); for (k, v) in self.iter() { try!(serializer.serialize_map_elt(k, v)); } - serializer.serialize_map_end(Some(self.len())) + serializer.serialize_map_end(Some(self.len()), state) } } diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 682fe020..072a0a0d 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -44,6 +44,12 @@ pub trait Serialize { pub trait Serializer { /// The error type that can be returned if some error occurs during serialization. type Error: Error; + /// A state object that is returned from `serialize_seq` and needs to be re-inserted into + /// `serialize_seq_end` when the serialization of the sequence is done + type SeqState; + /// A state object that is returned from `serialize_map` and needs to be re-inserted into + /// `serialize_map_end` when the serialization of the map is done + type MapState; /// Serializes a `bool` value. fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error>; @@ -136,11 +142,11 @@ pub trait Serializer { /// byte slices separately from generic arrays. By default it serializes as a regular array. #[inline] fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - try!(self.serialize_seq(Some(value.len()))); + let state = try!(self.serialize_seq(Some(value.len()))); for b in value.iter() { try!(self.serialize_seq_elt(b)); } - self.serialize_seq_end(Some(value.len())) + self.serialize_seq_end(Some(value.len()), state) } /// Serializes a `()` value. @@ -174,9 +180,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - try!(self.serialize_tuple_struct(name, 1)); + let state = try!(self.serialize_tuple_struct(name, 1)); try!(self.serialize_tuple_struct_elt(value)); - self.serialize_tuple_struct_end(name, 1) + self.serialize_tuple_struct_end(name, 1, state) } /// Allows a variant with a single item to be more efficiently @@ -190,9 +196,9 @@ pub trait Serializer { value: T) -> Result<(), Self::Error> where T: Serialize, { - try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); + let state = try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); try!(self.serialize_tuple_variant_elt(value)); - self.serialize_tuple_variant_end(name, variant_index, variant, 1) + self.serialize_tuple_variant_end(name, variant_index, variant, 1, state) } /// Serializes a `None` value..serialize @@ -206,20 +212,20 @@ pub trait Serializer { /// /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item /// in the sequence. - fn serialize_seq(&mut self, len: Option) -> Result<(), Self::Error>; + fn serialize_seq(&mut self, len: Option) -> Result; /// Serializes a sequence element. fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize; /// Finish serializing a sequence. - fn serialize_seq_end(&mut self, len: Option) -> Result<(), Self::Error>; + fn serialize_seq_end(&mut self, len: Option, state: Self::SeqState) -> Result<(), Self::Error>; /// Serializes a tuple. /// /// By default this serializes a tuple as a sequence. #[inline] - fn serialize_tuple(&mut self, len: usize) -> Result<(), Self::Error> + fn serialize_tuple(&mut self, len: usize) -> Result { self.serialize_seq(Some(len)) } @@ -237,15 +243,15 @@ pub trait Serializer { /// /// By default, tuples are serialized as a sequence. #[inline] - fn serialize_tuple_end(&mut self, len: usize) -> Result<(), Self::Error> { - self.serialize_seq_end(Some(len)) + fn serialize_tuple_end(&mut self, len: usize, state: Self::SeqState) -> Result<(), Self::Error> { + self.serialize_seq_end(Some(len), state) } /// Serializes a fixed-size array. /// /// By default this serializes an array as a sequence. #[inline] - fn serialize_fixed_size_array(&mut self, size: usize) -> Result<(), Self::Error> + fn serialize_fixed_size_array(&mut self, size: usize) -> Result { self.serialize_seq(Some(size)) } @@ -257,7 +263,7 @@ pub trait Serializer { fn serialize_tuple_struct(&mut self, _name: &'static str, len: usize, - ) -> Result<(), Self::Error> + ) -> Result { self.serialize_tuple(len) } @@ -279,8 +285,9 @@ pub trait Serializer { fn serialize_tuple_struct_end(&mut self, _name: &'static str, len: usize, + state: Self::SeqState, ) -> Result<(), Self::Error> { - self.serialize_tuple_end(len) + self.serialize_tuple_end(len, state) } /// Serializes a tuple variant. @@ -292,7 +299,7 @@ pub trait Serializer { _variant_index: usize, variant: &'static str, len: usize, - ) -> Result<(), Self::Error> + ) -> Result { self.serialize_tuple_struct(variant, len) } @@ -316,18 +323,19 @@ pub trait Serializer { _variant_index: usize, variant: &'static str, len: usize, + state: Self::SeqState, ) -> Result<(), Self::Error> { - self.serialize_tuple_struct_end(variant, len) + self.serialize_tuple_struct_end(variant, len, state) } /// Serialize a map. - fn serialize_map(&mut self, len: Option) -> Result<(), Self::Error>; + fn serialize_map(&mut self, len: Option) -> Result; /// Serialize a map element fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; /// Finishes serializing a map - fn serialize_map_end(&mut self, len: Option) -> Result<(), Self::Error>; + fn serialize_map_end(&mut self, len: Option, state: Self::MapState) -> Result<(), Self::Error>; /// Serializes a struct. /// @@ -336,7 +344,7 @@ pub trait Serializer { fn serialize_struct(&mut self, _name: &'static str, len: usize, - ) -> Result<(), Self::Error> + ) -> Result { self.serialize_map(Some(len)) } @@ -354,8 +362,9 @@ pub trait Serializer { fn serialize_struct_end(&mut self, _name: &'static str, len: usize, + state: Self::MapState, ) -> Result<(), Self::Error> { - self.serialize_map_end(Some(len)) + self.serialize_map_end(Some(len), state) } /// Serializes a struct variant. @@ -367,7 +376,7 @@ pub trait Serializer { _variant_index: usize, variant: &'static str, len: usize, - ) -> Result<(), Self::Error> + ) -> Result { self.serialize_struct(variant, len) } @@ -387,7 +396,8 @@ pub trait Serializer { _variant_index: usize, variant: &'static str, len: usize, + state: Self::MapState, ) -> Result<(), Self::Error> { - self.serialize_struct_end(variant, len) + self.serialize_struct_end(variant, len, state) } } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index c405d7fb..27e2927b 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -230,9 +230,9 @@ fn serialize_tuple_struct( let len = serialize_stmts.len(); quote_expr!(cx, { - try!(_serializer.serialize_tuple_struct($type_name, $len)); + let state = try!(_serializer.serialize_tuple_struct($type_name, $len)); $serialize_stmts - _serializer.serialize_tuple_struct_end($type_name, $len) + _serializer.serialize_tuple_struct_end($type_name, $len, state) }) } @@ -270,9 +270,9 @@ fn serialize_struct( quote_expr!(cx, { let len = $len; - try!(_serializer.serialize_struct($type_name, len)); + let state = try!(_serializer.serialize_struct($type_name, len)); $serialize_fields - _serializer.serialize_struct_end($type_name, len) + _serializer.serialize_struct_end($type_name, len, state) }) } @@ -464,9 +464,9 @@ fn serialize_tuple_variant( let len = serialize_stmts.len(); quote_expr!(cx, { - try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); + let state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); $serialize_stmts - _serializer.serialize_tuple_variant_end($type_name, $variant_index, $variant_name, $len) + _serializer.serialize_tuple_variant_end($type_name, $variant_index, $variant_name, $len, state) }) } @@ -507,7 +507,7 @@ fn serialize_struct_variant( quote_expr!(cx, { let len = $len; - try!(_serializer.serialize_struct_variant( + let state = try!(_serializer.serialize_struct_variant( $item_name, $variant_index, $variant_name, @@ -519,6 +519,7 @@ fn serialize_struct_variant( $variant_index, $variant_name, len, + state, ) }) } diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index e2c73dd3..9a8632f1 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -34,6 +34,8 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> where I: Iterator>, { type Error = Error; + type MapState = (); + type SeqState = (); fn serialize_unit(&mut self) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::Unit)); @@ -165,7 +167,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_seq_end(&mut self, _len: Option) -> Result<(), Error> { + fn serialize_seq_end(&mut self, _len: Option, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); Ok(()) } @@ -189,7 +191,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_end(&mut self, _len: usize) -> Result<(), Error> { + fn serialize_tuple_end(&mut self, _len: usize, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); Ok(()) } @@ -217,7 +219,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_struct_end(&mut self, _name: &str, _len: usize) -> Result<(), Error> { + fn serialize_tuple_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); Ok(()) } @@ -244,7 +246,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> _name: &str, _variant_index: usize, _variant: &str, - _len: usize) -> Result<(), Error> { + _len: usize, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); Ok(()) } @@ -262,7 +264,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_map_end(&mut self, _len: Option) -> Result<(), Self::Error> { + fn serialize_map_end(&mut self, _len: Option, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); Ok(()) } @@ -280,7 +282,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_struct_end(&mut self, _name: &str, _len: usize) -> Result<(), Self::Error> { + fn serialize_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); Ok(()) } @@ -306,7 +308,7 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> _name: &str, _variant_index: usize, _variant: &str, - _len: usize) -> Result<(), Self::Error> { + _len: usize, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); Ok(()) } diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index 76977138..54ce5f18 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -52,6 +52,8 @@ impl BytesSerializer { impl serde::Serializer for BytesSerializer { type Error = Error; + type SeqState = (); + type MapState = (); fn serialize_unit(&mut self) -> Result<(), Error> { Err(Error) @@ -106,7 +108,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_seq_end(&mut self, _: Option) -> Result<(), Error> + fn serialize_seq_end(&mut self, _: Option, _: ()) -> Result<(), Error> { Err(Error) } @@ -123,7 +125,7 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_map_end(&mut self, _: Option) -> Result<(), Error> + fn serialize_map_end(&mut self, _: Option, _: ()) -> Result<(), Error> { Err(Error) } From 54c80ad6778681b7c180e9b5b0e91467a7b2d872 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 14 Jul 2016 15:37:05 +0200 Subject: [PATCH 10/16] fix range serialization --- serde/src/ser/impls.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index a7f861eb..4c6d1182 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -305,11 +305,12 @@ impl Serialize for ops::Range fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len()))); + let len = iter::Step::steps_between(&self.start, &self.end, &A::one()); + let state = try!(serializer.serialize_seq(Some(len))); for e in self.iter() { - try!(seq_serializer.serialize_elt(e)); + try!(serializer.serialize_seq_elt(e)); } - seq_serializer.drop() + serializer.serialize_seq_end(Some(len), state); } } From 29013447225c78345fb7f99711abfb126c0323ad Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 14 Jul 2016 16:16:20 +0200 Subject: [PATCH 11/16] this time really fix ranges --- serde/src/ser/impls.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 4c6d1182..3ae1dcdc 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -306,11 +306,11 @@ impl Serialize for ops::Range where S: Serializer, { let len = iter::Step::steps_between(&self.start, &self.end, &A::one()); - let state = try!(serializer.serialize_seq(Some(len))); - for e in self.iter() { + let state = try!(serializer.serialize_seq(len)); + for e in self.clone() { try!(serializer.serialize_seq_elt(e)); } - serializer.serialize_seq_end(Some(len), state); + serializer.serialize_seq_end(len, state); } } From 0feeb7a3416014831f0b15741af87e45ea314061 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 15 Jul 2016 00:01:31 -0700 Subject: [PATCH 12/16] David's take on Serializer --- serde/src/ser/mod.rs | 551 ++++++++++++++++++++----------------------- 1 file changed, 253 insertions(+), 298 deletions(-) diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 072a0a0d..855d914b 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -44,360 +44,315 @@ pub trait Serialize { pub trait Serializer { /// The error type that can be returned if some error occurs during serialization. type Error: Error; - /// A state object that is returned from `serialize_seq` and needs to be re-inserted into - /// `serialize_seq_end` when the serialization of the sequence is done + + /// A state object that is initialized by `serialize_seq`, passed to + /// `serialize_seq_elt`, and consumed by `serialize_seq_end`. Use `()` if no + /// state is required. type SeqState; - /// A state object that is returned from `serialize_map` and needs to be re-inserted into - /// `serialize_map_end` when the serialization of the map is done + /// A state object that is initialized by `serialize_tuple`, passed to + /// `serialize_tuple_elt`, and consumed by `serialize_tuple_end`. Use `()` + /// if no state is required. + type TupleState; + /// A state object that is initialized by `serialize_tuple_struct`, passed + /// to `serialize_tuple_struct_elt`, and consumed by + /// `serialize_tuple_struct_end`. Use `()` if no state is required. + type TupleStructState; + /// A state object that is initialized by `serialize_tuple_variant`, passed + /// to `serialize_tuple_variant_elt`, and consumed by + /// `serialize_tuple_variant_end`. Use `()` if no state is required. + type TupleVariantState; + /// A state object that is initialized by `serialize_map`, passed to + /// `serialize_map_elt`, and consumed by `serialize_map_end`. Use `()` if no + /// state is required. type MapState; + /// A state object that is initialized by `serialize_struct`, passed to + /// `serialize_struct_elt`, and consumed by `serialize_struct_end`. Use `()` + /// if no state is required. + type StructState; + /// A state object that is initialized by `serialize_struct_variant`, passed + /// to `serialize_struct_variant_elt`, and consumed by + /// `serialize_struct_variant_end`. Use `()` if no state is required. + type StructVariantState; /// Serializes a `bool` value. fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error>; - /// Serializes a `isize` value. By default it casts the value to a `i64` and - /// passes it to the `serialize_i64` method. - #[inline] - fn serialize_isize(&mut self, v: isize) -> Result<(), Self::Error> { - self.serialize_i64(v as i64) - } + /// Serializes an `isize` value. If the format does not differentiate + /// between `isize` and `i64`, a reasonable implementation would be to cast + /// the value to `i64` and forward to `serialize_i64`. + fn serialize_isize(&mut self, v: isize) -> Result<(), Self::Error>; - /// Serializes a `i8` value. By default it casts the value to a `i64` and - /// passes it to the `serialize_i64` method. - #[inline] - fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error> { - self.serialize_i64(v as i64) - } + /// Serializes an `i8` value. If the format does not differentiate between + /// `i8` and `i64`, a reasonable implementation would be to cast the value + /// to `i64` and forward to `serialize_i64`. + fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error>; - /// Serializes a `i16` value. By default it casts the value to a `i64` and - /// passes it to the `serialize_i64` method. - #[inline] - fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error> { - self.serialize_i64(v as i64) - } + /// Serializes an `i16` value. If the format does not differentiate between + /// `i16` and `i64`, a reasonable implementation would be to cast the value + /// to `i64` and forward to `serialize_i64`. + fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error>; - /// Serializes a `i32` value. By default it casts the value to a `i64` and - /// passes it to the `serialize_i64` method. - #[inline] - fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error> { - self.serialize_i64(v as i64) - } + /// Serializes an `i32` value. If the format does not differentiate between + /// `i32` and `i64`, a reasonable implementation would be to cast the value + /// to `i64` and forward to `serialize_i64`. + fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error>; - /// Serializes a `i64` value. - #[inline] + /// Serializes an `i64` value. fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error>; - /// Serializes a `usize` value. By default it casts the value to a `u64` and - /// passes it to the `serialize_u64` method. - #[inline] - fn serialize_usize(&mut self, v: usize) -> Result<(), Self::Error> { - self.serialize_u64(v as u64) - } + /// Serializes a `usize` value. If the format does not differentiate between + /// `usize` and `u64`, a reasonable implementation would be to cast the + /// value to `u64` and forward to `serialize_u64`. + fn serialize_usize(&mut self, v: usize) -> Result<(), Self::Error>; - /// Serializes a `u8` value. By default it casts the value to a `u64` and passes - /// it to the `serialize_u64` method. - #[inline] - fn serialize_u8(&mut self, v: u8) -> Result<(), Self::Error> { - self.serialize_u64(v as u64) - } + /// Serializes a `u8` value. If the format does not differentiate between + /// `u8` and `u64`, a reasonable implementation would be to cast the value + /// to `u64` and forward to `serialize_u64`. + fn serialize_u8(&mut self, v: u8) -> Result<(), Self::Error>; - /// Serializes a `u32` value. By default it casts the value to a `u64` and passes - /// it to the `serialize_u64` method. - #[inline] - fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error> { - self.serialize_u64(v as u64) - } + /// Serializes a `u16` value. If the format does not differentiate between + /// `u16` and `u64`, a reasonable implementation would be to cast the value + /// to `u64` and forward to `serialize_u64`. + fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error>; - /// Serializes a `u32` value. By default it casts the value to a `u64` and passes - /// it to the `serialize_u64` method. - #[inline] - fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error> { - self.serialize_u64(v as u64) - } + /// Serializes a `u32` value. If the format does not differentiate between + /// `u32` and `u64`, a reasonable implementation would be to cast the value + /// to `u64` and forward to `serialize_u64`. + fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error>; /// `Serializes a `u64` value. - #[inline] fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error>; - /// Serializes a `f32` value. By default it casts the value to a `f64` and passes - /// it to the `serialize_f64` method. - #[inline] - fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error> { - self.serialize_f64(v as f64) - } + /// Serializes an `f32` value. If the format does not differentiate between + /// `f32` and `f64`, a reasonable implementation would be to cast the value + /// to `f64` and forward to `serialize_f64`. + fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error>; - /// Serializes a `f64` value. + /// Serializes an `f64` value. fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error>; - /// Serializes a character. By default it serializes it as a `&str` containing a - /// single character. - #[inline] - fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> { - self.serialize_str(::utils::encode_utf8(v).as_str()) - } + /// Serializes a character. + fn serialize_char(&mut self, v: char) -> Result<(), Self::Error>; /// Serializes a `&str`. fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error>; - /// Enables those serialization formats that support serializing - /// byte slices separately from generic arrays. By default it serializes as a regular array. - #[inline] - fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - let state = try!(self.serialize_seq(Some(value.len()))); - for b in value.iter() { - try!(self.serialize_seq_elt(b)); - } - self.serialize_seq_end(Some(value.len()), state) - } + /// Enables serializers to serialize byte slices more compactly or more + /// efficiently than other types of slices. If no efficient implementation + /// is available, a reasonable implementation would be to forward to + /// `serialize_seq`. + fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error>; /// Serializes a `()` value. fn serialize_unit(&mut self) -> Result<(), Self::Error>; - /// Serializes a unit struct value. - /// - /// By default, unit structs are serialized as a `()`. - #[inline] - fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> { - self.serialize_unit() - } + /// Serializes a unit struct value. A reasonable implementation would be to + /// forward to `serialize_unit`. + fn serialize_unit_struct( + &mut self, + name: &str, + ) -> Result<(), Self::Error>; - /// Serializes a unit variant, otherwise known as a variant with no arguments. - /// - /// By default, unit variants are serialized as a `()`. - #[inline] - fn serialize_unit_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str) -> Result<(), Self::Error> { - self.serialize_unit() - } + /// Serializes a unit variant, otherwise known as a variant with no + /// arguments. A reasonable implementation would be to forward to + /// `serialize_unit`. + fn serialize_unit_variant( + &mut self, + name: &str, + variant_index: usize, + variant: &str, + ) -> Result<(), Self::Error>; - /// Allows a tuple struct with a single element, also known as a - /// newtyped value, to be more efficiently serialized than a tuple struct with multiple items. - /// By default it just serializes the value as a tuple struct sequence. - #[inline] - fn serialize_newtype_struct(&mut self, - name: &'static str, - value: T) -> Result<(), Self::Error> - where T: Serialize, - { - let state = try!(self.serialize_tuple_struct(name, 1)); - try!(self.serialize_tuple_struct_elt(value)); - self.serialize_tuple_struct_end(name, 1, state) - } + /// Allows a tuple struct with a single element, also known as a newtype + /// struct, to be more efficiently serialized than a tuple struct with + /// multiple items. A reasonable implementation would be to forward to + /// `serialize_tuple_struct`. + fn serialize_newtype_struct( + &mut self, + name: &str, + value: T, + ) -> Result<(), Self::Error>; - /// Allows a variant with a single item to be more efficiently - /// serialized than a variant with multiple items. By default it just serializes the value as a - /// tuple variant sequence. - #[inline] - fn serialize_newtype_variant(&mut self, - name: &'static str, - variant_index: usize, - variant: &'static str, - value: T) -> Result<(), Self::Error> - where T: Serialize, - { - let state = try!(self.serialize_tuple_variant(name, variant_index, variant, 1)); - try!(self.serialize_tuple_variant_elt(value)); - self.serialize_tuple_variant_end(name, variant_index, variant, 1, state) - } + /// Allows a variant with a single item to be more efficiently serialized + /// than a variant with multiple items. A reasonable implementation would be + /// to forward to `serialize_tuple_variant`. + fn serialize_newtype_variant( + &mut self, + name: &str, + variant_index: usize, + variant: &str, + value: T, + ) -> Result<(), Self::Error>; - /// Serializes a `None` value..serialize + /// Serializes a `None` value. fn serialize_none(&mut self) -> Result<(), Self::Error>; /// Serializes a `Some(...)` value. - fn serialize_some(&mut self, value: V) -> Result<(), Self::Error> - where V: Serialize; + fn serialize_some( + &mut self, + value: T, + ) -> Result<(), Self::Error>; - /// Serializes a sequence. - /// - /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item - /// in the sequence. - fn serialize_seq(&mut self, len: Option) -> Result; + /// Begins to serialize a sequence. This call must be followed by zero or + /// more calls to `serialize_seq_elt`, then a call to `serialize_seq_end`. + fn serialize_seq( + &mut self, + len: Option, + ) -> Result; - /// Serializes a sequence element. - fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize; + /// Serializes a sequence element. Must have previously called + /// `serialize_seq`. + fn serialize_seq_elt( + &mut self, + state: &mut Self::SeqState, + value: T, + ) -> Result<(), Self::Error>; - /// Finish serializing a sequence. - fn serialize_seq_end(&mut self, len: Option, state: Self::SeqState) -> Result<(), Self::Error>; + /// Finishes serializing a sequence. + fn serialize_seq_end( + &mut self, + state: Self::SeqState, + ) -> Result<(), Self::Error>; - /// Serializes a tuple. - /// - /// By default this serializes a tuple as a sequence. - #[inline] - fn serialize_tuple(&mut self, len: usize) -> Result - { - self.serialize_seq(Some(len)) - } + /// Begins to serialize a tuple. This call must be followed by zero or more + /// calls to `serialize_tuple_elt`, then a call to `serialize_tuple_end`. A + /// reasonable implementation would be to forward to `serialize_seq`. + fn serialize_tuple( + &mut self, + len: usize, + ) -> Result; - /// Serializes a tuple element. - /// - /// By default, tuples are serialized as a sequence. - #[inline] - fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize { - self.serialize_seq_elt(value) - } + /// Serializes a tuple element. Must have previously called + /// `serialize_tuple`. + fn serialize_tuple_elt( + &mut self, + state: &mut Self::TupleState, + value: T, + ) -> Result<(), Self::Error>; - /// Finishes serialization of a tuple. - /// - /// By default, tuples are serialized as a sequence. - #[inline] - fn serialize_tuple_end(&mut self, len: usize, state: Self::SeqState) -> Result<(), Self::Error> { - self.serialize_seq_end(Some(len), state) - } + /// Finishes serializing a tuple. + fn serialize_tuple_end( + &mut self, + state: Self::TupleState, + ) -> Result<(), Self::Error>; - /// Serializes a fixed-size array. - /// - /// By default this serializes an array as a sequence. - #[inline] - fn serialize_fixed_size_array(&mut self, size: usize) -> Result - { - self.serialize_seq(Some(size)) - } + /// Begins to serialize a tuple struct. This call must be followed by zero + /// or more calls to `serialize_tuple_struct_elt`, then a call to + /// `serialize_tuple_struct_end`. A reasonable implementation would be to + /// forward to `serialize_tuple`. + fn serialize_tuple_struct( + &mut self, + name: &str, + len: usize, + ) -> Result; - /// Serializes a tuple struct. - /// - /// By default, tuple structs are serialized as a tuple. - #[inline] - fn serialize_tuple_struct(&mut self, - _name: &'static str, - len: usize, - ) -> Result - { - self.serialize_tuple(len) - } + /// Serializes a tuple struct element. Must have previously called + /// `serialize_tuple_struct`. + fn serialize_tuple_struct_elt( + &mut self, + state: &mut Self::TupleStructState, + value: T, + ) -> Result<(), Self::Error>; - /// Serializes a tuple struct element. - /// - /// By default, tuple struct elements are serialized as a tuple element. - #[inline] - fn serialize_tuple_struct_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize - { - self.serialize_tuple_elt(value) - } + /// Finishes serializing a tuple struct. + fn serialize_tuple_struct_end( + &mut self, + state: Self::TupleStructState, + ) -> Result<(), Self::Error>; - /// Finishes serialization of a tuple struct. - /// - /// By default, tuple structs are serialized as a sequence. - #[inline] - fn serialize_tuple_struct_end(&mut self, - _name: &'static str, - len: usize, - state: Self::SeqState, - ) -> Result<(), Self::Error> { - self.serialize_tuple_end(len, state) - } + /// Begins to serialize a tuple variant. This call must be followed by zero + /// or more calls to `serialize_tuple_variant_elt`, then a call to + /// `serialize_tuple_variant_end`. A reasonable implementation would be to + /// forward to `serialize_tuple_struct`. + fn serialize_tuple_variant( + &mut self, + name: &str, + variant_index: usize, + variant: &str, + len: usize, + ) -> Result; - /// Serializes a tuple variant. - /// - /// By default, tuple variants are serialized as a tuple struct. - #[inline] - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - len: usize, - ) -> Result - { - self.serialize_tuple_struct(variant, len) - } + /// Serializes a tuple variant element. Must have previously called + /// `serialize_tuple_variant`. + fn serialize_tuple_variant_elt( + &mut self, + state: &mut Self::TupleVariantState, + value: T, + ) -> Result<(), Self::Error>; - /// Serializes a tuple variant element. - /// - /// By default, tuple variants are serialized as tuples. - #[inline] - fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize - { - self.serialize_tuple_struct_elt(value) - } + /// Finishes serializing a tuple variant. + fn serialize_tuple_variant_end( + &mut self, + state: Self::TupleVariantState, + ) -> Result<(), Self::Error>; - /// Finishes serialization of a tuple variant. - /// - /// By default, tuple variants are serialized as tuples. - #[inline] - fn serialize_tuple_variant_end(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - len: usize, - state: Self::SeqState, - ) -> Result<(), Self::Error> { - self.serialize_tuple_struct_end(variant, len, state) - } + /// Begins to serialize a map. This call must be followed by zero or more + /// calls to `serialize_map_elt`, then a call to `serialize_map_end`. + fn serialize_map( + &mut self, + len: Option, + ) -> Result; - /// Serialize a map. - fn serialize_map(&mut self, len: Option) -> Result; + /// Serialize a map element. Must have previously called `serialize_map`. + fn serialize_map_elt( + &mut self, + state: &mut Self::MapState, + key: K, + value: V, + ) -> Result<(), Self::Error>; - /// Serialize a map element - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize; + /// Finishes serializing a map. + fn serialize_map_end( + &mut self, + state: Self::MapState, + ) -> Result<(), Self::Error>; - /// Finishes serializing a map - fn serialize_map_end(&mut self, len: Option, state: Self::MapState) -> Result<(), Self::Error>; + /// Begins to serialize a struct. This call must be followed by zero or more + /// calls to `serialize_struct_elt`, then a call to `serialize_struct_end`. + fn serialize_struct( + &mut self, + name: &str, + len: usize, + ) -> Result; - /// Serializes a struct. - /// - /// By default, structs are serialized as a map with the field name as the key. - #[inline] - fn serialize_struct(&mut self, - _name: &'static str, - len: usize, - ) -> Result - { - self.serialize_map(Some(len)) - } + /// Serializes a struct field. Must have previously called + /// `serialize_struct`. + fn serialize_struct_elt( + &mut self, + state: &mut Self::StructState, + key: &str, + value: V, + ) -> Result<(), Self::Error>; - /// Serialize a struct field - /// - /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { - self.serialize_map_elt(key, value) - } + /// Finishes serializing a struct. + fn serialize_struct_end( + &mut self, + state: Self::StructState, + ) -> Result<(), Self::Error>; - /// Finishes serializing a struct - /// - /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_end(&mut self, - _name: &'static str, - len: usize, - state: Self::MapState, - ) -> Result<(), Self::Error> { - self.serialize_map_end(Some(len), state) - } + /// Begins to serialize a struct variant. This call must be followed by zero + /// or more calls to `serialize_struct_variant_elt`, then a call to + /// `serialize_struct_variant_end`. + fn serialize_struct_variant( + &mut self, + name: &str, + variant_index: usize, + variant: &str, + len: usize, + ) -> Result; - /// Serializes a struct variant. - /// - /// By default, struct variants are serialized as a struct. - #[inline] - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - len: usize, - ) -> Result - { - self.serialize_struct(variant, len) - } + /// Serialize a struct variant element. Must have previously called + /// `serialize_struct_variant`. + fn serialize_struct_variant_elt( + &mut self, + state: &mut Self::StructVariantState, + key: &str, + value: V, + ) -> Result<(), Self::Error>; - /// Serialize a struct variant element - /// - /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_variant_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { - self.serialize_struct_elt(key, value) - } - - /// Finishes serializing a struct variant - /// - /// By default, structs are serialized as a map with the field name as the key. - fn serialize_struct_variant_end(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - len: usize, - state: Self::MapState, - ) -> Result<(), Self::Error> { - self.serialize_struct_end(variant, len, state) - } + /// Finishes serializing a struct variant. + fn serialize_struct_variant_end( + &mut self, + state: Self::StructVariantState, + ) -> Result<(), Self::Error>; } From 921751753252633dedf9d517e227ed157f60e52d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 15 Jul 2016 00:55:38 -0700 Subject: [PATCH 13/16] Update impls --- serde/src/ser/impls.rs | 165 +++++++++++++++-------------------------- 1 file changed, 59 insertions(+), 106 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 3ae1dcdc..b2921b00 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -152,11 +152,11 @@ impl Serialize for [T] fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let state = try!(serializer.serialize_seq(Some(self.len()))); + let mut state = try!(serializer.serialize_seq(Some(self.len()))); for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); + try!(serializer.serialize_seq_elt(&mut state, e)); } - serializer.serialize_seq_end(Some(self.len()), state) + serializer.serialize_seq_end(state) } } @@ -169,11 +169,11 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let state = try!(serializer.serialize_fixed_size_array($len)); + let mut state = try!(serializer.serialize_seq(Some($len))); for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); + try!(serializer.serialize_seq_elt(&mut state, e)); } - serializer.serialize_seq_end(Some(self.len()), state) + serializer.serialize_seq_end(state) } } } @@ -215,52 +215,40 @@ array_impls!(32); /////////////////////////////////////////////////////////////////////////////// +macro_rules! serialize_seq { + () => { + #[inline] + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer, + { + let mut state = try!(serializer.serialize_seq(Some(self.len()))); + for e in self { + try!(serializer.serialize_seq_elt(&mut state, e)); + } + serializer.serialize_seq_end(state) + } + } +} + #[cfg(any(feature = "std", feature = "collections"))] impl Serialize for BinaryHeap where T: Serialize + Ord { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len()), state) - } + serialize_seq!(); } #[cfg(any(feature = "std", feature = "collections"))] impl Serialize for BTreeSet where T: Serialize + Ord, { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len()), state) - } + serialize_seq!(); } #[cfg(all(feature = "nightly", feature = "collections"))] impl Serialize for EnumSet where T: Serialize + CLike { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len())) - } + serialize_seq!(); } #[cfg(feature = "std")] @@ -268,32 +256,24 @@ impl Serialize for HashSet where T: Serialize + Eq + Hash, H: BuildHasher, { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len()), state) - } + serialize_seq!(); } #[cfg(any(feature = "std", feature = "collections"))] impl Serialize for LinkedList where T: Serialize, { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len()), state) - } + serialize_seq!(); +} + +#[cfg(any(feature = "std", feature = "collections"))] +impl Serialize for Vec where T: Serialize { + serialize_seq!(); +} + +#[cfg(any(feature = "std", feature = "collections"))] +impl Serialize for VecDeque where T: Serialize { + serialize_seq!(); } #[cfg(feature = "nightly")] @@ -306,35 +286,11 @@ impl Serialize for ops::Range where S: Serializer, { let len = iter::Step::steps_between(&self.start, &self.end, &A::one()); - let state = try!(serializer.serialize_seq(len)); + let mut state = try!(serializer.serialize_seq(len)); for e in self.clone() { - try!(serializer.serialize_seq_elt(e)); + try!(serializer.serialize_seq_elt(&mut state, e)); } - serializer.serialize_seq_end(len, state); - } -} - -#[cfg(any(feature = "std", feature = "collections"))] -impl Serialize for Vec where T: Serialize { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - (&self[..]).serialize(serializer) - } -} - -#[cfg(any(feature = "std", feature = "collections"))] -impl Serialize for VecDeque where T: Serialize { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_seq(Some(self.len()))); - for e in self.iter() { - try!(serializer.serialize_seq_elt(e)); - } - serializer.serialize_seq_end(Some(self.len()), state) + serializer.serialize_seq_end(state) } } @@ -370,11 +326,11 @@ macro_rules! tuple_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let state = try!(serializer.serialize_tuple($len)); + let mut state = try!(serializer.serialize_tuple($len)); $( - try!(serializer.serialize_tuple_elt(&e!(self.$idx))); + try!(serializer.serialize_tuple_elt(&mut state, &e!(self.$idx))); )+ - serializer.serialize_tuple_end($len, state) + serializer.serialize_tuple_end(state) } } )+ @@ -554,21 +510,27 @@ tuple_impls! { /////////////////////////////////////////////////////////////////////////////// +macro_rules! serialize_map { + () => { + #[inline] + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer, + { + let mut state = try!(serializer.serialize_map(Some(self.len()))); + for (k, v) in self { + try!(serializer.serialize_map_elt(&mut state, k, v)); + } + serializer.serialize_map_end(state) + } + } +} + #[cfg(any(feature = "std", feature = "collections"))] impl Serialize for BTreeMap where K: Serialize + Ord, V: Serialize, { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_map(Some(self.len()))); - for (k, v) in self.iter() { - try!(serializer.serialize_map_elt(k, v)); - } - serializer.serialize_map_end(Some(self.len()), state) - } + serialize_map!(); } #[cfg(feature = "std")] @@ -577,16 +539,7 @@ impl Serialize for HashMap V: Serialize, H: BuildHasher, { - #[inline] - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: Serializer, - { - let state = try!(serializer.serialize_map(Some(self.len()))); - for (k, v) in self.iter() { - try!(serializer.serialize_map_elt(k, v)); - } - serializer.serialize_map_end(Some(self.len()), state) - } + serialize_map!(); } /////////////////////////////////////////////////////////////////////////////// From 2e4cc0b443a4aa63b7faf5304e267fa0bad66a88 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 15 Jul 2016 00:58:48 -0700 Subject: [PATCH 14/16] Restore serialize_seq_fixed_size --- serde/src/ser/mod.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 855d914b..a8cc930f 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -214,6 +214,15 @@ pub trait Serializer { state: Self::SeqState, ) -> Result<(), Self::Error>; + /// Begins to serialize a sequence whose length will be known at + /// deserialization time. This call must be followed by zero or more calls + /// to `serialize_seq_elt`, then a call to `serialize_seq_end`. A reasonable + /// implementation would be to forward to `serialize_seq`. + fn serialize_seq_fixed_size( + &mut self, + size: usize, + ) -> Result; + /// Begins to serialize a tuple. This call must be followed by zero or more /// calls to `serialize_tuple_elt`, then a call to `serialize_tuple_end`. A /// reasonable implementation would be to forward to `serialize_seq`. From fbad1940423489657d4d00134dd4de53408e251e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 15 Jul 2016 00:59:56 -0700 Subject: [PATCH 15/16] Restore 'static requirement for names --- serde/src/ser/mod.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index a8cc930f..3e6bc244 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -150,7 +150,7 @@ pub trait Serializer { /// forward to `serialize_unit`. fn serialize_unit_struct( &mut self, - name: &str, + name: &'static str, ) -> Result<(), Self::Error>; /// Serializes a unit variant, otherwise known as a variant with no @@ -158,9 +158,9 @@ pub trait Serializer { /// `serialize_unit`. fn serialize_unit_variant( &mut self, - name: &str, + name: &'static str, variant_index: usize, - variant: &str, + variant: &'static str, ) -> Result<(), Self::Error>; /// Allows a tuple struct with a single element, also known as a newtype @@ -169,7 +169,7 @@ pub trait Serializer { /// `serialize_tuple_struct`. fn serialize_newtype_struct( &mut self, - name: &str, + name: &'static str, value: T, ) -> Result<(), Self::Error>; @@ -178,9 +178,9 @@ pub trait Serializer { /// to forward to `serialize_tuple_variant`. fn serialize_newtype_variant( &mut self, - name: &str, + name: &'static str, variant_index: usize, - variant: &str, + variant: &'static str, value: T, ) -> Result<(), Self::Error>; @@ -251,7 +251,7 @@ pub trait Serializer { /// forward to `serialize_tuple`. fn serialize_tuple_struct( &mut self, - name: &str, + name: &'static str, len: usize, ) -> Result; @@ -275,9 +275,9 @@ pub trait Serializer { /// forward to `serialize_tuple_struct`. fn serialize_tuple_variant( &mut self, - name: &str, + name: &'static str, variant_index: usize, - variant: &str, + variant: &'static str, len: usize, ) -> Result; @@ -320,7 +320,7 @@ pub trait Serializer { /// calls to `serialize_struct_elt`, then a call to `serialize_struct_end`. fn serialize_struct( &mut self, - name: &str, + name: &'static str, len: usize, ) -> Result; @@ -329,7 +329,7 @@ pub trait Serializer { fn serialize_struct_elt( &mut self, state: &mut Self::StructState, - key: &str, + key: &'static str, value: V, ) -> Result<(), Self::Error>; @@ -344,9 +344,9 @@ pub trait Serializer { /// `serialize_struct_variant_end`. fn serialize_struct_variant( &mut self, - name: &str, + name: &'static str, variant_index: usize, - variant: &str, + variant: &'static str, len: usize, ) -> Result; @@ -355,7 +355,7 @@ pub trait Serializer { fn serialize_struct_variant_elt( &mut self, state: &mut Self::StructVariantState, - key: &str, + key: &'static str, value: V, ) -> Result<(), Self::Error>; From 42c41922ce7af6d60322c840456ed70efa85a1e3 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 15 Jul 2016 12:59:30 +0200 Subject: [PATCH 16/16] adjust tests for new interface --- serde/src/ser/impls.rs | 2 +- serde_codegen/src/ser.rs | 30 +++----- serde_test/src/ser.rs | 57 +++++++------- testing/tests/test_bytes.rs | 150 +++++++++++++++++++++++++++++++++++- 4 files changed, 189 insertions(+), 50 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index b2921b00..a8876c95 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -169,7 +169,7 @@ macro_rules! array_impls { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - let mut state = try!(serializer.serialize_seq(Some($len))); + let mut state = try!(serializer.serialize_seq_fixed_size($len)); for e in self.iter() { try!(serializer.serialize_seq_elt(&mut state, e)); } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index 27e2927b..9937c33b 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -230,9 +230,9 @@ fn serialize_tuple_struct( let len = serialize_stmts.len(); quote_expr!(cx, { - let state = try!(_serializer.serialize_tuple_struct($type_name, $len)); + let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len)); $serialize_stmts - _serializer.serialize_tuple_struct_end($type_name, $len, state) + _serializer.serialize_tuple_struct_end(state) }) } @@ -269,10 +269,9 @@ fn serialize_struct( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - let len = $len; - let state = try!(_serializer.serialize_struct($type_name, len)); + let mut state = try!(_serializer.serialize_struct($type_name, $len)); $serialize_fields - _serializer.serialize_struct_end($type_name, len, state) + _serializer.serialize_struct_end(state) }) } @@ -464,9 +463,9 @@ fn serialize_tuple_variant( let len = serialize_stmts.len(); quote_expr!(cx, { - let state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); + let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); $serialize_stmts - _serializer.serialize_tuple_variant_end($type_name, $variant_index, $variant_name, $len, state) + _serializer.serialize_tuple_variant_end(state) }) } @@ -506,21 +505,14 @@ fn serialize_struct_variant( .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); quote_expr!(cx, { - let len = $len; - let state = try!(_serializer.serialize_struct_variant( + let mut state = try!(_serializer.serialize_struct_variant( $item_name, $variant_index, $variant_name, - len, + $len, )); $serialize_fields - _serializer.serialize_struct_variant_end( - $item_name, - $variant_index, - $variant_name, - len, - state, - ) + _serializer.serialize_struct_variant_end(state) }) } @@ -553,7 +545,7 @@ fn serialize_tuple_struct_visitor( quote_stmt!(cx, if !$skip { - try!(_serializer.$func($field_expr)); + try!(_serializer.$func(&mut state, $field_expr)); } ).unwrap() }) @@ -592,7 +584,7 @@ fn serialize_struct_visitor( quote_stmt!(cx, if !$skip { - try!(_serializer.$func($key_expr, $field_expr)); + try!(_serializer.$func(&mut state, $key_expr, $field_expr)); } ).unwrap() }) diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index 9a8632f1..aa0f8186 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -36,6 +36,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> type Error = Error; type MapState = (); type SeqState = (); + type TupleState = (); + type TupleStructState = (); + type TupleVariantState = (); + type StructState = (); + type StructVariantState = (); fn serialize_unit(&mut self) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::Unit)); @@ -160,38 +165,38 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_seq_elt(&mut self, value: T) -> Result<(), Error> + fn serialize_seq_elt(&mut self, _: &mut (), value: T) -> Result<(), Error> where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::SeqSep)); value.serialize(self) } - fn serialize_seq_end(&mut self, _len: Option, _: ()) -> Result<(), Error> { + fn serialize_seq_end(&mut self, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); Ok(()) } - fn serialize_fixed_size_array<'b>(&'b mut self, len: usize) -> Result<(), Error> + fn serialize_seq_fixed_size(&mut self, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len))); Ok(()) } - fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result<(), Error> + fn serialize_tuple(&mut self, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len))); Ok(()) } - fn serialize_tuple_elt(&mut self, value: T) -> Result<(), Error> + fn serialize_tuple_elt(&mut self, _: &mut (), value: T) -> Result<(), Error> where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::TupleSep)); value.serialize(self) } - fn serialize_tuple_end(&mut self, _len: usize, _: ()) -> Result<(), Error> { + fn serialize_tuple_end(&mut self, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); Ok(()) } @@ -205,21 +210,21 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> value.serialize(self) } - fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<(), Error> + fn serialize_tuple_struct(&mut self, name: &'static str, len: usize) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len))); Ok(()) } - fn serialize_tuple_struct_elt(&mut self, value: T) -> Result<(), Error> + fn serialize_tuple_struct_elt(&mut self, _: &mut (), value: T) -> Result<(), Error> where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep)); value.serialize(self) } - fn serialize_tuple_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Error> { + fn serialize_tuple_struct_end(&mut self, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); Ok(()) } @@ -235,18 +240,14 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_tuple_variant_elt(&mut self, value: T) -> Result<(), Error> + fn serialize_tuple_variant_elt(&mut self, _: &mut (), value: T) -> Result<(), Error> where T: Serialize { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep)); value.serialize(self) } - fn serialize_tuple_variant_end(&mut self, - _name: &str, - _variant_index: usize, - _variant: &str, - _len: usize, _: ()) -> Result<(), Error> { + fn serialize_tuple_variant_end(&mut self, _: ()) -> Result<(), Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); Ok(()) } @@ -258,13 +259,13 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + fn serialize_map_elt(&mut self, _: &mut (), key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::MapSep)); try!(key.serialize(self)); value.serialize(self) } - fn serialize_map_end(&mut self, _len: Option, _: ()) -> Result<(), Self::Error> { + fn serialize_map_end(&mut self, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); Ok(()) } @@ -276,18 +277,18 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_struct_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + fn serialize_struct_elt(&mut self, _: &mut (), key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::StructSep)); try!(key.serialize(self)); value.serialize(self) } - fn serialize_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Self::Error> { + fn serialize_struct_end(&mut self, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); Ok(()) } - fn serialize_struct_variant<'b>(&'b mut self, + fn serialize_struct_variant(&mut self, name: &str, _variant_index: usize, variant: &str, @@ -298,18 +299,22 @@ impl<'a, I> ser::Serializer for Serializer<'a, I> Ok(()) } - fn serialize_struct_variant_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { + fn serialize_struct_variant_elt(&mut self, _: &mut (), key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize { assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep)); try!(key.serialize(self)); value.serialize(self) } - fn serialize_struct_variant_end(&mut self, - _name: &str, - _variant_index: usize, - _variant: &str, - _len: usize, _: ()) -> Result<(), Self::Error> { + fn serialize_struct_variant_end(&mut self, _: ()) -> Result<(), Self::Error> { assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); Ok(()) } + + fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { + let mut state = try!(self.serialize_seq(Some(value.len()))); + for c in value { + try!(self.serialize_seq_elt(&mut state, c)); + } + self.serialize_seq_end(state) + } } diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index 54ce5f18..b2e21b2e 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -54,15 +54,60 @@ impl serde::Serializer for BytesSerializer { type Error = Error; type SeqState = (); type MapState = (); + type TupleState = (); + type TupleStructState = (); + type TupleVariantState = (); + type StructState = (); + type StructVariantState = (); fn serialize_unit(&mut self) -> Result<(), Error> { Err(Error) } + fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error> { + Err(Error) + } + + fn serialize_unit_variant(&mut self, _: &'static str, _: usize, _: &'static str) -> Result<(), Error> { + Err(Error) + } + fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> { Err(Error) } + fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> { + Err(Error) + } + + fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> { + Err(Error) + } + + fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> { + Err(Error) + } + + fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> { + Err(Error) + } + + fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> { + Err(Error) + } + + fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> { + Err(Error) + } + + fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> { + Err(Error) + } + + fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> { + Err(Error) + } + fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> { Err(Error) } @@ -97,18 +142,83 @@ impl serde::Serializer for BytesSerializer { Err(Error) } + fn serialize_newtype_struct(&mut self, _: &'static str, _value: V) -> Result<(), Error> + where V: serde::Serialize, + { + Err(Error) + } + + fn serialize_newtype_variant(&mut self, _: &'static str, _: usize, _: &'static str, _value: V) -> Result<(), Error> + where V: serde::Serialize, + { + Err(Error) + } + fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { Err(Error) } - fn serialize_seq_elt(&mut self, _value: T) -> Result<(), Error> + fn serialize_seq_fixed_size(&mut self, _len: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_seq_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> where T: serde::Serialize { Err(Error) } - fn serialize_seq_end(&mut self, _: Option, _: ()) -> Result<(), Error> + fn serialize_seq_end(&mut self, _: ()) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> + where T: serde::Serialize + { + Err(Error) + } + + fn serialize_tuple_end(&mut self, _: ()) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple_struct(&mut self, _: &'static str, _len: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple_struct_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> + where T: serde::Serialize + { + Err(Error) + } + + fn serialize_tuple_struct_end(&mut self, _: ()) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple_variant(&mut self, _: &'static str, _: usize, _: &'static str, _len: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_tuple_variant_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> + where T: serde::Serialize + { + Err(Error) + } + + fn serialize_tuple_variant_end(&mut self, _: ()) -> Result<(), Error> { Err(Error) } @@ -118,14 +228,46 @@ impl serde::Serializer for BytesSerializer { Err(Error) } - fn serialize_map_elt(&mut self, _key: K, _value: V) -> Result<(), Error> + fn serialize_map_elt(&mut self, _: &mut (), _key: K, _value: V) -> Result<(), Error> where K: serde::Serialize, V: serde::Serialize, { Err(Error) } - fn serialize_map_end(&mut self, _: Option, _: ()) -> Result<(), Error> + fn serialize_map_end(&mut self, _: ()) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_struct(&mut self, _: &'static str, _: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_struct_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> + where V: serde::Serialize, + { + Err(Error) + } + + fn serialize_struct_end(&mut self, _: ()) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_struct_variant(&mut self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<(), Error> + { + Err(Error) + } + + fn serialize_struct_variant_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> + where V: serde::Serialize, + { + Err(Error) + } + + fn serialize_struct_variant_end(&mut self, _: ()) -> Result<(), Error> { Err(Error) }