Update Serde to 0.9.

3 files changed, 256 insertions, 260 deletions

diff --git a/Cargo.toml b/Cargo.toml
index f215f62..139f0c8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,8 +18,7 @@ rustc-serialize = "0.3.19"
 xml-rs = "0.3.4"
 byteorder = "0.5.3"
 chrono = "0.2.22"
-serde = { version = "0.8.21", optional = true }
+serde = { version = "0.9.5", optional = true }
 
 [dev-dependencies]
-# Should be an optional dependency on serde_serialization
-serde_derive = { version = "0.8.21" }
+serde_derive = { version = "0.9.5" }
diff --git a/src/serde/de.rs b/src/serde/de.rs
index f888852..0f4ffa4 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -1,9 +1,9 @@
 // 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 serde_base::de;
 use std::iter::Peekable;
+use std::fmt::Display;
 
 use {Error, PlistEvent, u64_option_to_usize};
 
@@ -38,13 +38,9 @@ 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
+impl de::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Serde(msg.to_string())
     }
 }
 
@@ -62,24 +58,28 @@ impl<I> Deserializer<I>
     }
 }
 
-impl<I> SerdeDeserializer for Deserializer<I>
+impl<'a, I> de::Deserializer for &'a mut 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
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::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))
+                let ret = visitor.visit_seq(MapAndSeqVisitor::new(self, len))?;
+                expect!(self.events.next(), PlistEvent::EndArray);
+                Ok(ret)
             }
             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))
+                let ret = visitor.visit_map(MapAndSeqVisitor::new(self, len))?;
+                expect!(self.events.next(), PlistEvent::EndDictionary);
+                Ok(ret)
             }
             PlistEvent::EndDictionary => return Err(event_mismatch_error()),
 
@@ -94,20 +94,20 @@ impl<I> SerdeDeserializer for Deserializer<I>
     }
 
     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
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string
+        seq seq_fixed_size bytes byte_buf 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
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::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
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
     {
         expect!(self.events.next(), PlistEvent::StartDictionary(_));
 
@@ -123,7 +123,9 @@ impl<I> SerdeDeserializer for Deserializer<I>
                 expect!(self.events.next(), PlistEvent::StringValue(_));
                 ret
             }
-            PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)),
+            PlistEvent::StringValue(ref s) if &s[..] == "Some" => {
+                try!(visitor.visit_some(&mut *self))
+            }
             _ => return Err(event_mismatch_error()),
         };
 
@@ -132,64 +134,71 @@ impl<I> SerdeDeserializer for Deserializer<I>
         Ok(ret)
     }
 
-    fn deserialize_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(self,
                                      _name: &'static str,
-                                     mut visitor: V)
+                                     visitor: V)
                                      -> Result<V::Value, Self::Error>
-        where V: Visitor
+        where V: de::Visitor
     {
         visitor.visit_newtype_struct(self)
     }
 
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                            _enum: &'static str,
                            _variants: &'static [&'static str],
-                           mut visitor: V)
+                           visitor: V)
                            -> Result<V::Value, Self::Error>
-        where V: EnumVisitor
+        where V: de::Visitor
     {
         expect!(self.events.next(), PlistEvent::StartDictionary(_));
-        let ret = try!(visitor.visit(&mut *self));
+        let ret = try!(visitor.visit_enum(&mut *self));
         expect!(self.events.next(), PlistEvent::EndDictionary);
         Ok(ret)
     }
 }
 
-impl<I> VariantVisitor for Deserializer<I>
+impl<'a, I> de::EnumVisitor for &'a mut Deserializer<I>
     where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
+    type Variant = Self;
 
-    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize
+    fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Self::Error>
+        where V: de::DeserializeSeed
     {
-        <V as Deserialize>::deserialize(self)
+        Ok((seed.deserialize(&mut *self)?, self))
     }
+}
+
+impl<'a, I> de::VariantVisitor for &'a mut Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
 
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        <() as Deserialize>::deserialize(self)
+    fn visit_unit(self) -> Result<(), Self::Error> {
+        <() as de::Deserialize>::deserialize(self)
     }
 
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: Deserialize
+    fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+        where T: de::DeserializeSeed
     {
-        <T as Deserialize>::deserialize(self)
+        seed.deserialize(self)
     }
 
