From b8787a29a3a8d4bdeedecccbd2ab3a9b386f7683 Mon Sep 17 00:00:00 2001
From: Edward Barnard
Date: Sat, 7 Jan 2017 10:53:37 +0000
Subject: Support Serde 0.8. Bump minimum Rust version to 0.15.

---
 src/de.rs        | 276 ----------------------------------------------
 src/lib.rs       |  26 ++---
 src/ser.rs       | 186 -------------------------------
 src/serde/de.rs  | 285 +++++++++++++++++++++++++++++++++++++++++++++++
 src/serde/mod.rs |  24 ++++
 src/serde/ser.rs | 329 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 645 insertions(+), 481 deletions(-)
 delete mode 100644 src/de.rs
 delete mode 100644 src/ser.rs
 create mode 100644 src/serde/de.rs
 create mode 100644 src/serde/mod.rs
 create mode 100644 src/serde/ser.rs

(limited to 'src')

diff --git a/src/de.rs b/src/de.rs
deleted file mode 100644
index 1d9531c..0000000
--- a/src/de.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-// Tests for the serializer and deserializer are located in tests/serde_/mod.rs.
-// They can be run with `cargo test --features serde_tests`.
-
-use serde::de::{Deserializer as SerdeDeserializer, Error as SerdeError, Visitor, SeqVisitor,
-                MapVisitor, VariantVisitor, Deserialize, EnumVisitor};
-use std::iter::Peekable;
-
-use {Error, PlistEvent, u64_option_to_usize};
-
-macro_rules! expect {
-    ($next:expr, $pat:pat) => {
-        match $next {
-            Some(Ok(v@$pat)) => v,
-            None => return Err(Error::UnexpectedEof),
-            _ => return Err(event_mismatch_error())
-        }
-    };
-    ($next:expr, $pat:pat => $save:expr) => {
-        match $next {
-            Some(Ok($pat)) => $save,
-            None => return Err(Error::UnexpectedEof),
-            _ => return Err(event_mismatch_error())
-        }
-    };
-}
-
-macro_rules! try_next {
-    ($next:expr) => {
-        match $next {
-            Some(Ok(v)) => v,
-            Some(Err(_)) => return Err(event_mismatch_error()),
-            None => return Err(Error::UnexpectedEof)
-        }
-    }
-}
-
-fn event_mismatch_error() -> Error {
-    Error::InvalidData
-}
-
-impl SerdeError for Error {
-    fn custom<T: Into<String>>(msg: T) -> Self {
-        Error::Serde(msg.into())
-    }
-
-    fn end_of_stream() -> Self {
-        Error::UnexpectedEof
-    }
-}
-
-pub struct Deserializer<I>
-    where I: IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    events: Peekable<<I as IntoIterator>::IntoIter>,
-}
-
-impl<I> Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    pub fn new(iter: I) -> Deserializer<I> {
-        Deserializer { events: iter.into_iter().peekable() }
-    }
-}
-
-impl<I> SerdeDeserializer for Deserializer<I>
-    where I: IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    type Error = Error;
-
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        match try_next!(self.events.next()) {
-            PlistEvent::StartArray(len) => {
-                let len = try!(u64_option_to_usize(len));
-                visitor.visit_seq(MapSeq::new(self, len))
-            }
-            PlistEvent::EndArray => return Err(event_mismatch_error()),
-
-            PlistEvent::StartDictionary(len) => {
-                let len = try!(u64_option_to_usize(len));
-                visitor.visit_map(MapSeq::new(self, len))
-            }
-            PlistEvent::EndDictionary => return Err(event_mismatch_error()),
-
-            PlistEvent::BooleanValue(v) => visitor.visit_bool(v),
-            PlistEvent::DataValue(v) => visitor.visit_byte_buf(v),
-            PlistEvent::DateValue(v) => visitor.visit_string(v.to_rfc3339()),
-            PlistEvent::IntegerValue(v) if v.is_positive() => visitor.visit_u64(v as u64),
-            PlistEvent::IntegerValue(v) => visitor.visit_i64(v as i64),
-            PlistEvent::RealValue(v) => visitor.visit_f64(v),
-            PlistEvent::StringValue(v) => visitor.visit_string(v),
-        }
-    }
-
-    fn deserialize_unit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        expect!(self.events.next(), PlistEvent::StringValue(_));
-        visitor.visit_unit()
-    }
-
-    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        expect!(self.events.next(), PlistEvent::StartDictionary(_));
-
-        let ret = match try_next!(self.events.next()) {
-            PlistEvent::StringValue(ref s) if &s[..] == "None" => {
-                let ret = match visitor.visit_none() {
-                    Ok(ret) => ret,
-                    Err(e) => return Err(e),
-                };
-                // For some reason the try! below doesn't work - probably a macro hygene issue
-                // with Error and ::Error
-                // let ret = try!(visitor.visit_none());
-                expect!(self.events.next(), PlistEvent::StringValue(_));
-                ret
-            }
-            PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)),
-            _ => return Err(event_mismatch_error()),
-        };
-
-        expect!(self.events.next(), PlistEvent::EndDictionary);
-
-        Ok(ret)
-    }
-
-    fn deserialize_newtype_struct<V>(&mut self,
-                               _name: &'static str,
-                               mut visitor: V)
-                               -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_enum<V>(&mut self,
-                     _enum: &'static str,
-                     _variants: &'static [&'static str],
-                     mut visitor: V)
-                     -> Result<V::Value, Self::Error>
-        where V: EnumVisitor
-    {
-        expect!(self.events.next(), PlistEvent::StartDictionary(_));
-        let ret = try!(visitor.visit(&mut *self));
-        expect!(self.events.next(), PlistEvent::EndDictionary);
-        Ok(ret)
-    }
-}
-
-impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize
-    {
-        <V as Deserialize>::deserialize(self)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        <() as Deserialize>::deserialize(self)
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: Deserialize
-    {
-        <T as Deserialize>::deserialize(self)
-    }
-
-    fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        <Self as SerdeDeserializer>::deserialize_tuple(self, len, visitor)
-    }
-
-    fn visit_struct<V>(&mut self,
-                       fields: &'static [&'static str],
-                       visitor: V)
-                       -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        let name = "";
-        <Self as SerdeDeserializer>::deserialize_struct(self, name, fields, visitor)
-    }
-}
-
-struct MapSeq<'a, I>
-    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    de: &'a mut Deserializer<I>,
-    remaining: Option<usize>,
-    finished: bool,
-}
-
-impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapSeq<'a, I> {
-        MapSeq {
-            de: de,
-            remaining: len,
-            finished: false,
-        }
-    }
-}
-
-impl<'a, I> SeqVisitor for MapSeq<'a, I>
-    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
-        where T: Deserialize
-    {
-        match self.de.events.peek() {
-            Some(&Ok(PlistEvent::EndArray)) => {
-                self.de.events.next();
-                self.finished = true;
-                return Ok(None);
-            }
-            _ => <T as Deserialize>::deserialize(self.de).map(|k| Some(k)),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Self::Error> {
-        if !self.finished {
-            self.finished = true;
-            expect!(self.de.events.next(), PlistEvent::EndArray);
-        }
-        Ok(())
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        <Self as MapVisitor>::size_hint(self)
-    }
-}
-
-impl<'a, I> MapVisitor for MapSeq<'a, I>
-    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
-{
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-        where K: Deserialize
-    {
-        match self.de.events.peek() {
-            Some(&Ok(PlistEvent::EndDictionary)) => {
-                self.de.events.next();
-                self.finished = true;
-                return Ok(None);
-            }
-            _ => <K as Deserialize>::deserialize(self.de).map(|k| Some(k)),
-        }
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize
-    {
-        <V as Deserialize>::deserialize(self.de)
-    }
-
-    fn end(&mut self) -> Result<(), Self::Error> {
-        if !self.finished {
-            self.finished = true;
-            expect!(self.de.events.next(), PlistEvent::EndDictionary);
-        }
-        Ok(())
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.remaining {
-            Some(len) => (len, Some(len)),
-            None => (0, None),
-        }
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index e63e18e..c3ef24b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -38,38 +38,26 @@
 extern crate byteorder;
 extern crate chrono;
 extern crate rustc_serialize;
-extern crate serde;
 extern crate xml as xml_rs;
 
 pub mod binary;
 pub mod xml;
 
 mod builder;
-mod de;
-mod ser;
 
-pub use de::Deserializer;
-pub use ser::Serializer;
+// Optional serde module
+#[cfg(feature = "serde")]
+#[macro_use]
+extern crate serde as serde_base;
+#[cfg(feature = "serde")]
+pub mod serde;
 
 use chrono::{DateTime, UTC};
-use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::fmt;
-use std::io::{Read, Seek, SeekFrom, Write};
+use std::io::{Read, Seek, SeekFrom};
 use std::io::Error as IoError;
 
-pub fn deserialize<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> {
-    let reader = EventReader::new(reader);
-    let mut de = Deserializer::new(reader);
-    Deserialize::deserialize(&mut de)
-}
-
-pub fn serialize_to_xml<W: Write, T: Serialize>(writer: W, value: &T) -> Result<()> {
-    let writer = xml::EventWriter::new(writer);
-    let mut ser = Serializer::new(writer);
-    value.serialize(&mut ser)
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub enum Plist {
     Array(Vec<Plist>),
diff --git a/src/ser.rs b/src/ser.rs
deleted file mode 100644
index 54294b5..0000000
--- a/src/ser.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Tests for the serializer and deserializer are located in tests/serde_/mod.rs.
-// They can be run with `cargo test --features serde_tests`.
-
-use serde::ser::{Error as SerdeError, MapVisitor, Serialize, Serializer as SerdeSerializer, SeqVisitor};
-
-use {Error, EventWriter, PlistEvent};
-
-impl SerdeError for Error {
-    fn custom<T: Into<String>>(msg: T) -> Self {
-        Error::Serde(msg.into())
-    }
-
-    fn invalid_value(_: &str) -> Self {
-        Error::InvalidData
-    }
-}
-
-pub struct Serializer<W: EventWriter> {
-    writer: W,
-}
-
-impl<W: EventWriter> Serializer<W> {
-    pub fn new(writer: W) -> Serializer<W> {
-        Serializer { writer: writer }
-    }
-
-    #[inline]
-    fn emit(&mut self, event: PlistEvent) -> Result<(), Error> {
-        self.writer.write(&event)
-    }
-
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-
-    fn single_key_dict<F>(&mut self,
-                          key: String,
-                          value_fn: F)
-                          -> Result<(), <Self as SerdeSerializer>::Error>
-        where F: FnOnce(&mut Serializer<W>) -> Result<(), <Self as SerdeSerializer>::Error>
-    {
-        // Emit {key: value}
-        try!(self.emit(PlistEvent::StartDictionary(Some(1))));
-        try!(self.emit(PlistEvent::StringValue(key)));
-        try!(value_fn(self));
-        try!(self.emit(PlistEvent::EndDictionary));
-        Ok(())
-    }
-}
-
-impl<W: EventWriter> SerdeSerializer for Serializer<W> {
-    type Error = Error;
-
-    fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::BooleanValue(v))
-    }
-
-    fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::IntegerValue(v))
-    }
-
-    fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::IntegerValue(v as i64))
-    }
-
-    fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::RealValue(v))
-    }
-
-    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::StringValue(value.to_owned()))
-    }
-
-    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::DataValue(value.to_owned()))
-    }
-
-    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
-        // Emit empty string
-        self.emit(PlistEvent::StringValue(String::new()))
-    }
-
-    fn serialize_none(&mut self) -> Result<(), Self::Error> {
-        self.single_key_dict("None".to_owned(), |this| this.serialize_unit())
-    }
-
-    fn serialize_some<V>(&mut self, value: V) -> Result<(), Self::Error>
-        where V: Serialize
-    {
-        self.single_key_dict("Some".to_owned(), |this| value.serialize(this))
-    }
-
-    fn serialize_seq<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
-        where V: SeqVisitor
-    {
-        let len = visitor.len().map(|len| len as u64);
-        try!(self.emit(PlistEvent::StartArray(len)));
-        loop {
-            match try!(visitor.visit(self)) {
-                Some(()) => (),
-                None => break,
-            }
-        }
-        try!(self.emit(PlistEvent::EndArray));
-        Ok(())
-    }
-
-    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_map<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
-        where V: MapVisitor
-    {
-        let len = visitor.len().map(|len| len as u64);
-        try!(self.emit(PlistEvent::StartDictionary(len)));
-        loop {
-            match try!(visitor.visit(self)) {
-                Some(()) => (),
-                None => break,
-            }
-        }
-        try!(self.emit(PlistEvent::EndDictionary));
-        Ok(())
-    }
-
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
-        where K: Serialize,
-              V: Serialize
-    {
-        try!(key.serialize(self));
-        try!(value.serialize(self));
-        Ok(())
-    }
-
-    fn serialize_unit_variant(&mut self,
-                          _name: &'static str,
-                          _variant_index: usize,
-                          variant: &'static str)
-                          -> Result<(), Self::Error> {
-        self.single_key_dict(variant.to_owned(), |this| this.serialize_unit())
-    }
-
-    fn serialize_newtype_struct<T>(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T>(&mut self,
-                                _name: &'static str,
-                                _variant_index: usize,
-                                variant: &'static str,
-                                value: T)
-                                -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        self.single_key_dict(variant.to_owned(), |this| value.serialize(this))
-    }
-
-    fn serialize_tuple_variant<V>(&mut self,
-                              _name: &'static str,
-                              _variant_index: usize,
-                              variant: &'static str,
-                              visitor: V)
-                              -> Result<(), Self::Error>
-        where V: SeqVisitor
-    {
-        self.single_key_dict(variant.to_owned(),
-                             |this| this.serialize_tuple_struct(variant, visitor))
-    }
-
-    fn serialize_struct_variant<V>(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               variant: &'static str,
-                               visitor: V)
-                               -> Result<(), Self::Error>
-        where V: MapVisitor
-    {
-        self.single_key_dict(variant.to_owned(),
-                             |this| this.serialize_struct(variant, visitor))
-    }
-}
diff --git a/src/serde/de.rs b/src/serde/de.rs
new file mode 100644
index 0000000..f888852
--- /dev/null
+++ b/src/serde/de.rs
@@ -0,0 +1,285 @@
+// Tests for the serializer and deserializer are located in tests/serde_/mod.rs.
+// They can be run with `cargo test --features serde_tests`.
+
+use serde_base::de::{Deserializer as SerdeDeserializer, Error as SerdeError, Visitor, SeqVisitor,
+                     MapVisitor, VariantVisitor, Deserialize, EnumVisitor};
+use std::iter::Peekable;
+
+use {Error, PlistEvent, u64_option_to_usize};
+
+macro_rules! expect {
+    ($next:expr, $pat:pat) => {
+        match $next {
+            Some(Ok(v@$pat)) => v,
+            None => return Err(Error::UnexpectedEof),
+            _ => return Err(event_mismatch_error())
+        }
+    };
+    ($next:expr, $pat:pat => $save:expr) => {
+        match $next {
+            Some(Ok($pat)) => $save,
+            None => return Err(Error::UnexpectedEof),
+            _ => return Err(event_mismatch_error())
+        }
+    };
+}
+
+macro_rules! try_next {
+    ($next:expr) => {
+        match $next {
+            Some(Ok(v)) => v,
+            Some(Err(_)) => return Err(event_mismatch_error()),
+            None => return Err(Error::UnexpectedEof)
+        }
+    }
+}
+
+fn event_mismatch_error() -> Error {
+    Error::InvalidData
+}
+
+impl SerdeError for Error {
+    fn custom<T: Into<String>>(msg: T) -> Self {
+        Error::Serde(msg.into())
+    }
+
+    fn end_of_stream() -> Self {
+        Error::UnexpectedEof
+    }
+}
+
+pub struct Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    events: Peekable<<I as IntoIterator>::IntoIter>,
+}
+
+impl<I> Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    pub fn new(iter: I) -> Deserializer<I> {
+        Deserializer { events: iter.into_iter().peekable() }
+    }
+}
+
+impl<I> SerdeDeserializer for Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        match try_next!(self.events.next()) {
+            PlistEvent::StartArray(len) => {
+                let len = try!(u64_option_to_usize(len));
+                visitor.visit_seq(MapAndSeqVisitor::new(self, len))
+            }
+            PlistEvent::EndArray => return Err(event_mismatch_error()),
+
+            PlistEvent::StartDictionary(len) => {
+                let len = try!(u64_option_to_usize(len));
+                visitor.visit_map(MapAndSeqVisitor::new(self, len))
+            }
+            PlistEvent::EndDictionary => return Err(event_mismatch_error()),
+
+            PlistEvent::BooleanValue(v) => visitor.visit_bool(v),
+            PlistEvent::DataValue(v) => visitor.visit_byte_buf(v),
+            PlistEvent::DateValue(v) => visitor.visit_string(v.to_rfc3339()),
+            PlistEvent::IntegerValue(v) if v.is_positive() => visitor.visit_u64(v as u64),
+            PlistEvent::IntegerValue(v) => visitor.visit_i64(v as i64),
+            PlistEvent::RealValue(v) => visitor.visit_f64(v),
+            PlistEvent::StringValue(v) => visitor.visit_string(v),
+        }
+    }
+
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        seq seq_fixed_size bytes map unit_struct
+        tuple_struct struct struct_field tuple ignored_any
+    }
+
+    fn deserialize_unit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        expect!(self.events.next(), PlistEvent::StringValue(_));
+        visitor.visit_unit()
+    }
+
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        expect!(self.events.next(), PlistEvent::StartDictionary(_));
+
+        let ret = match try_next!(self.events.next()) {
+            PlistEvent::StringValue(ref s) if &s[..] == "None" => {
+                let ret = match visitor.visit_none() {
+                    Ok(ret) => ret,
+                    Err(e) => return Err(e),
+                };
+                // For some reason the try! below doesn't work - probably a macro hygene issue
+                // with Error and ::Error
+                // let ret = try!(visitor.visit_none());
+                expect!(self.events.next(), PlistEvent::StringValue(_));
+                ret
+            }
+            PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)),
+            _ => return Err(event_mismatch_error()),
+        };
+
+        expect!(self.events.next(), PlistEvent::EndDictionary);
+
+        Ok(ret)
+    }
+
+    fn deserialize_newtype_struct<V>(&mut self,
+                                     _name: &'static str,
+                                     mut visitor: V)
+                                     -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_enum<V>(&mut self,
+                           _enum: &'static str,
+                           _variants: &'static [&'static str],
+                           mut visitor: V)
+                           -> Result<V::Value, Self::Error>
+        where V: EnumVisitor
+    {
+        expect!(self.events.next(), PlistEvent::StartDictionary(_));
+        let ret = try!(visitor.visit(&mut *self));
+        expect!(self.events.next(), PlistEvent::EndDictionary);
+        Ok(ret)
+    }
+}
+
+impl<I> VariantVisitor for Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize
+    {
+        <V as Deserialize>::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        <() as Deserialize>::deserialize(self)
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: Deserialize
+    {
+        <T as Deserialize>::deserialize(self)
+    }
+
+    fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        <Self as SerdeDeserializer>::deserialize_tuple(self, len, visitor)
+    }
+
+    fn visit_struct<V>(&mut self,
+                       fields: &'static [&'static str],
+                       visitor: V)
+                       -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        let name = "";
+        <Self as SerdeDeserializer>::deserialize_struct(self, name, fields, visitor)
+    }
+}
+
+struct MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    de: &'a mut Deserializer<I>,
+    remaining: Option<usize>,
+    finished: bool,
+}
+
+impl<'a, I> MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapAndSeqVisitor<'a, I> {
+        MapAndSeqVisitor {
+            de: de,
+            remaining: len,
+            finished: false,
+        }
+    }
+}
+
+impl<'a, I> SeqVisitor for MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: Deserialize
+    {
+        match self.de.events.peek() {
+            Some(&Ok(PlistEvent::EndArray)) => {
+                self.de.events.next();
+                self.finished = true;
+                return Ok(None);
+            }
+            _ => <T as Deserialize>::deserialize(self.de).map(|k| Some(k)),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Self::Error> {
+        if !self.finished {
+            self.finished = true;
+            expect!(self.de.events.next(), PlistEvent::EndArray);
+        }
+        Ok(())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        <Self as MapVisitor>::size_hint(self)
+    }
+}
+
+impl<'a, I> MapVisitor for MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
+        where K: Deserialize
+    {
+        match self.de.events.peek() {
+            Some(&Ok(PlistEvent::EndDictionary)) => {
+                self.de.events.next();
+                self.finished = true;
+                return Ok(None);
+            }
+            _ => <K as Deserialize>::deserialize(self.de).map(|k| Some(k)),
+        }
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize
+    {
+        <V as Deserialize>::deserialize(self.de)
+    }
+
+    fn end(&mut self) -> Result<(), Self::Error> {
+        if !self.finished {
+            self.finished = true;
+            expect!(self.de.events.next(), PlistEvent::EndDictionary);
+        }
+        Ok(())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.remaining {
+            Some(len) => (len, Some(len)),
+            None => (0, None),
+        }
+    }
+}
diff --git a/src/serde/mod.rs b/src/serde/mod.rs
new file mode 100644
index 0000000..0c2d7fa
--- /dev/null
+++ b/src/serde/mod.rs
@@ -0,0 +1,24 @@
+mod de;
+mod ser;
+
+pub use self::de::Deserializer;
+pub use self::ser::Serializer;
+
+use serde_base::{Deserialize, Serialize};
+use std::io::{Read, Seek, Write};
+
+use Result;
+use xml::EventReader;
+use xml::EventWriter;
+
+pub fn deserialize<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> {
+    let reader = EventReader::new(reader);
+    let mut de = Deserializer::new(reader);
+    Deserialize::deserialize(&mut de)
+}
+
+pub fn serialize_to_xml<W: Write, T: Serialize>(writer: W, value: &T) -> Result<()> {
+    let writer = EventWriter::new(writer);
+    let mut ser = Serializer::new(writer);
+    value.serialize(&mut ser)
+}
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
new file mode 100644
index 0000000..2875ed2
--- /dev/null
+++ b/src/serde/ser.rs
@@ -0,0 +1,329 @@
+// Tests for the serializer and deserializer are located in tests/serde_/mod.rs.
+// They can be run with `cargo test --features serde_tests`.
+
+use serde_base::ser::{Error as SerdeError, Serialize, Serializer as SerdeSerializer};
+
+use {Error, EventWriter, PlistEvent};
+
+impl SerdeError for Error {
+    fn custom<T: Into<String>>(msg: T) -> Self {
+        Error::Serde(msg.into())
+    }
+
+    fn invalid_value(_: &str) -> Self {
+        Error::InvalidData
+    }
+}
+
+pub struct Serializer<W: EventWriter> {
+    writer: W,
+}
+
+impl<W: EventWriter> Serializer<W> {
+    pub fn new(writer: W) -> Serializer<W> {
+        Serializer { writer: writer }
+    }
+
+    #[inline]
+    fn emit(&mut self, event: PlistEvent) -> Result<(), <Self as SerdeSerializer>::Error> {
+        Ok(self.writer.write(&event)?)
+    }
+
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+
+    // Emit {key: value}
+    fn single_key_dict(&mut self, key: String) -> Result<(), <Self as SerdeSerializer>::Error> {
+        try!(self.emit(PlistEvent::StartDictionary(Some(1))));
+        try!(self.emit(PlistEvent::StringValue(key)));
+        Ok(())
+    }
+
+    fn single_key_dict_end(&mut self) -> Result<(), <Self as SerdeSerializer>::Error> {
+        try!(self.emit(PlistEvent::EndDictionary));
+        Ok(())
+    }
+}
+
+impl<W: EventWriter> SerdeSerializer for Serializer<W> {
+    type Error = Error;
+    type SeqState = ();
+    type TupleState = ();
+    type TupleStructState = ();
+    type TupleVariantState = ();
+    type MapState = ();
+    type StructState = ();
+    type StructVariantState = ();
+
+    fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::BooleanValue(v))
+    }
+
+    fn serialize_isize(&mut self, v: isize) -> Result<(), Self::Error> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error> {
+        self.serialize_i64(v as i64)
+    }
+
+    fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::IntegerValue(v))
+    }
+
+    fn serialize_usize(&mut self, v: usize) -> Result<(), Self::Error> {
+        self.serialize_u64(v as u64)
+    }
+
+    fn serialize_u8(&mut self, v: u8) -> Result<(), Self::Error> {
+        self.serialize_u64(v as u64)
+    }
+
+    fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error> {
+        self.serialize_u64(v as u64)
+    }
+
+    fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error> {
+        self.serialize_u64(v as u64)
+    }
+
+    fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::IntegerValue(v as i64))
+    }
+
+    fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error> {
+        self.serialize_f64(v as f64)
+    }
+
+    fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::RealValue(v))
+    }
+
+    fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> {
+        let sstr = v.to_string();
+        self.serialize_str(&sstr)
+    }
+
+    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::StringValue(value.to_owned()))
+    }
+
+    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::DataValue(value.to_owned()))
+    }
+
+    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
+        // Emit empty string
+        self.emit(PlistEvent::StringValue(String::new()))
+    }
+
+    fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              variant: &'static str)
+                              -> Result<(), Self::Error> {
+        self.single_key_dict(variant.to_owned())?;
+        self.serialize_unit()?;
+        self.single_key_dict_end()?;
+        Ok(())
+    }
+
+    fn serialize_newtype_struct<T: Serialize>(&mut self,
+                                              _name: &'static str,
+                                              value: T)
+                                              -> Result<(), Self::Error> {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: Serialize>(&mut self,
+                                               _name: &'static str,
+                                               _variant_index: usize,
+                                               variant: &'static str,
+                                               value: T)
+                                               -> Result<(), Self::Error> {
+        self.single_key_dict(variant.to_owned())?;
+        value.serialize(self)?;
+        self.single_key_dict_end()
+    }
+
+    fn serialize_none(&mut self) -> Result<(), Self::Error> {
+        self.single_key_dict("None".to_owned())?;
+        self.serialize_unit()?;
+        self.single_key_dict_end()
+    }
+
+    fn serialize_some<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error> {
+        self.single_key_dict("Some".to_owned())?;
+        value.serialize(self)?;
+        self.single_key_dict_end()
+    }
+
+    fn serialize_seq(&mut self, len: Option<usize>) -> Result<Self::SeqState, Self::Error> {
+        let len = len.map(|len| len as u64);
+        self.emit(PlistEvent::StartArray(len))
+    }
+
+    fn serialize_seq_elt<T: Serialize>(&mut self,
+                                       _state: &mut Self::SeqState,
+                                       value: T)
+                                       -> Result<(), Self::Error> {
+        value.serialize(self)
+    }
+
+    fn serialize_seq_end(&mut self, _state: Self::SeqState) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::EndArray)
+    }
+
+    fn serialize_seq_fixed_size(&mut self, size: usize) -> Result<Self::SeqState, Self::Error> {
+        self.serialize_seq(Some(size))
+    }
+
+    fn serialize_tuple(&mut self, len: usize) -> Result<Self::TupleState, Self::Error> {
+        self.serialize_seq_fixed_size(len)
+    }
+
+    fn serialize_tuple_elt<T: Serialize>(&mut self,
+                                         state: &mut Self::TupleState,
+                                         value: T)
+                                         -> Result<(), Self::Error> {
+        self.serialize_seq_elt(state, value)
+    }
+
+    fn serialize_tuple_end(&mut self, state: Self::TupleState) -> Result<(), Self::Error> {
+        self.serialize_seq_end(state)
+    }
+
+    fn serialize_tuple_struct(&mut self,
+                              _name: &'static str,
+                              len: usize)
+                              -> Result<Self::TupleStructState, Self::Error> {
+        self.serialize_seq_fixed_size(len)
+    }
+
+    fn serialize_tuple_struct_elt<T: Serialize>(&mut self,
+                                                state: &mut Self::TupleStructState,
+                                                value: T)
+                                                -> Result<(), Self::Error> {
+        self.serialize_seq_elt(state, value)
+    }
+
+    fn serialize_tuple_struct_end(&mut self,
+                                  state: Self::TupleStructState)
+                                  -> Result<(), Self::Error> {
+        self.serialize_seq_end(state)
+    }
+
+    fn serialize_tuple_variant(&mut self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               variant: &'static str,
+                               len: usize)
+                               -> Result<Self::TupleVariantState, Self::Error> {
+
+        self.single_key_dict(variant.to_owned())?;
+        self.serialize_seq_fixed_size(len)
+    }
+
+    fn serialize_tuple_variant_elt<T: Serialize>(&mut self,
+                                                 state: &mut Self::TupleVariantState,
+                                                 value: T)
+                                                 -> Result<(), Self::Error> {
+        self.serialize_seq_elt(state, value)
+    }
+    fn serialize_tuple_variant_end(&mut self,
+                                   state: Self::TupleVariantState)
+                                   -> Result<(), Self::Error> {
+        self.serialize_seq_end(state)?;
+        self.single_key_dict_end()
+    }
+
+
+    fn serialize_map(&mut self, len: Option<usize>) -> Result<Self::MapState, Self::Error> {
+        let len = len.map(|len| len as u64);
+        self.emit(PlistEvent::StartDictionary(len))
+    }
+
+    fn serialize_map_key<T>(&mut self,
+                            _state: &mut Self::MapState,
+                            key: T)
+                            -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        key.serialize(self)
+    }
+
+    fn serialize_map_value<T>(&mut self,
+                              _state: &mut Self::MapState,
+                              value: T)
+                              -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_map_end(&mut self, _state: Self::MapState) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::EndDictionary)
+    }
+
+    fn serialize_struct(&mut self,
+                        _name: &'static str,
+                        len: usize)
+                        -> Result<Self::StructState, Self::Error> {
+        self.serialize_map(Some(len))?;
+        Ok(())
+    }
+
+    fn serialize_struct_elt<V: Serialize>(&mut self,
+                                          state: &mut Self::StructState,
+                                          key: &'static str,
+                                          value: V)
+                                          -> Result<(), Self::Error> {
+        self.serialize_map_key(state, key)?;
+        self.serialize_map_value(state, value)?;
+        Ok(())
+    }
+
+    fn serialize_struct_end(&mut self, state: Self::StructState) -> Result<(), Self::Error> {
+        self.serialize_map_end(state)
+    }
+
+    fn serialize_struct_variant(&mut self,
+                                name: &'static str,
+                                _variant_index: usize,
+                                variant: &'static str,
+                                len: usize)
+                                -> Result<Self::StructVariantState, Self::Error> {
+        self.single_key_dict(variant.to_owned())?;
+        self.serialize_struct(name, len)?;
+        Ok(())
+    }
+
+    fn serialize_struct_variant_elt<V: Serialize>(&mut self,
+                                                  state: &mut Self::StructVariantState,
+                                                  key: &'static str,
+                                                  value: V)
+                                                  -> Result<(), Self::Error> {
+        self.serialize_struct_elt(state, key, value)
+    }
+
+    fn serialize_struct_variant_end(&mut self,
+                                    state: Self::StructVariantState)
+                                    -> Result<(), Self::Error> {
+        self.serialize_struct_end(state)?;
+        self.single_key_dict_end()?;
+        Ok(())
+    }
+}
-- 
cgit v1.2.3