From 3a24da087b73e8899285e95e6d96198e1b7925d7 Mon Sep 17 00:00:00 2001 From: Ty Overby Date: Fri, 13 Oct 2017 08:57:04 -0700 Subject: [PATCH] cargo fmt source --- examples/basic.rs | 2 +- src/de/mod.rs | 201 +++++++++++++++++++----------- src/de/read.rs | 84 ++++++++----- src/internal.rs | 111 +++++++++++------ src/lib.rs | 37 ++++-- src/ser/mod.rs | 309 +++++++++++++++++++++++++++------------------- tests/test.rs | 113 +++++++++++------ 7 files changed, 537 insertions(+), 320 deletions(-) diff --git a/examples/basic.rs b/examples/basic.rs index 1632d75..04e48c4 100644 --- a/examples/basic.rs +++ b/examples/basic.rs @@ -2,7 +2,7 @@ extern crate serde_derive; extern crate bincode; -use bincode::{serialize, deserialize, Infinite}; +use bincode::{deserialize, serialize, Infinite}; #[derive(Serialize, Deserialize, PartialEq, Debug)] struct Entity { diff --git a/src/de/mod.rs b/src/de/mod.rs index 0bb1667..6724fc1 100644 --- a/src/de/mod.rs +++ b/src/de/mod.rs @@ -5,7 +5,7 @@ use byteorder::{ReadBytesExt, ByteOrder}; use serde_crate as serde; use serde_crate::de::IntoDeserializer; use serde_crate::de::Error as DeError; -use ::SizeLimit; +use SizeLimit; use super::{Result, Error, ErrorKind}; use self::read::BincodeRead; @@ -36,7 +36,7 @@ impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer Deserializer { reader: r, size_limit: size_limit, - _phantom: PhantomData + _phantom: PhantomData, } } @@ -57,8 +57,7 @@ impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer fn read_string(&mut self) -> Result { let vec = self.read_vec()?; - String::from_utf8(vec).map_err(|e| - ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into()) + String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into()) } } @@ -76,26 +75,30 @@ macro_rules! impl_nums { } impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer -where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { +where + R: BincodeRead<'de>, + S: SizeLimit, + E: ByteOrder, +{ type Error = Error; #[inline] fn deserialize_any(self, _visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { Err(Box::new(ErrorKind::DeserializeAnyNotSupported)) } fn deserialize_bool(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { let value: u8 = try!(serde::Deserialize::deserialize(self)); match value { 1 => visitor.visit_bool(true), 0 => visitor.visit_bool(false), - value => { - Err(ErrorKind::InvalidBoolEncoding(value).into()) - } + value => Err(ErrorKind::InvalidBoolEncoding(value).into()), } } @@ -111,7 +114,8 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { #[inline] fn deserialize_u8(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { try!(self.read_type::()); visitor.visit_u8(try!(self.reader.read_u8())) @@ -119,45 +123,56 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { #[inline] fn deserialize_i8(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + 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<'de>, + where + V: serde::de::Visitor<'de>, { visitor.visit_unit() } fn deserialize_char(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { use std::str; - let error = || { - ErrorKind::InvalidCharEncoding.into() - }; + let error = || ErrorKind::InvalidCharEncoding.into(); let mut buf = [0u8; 4]; // Look at the first byte to see how many bytes must be read let _ = try!(self.reader.read_exact(&mut buf[..1])); let width = utf8_char_width(buf[0]); - if width == 1 { return visitor.visit_char(buf[0] as char) } - if width == 0 { return Err(error())} + if width == 1 { + return visitor.visit_char(buf[0] as char); + } + if width == 0 { + return Err(error()); + } if self.reader.read_exact(&mut buf[1..width]).is_err() { return Err(error()); } - let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error())); + let res = try!( + str::from_utf8(&buf[..width]) + .ok() + .and_then(|s| s.chars().next()) + .ok_or(error()) + ); visitor.visit_char(res) } fn deserialize_str(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); try!(self.read_bytes(len as u64)); @@ -165,13 +180,15 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { } fn deserialize_string(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + 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<'de>, + where + V: serde::de::Visitor<'de>, { let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); try!(self.read_bytes(len as u64)); @@ -179,16 +196,20 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { } fn deserialize_byte_buf(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { visitor.visit_byte_buf(try!(self.read_vec())) } - fn deserialize_enum(self, - _enum: &'static str, - _variants: &'static [&'static str], - visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_enum( + self, + _enum: &'static str, + _variants: &'static [&'static str], + visitor: V, + ) -> Result + where + V: serde::de::Visitor<'de>, { impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { @@ -207,25 +228,35 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { visitor.visit_enum(self) } - fn deserialize_tuple(self, - len: usize, - visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_tuple(self, len: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'de>, { struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { deserializer: &'a mut Deserializer, len: usize, } - impl<'de, 'a, 'b: 'a, R: BincodeRead<'de>+ 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqAccess<'de> for Access<'a, R, S, E> { + impl< + 'de, + 'a, + 'b: 'a, + R: BincodeRead<'de> + 'b, + S: SizeLimit, + E: ByteOrder, + > serde::de::SeqAccess<'de> for Access<'a, R, S, E> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result> - where T: serde::de::DeserializeSeed<'de>, + where + T: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; - let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + let value = try!(serde::de::DeserializeSeed::deserialize( + seed, + &mut *self.deserializer, + )); Ok(Some(value)) } else { Ok(None) @@ -237,22 +268,27 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { } } - visitor.visit_seq(Access { deserializer: self, len: len }) + visitor.visit_seq(Access { + deserializer: self, + len: len, + }) } fn deserialize_option(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self)); match value { 0 => visitor.visit_none(), 1 => visitor.visit_some(&mut *self), - v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()) + v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()), } } fn deserialize_seq(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { let len = try!(serde::Deserialize::deserialize(&mut *self)); @@ -260,22 +296,34 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { } fn deserialize_map(self, visitor: V) -> Result - where V: serde::de::Visitor<'de>, + where + V: serde::de::Visitor<'de>, { struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { deserializer: &'a mut Deserializer, len: usize, } - impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapAccess<'de> for Access<'a, R, S, E> { + impl< + 'de, + 'a, + 'b: 'a, + R: BincodeRead<'de> + 'b, + S: SizeLimit, + E: ByteOrder, + > serde::de::MapAccess<'de> for Access<'a, R, S, E> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result> - where K: serde::de::DeserializeSeed<'de>, + where + K: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; - let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + let key = try!(serde::de::DeserializeSeed::deserialize( + seed, + &mut *self.deserializer, + )); Ok(Some(key)) } else { Ok(None) @@ -283,9 +331,13 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { } fn next_value_seed(&mut self, seed: V) -> Result - where V: serde::de::DeserializeSeed<'de>, + where + V: serde::de::DeserializeSeed<'de>, { - let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + let value = try!(serde::de::DeserializeSeed::deserialize( + seed, + &mut *self.deserializer, + )); Ok(value) } @@ -296,54 +348,61 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { let len = try!(serde::Deserialize::deserialize(&mut *self)); - visitor.visit_map(Access { 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<'de>, + fn deserialize_struct( + self, + _name: &str, + fields: &'static [&'static str], + visitor: V, + ) -> Result + where + V: serde::de::Visitor<'de>, { self.deserialize_tuple(fields.len(), visitor) } - fn deserialize_identifier(self, - _visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_identifier(self, _visitor: V) -> Result + where + V: serde::de::Visitor<'de>, { 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<'de>, + fn deserialize_newtype_struct(self, _name: &str, visitor: V) -> Result + where + V: serde::de::Visitor<'de>, { visitor.visit_newtype_struct(self) } - fn deserialize_unit_struct(self, - _name: &'static str, - visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result + where + V: serde::de::Visitor<'de>, { visitor.visit_unit() } - fn deserialize_tuple_struct(self, - _name: &'static str, - len: usize, - visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_tuple_struct( + self, + _name: &'static str, + len: usize, + visitor: V, + ) -> Result + where + V: serde::de::Visitor<'de>, { self.deserialize_tuple(len, visitor) } - fn deserialize_ignored_any(self, - _visitor: V) -> Result - where V: serde::de::Visitor<'de>, + fn deserialize_ignored_any(self, _visitor: V) -> Result + where + V: serde::de::Visitor<'de>, { let message = "bincode does not support Deserializer::deserialize_ignored_any"; Err(Error::custom(message)) diff --git a/src/de/read.rs b/src/de/read.rs index 8ef0403..0c12020 100644 --- a/src/de/read.rs +++ b/src/de/read.rs @@ -1,25 +1,27 @@ use std::io; -use ::Result; +use Result; use serde_crate as serde; /// A byte-oriented reading trait that is specialized for /// slices and generic readers. pub trait BincodeRead<'storage>: io::Read + ::private::Sealed { #[doc(hidden)] - fn forward_read_str(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'storage>; + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'storage>; #[doc(hidden)] fn get_byte_buffer(&mut self, length: usize) -> Result>; #[doc(hidden)] - fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'storage>; + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'storage>; } /// A BincodeRead implementation for byte slices pub struct SliceReader<'storage> { - slice: &'storage [u8] + slice: &'storage [u8], } /// A BincodeRead implementation for io::Readers @@ -28,16 +30,14 @@ pub struct IoReader { temp_buffer: Vec, } -impl <'storage> SliceReader<'storage> { +impl<'storage> SliceReader<'storage> { /// Constructs a slice reader pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> { - SliceReader { - slice: bytes, - } + SliceReader { slice: bytes } } } -impl IoReader { +impl IoReader { /// Constructs an IoReadReader pub fn new(r: R) -> IoReader { IoReader { @@ -47,34 +47,38 @@ impl IoReader { } } -impl <'storage> io::Read for SliceReader<'storage> { - fn read(&mut self, out: & mut [u8]) -> io::Result { +impl<'storage> io::Read for SliceReader<'storage> { + fn read(&mut self, out: &mut [u8]) -> io::Result { (&mut self.slice).read(out) } - fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> { + fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> { (&mut self.slice).read_exact(out) } } -impl io::Read for IoReader { - fn read(&mut self, out: & mut [u8]) -> io::Result { +impl io::Read for IoReader { + fn read(&mut self, out: &mut [u8]) -> io::Result { self.reader.read(out) } - fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> { + fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> { self.reader.read_exact(out) } } -impl <'storage> SliceReader<'storage> { +impl<'storage> SliceReader<'storage> { fn unexpected_eof() -> Box<::ErrorKind> { - return Box::new(::ErrorKind::Io(io::Error::new(io::ErrorKind::UnexpectedEof, ""))); + return Box::new(::ErrorKind::Io( + io::Error::new(io::ErrorKind::UnexpectedEof, ""), + )); } } -impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { - fn forward_read_str(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'storage> { - use ::ErrorKind; +impl<'storage> BincodeRead<'storage> for SliceReader<'storage> { + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'storage>, + { + use ErrorKind; if length > self.slice.len() { return Err(SliceReader::unexpected_eof()); } @@ -98,8 +102,10 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { Ok(r.to_vec()) } - fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'storage> { + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'storage>, + { if length > self.slice.len() { return Err(SliceReader::unexpected_eof()); } @@ -110,12 +116,17 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { } } -impl IoReader where R: io::Read { +impl IoReader +where + R: io::Read, +{ fn fill_buffer(&mut self, length: usize) -> Result<()> { let current_length = self.temp_buffer.len(); - if length > current_length{ + if length > current_length { self.temp_buffer.reserve_exact(length - current_length); - unsafe { self.temp_buffer.set_len(length); } + unsafe { + self.temp_buffer.set_len(length); + } } self.reader.read_exact(&mut self.temp_buffer[..length])?; @@ -123,9 +134,14 @@ impl IoReader where R: io::Read { } } -impl BincodeRead<'static> for IoReader where R: io::Read { - fn forward_read_str(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'static> { +impl BincodeRead<'static> for IoReader +where + R: io::Read, +{ + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'static>, + { self.fill_buffer(length)?; let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) { @@ -142,8 +158,10 @@ impl BincodeRead<'static> for IoReader where R: io::Read { Ok(self.temp_buffer[..length].to_vec()) } - fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result - where V: serde::de::Visitor<'static> { + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where + V: serde::de::Visitor<'static>, + { self.fill_buffer(length)?; let r = visitor.visit_bytes(&self.temp_buffer[..length]); r diff --git a/src/internal.rs b/src/internal.rs index 960a65c..b85aed9 100644 --- a/src/internal.rs +++ b/src/internal.rs @@ -5,17 +5,13 @@ use std::io::{self, Write, Read}; use std::{error, fmt, result}; use std::str::Utf8Error; -use ::{CountSize, SizeLimit}; -use byteorder::{ByteOrder}; +use {CountSize, SizeLimit}; +use byteorder::ByteOrder; use std::error::Error as StdError; -pub use super::de::{ - Deserializer, -}; +pub use super::de::Deserializer; -pub use super::ser::{ - Serializer, -}; +pub use super::ser::Serializer; use super::ser::SizeChecker; @@ -52,7 +48,7 @@ pub enum ErrorKind { /// Bincode can not encode sequences of unknown length (like iterators). SequenceMustHaveLength, /// A custom error message from Serde. - Custom(String) + Custom(String), } impl StdError for ErrorKind { @@ -64,7 +60,9 @@ impl StdError for ErrorKind { ErrorKind::InvalidCharEncoding => "char is not valid", ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid", ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences", - ErrorKind::DeserializeAnyNotSupported => "bincode doesn't support serde::Deserializer::deserialize_any", + ErrorKind::DeserializeAnyNotSupported => { + "bincode doesn't support serde::Deserializer::deserialize_any" + } ErrorKind::SizeLimit => "the size limit for decoding has been reached", ErrorKind::Custom(ref msg) => msg, @@ -95,24 +93,29 @@ impl From for Error { impl fmt::Display for ErrorKind { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - ErrorKind::Io(ref ioerr) => - write!(fmt, "io error: {}", ioerr), - ErrorKind::InvalidUtf8Encoding(ref e) => - write!(fmt, "{}: {}", self.description(), e), - ErrorKind::InvalidBoolEncoding(b) => - write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b), - ErrorKind::InvalidCharEncoding => - write!(fmt, "{}", self.description()), - ErrorKind::InvalidTagEncoding(tag) => - write!(fmt, "{}, found {}", self.description(), tag), - ErrorKind::SequenceMustHaveLength => - write!(fmt, "bincode can only encode sequences and maps that have a knowable size ahead of time."), - ErrorKind::SizeLimit => - write!(fmt, "size limit was exceeded"), - ErrorKind::DeserializeAnyNotSupported=> - write!(fmt, "bincode does not support the serde::Deserializer::deserialize_any method"), - ErrorKind::Custom(ref s) => - s.fmt(fmt), + ErrorKind::Io(ref ioerr) => write!(fmt, "io error: {}", ioerr), + ErrorKind::InvalidUtf8Encoding(ref e) => write!(fmt, "{}: {}", self.description(), e), + ErrorKind::InvalidBoolEncoding(b) => { + write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b) + } + ErrorKind::InvalidCharEncoding => write!(fmt, "{}", self.description()), + ErrorKind::InvalidTagEncoding(tag) => { + write!(fmt, "{}, found {}", self.description(), tag) + } + ErrorKind::SequenceMustHaveLength => { + write!( + fmt, + "bincode can only encode sequences and maps that have a knowable size ahead of time." + ) + } + ErrorKind::SizeLimit => write!(fmt, "size limit was exceeded"), + ErrorKind::DeserializeAnyNotSupported => { + write!( + fmt, + "bincode does not support the serde::Deserializer::deserialize_any method" + ) + } + ErrorKind::Custom(ref s) => s.fmt(fmt), } } } @@ -138,10 +141,16 @@ impl serde::ser::Error for Error { /// writer is in an invalid state, as writing could bail out in the middle of /// serializing. pub fn serialize_into(writer: W, value: &T, size_limit: S) -> Result<()> - where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder +where + W: Write, + T: serde::Serialize, + S: SizeLimit, + E: ByteOrder, { if let Some(limit) = size_limit.limit() { - try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit)); + try!(serialized_size_bounded(value, limit).ok_or( + ErrorKind::SizeLimit, + )); } let mut serializer = Serializer::<_, E>::new(writer); @@ -153,11 +162,16 @@ pub fn serialize_into(writer: W, value: &T, size_limit: S) - /// If the serialization would take more bytes than allowed by `size_limit`, /// an error is returned. pub fn serialize(value: &T, size_limit: S) -> Result> - where T: serde::Serialize, S: SizeLimit, E: ByteOrder +where + T: serde::Serialize, + S: SizeLimit, + E: ByteOrder, { let mut writer = match size_limit.limit() { Some(size_limit) => { - let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(ErrorKind::SizeLimit)); + let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or( + ErrorKind::SizeLimit, + )); Vec::with_capacity(actual_size as usize) } None => { @@ -166,7 +180,11 @@ pub fn serialize(value: &T, size_limit: S) -> Result> } }; - try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite)); + try!(serialize_into::<_, _, _, E>( + &mut writer, + value, + super::Infinite, + )); Ok(writer) } @@ -175,7 +193,7 @@ impl SizeLimit for CountSize { self.total += c; if let Some(limit) = self.limit { if self.total > limit { - return Err(Box::new(ErrorKind::SizeLimit)) + return Err(Box::new(ErrorKind::SizeLimit)); } } Ok(()) @@ -191,10 +209,14 @@ impl SizeLimit for CountSize { /// This is used internally as part of the check for encode_into, but it can /// be useful for preallocating buffers if thats your style. pub fn serialized_size(value: &T) -> u64 - where T: serde::Serialize +where + T: serde::Serialize, { let mut size_counter = SizeChecker { - size_limit: CountSize { total: 0, limit: None } + size_limit: CountSize { + total: 0, + limit: None, + }, }; value.serialize(&mut size_counter).ok(); @@ -207,10 +229,14 @@ pub fn serialized_size(value: &T) -> u64 /// If it can be serialized in `max` or fewer bytes, that number will be returned /// inside `Some`. If it goes over bounds, then None is returned. pub fn serialized_size_bounded(value: &T, max: u64) -> Option - where T: serde::Serialize +where + T: serde::Serialize, { let mut size_counter = SizeChecker { - size_limit: CountSize { total: 0, limit: Some(max) } + size_limit: CountSize { + total: 0, + limit: Some(max), + }, }; match value.serialize(&mut size_counter) { @@ -229,7 +255,11 @@ 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: R, size_limit: S) -> Result - where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder +where + R: Read, + T: serde::de::DeserializeOwned, + S: SizeLimit, + E: ByteOrder, { let reader = ::de::read::IoReader::new(reader); let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit); @@ -241,7 +271,8 @@ pub fn deserialize_from(reader: R, size_limit: S) -> Result /// 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<'a, T, E: ByteOrder>(bytes: &'a [u8]) -> Result - where T: serde::de::Deserialize<'a>, +where + T: serde::de::Deserialize<'a>, { let reader = ::de::read::SliceReader::new(bytes); let mut deserializer = Deserializer::<_, _, E>::new(reader, super::Infinite); diff --git a/src/lib.rs b/src/lib.rs index 2c805ed..f5b9d79 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -45,7 +45,7 @@ pub mod internal; pub mod read_types { //! The types that the deserializer uses for optimizations - pub use ::de::read::{SliceReader, BincodeRead, IoReader}; + pub use de::read::{SliceReader, BincodeRead, IoReader}; } use std::io::{Read, Write}; @@ -62,7 +62,8 @@ pub type Serializer = internal::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<'a, T>(bytes: &'a [u8]) -> internal::Result - where T: serde_crate::de::Deserialize<'a>, +where + T: serde_crate::de::Deserialize<'a>, { internal::deserialize::<_, byteorder::LittleEndian>(bytes) } @@ -77,7 +78,10 @@ pub fn deserialize<'a, T>(bytes: &'a [u8]) -> internal::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) -> internal::Result - where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit +where + R: Read, + T: serde_crate::de::DeserializeOwned, + S: SizeLimit, { internal::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit) } @@ -90,8 +94,15 @@ pub fn deserialize_from(reader: &mut R, size_limit: S) -> inter /// If this returns an `Error` (other than SizeLimit), assume that the /// writer is in an invalid state, as writing could bail out in the middle of /// serializing. -pub fn serialize_into(writer: &mut W, value: &T, size_limit: S) -> internal::Result<()> - where W: Write, T: serde_crate::Serialize, S: SizeLimit +pub fn serialize_into( + writer: &mut W, + value: &T, + size_limit: S, +) -> internal::Result<()> +where + W: Write, + T: serde_crate::Serialize, + S: SizeLimit, { internal::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit) } @@ -101,7 +112,9 @@ pub fn serialize_into(writer: &mut W, value: &T, size_l /// If the serialization would take more bytes than allowed by `size_limit`, /// an error is returned. pub fn serialize(value: &T, size_limit: S) -> internal::Result> - where T: serde_crate::Serialize, S: SizeLimit +where + T: serde_crate::Serialize, + S: SizeLimit, { internal::serialize::<_, _, byteorder::LittleEndian>(value, size_limit) } @@ -159,15 +172,21 @@ impl SizeLimit for Bounded { } #[inline(always)] - fn limit(&self) -> Option { Some(self.0) } + fn limit(&self) -> Option { + Some(self.0) + } } impl SizeLimit for Infinite { #[inline(always)] - fn add(&mut self, _: u64) -> Result<()> { Ok (()) } + fn add(&mut self, _: u64) -> Result<()> { + Ok(()) + } #[inline(always)] - fn limit(&self) -> Option { None } + fn limit(&self) -> Option { + None + } } mod private { diff --git a/src/ser/mod.rs b/src/ser/mod.rs index 9082afa..34e5112 100644 --- a/src/ser/mod.rs +++ b/src/ser/mod.rs @@ -42,12 +42,18 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer type SerializeStruct = Compound<'a, W, E>; type SerializeStructVariant = Compound<'a, W, E>; - fn serialize_unit(self) -> Result<()> { Ok(()) } + fn serialize_unit(self) -> Result<()> { + Ok(()) + } - fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) } + fn serialize_unit_struct(self, _: &'static str) -> Result<()> { + Ok(()) + } fn serialize_bool(self, v: bool) -> Result<()> { - self.writer.write_u8(if v {1} else {0}).map_err(Into::into) + self.writer.write_u8(if v { 1 } else { 0 }).map_err( + Into::into, + ) } fn serialize_u8(self, v: u8) -> Result<()> { @@ -96,7 +102,9 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer } fn serialize_char(self, c: char) -> Result<()> { - self.writer.write_all(encode_utf8(c).as_slice()).map_err(Into::into) + self.writer.write_all(encode_utf8(c).as_slice()).map_err( + Into::into, + ) } fn serialize_bytes(self, v: &[u8]) -> Result<()> { @@ -109,7 +117,8 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer } fn serialize_some(self, v: &T) -> Result<()> - where T: serde::Serialize, + where + T: serde::Serialize, { try!(self.writer.write_u8(1)); v.serialize(self) @@ -118,70 +127,80 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer fn serialize_seq(self, len: Option) -> Result { let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); try!(self.serialize_u64(len as u64)); - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } fn serialize_tuple(self, _len: usize) -> Result { - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result { - Ok(Compound {ser: self}) + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result { + Ok(Compound { ser: self }) } - fn serialize_tuple_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) -> Result - { + fn serialize_tuple_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { try!(self.serialize_u32(variant_index)); - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } fn serialize_map(self, len: Option) -> Result { let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); try!(self.serialize_u64(len as u64)); - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } - fn serialize_struct_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) -> Result - { + fn serialize_struct_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { try!(self.serialize_u32(variant_index)); - Ok(Compound {ser: self}) + Ok(Compound { ser: self }) } - fn serialize_newtype_struct(self, - _name: &'static str, - value: &T) -> Result<()> - where T: serde::ser::Serialize, + fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> Result<()> + where + T: serde::ser::Serialize, { value.serialize(self) } - fn serialize_newtype_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - value: &T) -> Result<()> - where T: serde::ser::Serialize, + fn serialize_newtype_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + value: &T, + ) -> Result<()> + where + T: serde::ser::Serialize, { try!(self.serialize_u32(variant_index)); value.serialize(self) } - fn serialize_unit_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str) -> Result<()> { + fn serialize_unit_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + ) -> Result<()> { self.serialize_u32(variant_index) } } @@ -190,11 +209,9 @@ pub struct SizeChecker { pub size_limit: S, } -impl SizeChecker { +impl SizeChecker { pub fn new(size_limit: S) -> SizeChecker { - SizeChecker { - size_limit: size_limit - } + SizeChecker { size_limit: size_limit } } fn add_raw(&mut self, size: u64) -> Result<()> { @@ -218,9 +235,13 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { type SerializeStruct = SizeCompound<'a, S>; type SerializeStructVariant = SizeCompound<'a, S>; - fn serialize_unit(self) -> Result<()> { Ok(()) } + fn serialize_unit(self) -> Result<()> { + Ok(()) + } - fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) } + fn serialize_unit_struct(self, _: &'static str) -> Result<()> { + Ok(()) + } fn serialize_bool(self, _: bool) -> Result<()> { self.add_value(0 as u8) @@ -285,7 +306,8 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { } fn serialize_some(self, v: &T) -> Result<()> - where T: serde::Serialize, + where + T: serde::Serialize, { try!(self.add_value(1 as u8)); v.serialize(self) @@ -295,66 +317,78 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); try!(self.serialize_u64(len as u64)); - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } fn serialize_tuple(self, _len: usize) -> Result { - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result { - Ok(SizeCompound {ser: self}) + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result { + Ok(SizeCompound { ser: self }) } - fn serialize_tuple_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) -> Result - { + fn serialize_tuple_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { try!(self.add_value(variant_index)); - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } - fn serialize_map(self, len: Option) -> Result - { + fn serialize_map(self, len: Option) -> Result { let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); try!(self.serialize_u64(len as u64)); - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } - fn serialize_struct_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) -> Result - { + fn serialize_struct_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { try!(self.add_value(variant_index)); - Ok(SizeCompound {ser: self}) + Ok(SizeCompound { ser: self }) } - fn serialize_newtype_struct(self, _name: &'static str, v: &V) -> Result<()> { + fn serialize_newtype_struct( + self, + _name: &'static str, + v: &V, + ) -> Result<()> { v.serialize(self) } - fn serialize_unit_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str) -> Result<()> { + fn serialize_unit_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + ) -> Result<()> { self.add_value(variant_index) } - fn serialize_newtype_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - value: &V) -> Result<()> - { + fn serialize_newtype_variant( + self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + value: &V, + ) -> Result<()> { try!(self.add_value(variant_index)); value.serialize(self) } @@ -366,14 +400,17 @@ pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> { } impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -385,14 +422,17 @@ impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -404,14 +444,17 @@ impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -423,14 +466,17 @@ impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -442,21 +488,25 @@ impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_key(&mut self, value: &K) -> Result<()> - where K: serde::ser::Serialize + where + K: serde::ser::Serialize, { value.serialize(&mut *self.ser) } - #[inline] + #[inline] fn serialize_value(&mut self, value: &V) -> Result<()> - where V: serde::ser::Serialize + where + V: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -468,14 +518,17 @@ impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -487,14 +540,17 @@ impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E> } impl<'a, W, E> serde::ser::SerializeStructVariant for Compound<'a, W, E> - where W: Write, E: ByteOrder +where + W: Write, + E: ByteOrder, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -510,14 +566,14 @@ pub struct SizeCompound<'a, S: SizeLimit + 'a> { ser: &'a mut SizeChecker, } -impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -528,14 +584,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -546,14 +602,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -564,14 +620,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -582,21 +638,22 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_key(&mut self, value: &K) -> Result<()> - where K: serde::ser::Serialize + where + K: serde::ser::Serialize, { value.serialize(&mut *self.ser) } - #[inline] + #[inline] fn serialize_value(&mut self, value: &V) -> Result<()> - where V: serde::ser::Serialize + where + V: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -607,14 +664,14 @@ impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -625,14 +682,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> } } -impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S> -{ +impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> - where T: serde::ser::Serialize + where + T: serde::ser::Serialize, { value.serialize(&mut *self.ser) } @@ -642,13 +699,13 @@ impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S Ok(()) } } -const TAG_CONT: u8 = 0b1000_0000; -const TAG_TWO_B: u8 = 0b1100_0000; +const TAG_CONT: u8 = 0b1000_0000; +const TAG_TWO_B: u8 = 0b1100_0000; const TAG_THREE_B: u8 = 0b1110_0000; -const TAG_FOUR_B: u8 = 0b1111_0000; -const MAX_ONE_B: u32 = 0x80; -const MAX_TWO_B: u32 = 0x800; -const MAX_THREE_B: u32 = 0x10000; +const TAG_FOUR_B: u8 = 0b1111_0000; +const MAX_ONE_B: u32 = 0x80; +const MAX_TWO_B: u32 = 0x800; +const MAX_THREE_B: u32 = 0x10000; fn encode_utf8(c: char) -> EncodeUtf8 { let code = c as u32; @@ -662,13 +719,13 @@ fn encode_utf8(c: char) -> EncodeUtf8 { 2 } else if code < MAX_THREE_B { buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; - buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; + buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; buf[3] = (code & 0x3F) as u8 | TAG_CONT; 1 } else { buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT; - buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; + buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; buf[3] = (code & 0x3F) as u8 | TAG_CONT; 0 }; diff --git a/tests/test.rs b/tests/test.rs index 5299a01..4f5eee2 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -10,16 +10,17 @@ use std::fmt::Debug; use std::collections::HashMap; use std::borrow::Cow; -use bincode::{Infinite, Bounded}; +use bincode::{Bounded, Infinite}; use bincode::{serialized_size, ErrorKind, Result}; -use bincode::internal::{serialize, deserialize, deserialize_from}; +use bincode::internal::{deserialize, deserialize_from, serialize}; use bincode::serialize as serialize_little; use bincode::deserialize as deserialize_little; use bincode::deserialize_from as deserialize_from_little; fn the_same(element: V) - where V: serde::Serialize+serde::de::DeserializeOwned+PartialEq+Debug+'static +where + V: serde::Serialize + serde::de::DeserializeOwned + PartialEq + Debug + 'static, { let size = serialized_size(&element); @@ -34,7 +35,8 @@ fn the_same(element: V) { let encoded = serialize::<_, _, byteorder::BigEndian>(&element, Infinite).unwrap(); let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]).unwrap(); - let decoded_reader = deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap(); + let decoded_reader = + deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap(); assert_eq!(element, decoded); assert_eq!(element, decoded_reader); @@ -79,8 +81,8 @@ fn test_string() { #[test] fn test_tuple() { the_same((1isize,)); - the_same((1isize,2isize,3isize)); - the_same((1isize,"foo".to_string(),())); + the_same((1isize, 2isize, 3isize)); + the_same((1isize, "foo".to_string(), ())); } #[test] @@ -89,9 +91,13 @@ fn test_basic_struct() { struct Easy { x: isize, s: String, - y: usize + y: usize, } - the_same(Easy{x: -4, s: "foo".to_string(), y: 10}); + the_same(Easy { + x: -4, + s: "foo".to_string(), + y: 10, + }); } #[test] @@ -100,19 +106,27 @@ fn test_nested_struct() { struct Easy { x: isize, s: String, - y: usize + y: usize, } #[derive(Serialize, Deserialize, PartialEq, Debug)] struct Nest { f: Easy, b: usize, - s: Easy + s: Easy, } the_same(Nest { - f: Easy {x: -1, s: "foo".to_string(), y: 20}, + f: Easy { + x: -1, + s: "foo".to_string(), + y: 20, + }, b: 100, - s: Easy {x: -100, s: "bar".to_string(), y: 20} + s: Easy { + x: -100, + s: "bar".to_string(), + y: 20, + }, }); } @@ -147,15 +161,19 @@ fn test_enum() { OneArg(usize), Args(usize, usize), AnotherNoArg, - StructLike{x: usize, y: f32} + StructLike { x: usize, y: f32 }, } the_same(TestEnum::NoArg); the_same(TestEnum::OneArg(4)); //the_same(TestEnum::Args(4, 5)); the_same(TestEnum::AnotherNoArg); - the_same(TestEnum::StructLike{x: 4, y: 3.14159}); - the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg, - TestEnum::StructLike{x: 4, y:1.4}]); + the_same(TestEnum::StructLike { x: 4, y: 3.14159 }); + the_same(vec![ + TestEnum::NoArg, + TestEnum::OneArg(5), + TestEnum::AnotherNoArg, + TestEnum::StructLike { x: 4, y: 1.4 }, + ]); } #[test] @@ -163,7 +181,7 @@ fn test_vec() { let v: Vec = vec![]; the_same(v); the_same(vec![1u64]); - the_same(vec![1u64,2,3,4,5,6]); + the_same(vec![1u64, 2, 3, 4, 5, 6]); } #[test] @@ -197,11 +215,11 @@ fn test_fixed_size_array() { fn deserializing_errors() { match *deserialize_little::(&vec![0xA][..]).unwrap_err() { - ErrorKind::InvalidBoolEncoding(0xA) => {}, + ErrorKind::InvalidBoolEncoding(0xA) => {} _ => panic!(), } match *deserialize_little::(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..]).unwrap_err() { - ErrorKind::InvalidUtf8Encoding(_) => {}, + ErrorKind::InvalidUtf8Encoding(_) => {} _ => panic!(), } @@ -214,23 +232,25 @@ fn deserializing_errors() { match *deserialize_little::(&vec![0, 0, 0, 5][..]).unwrap_err() { // Error message comes from serde - ErrorKind::Custom(_) => {}, + ErrorKind::Custom(_) => {} _ => panic!(), } match *deserialize_little::>(&vec![5, 0][..]).unwrap_err() { - ErrorKind::InvalidTagEncoding(_) => {}, + ErrorKind::InvalidTagEncoding(_) => {} _ => panic!(), } } #[test] fn too_big_deserialize() { - let serialized = vec![0,0,0,3]; - let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3)); + let serialized = vec![0, 0, 0, 3]; + let deserialized: Result = + deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3)); assert!(deserialized.is_err()); - let serialized = vec![0,0,0,3]; - let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4)); + let serialized = vec![0, 0, 0, 3]; + let deserialized: Result = + deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4)); assert!(deserialized.is_ok()); } @@ -247,7 +267,8 @@ fn char_serialization() { #[test] fn too_big_char_deserialize() { let serialized = vec![0x41]; - let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1)); + let deserialized: Result = + deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1)); assert!(deserialized.is_ok()); assert_eq!(deserialized.unwrap(), 'A'); } @@ -297,7 +318,7 @@ fn encode_box() { #[test] fn test_cow_serialize() { - let large_object = vec![1u32,2,3,4,5,6]; + let large_object = vec![1u32, 2, 3, 4, 5, 6]; let mut large_map = HashMap::new(); large_map.insert(1, 2); @@ -305,28 +326,32 @@ fn test_cow_serialize() { #[derive(Serialize, Deserialize, Debug)] enum Message<'a> { M1(Cow<'a, Vec>), - M2(Cow<'a, HashMap>) + M2(Cow<'a, HashMap>), } // Test 1 { - let serialized = serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap(); - let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + let serialized = + serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap(); + let deserialized: Message<'static> = + deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M1(b) => assert!(&b.into_owned() == &large_object), - _ => assert!(false) + _ => assert!(false), } } // Test 2 { - let serialized = serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap(); - let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + let serialized = + serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap(); + let deserialized: Message<'static> = + deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M2(b) => assert!(&b.into_owned() == &large_map), - _ => assert!(false) + _ => assert!(false), } } } @@ -335,17 +360,19 @@ fn test_cow_serialize() { fn test_strbox_serialize() { let strx: &'static str = "hello world"; let serialized = serialize_little(&Cow::Borrowed(strx), Infinite).unwrap(); - let deserialized: Cow<'static, String> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + let deserialized: Cow<'static, String> = + deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); let stringx: String = deserialized.into_owned(); assert!(strx == &stringx[..]); } #[test] fn test_slicebox_serialize() { - let slice = [1u32, 2, 3 ,4, 5]; + let slice = [1u32, 2, 3, 4, 5]; let serialized = serialize_little(&Cow::Borrowed(&slice[..]), Infinite).unwrap(); println!("{:?}", serialized); - let deserialized: Cow<'static, Vec> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + let deserialized: Cow<'static, Vec> = + deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); { let sb: &[u32] = &deserialized; assert!(slice == sb); @@ -365,9 +392,15 @@ fn test_oom_protection() { #[derive(Serialize, Deserialize, PartialEq, Debug)] struct FakeVec { len: u64, - byte: u8 + byte: u8, } - let x = serialize_little(&FakeVec { len: 0xffffffffffffffffu64, byte: 1 }, Bounded(10)).unwrap(); + let x = serialize_little( + &FakeVec { + len: 0xffffffffffffffffu64, + byte: 1, + }, + Bounded(10), + ).unwrap(); let y: Result> = deserialize_from_little(&mut Cursor::new(&x[..]), Bounded(10)); assert!(y.is_err()); } @@ -394,7 +427,7 @@ fn bytes() { #[test] fn serde_bytes() { use serde_bytes::ByteBuf; - the_same(ByteBuf::from(vec![1,2,3,4,5])); + the_same(ByteBuf::from(vec![1, 2, 3, 4, 5])); }