Update to serde 1.0.

5 files changed, 56 insertions, 62 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 0afbf08..824de55 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ base64 = "0.4.1"
 byteorder = "1.0.0"
 chrono = "0.3.0"
 xml-rs = "0.4.1"
-serde = { version = "0.9.5", optional = true }
+serde = { version = "1.0.2", optional = true }
 
 [dev-dependencies]
-serde_derive = { version = "0.9.5" }
+serde_derive = { version = "1.0.2" }
diff --git a/src/serde/de.rs b/src/serde/de.rs
index 74abe87..72a81bd 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -58,18 +58,18 @@ impl<I> Deserializer<I>
     }
 }
 
-impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
+impl<'de, 'a, I> de::Deserializer<'de> for &'a mut Deserializer<I>
     where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
     {
         match try_next!(self.events.next()) {
             PlistEvent::StartArray(len) => {
                 let len = try!(u64_option_to_usize(len));
-                let ret = visitor.visit_seq(MapAndSeqVisitor::new(self, len))?;
+                let ret = visitor.visit_seq(MapAndSeqAccess::new(self, len))?;
                 expect!(self.events.next(), PlistEvent::EndArray);
                 Ok(ret)
             }
@@ -77,7 +77,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
 
             PlistEvent::StartDictionary(len) => {
                 let len = try!(u64_option_to_usize(len));
-                let ret = visitor.visit_map(MapAndSeqVisitor::new(self, len))?;
+                let ret = visitor.visit_map(MapAndSeqAccess::new(self, len))?;
                 expect!(self.events.next(), PlistEvent::EndDictionary);
                 Ok(ret)
             }
@@ -93,21 +93,21 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
         }
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         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
+        seq bytes byte_buf map unit_struct
+        tuple_struct struct tuple ignored_any identifier
     }
 
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+        where V: de::Visitor<'de>
     {
         expect!(self.events.next(), PlistEvent::StringValue(_));
         visitor.visit_unit()
     }
 
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+        where V: de::Visitor<'de>
     {
         expect!(self.events.next(), PlistEvent::StartDictionary(_));
 
@@ -138,7 +138,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
                                      _name: &'static str,
                                      visitor: V)
                                      -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+        where V: de::Visitor<'de>
     {
         visitor.visit_newtype_struct(self)
     }
@@ -148,7 +148,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
                            _variants: &'static [&'static str],
                            visitor: V)
                            -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+        where V: de::Visitor<'de>
     {
         expect!(self.events.next(), PlistEvent::StartDictionary(_));
         let ret = try!(visitor.visit_enum(&mut *self));
@@ -157,76 +157,76 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
     }
 }
 
-impl<'a, I> de::EnumVisitor for &'a mut Deserializer<I>
+impl<'de, 'a, I> de::EnumAccess<'de> for &'a mut Deserializer<I>
     where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
     type Variant = Self;
 
-    fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Self::Error>
-        where V: de::DeserializeSeed
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Self::Error>
+        where V: de::DeserializeSeed<'de>
     {
         Ok((seed.deserialize(&mut *self)?, self))
     }
 }
 
-impl<'a, I> de::VariantVisitor for &'a mut Deserializer<I>
+impl<'de, 'a, I> de::VariantAccess<'de> for &'a mut Deserializer<I>
     where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
 
-    fn visit_unit(self) -> Result<(), Self::Error> {
+    fn unit_variant(self) -> Result<(), Self::Error> {
         <() as de::Deserialize>::deserialize(self)
     }
 
-    fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
-        where T: de::DeserializeSeed
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+        where T: de::DeserializeSeed<'de>
     {
         seed.deserialize(self)
     }
 
-    fn visit_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
     {
         <Self as de::Deserializer>::deserialize_tuple(self, len, visitor)
     }
 
-    fn visit_struct<V>(self,
+    fn struct_variant<V>(self,
                        fields: &'static [&'static str],
                        visitor: V)
                        -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+        where V: de::Visitor<'de>
     {
         let name = "";
         <Self as de::Deserializer>::deserialize_struct(self, name, fields, visitor)
     }
 }
 
-struct MapAndSeqVisitor<'a, I>
+struct MapAndSeqAccess<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
     de: &'a mut Deserializer<I>,
     remaining: Option<usize>,
 }
 
-impl<'a, I> MapAndSeqVisitor<'a, I>
+impl<'a, I> MapAndSeqAccess<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
-    fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapAndSeqVisitor<'a, I> {
-        MapAndSeqVisitor {
+    fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapAndSeqAccess<'a, I> {
+        MapAndSeqAccess {
             de: de,
             remaining: len,
         }
     }
 }
 
-impl<'a, I> de::SeqVisitor for MapAndSeqVisitor<'a, I>
+impl<'de, 'a, I> de::SeqAccess<'de> for MapAndSeqAccess<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
 
-    fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where T: de::DeserializeSeed
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed<'de>
     {
         match self.de.events.peek() {
             Some(&Ok(PlistEvent::EndArray)) => Ok(None),
@@ -238,18 +238,18 @@ impl<'a, I> de::SeqVisitor for MapAndSeqVisitor<'a, I>
         }
     }
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        <Self as de::MapVisitor>::size_hint(self)
+    fn size_hint(&self) -> Option<usize> {
+        self.remaining
     }
 }
 
