mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Eliminate Visitor pattern

Browse Source 
Visitor is "pull", while `MapSerializer` and `SeqSerializer`
are "push" like the rest of the API.
This commit is contained in:
Dawid Ciężarkiewicz 2016-07-10 11:22:24 -07:00 committed by Oliver Schneider
parent 4ec0a7e672
commit 99038b044e
No known key found for this signature in database
GPG Key ID: 56D6EEA0FC67AC46
2 changed files with 124 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

274
serde/src/ser/impls.rs
View File

@ -64,8 +64,8 @@ use super::{
Error,
Serialize,
Serializer,
SeqVisitor,
MapVisitor,
SeqSerializer,
MapSerializer,
};
///////////////////////////////////////////////////////////////////////////////
@ -133,26 +133,6 @@ impl<T> Serialize for Option<T> where T: Serialize {
}
}
impl<T> SeqVisitor for Option<T> where T: Serialize {
#[inline]
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, 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<usize> {
Some(if self.is_some() { 1 } else { 0 })
}
}
///////////////////////////////////////////////////////////////////////////////
impl<T> Serialize for PhantomData<T> {
@ -164,69 +144,6 @@ impl<T> Serialize for PhantomData<T> {
}
}
///////////////////////////////////////////////////////////////////////////////
/// A `serde::Visitor` for sequence iterators.
///
/// # Examples
///
/// ```
/// use serde::{Serialize, Serializer};
/// use serde::ser::impls::SeqIteratorVisitor;
///
/// struct Seq(Vec<u32>);
///
/// impl Serialize for Seq {
/// fn serialize<S>(&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: Iter,
len: Option<usize>,
}
impl<T, Iter> SeqIteratorVisitor<Iter>
where Iter: Iterator<Item=T>
{
/// Construct a new `SeqIteratorVisitor<Iter>`.
#[inline]
pub fn new(iter: Iter, len: Option<usize>) -> SeqIteratorVisitor<Iter> {
SeqIteratorVisitor {
iter: iter,
len: len,
}
}
}
impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
where T: Serialize,
Iter: Iterator<Item=T>,
{
#[inline]
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, 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<usize> {
self.len
}
}
///////////////////////////////////////////////////////////////////////////////
@ -237,7 +154,12 @@ impl<T> Serialize for [T]
fn serialize<S>(&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<S>(&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<T> Serialize for BinaryHeap<T>
fn serialize<S>(&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<T> Serialize for BTreeSet<T>
fn serialize<S>(&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<T> Serialize for EnumSet<T>
fn serialize<S>(&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<T, H> Serialize for HashSet<T, H>
fn serialize<S>(&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<T> Serialize for LinkedList<T>
fn serialize<S>(&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<A> Serialize for ops::Range<A>
{
#[inline]
fn serialize<S>(&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<T> Serialize for VecDeque<T> where T: Serialize {
fn serialize<S>(&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<S>(&mut self, serializer: &mut S) -> Result<Option<()>, 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<usize> {
Some($len)
}
}
impl<$($T),+> Serialize for ($($T,)+)
where $($T: Serialize),+
{
#[inline]
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S,SS>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer<SeqSerializer=SS>,
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<u32, u32>);
///
/// impl Serialize for Map {
/// fn serialize<S>(&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: Iter,
len: Option<usize>,
}
impl<K, V, Iter> MapIteratorVisitor<Iter>
where Iter: Iterator<Item=(K, V)>
{
/// Construct a new `MapIteratorVisitor<Iter>`.
#[inline]
pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
MapIteratorVisitor {
iter: iter,
len: len,
}
}
}
impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
where K: Serialize,
V: Serialize,
I: Iterator<Item=(K, V)>,
{
#[inline]
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, 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<usize> {
self.len
}
}
*/
///////////////////////////////////////////////////////////////////////////////
@ -713,7 +567,11 @@ impl<K, V> Serialize for BTreeMap<K, V>
fn serialize<S>(&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<K, V, H> Serialize for HashMap<K, V, H>
fn serialize<S>(&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(())
}
}

158
serde/src/ser/mod.rs
View File

@ -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<K, V>(&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<T>(&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<Error = Self::Error>;
/// A sub-type used to serialize maps
type MapSerializer : MapSerializer<Error = Self::Error>;
/// 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<V>(&mut self, visitor: V) -> Result<(), Self::Error>
where V: SeqVisitor;
/// Serializes a sequence element.
fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
where T: Serialize;
fn serialize_seq(&mut self) -> Result<Self::SeqSerializer, Self::Error>;
/// Serializes a tuple.
///
/// By default this serializes a tuple as a sequence.
#[inline]
fn serialize_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error>
where V: SeqVisitor,
fn serialize_tuple(&mut self) -> Result<Self::SeqSerializer, Self::Error>
{
self.serialize_seq(visitor)
self.serialize_seq()
}
/// Serializes a tuple element.
@ -226,29 +249,30 @@ pub trait Serializer {
fn serialize_tuple_elt<T>(&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<V>(&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<V>(&mut self,
fn serialize_tuple_struct(&mut self,
_name: &'static str,
visitor: V) -> Result<(), Self::Error>
where V: SeqVisitor,
) -> Result<Self::SeqSerializer, Self::Error>
{
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<V>(&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::SeqSerializer, Self::Error>
{
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<V>(&mut self, visitor: V) -> Result<(), Self::Error>
where V: MapVisitor;
/// Serializes a map element (key-value pair).
fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
where K: Serialize,
V: Serialize;
/// Serialize a map.
fn serialize_map(&mut self) -> Result<Self::MapSerializer, Self::Error>;
/// Serializes a struct.
///
/// By default, structs are serialized as a map with the field name as the key.
#[inline]
fn serialize_struct<V>(&mut self,
fn serialize_struct(&mut self,
_name: &'static str,
visitor: V) -> Result<(), Self::Error>
where V: MapVisitor,
) -> Result<Self::MapSerializer, Self::Error>
{
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<V>(&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<V>(&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::MapSerializer, Self::Error>
{
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<V>(&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<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer;
/// Return the length of the sequence if known.
#[inline]
fn len(&self) -> Option<usize> {
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<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer;
/// Return the length of the map if known.
#[inline]
fn len(&self) -> Option<usize> {
None
self.serialize_struct(variant)
}
}