From 7eccffd7832a6bbc066d4700fc8f355b89a368bc Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 19 Apr 2017 16:05:59 -0700 Subject: [PATCH] Update to serde 1.0 branch (#149) * Update to serde 1.0 branch * The serde 1.0 branch merged --- Cargo.toml | 7 +-- src/lib.rs | 4 +- src/serde/mod.rs | 4 +- src/serde/reader.rs | 130 +++++++++++++++++++------------------------- src/serde/writer.rs | 56 ++++++------------- tests/test.rs | 7 ++- 6 files changed, 83 insertions(+), 125 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d5cc735..826bfe5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,9 +13,8 @@ description = "A binary serialization / deserialization strategy that uses Serde [dependencies] byteorder = "1.0.0" num-traits = "0.1.32" - -[dependencies.serde] -version = "0.9.*" +serde = { git = "https://github.com/serde-rs/serde", branch = "master" } [dev-dependencies] -serde_derive = "0.9.*" +serde_bytes = { git = "https://github.com/serde-rs/bytes", branch = "master" } +serde_derive = { git = "https://github.com/serde-rs/serde", branch = "master" } diff --git a/src/lib.rs b/src/lib.rs index 92abe36..4674671 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -61,7 +61,7 @@ pub type Serializer = serde::Serializer; /// This method does not have a size-limit because if you already have the bytes /// in memory, then you don't gain anything by having a limiter. pub fn deserialize(bytes: &[u8]) -> serde::Result - where T: serde_crate::Deserialize, + where T: serde_crate::de::DeserializeOwned, { serde::deserialize::<_, byteorder::LittleEndian>(bytes) } @@ -76,7 +76,7 @@ pub fn deserialize(bytes: &[u8]) -> serde::Result /// in is in an invalid state, as the error could be returned during any point /// in the reading. pub fn deserialize_from(reader: &mut R, size_limit: S) -> serde::Result - where R: Read, T: serde_crate::Deserialize, S: SizeLimit + where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit { serde::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit) } diff --git a/src/serde/mod.rs b/src/serde/mod.rs index 4230bad..f9988f3 100644 --- a/src/serde/mod.rs +++ b/src/serde/mod.rs @@ -223,7 +223,7 @@ pub fn serialized_size_bounded(value: &T, max: u64) -> Option /// in is in an invalid state, as the error could be returned during any point /// in the reading. pub fn deserialize_from(reader: &mut R, size_limit: S) -> Result - where R: Read, T: serde::Deserialize, S: SizeLimit, E: ByteOrder + where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder { let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit); serde::Deserialize::deserialize(&mut deserializer) @@ -234,7 +234,7 @@ pub fn deserialize_from(reader: &mut R, size_limit: S) -> Re /// This method does not have a size-limit because if you already have the bytes /// in memory, then you don't gain anything by having a limiter. pub fn deserialize(bytes: &[u8]) -> Result - where T: serde::Deserialize, + where T: serde::de::DeserializeOwned, { let mut reader = bytes; deserialize_from::<_, _, _, E>(&mut reader, super::Infinite) diff --git a/src/serde/reader.rs b/src/serde/reader.rs index 6090e29..f72a560 100644 --- a/src/serde/reader.rs +++ b/src/serde/reader.rs @@ -4,7 +4,7 @@ use std::marker::PhantomData; use byteorder::{ReadBytesExt, ByteOrder}; use serde_crate as serde; -use serde_crate::de::value::ValueDeserializer; +use serde_crate::de::IntoDeserializer; use serde_crate::de::Error as DeError; use ::SizeLimit; use super::{Result, Error, ErrorKind}; @@ -81,7 +81,7 @@ macro_rules! impl_nums { ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => { #[inline] fn $dser_method(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { try!(self.read_type::<$ty>()); let value = try!(self.reader.$reader_method::()); @@ -90,20 +90,20 @@ macro_rules! impl_nums { } } -impl<'a, R, S, E> serde::Deserializer for &'a mut Deserializer +impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer where R: Read, S: SizeLimit, E: ByteOrder { type Error = Error; #[inline] - fn deserialize(self, _visitor: V) -> Result - where V: serde::de::Visitor, + fn deserialize_any(self, _visitor: V) -> Result + where V: serde::de::Visitor<'de>, { let message = "bincode does not support Deserializer::deserialize"; Err(Error::custom(message)) } fn deserialize_bool(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { let value: u8 = try!(serde::Deserialize::deserialize(self)); match value { @@ -130,7 +130,7 @@ where R: Read, S: SizeLimit, E: ByteOrder { #[inline] fn deserialize_u8(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { try!(self.read_type::()); visitor.visit_u8(try!(self.reader.read_u8())) @@ -138,20 +138,20 @@ where R: Read, S: SizeLimit, E: ByteOrder { #[inline] fn deserialize_i8(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { try!(self.read_type::()); visitor.visit_i8(try!(self.reader.read_i8())) } fn deserialize_unit(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_unit() } fn deserialize_char(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { use std::str; @@ -179,25 +179,25 @@ where R: Read, S: SizeLimit, E: ByteOrder { } fn deserialize_str(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_str(&try!(self.read_string())) } fn deserialize_string(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_string(try!(self.read_string())) } fn deserialize_bytes(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_bytes(&try!(self.read_vec())) } fn deserialize_byte_buf(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_byte_buf(try!(self.read_vec())) } @@ -206,15 +206,15 @@ where R: Read, S: SizeLimit, E: ByteOrder { _enum: &'static str, _variants: &'static [&'static str], visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { - impl<'a, R: 'a, S, E> serde::de::EnumVisitor for &'a mut Deserializer + impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer where R: Read, S: SizeLimit, E: ByteOrder { type Error = Error; type Variant = Self; - fn visit_variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant)> - where V: serde::de::DeserializeSeed, + fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant)> + where V: serde::de::DeserializeSeed<'de>, { let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self)); let val: Result<_> = seed.deserialize(idx.into_deserializer()); @@ -225,39 +225,21 @@ where R: Read, S: SizeLimit, E: ByteOrder { visitor.visit_enum(self) } - fn deserialize_tuple(self, _len: usize, visitor: V) -> Result - where V: serde::de::Visitor, - { - struct TupleVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a>(&'a mut Deserializer); - - impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for TupleVisitor<'a, R, S, E> { - type Error = Error; - - fn visit_seed(&mut self, seed: T) -> Result> - where T: serde::de::DeserializeSeed, - { - let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.0)); - Ok(Some(value)) - } - } - visitor.visit_seq(TupleVisitor(self)) - } - - fn deserialize_seq_fixed_size(self, + fn deserialize_tuple(self, len: usize, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { - struct SeqVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { + struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { deserializer: &'a mut Deserializer, len: usize, } - impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for SeqVisitor<'a, R, S, E> { + impl<'de, 'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqAccess<'de> for Access<'a, R, S, E> { type Error = Error; - fn visit_seed(&mut self, seed: T) -> Result> - where T: serde::de::DeserializeSeed, + fn next_element_seed(&mut self, seed: T) -> Result> + where T: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; @@ -268,16 +250,16 @@ where R: Read, S: SizeLimit, E: ByteOrder { } } - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) + fn size_hint(&self) -> Option { + Some(self.len) } } - visitor.visit_seq(SeqVisitor { deserializer: self, len: len }) + visitor.visit_seq(Access { deserializer: self, len: len }) } fn deserialize_option(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self)); match value { @@ -291,26 +273,26 @@ where R: Read, S: SizeLimit, E: ByteOrder { } fn deserialize_seq(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { let len = try!(serde::Deserialize::deserialize(&mut *self)); - self.deserialize_seq_fixed_size(len, visitor) + self.deserialize_tuple(len, visitor) } fn deserialize_map(self, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { - struct MapVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { + struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { deserializer: &'a mut Deserializer, len: usize, } - impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapVisitor for MapVisitor<'a, R, S, E> { + impl<'de, 'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapAccess<'de> for Access<'a, R, S, E> { type Error = Error; - fn visit_key_seed(&mut self, seed: K) -> Result> - where K: serde::de::DeserializeSeed, + fn next_key_seed(&mut self, seed: K) -> Result> + where K: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; @@ -321,44 +303,44 @@ where R: Read, S: SizeLimit, E: ByteOrder { } } - fn visit_value_seed(&mut self, seed: V) -> Result - where V: serde::de::DeserializeSeed, + fn next_value_seed(&mut self, seed: V) -> Result + where V: serde::de::DeserializeSeed<'de>, { let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); Ok(value) } - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) + fn size_hint(&self) -> Option { + Some(self.len) } } let len = try!(serde::Deserialize::deserialize(&mut *self)); - visitor.visit_map(MapVisitor { deserializer: self, len: len }) + visitor.visit_map(Access { deserializer: self, len: len }) } fn deserialize_struct(self, _name: &str, fields: &'static [&'static str], visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { self.deserialize_tuple(fields.len(), visitor) } - fn deserialize_struct_field(self, + fn deserialize_identifier(self, _visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { - let message = "bincode does not support Deserializer::deserialize_struct_field"; + let message = "bincode does not support Deserializer::deserialize_identifier"; Err(Error::custom(message)) } fn deserialize_newtype_struct(self, _name: &str, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -366,7 +348,7 @@ where R: Read, S: SizeLimit, E: ByteOrder { fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { visitor.visit_unit() } @@ -375,46 +357,46 @@ where R: Read, S: SizeLimit, E: ByteOrder { _name: &'static str, len: usize, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { self.deserialize_tuple(len, visitor) } fn deserialize_ignored_any(self, _visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { let message = "bincode does not support Deserializer::deserialize_ignored_any"; Err(Error::custom(message)) } } -impl<'a, R, S, E> serde::de::VariantVisitor for &'a mut Deserializer +impl<'de, 'a, R, S, E> serde::de::VariantAccess<'de> for &'a mut Deserializer where R: Read, S: SizeLimit, E: ByteOrder { type Error = Error; - fn visit_unit(self) -> Result<()> { + fn unit_variant(self) -> Result<()> { Ok(()) } - fn visit_newtype_seed(self, seed: T) -> Result - where T: serde::de::DeserializeSeed, + fn newtype_variant_seed(self, seed: T) -> Result + where T: serde::de::DeserializeSeed<'de>, { serde::de::DeserializeSeed::deserialize(seed, self) } - fn visit_tuple(self, + fn tuple_variant(self, len: usize, visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { serde::de::Deserializer::deserialize_tuple(self, len, visitor) } - fn visit_struct(self, + fn struct_variant(self, fields: &'static [&'static str], visitor: V) -> Result - where V: serde::de::Visitor, + where V: serde::de::Visitor<'de>, { serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor) } diff --git a/src/serde/writer.rs b/src/serde/writer.rs index 2d6b7a0..35ed0f6 100644 --- a/src/serde/writer.rs +++ b/src/serde/writer.rs @@ -29,14 +29,6 @@ impl Serializer { _phantom: PhantomData, } } - - fn add_enum_tag(&mut self, tag: usize) -> Result<()> { - if tag > u32::MAX as usize { - panic!("Variant tag doesn't fit in a u32") - } - - serde::Serializer::serialize_u32(self, tag as u32) - } } impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer { @@ -129,10 +121,6 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer Ok(Compound {ser: self}) } - fn serialize_seq_fixed_size(self, _len: usize) -> Result { - Ok(Compound {ser: self}) - } - fn serialize_tuple(self, _len: usize) -> Result { Ok(Compound {ser: self}) } @@ -143,11 +131,11 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer fn serialize_tuple_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, _len: usize) -> Result { - try!(self.add_enum_tag(variant_index)); + try!(self.serialize_u32(variant_index)); Ok(Compound {ser: self}) } @@ -163,11 +151,11 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer fn serialize_struct_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, _len: usize) -> Result { - try!(self.add_enum_tag(variant_index)); + try!(self.serialize_u32(variant_index)); Ok(Compound {ser: self}) } @@ -181,20 +169,20 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer fn serialize_newtype_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, value: &T) -> Result<()> where T: serde::ser::Serialize, { - try!(self.add_enum_tag(variant_index)); + try!(self.serialize_u32(variant_index)); value.serialize(self) } fn serialize_unit_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str) -> Result<()> { - self.add_enum_tag(variant_index) + self.serialize_u32(variant_index) } } @@ -217,14 +205,6 @@ impl SizeChecker { use std::mem::size_of_val; self.add_raw(size_of_val(&t) as u64) } - - fn add_enum_tag(&mut self, tag: usize) -> Result<()> { - if tag > u32::MAX as usize { - panic!("Variant tag doesn't fit in a u32") - } - - self.add_value(tag as u32) - } } impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { @@ -318,10 +298,6 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { Ok(SizeCompound {ser: self}) } - fn serialize_seq_fixed_size(self, _len: usize) -> Result { - Ok(SizeCompound {ser: self}) - } - fn serialize_tuple(self, _len: usize) -> Result { Ok(SizeCompound {ser: self}) } @@ -332,11 +308,11 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { fn serialize_tuple_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, _len: usize) -> Result { - try!(self.add_enum_tag(variant_index)); + try!(self.add_value(variant_index)); Ok(SizeCompound {ser: self}) } @@ -354,11 +330,11 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { fn serialize_struct_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, _len: usize) -> Result { - try!(self.add_enum_tag(variant_index)); + try!(self.add_value(variant_index)); Ok(SizeCompound {ser: self}) } @@ -368,18 +344,18 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { fn serialize_unit_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str) -> Result<()> { - self.add_enum_tag(variant_index) + self.add_value(variant_index) } fn serialize_newtype_variant(self, _name: &'static str, - variant_index: usize, + variant_index: u32, _variant: &'static str, value: &V) -> Result<()> { - try!(self.add_enum_tag(variant_index)); + try!(self.add_value(variant_index)); value.serialize(self) } } diff --git a/tests/test.rs b/tests/test.rs index 5964a30..f2739ee 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -3,6 +3,7 @@ extern crate serde_derive; extern crate bincode; extern crate serde; +extern crate serde_bytes; extern crate byteorder; use std::fmt::Debug; @@ -18,7 +19,7 @@ use bincode::deserialize as deserialize_little; use bincode::deserialize_from as deserialize_from_little; fn the_same(element: V) - where V: serde::Serialize+serde::Deserialize+PartialEq+Debug+'static + where V: serde::Serialize+serde::de::DeserializeOwned+PartialEq+Debug+'static { let size = serialized_size(&element); { @@ -376,7 +377,7 @@ fn path_buf() { #[test] fn bytes() { - use serde::bytes::Bytes; + use serde_bytes::Bytes; let data = b"abc\0123"; let s = serialize_little(&data[..], Infinite).unwrap(); @@ -386,7 +387,7 @@ fn bytes() { #[test] fn serde_bytes() { - use serde::bytes::ByteBuf; + use serde_bytes::ByteBuf; the_same(ByteBuf::from(vec![1,2,3,4,5])); }