-    fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
+    fn visit_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
     {
-        <Self as SerdeDeserializer>::deserialize_tuple(self, len, visitor)
+        <Self as de::Deserializer>::deserialize_tuple(self, len, visitor)
     }
 
-    fn visit_struct<V>(&mut self,
+    fn visit_struct<V>(self,
                        fields: &'static [&'static str],
                        visitor: V)
                        -> Result<V::Value, Self::Error>
-        where V: Visitor
+        where V: de::Visitor
     {
         let name = "";
-        <Self as SerdeDeserializer>::deserialize_struct(self, name, fields, visitor)
+        <Self as de::Deserializer>::deserialize_struct(self, name, fields, visitor)
     }
 }
 
@@ -198,7 +207,6 @@ struct MapAndSeqVisitor<'a, I>
 {
     de: &'a mut Deserializer<I>,
     remaining: Option<usize>,
-    finished: bool,
 }
 
 impl<'a, I> MapAndSeqVisitor<'a, I>
@@ -208,72 +216,55 @@ impl<'a, I> MapAndSeqVisitor<'a, I>
         MapAndSeqVisitor {
             de: de,
             remaining: len,
-            finished: false,
         }
     }
 }
 
-impl<'a, I> SeqVisitor for MapAndSeqVisitor<'a, I>
+impl<'a, I> de::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
+    fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed
     {
         match self.de.events.peek() {
-            Some(&Ok(PlistEvent::EndArray)) => {
-                self.de.events.next();
-                self.finished = true;
-                return Ok(None);
+            Some(&Ok(PlistEvent::EndArray)) => Ok(None),
+            _ => {
+                let ret = seed.deserialize(&mut *self.de).map(|k| Some(k));
+                self.remaining = self.remaining.map(|r| r.saturating_sub(1));
+                ret
             }
-            _ => <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)
+        <Self as de::MapVisitor>::size_hint(self)
     }
 }
 
-impl<'a, I> MapVisitor for MapAndSeqVisitor<'a, I>
+impl<'a, I> de::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
+    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+        where K: de::DeserializeSeed
     {
         match self.de.events.peek() {
-            Some(&Ok(PlistEvent::EndDictionary)) => {
-                self.de.events.next();
-                self.finished = true;
-                return Ok(None);
+            Some(&Ok(PlistEvent::EndDictionary)) => return Ok(None),
+            _ => {
+                let ret = seed.deserialize(&mut *self.de).map(|k| Some(k));
+                self.remaining = self.remaining.map(|r| r.saturating_sub(1));
+                ret
             }
-            _ => <K as Deserialize>::deserialize(self.de).map(|k| Some(k)),
         }
     }
 
-    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize
+    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+        where V: de::DeserializeSeed
     {
-        <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(())
+        seed.deserialize(&mut *self.de)
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 2875ed2..0af90f2 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -1,17 +1,14 @@
 // 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 serde_base::ser;
+use std::fmt::Display;
 
 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
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Serde(msg.to_string())
     }
 }
 
@@ -24,8 +21,7 @@ impl<W: EventWriter> Serializer<W> {
         Serializer { writer: writer }
     }
 
