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

Thread a visitor through the serializers

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-10-13 20:43:20 -07:00
parent 1c3a42ea56
commit 6c98a3b739
3 changed files with 382 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
serde2/src/json/mod.rs
View File

@ -1,4 +1,4 @@
pub use self::ser::Serializer;
pub use self::ser::Writer;
pub use self::ser::{to_vec, to_string};
pub use self::ser::escape_str;

146
serde2/src/json/ser.rs
View File

@ -1,20 +1,22 @@
use std::f64;
use std::io::{IoError, MemWriter};
use std::io;
use std::num::{FPNaN, FPInfinite};
use ser;
use ser::Serializer;
/// A structure for implementing serialization to JSON.
pub struct Serializer<W> {
pub struct Writer<W> {
writer: W,
}
impl<W: Writer> Serializer<W> {
/// Creates a new JSON serializer whose output will be written to the writer
impl<W: io::Writer> Writer<W> {
/// Creates a new JSON visitr whose output will be written to the writer
/// specified.
#[inline]
pub fn new(writer: W) -> Serializer<W> {
Serializer {
pub fn new(writer: W) -> Writer<W> {
Writer {
writer: writer,
}
}
@ -26,146 +28,156 @@ impl<W: Writer> Serializer<W> {
}
}
impl<W: Writer> ser::Visitor<(), IoError> for Serializer<W> {
impl<W: io::Writer> ser::Serializer<W, (), IoError> for Writer<W> {
fn visit<
T: ser::Serialize,
>(&mut self, value: &T) -> Result<(), IoError> {
value.visit(&mut self.writer, Visitor)
}
}
struct Visitor;
impl<W: io::Writer> ser::Visitor<W, (), IoError> for Visitor {
#[inline]
fn visit_null(&mut self) -> Result<(), IoError> {
self.writer.write_str("null")
fn visit_null(&self, writer: &mut W) -> Result<(), IoError> {
writer.write_str("null")
}
#[inline]
fn visit_bool(&mut self, value: bool) -> Result<(), IoError> {
fn visit_bool(&self, writer: &mut W, value: bool) -> Result<(), IoError> {
if value {
self.writer.write_str("true")
writer.write_str("true")
} else {
self.writer.write_str("false")
writer.write_str("false")
}
}
#[inline]
fn visit_int(&mut self, value: int) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_int(&self, writer: &mut W, value: int) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_i8(&mut self, value: i8) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_i8(&self, writer: &mut W, value: i8) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_i16(&mut self, value: i16) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_i16(&self, writer: &mut W, value: i16) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_i32(&mut self, value: i32) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_i32(&self, writer: &mut W, value: i32) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_i64(&mut self, value: i64) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_i64(&self, writer: &mut W, value: i64) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_uint(&mut self, value: uint) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_uint(&self, writer: &mut W, value: uint) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_u8(&mut self, value: u8) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_u8(&self, writer: &mut W, value: u8) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_u16(&mut self, value: u16) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_u16(&self, writer: &mut W, value: u16) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_u32(&mut self, value: u32) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_u32(&self, writer: &mut W, value: u32) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_u64(&mut self, value: u64) -> Result<(), IoError> {
write!(self.writer, "{}", value)
fn visit_u64(&self, writer: &mut W, value: u64) -> Result<(), IoError> {
write!(writer, "{}", value)
}
#[inline]
fn visit_f64(&mut self, value: f64) -> Result<(), IoError> {
fmt_f64_or_null(&mut self.writer, value)
fn visit_f64(&self, writer: &mut W, value: f64) -> Result<(), IoError> {
fmt_f64_or_null(writer, value)
}
#[inline]
fn visit_char(&mut self, v: char) -> Result<(), IoError> {
escape_char(&mut self.writer, v)
fn visit_char(&self, writer: &mut W, v: char) -> Result<(), IoError> {
escape_char(writer, v)
}
#[inline]
fn visit_str(&mut self, value: &str) -> Result<(), IoError> {
escape_str(&mut self.writer, value)
fn visit_str(&self, writer: &mut W, value: &str) -> Result<(), IoError> {
escape_str(writer, value)
}
#[inline]
fn visit_seq<
V: ser::SeqVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("["));
V: ser::SeqVisitor<W, (), IoError>
>(&self, writer: &mut W, mut visitor: V) -> Result<(), IoError> {
try!(writer.write_str("["));
loop {
match try!(visitor.visit(self)) {
match try!(visitor.visit(writer, Visitor)) {
Some(()) => { }
None => { break; }
}
}
self.writer.write_str("]")
writer.write_str("]")
}
#[inline]
fn visit_seq_elt<
T: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, value: T) -> Result<(), IoError> {
T: ser::Serialize,
>(&self, writer: &mut W, first: bool, value: T) -> Result<(), IoError> {
if !first {
try!(self.writer.write_str(","));
try!(writer.write_str(","));
}
value.serialize(self)
value.visit(writer, Visitor)
}
#[inline]
fn visit_map<
V: ser::MapVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("{{"));
V: ser::MapVisitor<W, (), IoError>
>(&self, writer: &mut W, mut visitor: V) -> Result<(), IoError> {
try!(writer.write_str("{{"));
loop {
match try!(visitor.visit(self)) {
match try!(visitor.visit(writer, Visitor)) {
Some(()) => { }
None => { break; }
}
}
self.writer.write_str("}}")
writer.write_str("}}")
}
#[inline]
fn visit_map_elt<
K: ser::Serialize<Serializer<W>, (), IoError>,
V: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, key: K, value: V) -> Result<(), IoError> {
K: ser::Serialize,
V: ser::Serialize,
>(&self, writer: &mut W, first: bool, key: K, value: V) -> Result<(), IoError> {
if !first {
try!(self.writer.write_str(","));
try!(writer.write_str(","));
}
try!(key.serialize(self));
try!(self.writer.write_str(":"));
value.serialize(self)
try!(key.visit(writer, Visitor));
try!(writer.write_str(":"));
value.visit(writer, Visitor)
}
}
#[inline]
pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError> {
pub fn escape_bytes<W: io::Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError> {
try!(wr.write_str("\""));
let mut start = 0;
@ -199,18 +211,18 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError>
}
#[inline]
pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> Result<(), IoError> {
pub fn escape_str<W: io::Writer>(wr: &mut W, value: &str) -> Result<(), IoError> {
escape_bytes(wr, value.as_bytes())
}
#[inline]
pub fn escape_char<W: Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
pub fn escape_char<W: io::Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
let mut buf = [0, .. 4];
value.encode_utf8(buf);
escape_bytes(wr, buf)
}
fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
fn fmt_f64_or_null<W: io::Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
match value.classify() {
FPNaN | FPInfinite => wr.write_str("null"),
_ => wr.write_str(f64::to_str_digits(value, 6).as_slice()),
@ -219,17 +231,17 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
#[inline]
pub fn to_vec<
T: ser::Serialize<Serializer<MemWriter>, (), IoError>
T: ser::Serialize,
>(value: &T) -> Result<Vec<u8>, IoError> {
let writer = MemWriter::with_capacity(1024);
let mut state = Serializer::new(writer);
try!(value.serialize(&mut state));
Ok(state.unwrap().unwrap())
let mut writer = Writer::new(writer);
try!(writer.visit(value));
Ok(writer.unwrap().unwrap())
}
#[inline]
pub fn to_string<
T: ser::Serialize<Serializer<MemWriter>, (), IoError>
T: ser::Serialize,
>(value: &T) -> Result<Result<String, Vec<u8>>, IoError> {
let vec = try!(to_vec(value));
Ok(String::from_utf8(vec))

455
serde2/src/ser.rs
View File

@ -2,123 +2,130 @@ use std::collections::TreeMap;
///////////////////////////////////////////////////////////////////////////////
pub trait Serialize<S, R, E> {
fn serialize(&self, state: &mut S) -> Result<R, E>;
pub trait Serialize {
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
}
///////////////////////////////////////////////////////////////////////////////
pub trait Serializer<S, R, E> {
fn serialize<
T: Serialize<S, R, E>,
fn visit<
T: Serialize,
>(&mut self, value: &T) -> Result<R, E>;
}
///////////////////////////////////////////////////////////////////////////////
pub trait Visitor<R, E> {
fn visit_null(&mut self) -> Result<R, E>;
pub trait Visitor<S, R, E> {
fn visit_null(&self, state: &mut S) -> Result<R, E>;
fn visit_bool(&mut self, v: bool) -> Result<R, E>;
fn visit_bool(&self, state: &mut S, v: bool) -> Result<R, E>;
#[inline]
fn visit_int(&mut self, v: int) -> Result<R, E> {
self.visit_i64(v as i64)
fn visit_int(&self, state: &mut S, v: int) -> Result<R, E> {
self.visit_i64(state, v as i64)
}
#[inline]
fn visit_i8(&mut self, v: i8) -> Result<R, E> {
self.visit_i64(v as i64)
fn visit_i8(&self, state: &mut S, v: i8) -> Result<R, E> {
self.visit_i64(state, v as i64)
}
#[inline]
fn visit_i16(&mut self, v: i16) -> Result<R, E> {
self.visit_i64(v as i64)
fn visit_i16(&self, state: &mut S, v: i16) -> Result<R, E> {
self.visit_i64(state, v as i64)
}
#[inline]
fn visit_i32(&mut self, v: i32) -> Result<R, E> {
self.visit_i64(v as i64)
fn visit_i32(&self, state: &mut S, v: i32) -> Result<R, E> {
self.visit_i64(state, v as i64)
}
#[inline]
fn visit_i64(&mut self, v: i64) -> Result<R, E>;
fn visit_i64(&self, state: &mut S, v: i64) -> Result<R, E>;
#[inline]
fn visit_uint(&mut self, v: uint) -> Result<R, E> {
self.visit_u64(v as u64)
fn visit_uint(&self, state: &mut S, v: uint) -> Result<R, E> {
self.visit_u64(state, v as u64)
}
#[inline]
fn visit_u8(&mut self, v: u8) -> Result<R, E> {
self.visit_u64(v as u64)
fn visit_u8(&self, state: &mut S, v: u8) -> Result<R, E> {
self.visit_u64(state, v as u64)
}
#[inline]
fn visit_u16(&mut self, v: u16) -> Result<R, E> {
self.visit_u64(v as u64)
fn visit_u16(&self, state: &mut S, v: u16) -> Result<R, E> {
self.visit_u64(state, v as u64)
}
#[inline]
fn visit_u32(&mut self, v: u32) -> Result<R, E> {
self.visit_u64(v as u64)
fn visit_u32(&self, state: &mut S, v: u32) -> Result<R, E> {
self.visit_u64(state, v as u64)
}
#[inline]
fn visit_u64(&mut self, v: u64) -> Result<R, E>;
fn visit_u64(&self, state: &mut S, v: u64) -> Result<R, E>;
#[inline]
fn visit_f32(&mut self, v: f32) -> Result<R, E> {
self.visit_f64(v as f64)
fn visit_f32(&self, state: &mut S, v: f32) -> Result<R, E> {
self.visit_f64(state, v as f64)
}
fn visit_f64(&mut self, v: f64) -> Result<R, E>;
fn visit_f64(&self, state: &mut S, v: f64) -> Result<R, E>;
fn visit_char(&mut self, value: char) -> Result<R, E>;
fn visit_char(&self, state: &mut S, value: char) -> Result<R, E>;
fn visit_str(&mut self, value: &str) -> Result<R, E>;
fn visit_str(&self, state: &mut S, value: &str) -> Result<R, E>;
fn visit_seq<
V: SeqVisitor<Self, R, E>,
>(&mut self, visitor: V) -> Result<R, E>;
V: SeqVisitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
#[inline]
fn visit_named_seq<
V: SeqVisitor<Self, R, E>,
>(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(visitor)
V: SeqVisitor<S, R, E>,
>(&self, state: &mut S, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(state, visitor)
}
#[inline]
fn visit_enum<
V: SeqVisitor<Self, R, E>,
>(&mut self, _name: &'static str, _variant: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(visitor)
V: SeqVisitor<S, R, E>,
>(&self, state: &mut S, _name: &'static str, _variant: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(state, visitor)
}
fn visit_seq_elt<
T: Serialize<Self, R, E>,
>(&mut self, first: bool, value: T) -> Result<R, E>;
T: Serialize,
>(&self, state: &mut S, first: bool, value: T) -> Result<R, E>;
fn visit_map<
V: MapVisitor<Self, R, E>,
>(&mut self, visitor: V) -> Result<R, E>;
V: MapVisitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
#[inline]
fn visit_named_map<
V: MapVisitor<Self, R, E>,
>(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_map(visitor)
V: MapVisitor<S, R, E>,
>(&self, state: &mut S, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_map(state, visitor)
}
fn visit_map_elt<
K: Serialize<Self, R, E>,
V: Serialize<Self, R, E>,
>(&mut self, first: bool, key: K, value: V) -> Result<R, E>;
K: Serialize,
V: Serialize,
>(&self, state: &mut S, first: bool, key: K, value: V) -> Result<R, E>;
}
pub trait SeqVisitor<S, R, E> {
fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
fn visit<
V: Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E>;
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
@ -127,7 +134,9 @@ pub trait SeqVisitor<S, R, E> {
}
pub trait MapVisitor<S, R, E> {
fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
fn visit<
V: Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E>;
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
@ -135,48 +144,76 @@ pub trait MapVisitor<S, R, E> {
}
}
///////////////////////////////////////////////////////////////////////////////
impl Serialize for () {
#[inline]
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_null(state)
}
}
///////////////////////////////////////////////////////////////////////////////
macro_rules! impl_serialize {
macro_rules! impl_visit {
($ty:ty, $method:ident) => {
impl<S: Visitor<R, E>, R, E> Serialize<S, R, E> for $ty {
impl Serialize for $ty {
#[inline]
fn serialize(&self, state: &mut S) -> Result<R, E> {
state.$method(*self)
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.$method(state, *self)
}
}
}
}
impl_serialize!(bool, visit_bool)
impl_serialize!(int, visit_int)
impl_serialize!(i8, visit_i8)
impl_serialize!(i16, visit_i16)
impl_serialize!(i32, visit_i32)
impl_serialize!(i64, visit_i64)
impl_serialize!(uint, visit_uint)
impl_serialize!(u8, visit_u8)
impl_serialize!(u16, visit_u16)
impl_serialize!(u32, visit_u32)
impl_serialize!(u64, visit_u64)
impl_serialize!(f32, visit_f32)
impl_serialize!(f64, visit_f64)
impl_serialize!(char, visit_char)
impl_visit!(bool, visit_bool)
impl_visit!(int, visit_int)
impl_visit!(i8, visit_i8)
impl_visit!(i16, visit_i16)
impl_visit!(i32, visit_i32)
impl_visit!(i64, visit_i64)
impl_visit!(uint, visit_uint)
impl_visit!(u8, visit_u8)
impl_visit!(u16, visit_u16)
impl_visit!(u32, visit_u32)
impl_visit!(u64, visit_u64)
impl_visit!(f32, visit_f32)
impl_visit!(f64, visit_f64)
impl_visit!(char, visit_char)
///////////////////////////////////////////////////////////////////////////////
impl<'a, S: Visitor<R, E>, R, E> Serialize<S, R, E> for &'a str {
impl<'a> Serialize for &'a str {
#[inline]
fn serialize(&self, s: &mut S) -> Result<R, E> {
s.visit_str(*self)
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_str(state, *self)
}
}
impl<S: Visitor<R, E>, R, E> Serialize<S, R, E> for String {
impl Serialize for String {
#[inline]
fn serialize(&self, s: &mut S) -> Result<R, E> {
s.visit_str(self.as_slice())
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_str(state, self.as_slice())
}
}
@ -198,20 +235,22 @@ impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
}
impl<
T: Serialize,
Iter: Iterator<T>,
S: Visitor<R, E>,
S,
R,
E,
T: Serialize<S, R, E>,
> SeqVisitor<S, R, E> for SeqIteratorVisitor<Iter> {
#[inline]
fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
fn visit<
V: Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
let first = self.first;
self.first = false;
match self.iter.next() {
Some(value) => {
let value = try!(state.visit_seq_elt(first, value));
let value = try!(visitor.visit_seq_elt(state, first, value));
Ok(Some(value))
}
None => Ok(None),
@ -227,74 +266,178 @@ impl<
///////////////////////////////////////////////////////////////////////////////
impl<
S: Visitor<R, E>,
R,
E,
T: Serialize<S, R, E>,
> Serialize<S, R, E> for Vec<T> {
T: Serialize,
> Serialize for Vec<T> {
#[inline]
fn serialize(&self, state: &mut S) -> Result<R, E> {
state.visit_seq(SeqIteratorVisitor::new(self.iter()))
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_seq(state, SeqIteratorVisitor::new(self.iter()))
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
'a,
S: Visitor<R, E>,
R,
E,
T0: Serialize<S, R, E>,
T1: Serialize<S, R, E>
> Serialize<S, R, E> for (T0, T1) {
#[inline]
fn serialize(&self, state: &mut S) -> Result<R, E> {
struct Visitor<'a, T0: 'a, T1: 'a> {
value: &'a (T0, T1),
state: uint,
macro_rules! tuple_impls {
($(
($($T:ident),+) {
$($state:pat => $method:ident,)+
}
)+) => {
$(
impl<
$($T: Serialize),+
> Serialize for ($($T,)+) {
#[inline]
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
struct Visitor<'a, $($T: 'a),+> {
state: uint,
tuple: &'a ($($T,)+),
}
impl<
'a,
S: self::Visitor<R, E>,
R,
E,
T0: Serialize<S, R, E>,
T1: Serialize<S, R, E>,
> SeqVisitor<S, R, E> for Visitor<'a, T0, T1> {
#[inline]
fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
match self.state {
0 => {
self.state += 1;
let (ref value, _) = *self.value;
let v = try!(state.visit_seq_elt(true, value));
Ok(Some(v))
}
1 => {
self.state += 1;
let (_, ref value) = *self.value;
let v = try!(state.visit_seq_elt(false, value));
Ok(Some(v))
}
_ => {
Ok(None)
impl<
'a,
S,
R,
E,
$($T: Serialize),+
> SeqVisitor<S, R, E> for Visitor<'a, $($T),+> {
fn visit<
V: self::Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
match self.state {
$(
$state => {
self.state += 1;
let value = self.tuple.$method();
let value = try!(visitor.visit_seq_elt(state, true, value));
Ok(Some(value))
}
)+
_ => {
Ok(None)
}
}
}
}
visitor.visit_seq(state, Visitor {
state: 0,
tuple: self,
})
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
let size = 2 - self.state;
(size, Some(size))
}
}
state.visit_seq(Visitor { value: self, state: 0 })
)+
}
}
tuple_impls! {
(T0) {
0 => ref0,
}
(T0, T1) {
0 => ref0,
1 => ref1,
}
(T0, T1, T2, T3) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
}
(T0, T1, T2, T3, T4) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
}
(T0, T1, T2, T3, T4, T5) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
}
(T0, T1, T2, T3, T4, T5, T6) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
}
(T0, T1, T2, T3, T4, T5, T6, T7) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
7 => ref7,
}
(T0, T1, T2, T3, T4, T5, T6, T7, T8) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
7 => ref7,
8 => ref8,
}
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
7 => ref7,
8 => ref8,
9 => ref9,
}
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
7 => ref7,
8 => ref8,
9 => ref9,
10 => ref10,
}
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
0 => ref0,
1 => ref1,
2 => ref2,
3 => ref3,
4 => ref4,
5 => ref5,
6 => ref6,
7 => ref7,
8 => ref8,
9 => ref9,
10 => ref10,
11 => ref11,
}
}
///////////////////////////////////////////////////////////////////////////////
@ -314,21 +457,23 @@ impl<K, V, Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
}
impl<
S: Visitor<R, E>,
K: Serialize,
V: Serialize,
Iter: Iterator<(K, V)>,
S,
R,
E,
K: Serialize<S, R, E>,
V: Serialize<S, R, E>,
Iter: Iterator<(K, V)>,
> MapVisitor<S, R, E> for MapIteratorVisitor<Iter> {
#[inline]
fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
fn visit<
V: Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
let first = self.first;
self.first = false;
match self.iter.next() {
Some((key, value)) => {
let value = try!(state.visit_map_elt(first, key, value));
let value = try!(visitor.visit_map_elt(state, first, key, value));
Ok(Some(value))
}
None => Ok(None)
@ -344,15 +489,17 @@ impl<
///////////////////////////////////////////////////////////////////////////////
impl<
S: Visitor<R, E>,
R,
E,
K: Serialize<S, R, E> + Ord,
V: Serialize<S, R, E>,
> Serialize<S, R, E> for TreeMap<K, V> {
K: Serialize + Ord,
V: Serialize,
> Serialize for TreeMap<K, V> {
#[inline]
fn serialize(&self, state: &mut S) -> Result<R, E> {
state.visit_map(MapIteratorVisitor::new(self.iter()))
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_map(state, MapIteratorVisitor::new(self.iter()))
}
}
@ -360,13 +507,15 @@ impl<
impl<
'a,
S: Visitor<R, E>,
R,
E,
T: Serialize<S, R, E>
> Serialize<S, R, E> for &'a T {
T: Serialize,
> Serialize for &'a T {
#[inline]
fn serialize(&self, state: &mut S) -> Result<R, E> {
(**self).serialize(state)
fn visit<
S,
R,
E,
V: Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
(**self).visit(state, visitor)
}
}