Merge pull request #8 from Michael-F-Bryan/serialize

Basic implementation of Serializer

Author: oli-obk

src/error.rs

@@ -1,13 +1,17 @@
 use xml::reader;
 use std::fmt::{self, Display, Debug};
 use std::error::Error as StdError;
-use std::num;
-use serde::de::Error as SerdeError;
+use std::num::ParseIntError;
+use std::io;
+use serde::de::Error as DeError;
+use serde::ser::Error as SerError;
 
 pub enum Error {
-    ParseIntError(num::ParseIntError),
+    ParseIntError(ParseIntError),
     Syntax(reader::Error),
     Custom(String),
+    Io(io::Error),
+    UnsupportedOperation(String),
 }
 
 pub type VResult<V> = Result<V, Error>;
@@ -55,6 +59,8 @@ impl Display for Error {
             Error::ParseIntError(ref error) => Display::fmt(error, fmt),
             Error::Syntax(ref error) => Display::fmt(error, fmt),
             Error::Custom(ref display) => Display::fmt(display, fmt),
+            Error::Io(ref err) => Display::fmt(err, fmt),
+            Error::UnsupportedOperation(ref msg) => write!(fmt, "Unsupported Operation: {}", msg),
         }
     }
 }
@@ -65,29 +71,46 @@ impl Debug for Error {
             Error::ParseIntError(ref error) => Display::fmt(error, fmt),
             Error::Syntax(ref error) => Debug::fmt(error, fmt),
             Error::Custom(ref display) => Display::fmt(display, fmt),
+            Error::Io(ref err) => Display::fmt(err, fmt),
+            Error::UnsupportedOperation(ref msg) => write!(fmt, "Unsupported Operation: {}", msg),
         }
     }
 }
 
+impl From<io::Error> for Error {
+    fn from(other: io::Error) -> Self {
+        Error::Io(other)
+    }
+}
+
 impl StdError for Error {
     fn description(&self) -> &str {
         match *self {
             Error::ParseIntError(ref error) => error.description(),
             Error::Syntax(ref error) => error.description(),
+            Error::Io(ref error) => error.description(),
             Error::Custom(_) => "other error",
+            Error::UnsupportedOperation(_) => "Unsupported Operation",
         }
     }
 
     fn cause(&self) -> Option<&StdError> {
         match *self {
             Error::ParseIntError(ref error) => Some(error),
             Error::Syntax(ref error) => Some(error),
+            Error::Io(ref error) => Some(error),
             _ => None,
         }
     }
 }
 
-impl SerdeError for Error {
+impl DeError for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Custom(msg.to_string())
+    }
+}
+
+impl SerError for Error {
     fn custom<T: Display>(msg: T) -> Self {
         Error::Custom(msg.to_string())
     }

src/lib.rs

@@ -4,14 +4,20 @@ extern crate serde;
 #[macro_use]
 extern crate log;
 
+#[cfg(test)]
+#[macro_use]
+extern crate serde_derive;
+
 #[macro_use]
 mod error;
 mod map;
 mod seq;
 mod var;
+mod serialize;
 
 pub use error::Error;
 pub use xml::reader::{EventReader, ParserConfig};
+pub use serialize::{serialize, Serializer};
 
 use error::VResult;
 use xml::reader::XmlEvent;
@@ -72,7 +78,7 @@ impl<'de, R: Read> Deserializer<R> {
                 XmlEvent::StartDocument { .. } |
                 XmlEvent::EndDocument { .. } |
                 XmlEvent::ProcessingInstruction { .. } |
-                XmlEvent::Comment(_) => { /* skip */ }
+                XmlEvent::Comment(_) => { /* skip */ },
 
                 other => return Ok(other),
             }
@@ -88,11 +94,11 @@ impl<'de, R: Read> Deserializer<R> {
         match next {
             XmlEvent::StartElement { .. } => {
                 self.depth += 1;
-            }
+            },
             XmlEvent::EndElement { .. } => {
                 self.depth -= 1;
-            }
-            _ => {}
+            },
+            _ => {},
         }
         debug!("Fetched {:?}", next);
         Ok(next)
@@ -106,10 +112,8 @@ impl<'de, R: Read> Deserializer<R> {
         ::std::mem::replace(&mut self.is_map_value, false)
     }
 
-    fn read_inner_value<V: Visitor<'de>, F: FnOnce(&mut Self) -> VResult<V::Value>>(
-        &mut self,
-        f: F,
-    ) -> VResult<V::Value> {
+    fn read_inner_value<V: Visitor<'de>, F: FnOnce(&mut Self) -> VResult<V::Value>>(&mut self, f: F)
+        -> VResult<V::Value> {
         if self.unset_map_value() {
             debug_expect!(self.next(), Ok(XmlEvent::StartElement { name, .. }) => {
                 let result = f(self)?;
@@ -162,12 +166,8 @@ impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
         newtype_struct identifier
     }
 
-    fn deserialize_struct<V: Visitor<'de>>(
-        self,
-        _name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> VResult<V::Value> {
+    fn deserialize_struct<V: Visitor<'de>>(self, _name: &'static str, fields: &'static [&'static str], visitor: V)
+        -> VResult<V::Value> {
         self.unset_map_value();
         expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
             let map_value = visitor.visit_map(MapAccess::new(
@@ -248,33 +248,21 @@ impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
         })
     }
 
-    fn deserialize_unit_struct<V: Visitor<'de>>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> VResult<V::Value> {
+    fn deserialize_unit_struct<V: Visitor<'de>>(self, _name: &'static str, visitor: V) -> VResult<V::Value> {
         self.deserialize_unit(visitor)
     }
 
-    fn deserialize_tuple_struct<V: Visitor<'de>>(
-        self,
-        _name: &'static str,
-        len: usize,
-        visitor: V,
-    ) -> VResult<V::Value> {
+    fn deserialize_tuple_struct<V: Visitor<'de>>(self, _name: &'static str, len: usize, visitor: V)
+        -> VResult<V::Value> {
         self.deserialize_tuple(len, visitor)
     }
 
     fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> VResult<V::Value> {
         visitor.visit_seq(SeqAccess::new(self, Some(len)))
     }
 
-    fn deserialize_enum<V: Visitor<'de>>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> VResult<V::Value> {
+    fn deserialize_enum<V: Visitor<'de>>(self, _name: &'static str, _variants: &'static [&'static str], visitor: V)
+        -> VResult<V::Value> {
         self.read_inner_value::<V, _>(|this| visitor.visit_enum(EnumAccess::new(this)))
     }