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

cargo fmt source

This commit is contained in:
Ty Overby 2017-10-13 08:57:04 -07:00
parent 470aa1c703
commit 3a24da087b
7 changed files with 537 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/basic.rs
View File

@ -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 {

189
src/de/mod.rs
View File

@ -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<R, S, E>
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<R, S, E>
fn read_string(&mut self) -> Result<String> {
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<R, S, E>
where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
where
R: BincodeRead<'de>,
S: SizeLimit,
E: ByteOrder,
{
type Error = Error;
#[inline]
fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
where
V: serde::de::Visitor<'de>,
{
Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
where
V: serde::de::Visitor<'de>,
{
try!(self.read_type::<u8>());
visitor.visit_u8(try!(self.reader.read_u8()))
@ -119,45 +123,56 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
#[inline]
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
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<'de>,
where
V: serde::de::Visitor<'de>,
{
visitor.visit_unit()
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
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<'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<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
where
V: serde::de::Visitor<'de>,
{
visitor.visit_byte_buf(try!(self.read_vec()))
}
fn deserialize_enum<V>(self,
fn deserialize_enum<V>(
self,
_enum: &'static str,
_variants: &'static [&'static str],
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
visitor: V,
) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, S, E>
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<V>(self,
len: usize,
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
deserializer: &'a mut Deserializer<R, S, E>,
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<T>(&mut self, seed: T) -> Result<Option<T::Value>>
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<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
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<V>(self, visitor: V) -> Result<V::Value>
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<R, S, E>,
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<K>(&mut self, seed: K) -> Result<Option<K::Value>>
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<V>(&mut self, seed: V) -> Result<V::Value>
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<V>(self,
fn deserialize_struct<V>(
self,
_name: &str,
fields: &'static [&'static str],
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
visitor: V,
) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
self.deserialize_tuple(fields.len(), visitor)
}
fn deserialize_identifier<V>(self,
_visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
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<'de>,
fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
fn deserialize_unit_struct<V>(self,
_name: &'static str,
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
visitor.visit_unit()
}
fn deserialize_tuple_struct<V>(self,
fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
len: usize,
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'de>,
visitor: V,
) -> Result<V::Value>
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<'de>,
fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
where
V: serde::de::Visitor<'de>,
{
let message = "bincode does not support Deserializer::deserialize_ignored_any";
Err(Error::custom(message))

72
src/de/read.rs
View File

@ -1,5 +1,5 @@
use std::io;
use ::Result;
use Result;
use serde_crate as serde;
/// A byte-oriented reading trait that is specialized for
@ -7,19 +7,21 @@ use serde_crate as serde;
pub trait BincodeRead<'storage>: io::Read + ::private::Sealed {
#[doc(hidden)]
fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'storage>;
where
V: serde::de::Visitor<'storage>;
#[doc(hidden)]
fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>>;
#[doc(hidden)]
fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'storage>;
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<R> {
temp_buffer: Vec<u8>,
}
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 <R> IoReader<R> {
impl<R> IoReader<R> {
/// Constructs an IoReadReader
pub fn new(r: R) -> IoReader<R> {
IoReader {
@ -47,34 +47,38 @@ impl <R> IoReader<R> {
}
}
impl <'storage> io::Read for SliceReader<'storage> {
fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
impl<'storage> io::Read for SliceReader<'storage> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
(&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 <R: io::Read> io::Read for IoReader<R> {
fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
impl<R: io::Read> io::Read for IoReader<R> {
fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
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> {
impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'storage> {
use ::ErrorKind;
where
V: serde::de::Visitor<'storage>,
{
use ErrorKind;
if length > self.slice.len() {
return Err(SliceReader::unexpected_eof());
}
@ -99,7 +103,9 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> {
}
fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'storage> {
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 <R> IoReader<R> where R: io::Read {
impl<R> IoReader<R>
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 <R> IoReader<R> where R: io::Read {
}
}
impl <R> BincodeRead<'static> for IoReader<R> where R: io::Read {
impl<R> BincodeRead<'static> for IoReader<R>
where
R: io::Read,
{
fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'static> {
where
V: serde::de::Visitor<'static>,
{
self.fill_buffer(length)?;
let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) {
@ -143,7 +159,9 @@ impl <R> BincodeRead<'static> for IoReader<R> where R: io::Read {
}
fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor<'static> {
where
V: serde::de::Visitor<'static>,
{
self.fill_buffer(length)?;
let r = visitor.visit_bytes(&self.temp_buffer[..length]);
r

111
src/internal.rs
View File

@ -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<io::Error> 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<W, T: ?Sized, S, E>(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<W, T: ?Sized, S, E>(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<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
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<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
}
};
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<T: ?Sized>(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<T: ?Sized>(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<T: ?Sized>(value: &T, max: u64) -> Option<u64>
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<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, T, S, E>(reader: R, size_limit: S) -> Result<T>
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<R, T, S, E>(reader: R, size_limit: S) -> Result<T>
/// 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<T>
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);

37
src/lib.rs
View File

@ -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<W> = internal::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<'a, T>(bytes: &'a [u8]) -> internal::Result<T>
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<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) -> internal::Result<T>
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<R: ?Sized, T, S>(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<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_limit: S) -> internal::Result<()>
where W: Write, T: serde_crate::Serialize, S: SizeLimit
pub fn serialize_into<W: ?Sized, T: ?Sized, S>(
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<W: ?Sized, T: ?Sized, S>(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<T: ?Sized, S>(value: &T, size_limit: S) -> internal::Result<Vec<u8>>
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<u64> { Some(self.0) }
fn limit(&self) -> Option<u64> {
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<u64> { None }
fn limit(&self) -> Option<u64> {
None
}
}
mod private {

255
src/ser/mod.rs
View File

@ -42,12 +42,18 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
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<W, E>
}
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<W, E>
}
fn serialize_some<T: ?Sized>(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<W, E>
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
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<Self::SerializeTuple> {
Ok(Compound {ser: self})
Ok(Compound { ser: self })
}
fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
Ok(Compound {ser: self})
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct> {
Ok(Compound { ser: self })
}
fn serialize_tuple_variant(self,
fn serialize_tuple_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeTupleVariant>
{
_len: usize,
) -> Result<Self::SerializeTupleVariant> {
try!(self.serialize_u32(variant_index));
Ok(Compound {ser: self})
Ok(Compound { ser: self })
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
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<Self::SerializeStruct> {
Ok(Compound {ser: self})
Ok(Compound { ser: self })
}
fn serialize_struct_variant(self,
fn serialize_struct_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeStructVariant>
{
_len: usize,
) -> Result<Self::SerializeStructVariant> {
try!(self.serialize_u32(variant_index));
Ok(Compound {ser: self})
Ok(Compound { ser: self })
}
fn serialize_newtype_struct<T: ?Sized>(self,
_name: &'static str,
value: &T) -> Result<()>
where T: serde::ser::Serialize,
fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
where
T: serde::ser::Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized>(self,
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
value: &T) -> Result<()>
where T: serde::ser::Serialize,
value: &T,
) -> Result<()>
where
T: serde::ser::Serialize,
{
try!(self.serialize_u32(variant_index));
value.serialize(self)
}
fn serialize_unit_variant(self,
fn serialize_unit_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str) -> Result<()> {
_variant: &'static str,
) -> Result<()> {
self.serialize_u32(variant_index)
}
}
@ -190,11 +209,9 @@ pub struct SizeChecker<S: SizeLimit> {
pub size_limit: S,
}
impl <S: SizeLimit> SizeChecker<S> {
impl<S: SizeLimit> SizeChecker<S> {
pub fn new(size_limit: S) -> SizeChecker<S> {
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<S> {
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<S> {
}
fn serialize_some<T: ?Sized>(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<S> {
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<Self::SerializeTuple> {
Ok(SizeCompound {ser: self})
Ok(SizeCompound { ser: self })
}
fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
Ok(SizeCompound {ser: self})
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct> {
Ok(SizeCompound { ser: self })
}
fn serialize_tuple_variant(self,
fn serialize_tuple_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeTupleVariant>
{
_len: usize,
) -> Result<Self::SerializeTupleVariant> {
try!(self.add_value(variant_index));
Ok(SizeCompound {ser: self})
Ok(SizeCompound { ser: self })
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>
{
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
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<Self::SerializeStruct> {
Ok(SizeCompound {ser: self})
Ok(SizeCompound { ser: self })
}
fn serialize_struct_variant(self,
fn serialize_struct_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
_len: usize) -> Result<Self::SerializeStructVariant>
{
_len: usize,
) -> Result<Self::SerializeStructVariant> {
try!(self.add_value(variant_index));
Ok(SizeCompound {ser: self})
Ok(SizeCompound { ser: self })
}
fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(self, _name: &'static str, v: &V) -> Result<()> {
fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(
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<()> {
self.add_value(variant_index)
}
fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(self,
fn serialize_unit_variant(
self,
_name: &'static str,
variant_index: u32,
_variant: &'static str,
value: &V) -> Result<()>
{
) -> Result<()> {
self.add_value(variant_index)
}
fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(
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<T: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&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<K: ?Sized>(&mut self, value: &K) -> Result<()>
where K: serde::ser::Serialize
where
K: serde::ser::Serialize,
{
value.serialize(&mut *self.ser)
}
#[inline]
fn serialize_value<V: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&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<S>,
}
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<T: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&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<K: ?Sized>(&mut self, value: &K) -> Result<()>
where K: serde::ser::Serialize
where
K: serde::ser::Serialize,
{
value.serialize(&mut *self.ser)
}
#[inline]
fn serialize_value<V: ?Sized>(&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<T: ?Sized>(&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<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
where T: serde::ser::Serialize
where
T: serde::ser::Serialize,
{
value.serialize(&mut *self.ser)
}

113
tests/test.rs
View File

@ -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<V>(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<V>(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<u8> = 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::<bool>(&vec![0xA][..]).unwrap_err() {
ErrorKind::InvalidBoolEncoding(0xA) => {},
ErrorKind::InvalidBoolEncoding(0xA) => {}
_ => panic!(),
}
match *deserialize_little::<String>(&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::<Test>(&vec![0, 0, 0, 5][..]).unwrap_err() {
// Error message comes from serde
ErrorKind::Custom(_) => {},
ErrorKind::Custom(_) => {}
_ => panic!(),
}
match *deserialize_little::<Option<u8>>(&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<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3));
let serialized = vec![0, 0, 0, 3];
let deserialized: Result<u32> =
deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3));
assert!(deserialized.is_err());
let serialized = vec![0,0,0,3];
let deserialized: Result<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4));
let serialized = vec![0, 0, 0, 3];
let deserialized: Result<u32> =
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<char> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1));
let deserialized: Result<char> =
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<u32>>),
M2(Cow<'a, HashMap<u32, u32>>)
M2(Cow<'a, HashMap<u32, u32>>),
}
// 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<u32>> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
let deserialized: Cow<'static, Vec<u32>> =
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<Vec<u8>> = 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]));
}