diff options
| -rw-r--r-- | Cargo.toml | 5 | ||||
| -rw-r--r-- | src/serde/de.rs | 153 | ||||
| -rw-r--r-- | src/serde/ser.rs | 358 |
3 files changed, 256 insertions, 260 deletions
@@ -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() } } |