-impl<'a, I> de::MapVisitor for MapAndSeqVisitor<'a, I>
+impl<'de, 'a, I> de::MapAccess<'de> for MapAndSeqAccess<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
     type Error = Error;
 
-    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
-        where K: de::DeserializeSeed
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+        where K: de::DeserializeSeed<'de>
     {
         match self.de.events.peek() {
             Some(&Ok(PlistEvent::EndDictionary)) => return Ok(None),
@@ -261,16 +261,13 @@ impl<'a, I> de::MapVisitor for MapAndSeqVisitor<'a, I>
         }
     }
 
-    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
-        where V: de::DeserializeSeed
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+        where V: de::DeserializeSeed<'de>
     {
         seed.deserialize(&mut *self.de)
     }
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.remaining {
-            Some(len) => (len, Some(len)),
-            None => (0, None),
-        }
+    fn size_hint(&self) -> Option<usize> {
+        self.remaining
     }
 }
diff --git a/src/serde/mod.rs b/src/serde/mod.rs
index 66cf430..734b629 100644
--- a/src/serde/mod.rs
+++ b/src/serde/mod.rs
@@ -4,14 +4,15 @@ mod ser;
 pub use self::de::Deserializer;
 pub use self::ser::Serializer;
 
-use serde_base::{Deserialize, Serialize};
+use serde_base::de::{Deserialize, DeserializeOwned};
+use serde_base::ser::Serialize;
 use std::io::{Read, Seek, Write};
 
 use Result;
 use EventReader;
 use xml;
 
-pub fn deserialize<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> {
+pub fn deserialize<R: Read + Seek, T: DeserializeOwned>(reader: R) -> Result<T> {
     let reader = EventReader::new(reader);
     let mut de = Deserializer::new(reader);
     Deserialize::deserialize(&mut de)
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 0af90f2..48ad39f 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -99,8 +99,7 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
     }
 
     fn serialize_char(self, v: char) -> Result<(), Self::Error> {
-        let sstr = v.to_string();
-        self.serialize_str(&sstr)
+        self.emit(PlistEvent::StringValue(v.to_string()))
     }
 
     fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
@@ -134,7 +133,7 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
 
     fn serialize_unit_variant(self,
                               _name: &'static str,
-                              _variant_index: usize,
+                              _variant_index: u32,
                               variant: &'static str)
                               -> Result<(), Self::Error> {
         self.single_key_dict(variant.to_owned())?;
@@ -152,7 +151,7 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
 
     fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self,
                                                              _name: &'static str,
-                                                             _variant_index: usize,
+                                                             _variant_index: u32,
                                                              variant: &'static str,
                                                              value: &T)
                                                              -> Result<(), Self::Error> {
@@ -167,29 +166,25 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
         Ok(Compound { ser: self })
     }
 
-    fn serialize_seq_fixed_size(self, size: usize) -> Result<Self::SerializeSeq, Self::Error> {
-        self.serialize_seq(Some(size))
-    }
-
     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        self.serialize_seq_fixed_size(len)
+        self.serialize_seq(Some(len))
     }
 
     fn serialize_tuple_struct(self,
                               _name: &'static str,
                               len: usize)
                               -> Result<Self::SerializeTupleStruct, Self::Error> {
-        self.serialize_seq_fixed_size(len)
+        self.serialize_tuple(len)
     }
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
-                               _variant_index: usize,
+                               _variant_index: u32,
                                variant: &'static str,
                                len: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
         self.single_key_dict(variant.to_owned())?;
-        self.serialize_seq_fixed_size(len)
+        self.serialize_tuple(len)
     }
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -207,7 +202,7 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
 
     fn serialize_struct_variant(self,
                                 name: &'static str,
-                                _variant_index: usize,
+                                _variant_index: u32,
                                 variant: &'static str,
                                 len: usize)
                                 -> Result<Self::SerializeStructVariant, Self::Error> {
@@ -325,7 +320,7 @@ impl<'a, W: EventWriter> ser::SerializeStructVariant for Compound<'a, W> {
                                                    key: &'static str,
                                                    value: &T)
                                                    -> Result<(), Self::Error> {
-        <Self as ser::SerializeMap>::serialize_entry(self, key, value)
+        <Self as ser::SerializeStruct>::serialize_field(self, key, value)
     }
 
     fn end(self) -> Result<Self::Ok, Self::Error> {
diff --git a/tests/serde_tests/mod.rs b/tests/serde_tests/mod.rs
index 42f9824..5235896 100644
--- a/tests/serde_tests/mod.rs
+++ b/tests/serde_tests/mod.rs
@@ -1,7 +1,8 @@
 use plist::{EventWriter, PlistEvent, Result as PlistResult};
 use plist::serde::{Serializer, Deserializer};
 use plist::PlistEvent::*;
-use serde::{Deserialize, Serialize};
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;
 use std::fmt::Debug;
 
 struct VecWriter {
@@ -35,7 +36,7 @@ fn new_deserializer(events: Vec<PlistEvent>) -> Deserializer<Vec<PlistResult<Pli
 }
 
 fn assert_roundtrip<T>(obj: T, comparison: Option<&[PlistEvent]>)
-    where T: Debug + Deserialize + PartialEq + Serialize
+    where T: Debug + DeserializeOwned + PartialEq + Serialize
 {
     let mut se = new_serializer();