-    #[inline]
-    fn emit(&mut self, event: PlistEvent) -> Result<(), <Self as SerdeSerializer>::Error> {
+    fn emit(&mut self, event: PlistEvent) -> Result<(), Error> {
         Ok(self.writer.write(&event)?)
     }
 
@@ -34,103 +30,109 @@ impl<W: EventWriter> Serializer<W> {
     }
 
     // Emit {key: value}
-    fn single_key_dict(&mut self, key: String) -> Result<(), <Self as SerdeSerializer>::Error> {
+    fn single_key_dict(&mut self, key: String) -> Result<(), 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> {
+    fn single_key_dict_end(&mut self) -> Result<(), Error> {
         try!(self.emit(PlistEvent::EndDictionary));
         Ok(())
     }
 }
 
-impl<W: EventWriter> SerdeSerializer for Serializer<W> {
+impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
+    type Ok = ();
     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)
+    type SerializeSeq = Compound<'a, W>;
+    type SerializeTuple = Compound<'a, W>;
+    type SerializeTupleStruct = Compound<'a, W>;
+    type SerializeTupleVariant = Compound<'a, W>;
+    type SerializeMap = Compound<'a, W>;
+    type SerializeStruct = Compound<'a, W>;
+    type SerializeStructVariant = Compound<'a, W>;
+
+    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
+        self.emit(PlistEvent::BooleanValue(v))
     }
 
-    fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error> {
+    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
         self.serialize_i64(v as i64)
     }
 
-    fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error> {
+    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
         self.serialize_i64(v as i64)
     }
 
-    fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error> {
+    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
         self.serialize_i64(v as i64)
     }
 
-    fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> {
+    fn serialize_i64(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> {
+    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
         self.serialize_u64(v as u64)
     }
 
-    fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error> {
+    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
         self.serialize_u64(v as u64)
     }
 
-    fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error> {
+    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
         self.serialize_u64(v as u64)
     }
 
-    fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> {
+    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
         self.emit(PlistEvent::IntegerValue(v as i64))
     }
 
-    fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error> {
+    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
         self.serialize_f64(v as f64)
     }
 
-    fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> {
+    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
         self.emit(PlistEvent::RealValue(v))
     }
 
-    fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> {
+    fn serialize_char(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> {
+    fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
         self.emit(PlistEvent::StringValue(value.to_owned()))
     }
 
-    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+    fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error> {
         self.emit(PlistEvent::DataValue(value.to_owned()))
     }
 
-    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
+    fn serialize_none(self) -> Result<(), Self::Error> {
+        self.single_key_dict("None".to_owned())?;
+        self.serialize_unit()?;
+        self.single_key_dict_end()
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Self::Error> {
+        self.single_key_dict("Some".to_owned())?;
+        value.serialize(&mut *self)?;
+        self.single_key_dict_end()
+    }
+
+    fn serialize_unit(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> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
         self.serialize_unit()
     }
 
-    fn serialize_unit_variant(&mut self,
+    fn serialize_unit_variant(self,
                               _name: &'static str,
                               _variant_index: usize,
                               variant: &'static str)
@@ -141,189 +143,193 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         Ok(())
     }
 
-    fn serialize_newtype_struct<T: Serialize>(&mut self,
-                                              _name: &'static str,
-                                              value: T)
-                                              -> Result<(), Self::Error> {
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(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> {
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(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)?;
+        value.serialize(&mut *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_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        let len = len.map(|len| len as u64);
+        self.emit(PlistEvent::StartArray(len))?;
+        Ok(Compound { ser: self })
     }
 
-    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_fixed_size(self, size: usize) -> Result<Self::SerializeSeq, Self::Error> {
+        self.serialize_seq(Some(size))
     }
 
-    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_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        self.serialize_seq_fixed_size(len)
     }
 
-    fn serialize_seq_elt<T: Serialize>(&mut self,
-                                       _state: &mut Self::SeqState,
-                                       value: T)
-                                       -> Result<(), Self::Error> {
-        value.serialize(self)
+    fn serialize_tuple_struct(self,
+                              _name: &'static str,
+                              len: usize)
+                              -> Result<Self::SerializeTupleStruct, Self::Error> {
+        self.serialize_seq_fixed_size(len)
     }
 
-    fn serialize_seq_end(&mut self, _state: Self::SeqState) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::EndArray)
+    fn serialize_tuple_variant(self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               variant: &'static str,
+                               len: usize)
+                               -> Result<Self::SerializeTupleVariant, Self::Error> {
+        self.single_key_dict(variant.to_owned())?;
+        self.serialize_seq_fixed_size(len)
     }
 
-    fn serialize_seq_fixed_size(&mut self, size: usize) -> Result<Self::SeqState, Self::Error> {
-        self.serialize_seq(Some(size))
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        let len = len.map(|len| len as u64);
+        self.emit(PlistEvent::StartDictionary(len))?;
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_tuple(&mut self, len: usize) -> Result<Self::TupleState, Self::Error> {
-        self.serialize_seq_fixed_size(len)
+    fn serialize_struct(self,
+                        _name: &'static str,
+                        len: usize)
+                        -> Result<Self::SerializeStruct, Self::Error> {
+        self.serialize_map(Some(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_struct_variant(self,
+                                name: &'static str,
+                                _variant_index: usize,
+                                variant: &'static str,
+                                len: usize)
+                                -> Result<Self::SerializeStructVariant, Self::Error> {
+        self.single_key_dict(variant.to_owned())?;
+        self.serialize_struct(name, len)
     }
+}
+
+#[doc(hidden)]
+pub struct Compound<'a, W: 'a + EventWriter> {
+    ser: &'a mut Serializer<W>,
+}
+
+impl<'a, W: EventWriter> ser::SerializeSeq for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    fn serialize_tuple_end(&mut self, state: Self::TupleState) -> Result<(), Self::Error> {
-        self.serialize_seq_end(state)
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     value: &T)
+                                                     -> Result<(), Self::Error> {
+        value.serialize(&mut *self.ser)
     }
 
-    fn serialize_tuple_struct(&mut self,
-                              _name: &'static str,
-                              len: usize)
-                              -> Result<Self::TupleStructState, Self::Error> {
-        self.serialize_seq_fixed_size(len)
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.emit(PlistEvent::EndArray)
     }
+}
+
+impl<'a, W: EventWriter> ser::SerializeTuple for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    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_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     value: &T)
+                                                     -> Result<(), Self::Error> {
+        <Self as ser::SerializeSeq>::serialize_element(self, value)
     }
 
-    fn serialize_tuple_struct_end(&mut self,
-                                  state: Self::TupleStructState)
-                                  -> Result<(), Self::Error> {
-        self.serialize_seq_end(state)
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        <Self as ser::SerializeSeq>::end(self)
     }
+}
 
-    fn serialize_tuple_variant(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               variant: &'static str,
-                               len: usize)
-                               -> Result<Self::TupleVariantState, Self::Error> {
+impl<'a, W: EventWriter> ser::SerializeTupleStruct for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-        self.single_key_dict(variant.to_owned())?;
-        self.serialize_seq_fixed_size(len)
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   value: &T)
+                                                   -> Result<(), Self::Error> {
+        <Self as ser::SerializeSeq>::serialize_element(self, value)
     }
 
-    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 end(self) -> Result<Self::Ok, Self::Error> {
+        <Self as ser::SerializeSeq>::end(self)
     }
+}
 
+impl<'a, W: EventWriter> ser::SerializeTupleVariant for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    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_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   value: &T)
+                                                   -> Result<(), Self::Error> {
+        <Self as ser::SerializeSeq>::serialize_element(self, value)
     }
 
-    fn serialize_map_key<T>(&mut self,
-                            _state: &mut Self::MapState,
-                            key: T)
-                            -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        key.serialize(self)
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.emit(PlistEvent::EndArray)?;
+        self.ser.single_key_dict_end()
     }
+}
 
-    fn serialize_map_value<T>(&mut self,
-                              _state: &mut Self::MapState,
-                              value: T)
-                              -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        value.serialize(self)
-    }
+impl<'a, W: EventWriter> ser::SerializeMap for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    fn serialize_map_end(&mut self, _state: Self::MapState) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::EndDictionary)
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
+        key.serialize(&mut *self.ser)
     }
 
-    fn serialize_struct(&mut self,
-                        _name: &'static str,
-                        len: usize)
-                        -> Result<Self::StructState, Self::Error> {
-        self.serialize_map(Some(len))?;
-        Ok(())
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
+                                                   value: &T)
+                                                   -> Result<(), Self::Error> {
+        value.serialize(&mut *self.ser)
     }
 
-    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 end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.emit(PlistEvent::EndDictionary)
     }
+}
+
+impl<'a, W: EventWriter> ser::SerializeStruct for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    fn serialize_struct_end(&mut self, state: Self::StructState) -> Result<(), Self::Error> {
-        self.serialize_map_end(state)
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   key: &'static str,
+                                                   value: &T)
+                                                   -> Result<(), Self::Error> {
+        <Self as ser::SerializeMap>::serialize_entry(self, key, value)
     }
 
-    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 end(self) -> Result<Self::Ok, Self::Error> {
+        <Self as ser::SerializeMap>::end(self)
     }
+}
+
+impl<'a, W: EventWriter> ser::SerializeStructVariant for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
 
-    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_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   key: &'static str,
+                                                   value: &T)
+                                                   -> Result<(), Self::Error> {
+        <Self as ser::SerializeMap>::serialize_entry(self, 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(())
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.emit(PlistEvent::EndDictionary)?;
+        self.ser.single_key_dict_end()
     }
 }