pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-12 13:11:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Serialization should have an error type

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-10-11 11:05:24 -07:00
parent 7b669ac4c0
commit 1c3a42ea56
2 changed files with 144 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/src/json/ser.rs
+40 -42
View File
@@ -1,6 +1,6 @@
use std::io;
use std::num::{FPNaN, FPInfinite};
use std::f64; use std::f64;
use std::io::{IoError, MemWriter};
use std::num::{FPNaN, FPInfinite};
use ser; use ser;
@@ -26,14 +26,14 @@ impl<W: Writer> Serializer<W> {
} }
} }
impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> { impl<W: Writer> ser::Visitor<(), IoError> for Serializer<W> {
#[inline] #[inline]
fn visit_null(&mut self) -> io::IoResult<()> { fn visit_null(&mut self) -> Result<(), IoError> {
self.writer.write_str("null") self.writer.write_str("null")
} }
#[inline] #[inline]
fn visit_bool(&mut self, value: bool) -> io::IoResult<()> { fn visit_bool(&mut self, value: bool) -> Result<(), IoError> {
if value { if value {
self.writer.write_str("true") self.writer.write_str("true")
} else { } else {
@@ -42,80 +42,79 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
} }
#[inline] #[inline]
fn visit_int(&mut self, value: int) -> io::IoResult<()> { fn visit_int(&mut self, value: int) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_i8(&mut self, value: i8) -> io::IoResult<()> { fn visit_i8(&mut self, value: i8) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_i16(&mut self, value: i16) -> io::IoResult<()> { fn visit_i16(&mut self, value: i16) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_i32(&mut self, value: i32) -> io::IoResult<()> { fn visit_i32(&mut self, value: i32) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_i64(&mut self, value: i64) -> io::IoResult<()> { fn visit_i64(&mut self, value: i64) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_uint(&mut self, value: uint) -> io::IoResult<()> { fn visit_uint(&mut self, value: uint) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_u8(&mut self, value: u8) -> io::IoResult<()> { fn visit_u8(&mut self, value: u8) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_u16(&mut self, value: u16) -> io::IoResult<()> { fn visit_u16(&mut self, value: u16) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_u32(&mut self, value: u32) -> io::IoResult<()> { fn visit_u32(&mut self, value: u32) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_u64(&mut self, value: u64) -> io::IoResult<()> { fn visit_u64(&mut self, value: u64) -> Result<(), IoError> {
write!(self.writer, "{}", value) write!(self.writer, "{}", value)
} }
#[inline] #[inline]
fn visit_f64(&mut self, value: f64) -> io::IoResult<()> { fn visit_f64(&mut self, value: f64) -> Result<(), IoError> {
fmt_f64_or_null(&mut self.writer, value) fmt_f64_or_null(&mut self.writer, value)
} }
#[inline] #[inline]
fn visit_char(&mut self, v: char) -> io::IoResult<()> { fn visit_char(&mut self, v: char) -> Result<(), IoError> {
escape_char(&mut self.writer, v) escape_char(&mut self.writer, v)
} }
#[inline] #[inline]
fn visit_str(&mut self, value: &str) -> io::IoResult<()> { fn visit_str(&mut self, value: &str) -> Result<(), IoError> {
escape_str(&mut self.writer, value) escape_str(&mut self.writer, value)
} }
#[inline] #[inline]
fn visit_seq< fn visit_seq<
V: ser::SeqVisitor<Serializer<W>, io::IoResult<()>> V: ser::SeqVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> io::IoResult<()> { >(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("[")); try!(self.writer.write_str("["));
loop { loop {
match visitor.visit(self) { match try!(visitor.visit(self)) {
Some(Ok(())) => { } Some(()) => { }
Some(Err(err)) => { return Err(err); }
None => { break; } None => { break; }
} }
} }
@@ -125,8 +124,8 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline] #[inline]
fn visit_seq_elt< fn visit_seq_elt<
T: ser::Serialize<Serializer<W>, io::IoResult<()>> T: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, value: T) -> io::IoResult<()> { >(&mut self, first: bool, value: T) -> Result<(), IoError> {
if !first { if !first {
try!(self.writer.write_str(",")); try!(self.writer.write_str(","));
} }
@@ -136,14 +135,13 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline] #[inline]
fn visit_map< fn visit_map<
V: ser::MapVisitor<Serializer<W>, io::IoResult<()>> V: ser::MapVisitor<Serializer<W>, (), IoError>
>(&mut self, mut visitor: V) -> io::IoResult<()> { >(&mut self, mut visitor: V) -> Result<(), IoError> {
try!(self.writer.write_str("{{")); try!(self.writer.write_str("{{"));
loop { loop {
match visitor.visit(self) { match try!(visitor.visit(self)) {
Some(Ok(())) => { } Some(()) => { }
Some(Err(err)) => { return Err(err); }
None => { break; } None => { break; }
} }
} }
@@ -153,9 +151,9 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
#[inline] #[inline]
fn visit_map_elt< fn visit_map_elt<
K: ser::Serialize<Serializer<W>, io::IoResult<()>>, K: ser::Serialize<Serializer<W>, (), IoError>,
V: ser::Serialize<Serializer<W>, io::IoResult<()>> V: ser::Serialize<Serializer<W>, (), IoError>
>(&mut self, first: bool, key: K, value: V) -> io::IoResult<()> { >(&mut self, first: bool, key: K, value: V) -> Result<(), IoError> {
if !first { if !first {
try!(self.writer.write_str(",")); try!(self.writer.write_str(","));
} }
@@ -167,7 +165,7 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
} }
#[inline] #[inline]
pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> { pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError> {
try!(wr.write_str("\"")); try!(wr.write_str("\""));
let mut start = 0; let mut start = 0;
@@ -201,18 +199,18 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
} }
#[inline] #[inline]
pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> { pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> Result<(), IoError> {
escape_bytes(wr, value.as_bytes()) escape_bytes(wr, value.as_bytes())
} }
#[inline] #[inline]
pub fn escape_char<W: Writer>(wr: &mut W, value: char) -> io::IoResult<()> { pub fn escape_char<W: Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
let mut buf = [0, .. 4]; let mut buf = [0, .. 4];
value.encode_utf8(buf); value.encode_utf8(buf);
escape_bytes(wr, buf) escape_bytes(wr, buf)
} }
fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> { fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
match value.classify() { match value.classify() {
FPNaN | FPInfinite => wr.write_str("null"), FPNaN | FPInfinite => wr.write_str("null"),
_ => wr.write_str(f64::to_str_digits(value, 6).as_slice()), _ => wr.write_str(f64::to_str_digits(value, 6).as_slice()),
@@ -221,9 +219,9 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> {
#[inline] #[inline]
pub fn to_vec< pub fn to_vec<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>> T: ser::Serialize<Serializer<MemWriter>, (), IoError>
>(value: &T) -> io::IoResult<Vec<u8>> { >(value: &T) -> Result<Vec<u8>, IoError> {
let writer = io::MemWriter::with_capacity(1024); let writer = MemWriter::with_capacity(1024);
let mut state = Serializer::new(writer); let mut state = Serializer::new(writer);
try!(value.serialize(&mut state)); try!(value.serialize(&mut state));
Ok(state.unwrap().unwrap()) Ok(state.unwrap().unwrap())
@@ -231,8 +229,8 @@ pub fn to_vec<
#[inline] #[inline]
pub fn to_string< pub fn to_string<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>> T: ser::Serialize<Serializer<MemWriter>, (), IoError>
>(value: &T) -> io::IoResult<Result<String, Vec<u8>>> { >(value: &T) -> Result<Result<String, Vec<u8>>, IoError> {
let vec = try!(to_vec(value)); let vec = try!(to_vec(value));
Ok(String::from_utf8(vec)) Ok(String::from_utf8(vec))
} }
serde2/src/ser.rs
+104 -87
View File
@@ -2,121 +2,123 @@ use std::collections::TreeMap;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
pub trait Serialize<S, R> { pub trait Serialize<S, R, E> {
fn serialize(&self, state: &mut S) -> R; fn serialize(&self, state: &mut S) -> Result<R, E>;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
pub trait Serializer<S, R> { pub trait Serializer<S, R, E> {
fn serialize<T: Serialize<S, R>>(&mut self, value: &T) -> R; fn serialize<
T: Serialize<S, R, E>,
>(&mut self, value: &T) -> Result<R, E>;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
pub trait Visitor<R> { pub trait Visitor<R, E> {
fn visit_null(&mut self) -> R; fn visit_null(&mut self) -> Result<R, E>;
fn visit_bool(&mut self, v: bool) -> R; fn visit_bool(&mut self, v: bool) -> Result<R, E>;
#[inline] #[inline]
fn visit_int(&mut self, v: int) -> R { fn visit_int(&mut self, v: int) -> Result<R, E> {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
#[inline] #[inline]
fn visit_i8(&mut self, v: i8) -> R { fn visit_i8(&mut self, v: i8) -> Result<R, E> {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
#[inline] #[inline]
fn visit_i16(&mut self, v: i16) -> R { fn visit_i16(&mut self, v: i16) -> Result<R, E> {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
#[inline] #[inline]
fn visit_i32(&mut self, v: i32) -> R { fn visit_i32(&mut self, v: i32) -> Result<R, E> {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
#[inline] #[inline]
fn visit_i64(&mut self, v: i64) -> R; fn visit_i64(&mut self, v: i64) -> Result<R, E>;
#[inline] #[inline]
fn visit_uint(&mut self, v: uint) -> R { fn visit_uint(&mut self, v: uint) -> Result<R, E> {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
#[inline] #[inline]
fn visit_u8(&mut self, v: u8) -> R { fn visit_u8(&mut self, v: u8) -> Result<R, E> {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
#[inline] #[inline]
fn visit_u16(&mut self, v: u16) -> R { fn visit_u16(&mut self, v: u16) -> Result<R, E> {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
#[inline] #[inline]
fn visit_u32(&mut self, v: u32) -> R { fn visit_u32(&mut self, v: u32) -> Result<R, E> {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
#[inline] #[inline]
fn visit_u64(&mut self, v: u64) -> R; fn visit_u64(&mut self, v: u64) -> Result<R, E>;
#[inline] #[inline]
fn visit_f32(&mut self, v: f32) -> R { fn visit_f32(&mut self, v: f32) -> Result<R, E> {
self.visit_f64(v as f64) self.visit_f64(v as f64)
} }
fn visit_f64(&mut self, v: f64) -> R; fn visit_f64(&mut self, v: f64) -> Result<R, E>;
fn visit_char(&mut self, value: char) -> R; fn visit_char(&mut self, value: char) -> Result<R, E>;
fn visit_str(&mut self, value: &str) -> R; fn visit_str(&mut self, value: &str) -> Result<R, E>;
fn visit_seq< fn visit_seq<
V: SeqVisitor<Self, R>, V: SeqVisitor<Self, R, E>,
>(&mut self, visitor: V) -> R; >(&mut self, visitor: V) -> Result<R, E>;
#[inline] #[inline]
fn visit_named_seq< fn visit_named_seq<
V: SeqVisitor<Self, R>, V: SeqVisitor<Self, R, E>,
>(&mut self, _name: &'static str, visitor: V) -> R { >(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(visitor) self.visit_seq(visitor)
} }
#[inline] #[inline]
fn visit_enum< fn visit_enum<
V: SeqVisitor<Self, R>, V: SeqVisitor<Self, R, E>,
>(&mut self, _name: &'static str, _variant: &'static str, visitor: V) -> R { >(&mut self, _name: &'static str, _variant: &'static str, visitor: V) -> Result<R, E> {
self.visit_seq(visitor) self.visit_seq(visitor)
} }
fn visit_seq_elt< fn visit_seq_elt<
T: Serialize<Self, R>, T: Serialize<Self, R, E>,
>(&mut self, first: bool, value: T) -> R; >(&mut self, first: bool, value: T) -> Result<R, E>;
fn visit_map< fn visit_map<
V: MapVisitor<Self, R>, V: MapVisitor<Self, R, E>,
>(&mut self, visitor: V) -> R; >(&mut self, visitor: V) -> Result<R, E>;
#[inline] #[inline]
fn visit_named_map< fn visit_named_map<
V: MapVisitor<Self, R>, V: MapVisitor<Self, R, E>,
>(&mut self, _name: &'static str, visitor: V) -> R { >(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
self.visit_map(visitor) self.visit_map(visitor)
} }
fn visit_map_elt< fn visit_map_elt<
K: Serialize<Self, R>, K: Serialize<Self, R, E>,
V: Serialize<Self, R>, V: Serialize<Self, R, E>,
>(&mut self, first: bool, key: K, value: V) -> R; >(&mut self, first: bool, key: K, value: V) -> Result<R, E>;
} }
pub trait SeqVisitor<S, R> { pub trait SeqVisitor<S, R, E> {
fn visit(&mut self, state: &mut S) -> Option<R>; fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
#[inline] #[inline]
fn size_hint(&self) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
@@ -124,8 +126,8 @@ pub trait SeqVisitor<S, R> {
} }
} }
pub trait MapVisitor<S, R> { pub trait MapVisitor<S, R, E> {
fn visit(&mut self, state: &mut S) -> Option<R>; fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
#[inline] #[inline]
fn size_hint(&self) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
@@ -138,9 +140,9 @@ pub trait MapVisitor<S, R> {
macro_rules! impl_serialize { macro_rules! impl_serialize {
($ty:ty, $method:ident) => { ($ty:ty, $method:ident) => {
impl<S: Visitor<R>, R> Serialize<S, R> for $ty { impl<S: Visitor<R, E>, R, E> Serialize<S, R, E> for $ty {
#[inline] #[inline]
fn serialize(&self, state: &mut S) -> R { fn serialize(&self, state: &mut S) -> Result<R, E> {
state.$method(*self) state.$method(*self)
} }
} }
@@ -164,16 +166,16 @@ impl_serialize!(char, visit_char)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl<'a, S: Visitor<R>, R> Serialize<S, R> for &'a str { impl<'a, S: Visitor<R, E>, R, E> Serialize<S, R, E> for &'a str {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn serialize(&self, s: &mut S) -> Result<R, E> {
s.visit_str(*self) s.visit_str(*self)
} }
} }
impl<S: Visitor<R>, R> Serialize<S, R> for String { impl<S: Visitor<R, E>, R, E> Serialize<S, R, E> for String {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn serialize(&self, s: &mut S) -> Result<R, E> {
s.visit_str(self.as_slice()) s.visit_str(self.as_slice())
} }
} }
@@ -196,19 +198,23 @@ impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
} }
impl< impl<
T: Serialize<S, R>,
Iter: Iterator<T>, Iter: Iterator<T>,
S: Visitor<R>, S: Visitor<R, E>,
R R,
> SeqVisitor<S, R> for SeqIteratorVisitor<Iter> { E,
T: Serialize<S, R, E>,
> SeqVisitor<S, R, E> for SeqIteratorVisitor<Iter> {
#[inline] #[inline]
fn visit(&mut self, state: &mut S) -> Option<R> { fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
match self.iter.next() { match self.iter.next() {
Some(value) => Some(state.visit_seq_elt(first, value)), Some(value) => {
None => None let value = try!(state.visit_seq_elt(first, value));
Ok(Some(value))
}
None => Ok(None),
} }
} }
@@ -221,12 +227,13 @@ impl<
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
S: Visitor<R>, S: Visitor<R, E>,
R, R,
T: Serialize<S, R> E,
> Serialize<S, R> for Vec<T> { T: Serialize<S, R, E>,
> Serialize<S, R, E> for Vec<T> {
#[inline] #[inline]
fn serialize(&self, state: &mut S) -> R { fn serialize(&self, state: &mut S) -> Result<R, E> {
state.visit_seq(SeqIteratorVisitor::new(self.iter())) state.visit_seq(SeqIteratorVisitor::new(self.iter()))
} }
} }
@@ -235,13 +242,14 @@ impl<
impl< impl<
'a, 'a,
S: Visitor<R>, S: Visitor<R, E>,
R, R,
T0: Serialize<S, R>, E,
T1: Serialize<S, R> T0: Serialize<S, R, E>,
> Serialize<S, R> for (T0, T1) { T1: Serialize<S, R, E>
> Serialize<S, R, E> for (T0, T1) {
#[inline] #[inline]
fn serialize(&self, state: &mut S) -> R { fn serialize(&self, state: &mut S) -> Result<R, E> {
struct Visitor<'a, T0: 'a, T1: 'a> { struct Visitor<'a, T0: 'a, T1: 'a> {
value: &'a (T0, T1), value: &'a (T0, T1),
state: uint, state: uint,
@@ -249,26 +257,29 @@ impl<
impl< impl<
'a, 'a,
S: self::Visitor<R>, S: self::Visitor<R, E>,
R, R,
T0: Serialize<S, R>, E,
T1: Serialize<S, R>, T0: Serialize<S, R, E>,
> SeqVisitor<S, R> for Visitor<'a, T0, T1> { T1: Serialize<S, R, E>,
> SeqVisitor<S, R, E> for Visitor<'a, T0, T1> {
#[inline] #[inline]
fn visit(&mut self, state: &mut S) -> Option<R> { fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
match self.state { match self.state {
0 => { 0 => {
self.state += 1; self.state += 1;
let (ref value, _) = *self.value; let (ref value, _) = *self.value;
Some(state.visit_seq_elt(true, value)) let v = try!(state.visit_seq_elt(true, value));
Ok(Some(v))
} }
1 => { 1 => {
self.state += 1; self.state += 1;
let (_, ref value) = *self.value; let (_, ref value) = *self.value;
Some(state.visit_seq_elt(false, value)) let v = try!(state.visit_seq_elt(false, value));
Ok(Some(v))
} }
_ => { _ => {
None Ok(None)
} }
} }
} }
@@ -303,20 +314,24 @@ impl<K, V, Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
} }
impl< impl<
K: Serialize<S, R>, S: Visitor<R, E>,
V: Serialize<S, R>, R,
E,
K: Serialize<S, R, E>,
V: Serialize<S, R, E>,
Iter: Iterator<(K, V)>, Iter: Iterator<(K, V)>,
S: Visitor<R>, > MapVisitor<S, R, E> for MapIteratorVisitor<Iter> {
R
> MapVisitor<S, R> for MapIteratorVisitor<Iter> {
#[inline] #[inline]
fn visit(&mut self, state: &mut S) -> Option<R> { fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
match self.iter.next() { match self.iter.next() {
Some((key, value)) => Some(state.visit_map_elt(first, key, value)), Some((key, value)) => {
None => None let value = try!(state.visit_map_elt(first, key, value));
Ok(Some(value))
}
None => Ok(None)
} }
} }
@@ -329,13 +344,14 @@ impl<
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
S: Visitor<R>, S: Visitor<R, E>,
R, R,
K: Serialize<S, R> + Ord, E,
V: Serialize<S, R> K: Serialize<S, R, E> + Ord,
> Serialize<S, R> for TreeMap<K, V> { V: Serialize<S, R, E>,
> Serialize<S, R, E> for TreeMap<K, V> {
#[inline] #[inline]
fn serialize(&self, state: &mut S) -> R { fn serialize(&self, state: &mut S) -> Result<R, E> {
state.visit_map(MapIteratorVisitor::new(self.iter())) state.visit_map(MapIteratorVisitor::new(self.iter()))
} }
} }
@@ -344,12 +360,13 @@ impl<
impl< impl<
'a, 'a,
S: Visitor<R>, S: Visitor<R, E>,
R, R,
T: Serialize<S, R> E,
> Serialize<S, R> for &'a T { T: Serialize<S, R, E>
> Serialize<S, R, E> for &'a T {
#[inline] #[inline]
fn serialize(&self, state: &mut S) -> R { fn serialize(&self, state: &mut S) -> Result<R, E> {
(**self).serialize(state) (**self).serialize(state)
} }
} }