berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to serde 1.0 branch (#149) 

* Update to serde 1.0 branch

* The serde 1.0 branch merged
This commit is contained in:
David Tolnay 2017-04-19 16:05:59 -07:00 committed by Ty Overby
parent 0cf1185e9d
commit 7eccffd783
6 changed files with 83 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Cargo.toml
View File

@ -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" }

4
src/lib.rs
View File

@ -61,7 +61,7 @@ pub type Serializer<W> = serde::Serializer<W, byteorder::LittleEndian>;
/// 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<T>(bytes: &[u8]) -> serde::Result<T>
where T: serde_crate::Deserialize,
where T: serde_crate::de::DeserializeOwned,
{
serde::deserialize::<_, byteorder::LittleEndian>(bytes)
}
@ -76,7 +76,7 @@ pub fn deserialize<T>(bytes: &[u8]) -> serde::Result<T>
/// in is in an invalid state, as the error could be returned during any point
/// in the reading.
pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> serde::Result<T>
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)
}

4
src/serde/mod.rs
View File

@ -223,7 +223,7 @@ pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
/// in is in an invalid state, as the error could be returned during any point
/// in the reading.
pub fn deserialize_from<R: ?Sized, T, S, E>(reader: &mut R, size_limit: S) -> Result<T>
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<R: ?Sized, T, S, E>(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<T, E: ByteOrder>(bytes: &[u8]) -> Result<T>
where T: serde::Deserialize,
where T: serde::de::DeserializeOwned,
{
let mut reader = bytes;
deserialize_from::<_, _, _, E>(&mut reader, super::Infinite)

130
src/serde/reader.rs
View File

@ -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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
try!(self.read_type::<$ty>());
let value = try!(self.reader.$reader_method::<E>());
@ -90,20 +90,20 @@ macro_rules! impl_nums {
}
}
impl<'a, R, S, E> serde::Deserializer for &'a mut Deserializer<R, S, E>
impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer<R, S, E>
where R: Read, S: SizeLimit, E: ByteOrder {
type Error = Error;
#[inline]
fn deserialize<V>(self, _visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
{
let message = "bincode does not support Deserializer::deserialize";
Err(Error::custom(message))
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
try!(self.read_type::<u8>());
visitor.visit_u8(try!(self.reader.read_u8()))
@ -138,20 +138,20 @@ where R: Read, S: SizeLimit, E: ByteOrder {
#[inline]
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
try!(self.read_type::<i8>());
visitor.visit_i8(try!(self.reader.read_i8()))
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
visitor.visit_unit()
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
visitor.visit_str(&try!(self.read_string()))
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
visitor.visit_string(try!(self.read_string()))
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
visitor.visit_bytes(&try!(self.read_vec()))
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
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<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
impl<'a, R: 'a, S, E> serde::de::EnumVisitor for &'a mut Deserializer<R, S, E>
impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, S, E>
where R: Read, S: SizeLimit, E: ByteOrder {
type Error = Error;
type Variant = Self;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
where V: serde::de::DeserializeSeed,
fn variant_seed<V>(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<V>(self, _len: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
struct TupleVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a>(&'a mut Deserializer<R, S, E>);
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<T>(&mut self, seed: T) -> Result<Option<T::Value>>
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<V>(self,
fn deserialize_tuple<V>(self,
len: usize,
visitor: V) -> Result<V::Value>
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<R, S, E>,
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<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where T: serde::de::DeserializeSeed,
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
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<usize>) {
(self.len, Some(self.len))
fn size_hint(&self) -> Option<usize> {
Some(self.len)
}
}
visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
visitor.visit_seq(Access { deserializer: self, len: len })
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
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<R, S, E>,
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<K>(&mut self, seed: K) -> Result<Option<K::Value>>
where K: serde::de::DeserializeSeed,
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
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<V>(&mut self, seed: V) -> Result<V::Value>
where V: serde::de::DeserializeSeed,
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
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<usize>) {
(self.len, Some(self.len))
fn size_hint(&self) -> Option<usize> {
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<V>(self,
_name: &str,
fields: &'static [&'static str],
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
self.deserialize_tuple(fields.len(), visitor)
}
fn deserialize_struct_field<V>(self,
fn deserialize_identifier<V>(self,
_visitor: V) -> Result<V::Value>
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<V>(self,
_name: &str,
visitor: V) -> Result<V::Value>
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<V>(self,
_name: &'static str,
visitor: V) -> Result<V::Value>
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<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
self.deserialize_tuple(len, visitor)
}
fn deserialize_ignored_any<V>(self,
_visitor: V) -> Result<V::Value>
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<R, S, E>
impl<'de, 'a, R, S, E> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, S, E>
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<T>(self, seed: T) -> Result<T::Value>
where T: serde::de::DeserializeSeed,
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
where T: serde::de::DeserializeSeed<'de>,
{
serde::de::DeserializeSeed::deserialize(seed, self)
}
fn visit_tuple<V>(self,
fn tuple_variant<V>(self,
len: usize,
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
serde::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>
where V: serde::de::Visitor,
where V: serde::de::Visitor<'de>,
{
serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
}

56
src/serde/writer.rs
View File

@ -29,14 +29,6 @@ impl<W: Write, E: ByteOrder> Serializer<W, E> {
_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<W, E> {
@ -129,10 +121,6 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
Ok(Compound {ser: self})
}
fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self::SerializeSeq> {
Ok(Compound {ser: self})
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
Ok(Compound {ser: self})
}
@ -143,11 +131,11 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
fn serialize_tuple_variant(self,
_name: &'static str,
variant_index: usize,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeTupleVariant>
{
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<W, E>
fn serialize_struct_variant(self,
_name: &'static str,
variant_index: usize,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeStructVariant>
{
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<W, E>
fn serialize_newtype_variant<T: ?Sized>(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 <S: SizeLimit> SizeChecker<S> {
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<S> {
@ -318,10 +298,6 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
Ok(SizeCompound {ser: self})
}
fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self::SerializeSeq> {
Ok(SizeCompound {ser: self})
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
Ok(SizeCompound {ser: self})
}
@ -332,11 +308,11 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
fn serialize_tuple_variant(self,
_name: &'static str,
variant_index: usize,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeTupleVariant>
{
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<S> {
fn serialize_struct_variant(self,
_name: &'static str,
variant_index: usize,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeStructVariant>
{
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<S> {
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<V: serde::Serialize + ?Sized>(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)
}
}

7
tests/test.rs
View File

@ -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<V>(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]));
}