Serialization should have an error type

serde2/src/json/ser.rs

@@ -1,6 +1,6 @@
-use std::io;
-use std::num::{FPNaN, FPInfinite};
 use std::f64;
+use std::io::{IoError, MemWriter};
+use std::num::{FPNaN, FPInfinite};
 
 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]
-    fn visit_null(&mut self) -> io::IoResult<()> {
+    fn visit_null(&mut self) -> Result<(), IoError> {
         self.writer.write_str("null")
     }
 
     #[inline]
-    fn visit_bool(&mut self, value: bool) -> io::IoResult<()> {
+    fn visit_bool(&mut self, value: bool) -> Result<(), IoError> {
         if value {
             self.writer.write_str("true")
         } else {
@@ -42,80 +42,79 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
     }
 
     #[inline]
-    fn visit_int(&mut self, value: int) -> io::IoResult<()> {
+    fn visit_int(&mut self, value: int) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i8(&mut self, value: i8) -> io::IoResult<()> {
+    fn visit_i8(&mut self, value: i8) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i16(&mut self, value: i16) -> io::IoResult<()> {
+    fn visit_i16(&mut self, value: i16) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i32(&mut self, value: i32) -> io::IoResult<()> {
+    fn visit_i32(&mut self, value: i32) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i64(&mut self, value: i64) -> io::IoResult<()> {
+    fn visit_i64(&mut self, value: i64) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_uint(&mut self, value: uint) -> io::IoResult<()> {
+    fn visit_uint(&mut self, value: uint) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u8(&mut self, value: u8) -> io::IoResult<()> {
+    fn visit_u8(&mut self, value: u8) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u16(&mut self, value: u16) -> io::IoResult<()> {
+    fn visit_u16(&mut self, value: u16) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u32(&mut self, value: u32) -> io::IoResult<()> {
+    fn visit_u32(&mut self, value: u32) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u64(&mut self, value: u64) -> io::IoResult<()> {
+    fn visit_u64(&mut self, value: u64) -> Result<(), IoError> {
         write!(self.writer, "{}", value)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[inline]
     fn visit_seq<
-        V: ser::SeqVisitor<Serializer<W>, io::IoResult<()>>
-    >(&mut self, mut visitor: V) -> io::IoResult<()> {
+        V: ser::SeqVisitor<Serializer<W>, (), IoError>
+    >(&mut self, mut visitor: V) -> Result<(), IoError> {
         try!(self.writer.write_str("["));
 
         loop {
-            match visitor.visit(self) {
-                Some(Ok(())) => { }
-                Some(Err(err)) => { return Err(err); }
+            match try!(visitor.visit(self)) {
+                Some(()) => { }
                 None => { break; }
             }
         }
@@ -125,8 +124,8 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
 
     #[inline]
     fn visit_seq_elt<
-        T: ser::Serialize<Serializer<W>, io::IoResult<()>>
-    >(&mut self, first: bool, value: T) -> io::IoResult<()> {
+        T: ser::Serialize<Serializer<W>, (), IoError>
+    >(&mut self, first: bool, value: T) -> Result<(), IoError> {
         if !first {
             try!(self.writer.write_str(","));
         }
@@ -136,14 +135,13 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
 
     #[inline]
     fn visit_map<
-        V: ser::MapVisitor<Serializer<W>, io::IoResult<()>>
-    >(&mut self, mut visitor: V) -> io::IoResult<()> {
+        V: ser::MapVisitor<Serializer<W>, (), IoError>
+    >(&mut self, mut visitor: V) -> Result<(), IoError> {
         try!(self.writer.write_str("{{"));
 
         loop {
-            match visitor.visit(self) {
-                Some(Ok(())) => { }
-                Some(Err(err)) => { return Err(err); }
+            match try!(visitor.visit(self)) {
+                Some(()) => { }
                 None => { break; }
             }
         }
@@ -153,9 +151,9 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
 
     #[inline]
     fn visit_map_elt<
-        K: ser::Serialize<Serializer<W>, io::IoResult<()>>,
-        V: ser::Serialize<Serializer<W>, io::IoResult<()>>
-    >(&mut self, first: bool, key: K, value: V) -> io::IoResult<()> {
+        K: ser::Serialize<Serializer<W>, (), IoError>,
+        V: ser::Serialize<Serializer<W>, (), IoError>
+    >(&mut self, first: bool, key: K, value: V) -> Result<(), IoError> {
         if !first {
             try!(self.writer.write_str(","));
         }
@@ -167,7 +165,7 @@ impl<W: Writer> ser::Visitor<io::IoResult<()>> for Serializer<W> {
 }
 
 #[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("\""));
 
     let mut start = 0;
@@ -201,18 +199,18 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
 }
 
 #[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())
 }
 
 #[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];
     value.encode_utf8(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() {
         FPNaN | FPInfinite => wr.write_str("null"),
         _ => 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]
 pub fn to_vec<
-    T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
->(value: &T) -> io::IoResult<Vec<u8>> {
-    let writer = io::MemWriter::with_capacity(1024);
+    T: ser::Serialize<Serializer<MemWriter>, (), IoError>
+>(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())
@@ -231,8 +229,8 @@ pub fn to_vec<
 
 #[inline]
 pub fn to_string<
-    T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
->(value: &T) -> io::IoResult<Result<String, Vec<u8>>> {
+    T: ser::Serialize<Serializer<MemWriter>, (), IoError>
+>(value: &T) -> Result<Result<String, Vec<u8>>, IoError> {
     let vec = try!(to_vec(value));
     Ok(String::from_utf8(vec))
 }

serde2/src/ser.rs

@@ -2,121 +2,123 @@ use std::collections::TreeMap;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub trait Serialize<S, R> {
-    fn serialize(&self, state: &mut S) -> R;
+pub trait Serialize<S, R, E> {
+    fn serialize(&self, state: &mut S) -> Result<R, E>;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub trait Serializer<S, R> {
-    fn serialize<T: Serialize<S, R>>(&mut self, value: &T) -> R;
+pub trait Serializer<S, R, E> {
+    fn serialize<
+        T: Serialize<S, R, E>,
+    >(&mut self, value: &T) -> Result<R, E>;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub trait Visitor<R> {
-    fn visit_null(&mut self) -> R;
+pub trait Visitor<R, E> {
+    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]
-    fn visit_int(&mut self, v: int) -> R {
+    fn visit_int(&mut self, v: int) -> Result<R, E> {
         self.visit_i64(v as i64)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[inline]
-    fn visit_i64(&mut self, v: i64) -> R;
+    fn visit_i64(&mut self, v: i64) -> Result<R, E>;
 
     #[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)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[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)
     }
 
     #[inline]
-    fn visit_u64(&mut self, v: u64) -> R;
+    fn visit_u64(&mut self, v: u64) -> Result<R, E>;
 
     #[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)
     }
 
-    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<
-        V: SeqVisitor<Self, R>,
-    >(&mut self, visitor: V) -> R;
+        V: SeqVisitor<Self, R, E>,
+    >(&mut self, visitor: V) -> Result<R, E>;
 
     #[inline]
     fn visit_named_seq<
-        V: SeqVisitor<Self, R>,
-    >(&mut self, _name: &'static str, visitor: V) -> R {
+        V: SeqVisitor<Self, R, E>,
+    >(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
         self.visit_seq(visitor)
     }
 
     #[inline]
     fn visit_enum<
-        V: SeqVisitor<Self, R>,
-    >(&mut self, _name: &'static str, _variant: &'static str, visitor: V) -> R {
+        V: SeqVisitor<Self, R, E>,
+    >(&mut self, _name: &'static str, _variant: &'static str, visitor: V) -> Result<R, E> {
         self.visit_seq(visitor)
     }
 
     fn visit_seq_elt<
-        T: Serialize<Self, R>,
-    >(&mut self, first: bool, value: T) -> R;
+        T: Serialize<Self, R, E>,
+    >(&mut self, first: bool, value: T) -> Result<R, E>;
 
     fn visit_map<
-        V: MapVisitor<Self, R>,
-    >(&mut self, visitor: V) -> R;
+        V: MapVisitor<Self, R, E>,
+    >(&mut self, visitor: V) -> Result<R, E>;
 
     #[inline]
     fn visit_named_map<
-        V: MapVisitor<Self, R>,
-    >(&mut self, _name: &'static str, visitor: V) -> R {
+        V: MapVisitor<Self, R, E>,
+    >(&mut self, _name: &'static str, visitor: V) -> Result<R, E> {
         self.visit_map(visitor)
     }
 
     fn visit_map_elt<
-        K: Serialize<Self, R>,
-        V: Serialize<Self, R>,
-    >(&mut self, first: bool, key: K, value: V) -> R;
+        K: Serialize<Self, R, E>,
+        V: Serialize<Self, R, E>,
+    >(&mut self, first: bool, key: K, value: V) -> Result<R, E>;
 }
 
-pub trait SeqVisitor<S, R> {
-    fn visit(&mut self, state: &mut S) -> Option<R>;
+pub trait SeqVisitor<S, R, E> {
+    fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
 
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
@@ -124,8 +126,8 @@ pub trait SeqVisitor<S, R> {
     }
 }
 
-pub trait MapVisitor<S, R> {
-    fn visit(&mut self, state: &mut S) -> Option<R>;
+pub trait MapVisitor<S, R, E> {
+    fn visit(&mut self, state: &mut S) -> Result<Option<R>, E>;
 
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
@@ -138,9 +140,9 @@ pub trait MapVisitor<S, R> {
 
 macro_rules! impl_serialize {
     ($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]
-            fn serialize(&self, state: &mut S) -> R {
+            fn serialize(&self, state: &mut S) -> Result<R, E> {
                 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]
-    fn serialize(&self, s: &mut S) -> R {
+    fn serialize(&self, s: &mut S) -> Result<R, E> {
         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]
-    fn serialize(&self, s: &mut S) -> R {
+    fn serialize(&self, s: &mut S) -> Result<R, E> {
         s.visit_str(self.as_slice())
     }
 }
@@ -196,19 +198,23 @@ impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
 }
 
 impl<
-    T: Serialize<S, R>,
     Iter: Iterator<T>,
-    S: Visitor<R>,
-    R
-> SeqVisitor<S, R> for SeqIteratorVisitor<Iter> {
+    S: Visitor<R, E>,
+    R,
+    E,
+    T: Serialize<S, R, E>,
+> SeqVisitor<S, R, E> for SeqIteratorVisitor<Iter> {
     #[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;
         self.first = false;
 
         match self.iter.next() {
-            Some(value) => Some(state.visit_seq_elt(first, value)),
-            None => None
+            Some(value) => {
+                let value = try!(state.visit_seq_elt(first, value));
+                Ok(Some(value))
+            }
+            None => Ok(None),
         }
     }
 
@@ -221,12 +227,13 @@ impl<
 ///////////////////////////////////////////////////////////////////////////////
 
 impl<
-    S: Visitor<R>,
+    S: Visitor<R, E>,
     R,
-    T: Serialize<S, R>
-> Serialize<S, R> for Vec<T> {
+    E,
+    T: Serialize<S, R, E>,
+> Serialize<S, R, E> for Vec<T> {
     #[inline]
-    fn serialize(&self, state: &mut S) -> R {
+    fn serialize(&self, state: &mut S) -> Result<R, E> {
         state.visit_seq(SeqIteratorVisitor::new(self.iter()))
     }
 }
@@ -235,13 +242,14 @@ impl<
 
 impl<
     'a,
-    S: Visitor<R>,
+    S: Visitor<R, E>,
     R,
-    T0: Serialize<S, R>,
-    T1: Serialize<S, R>
-> Serialize<S, R> for (T0, T1) {
+    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) -> R {
+    fn serialize(&self, state: &mut S) -> Result<R, E> {
         struct Visitor<'a, T0: 'a, T1: 'a> {
             value: &'a (T0, T1),
             state: uint,
@@ -249,26 +257,29 @@ impl<
 
         impl<
             'a,
-            S: self::Visitor<R>,
+            S: self::Visitor<R, E>,
             R,
-            T0: Serialize<S, R>,
-            T1: Serialize<S, R>,
-        > SeqVisitor<S, R> for Visitor<'a, T0, T1> {
+            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) -> Option<R> {
+            fn visit(&mut self, state: &mut S) -> Result<Option<R>, E> {
                 match self.state {
                     0 => {
                         self.state += 1;
                         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 => {
                         self.state += 1;
                         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<
-    K: Serialize<S, R>,
-    V: Serialize<S, R>,
+    S: Visitor<R, E>,
+    R,
+    E,
+    K: Serialize<S, R, E>,
+    V: Serialize<S, R, E>,
     Iter: Iterator<(K, V)>,
-    S: Visitor<R>,
-    R
-> MapVisitor<S, R> for MapIteratorVisitor<Iter> {
+> MapVisitor<S, R, E> for MapIteratorVisitor<Iter> {
     #[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;
         self.first = false;
 
         match self.iter.next() {
-            Some((key, value)) => Some(state.visit_map_elt(first, key, value)),
-            None => None
+            Some((key, value)) => {
+                let value = try!(state.visit_map_elt(first, key, value));
+                Ok(Some(value))
+            }
+            None => Ok(None)
         }
     }
 
@@ -329,13 +344,14 @@ impl<
 ///////////////////////////////////////////////////////////////////////////////
 
 impl<
-    S: Visitor<R>,
+    S: Visitor<R, E>,
     R,
-    K: Serialize<S, R> + Ord,
-    V: Serialize<S, R>
-> Serialize<S, R> for TreeMap<K, V> {
+    E,
+    K: Serialize<S, R, E> + Ord,
+    V: Serialize<S, R, E>,
+> Serialize<S, R, E> for TreeMap<K, V> {
     #[inline]
-    fn serialize(&self, state: &mut S) -> R {
+    fn serialize(&self, state: &mut S) -> Result<R, E> {
         state.visit_map(MapIteratorVisitor::new(self.iter()))
     }
 }
@@ -344,12 +360,13 @@ impl<
 
 impl<
     'a,
-    S: Visitor<R>,
+    S: Visitor<R, E>,
     R,
-    T: Serialize<S, R>
-> Serialize<S, R> for &'a T {
+    E,
+    T: Serialize<S, R, E>
+> Serialize<S, R, E> for &'a T {
     #[inline]
-    fn serialize(&self, state: &mut S) -> R {
+    fn serialize(&self, state: &mut S) -> Result<R, E> {
         (**self).serialize(state)
     }
 }