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

Merge pull request #60 from TyOverby/serde-0.7 

Support serde 0.7
This commit is contained in:
Ty Overby 2016-03-04 15:18:50 -08:00
parent 6d3de67320 bde9aa6565
commit a486ac6192
4 changed files with 130 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "bincode" name = "bincode"
version = "0.4.1" version = "0.5.0"
authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>"] authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>"]
repository = "https://github.com/TyOverby/bincode" repository = "https://github.com/TyOverby/bincode"
@ -14,7 +14,7 @@ description = "A binary serialization / deserialization strategy and implementat
rustc-serialize = "0.3.*" rustc-serialize = "0.3.*"
byteorder = "0.4.*" byteorder = "0.4.*"
num = "0.1.*" num = "0.1.*"
serde = "0.6.*" serde = "0.7.*"
[dev-dependencies] [dev-dependencies]
serde_macros = "0.6.*" serde_macros = "0.7.*"

132
src/serde/reader.rs
View File

@ -9,6 +9,7 @@ use byteorder::{BigEndian, ReadBytesExt};
use num; use num;
use serde_crate as serde; use serde_crate as serde;
use serde_crate::de::value::ValueDeserializer; use serde_crate::de::value::ValueDeserializer;
use serde_crate::de::Deserializer as SerdeDeserializer;
use ::SizeLimit; use ::SizeLimit;
@ -46,10 +47,7 @@ pub enum DeserializeError {
/// If decoding a message takes more than the provided size limit, this /// If decoding a message takes more than the provided size limit, this
/// error is returned. /// error is returned.
SizeLimit, SizeLimit,
SyntaxError(String), Serde(serde::de::value::Error)
EndOfStreamError,
UnknownFieldError,
MissingFieldError,
} }
impl Error for DeserializeError { impl Error for DeserializeError {
@ -58,10 +56,8 @@ impl Error for DeserializeError {
DeserializeError::IoError(ref err) => Error::description(err), DeserializeError::IoError(ref err) => Error::description(err),
DeserializeError::InvalidEncoding(ref ib) => ib.desc, DeserializeError::InvalidEncoding(ref ib) => ib.desc,
DeserializeError::SizeLimit => "the size limit for decoding has been reached", DeserializeError::SizeLimit => "the size limit for decoding has been reached",
DeserializeError::SyntaxError(ref s) => &*s, DeserializeError::Serde(ref s) => s.description(),
DeserializeError::EndOfStreamError => "Unexpected EOF while reading a multi-byte number",
DeserializeError::UnknownFieldError => "unknown field error",
DeserializeError::MissingFieldError => "missing field error",
} }
} }
@ -70,10 +66,7 @@ impl Error for DeserializeError {
DeserializeError::IoError(ref err) => err.cause(), DeserializeError::IoError(ref err) => err.cause(),
DeserializeError::InvalidEncoding(_) => None, DeserializeError::InvalidEncoding(_) => None,
DeserializeError::SizeLimit => None, DeserializeError::SizeLimit => None,
DeserializeError::SyntaxError(_) => None, DeserializeError::Serde(ref s) => s.cause(),
DeserializeError::EndOfStreamError => None,
DeserializeError::UnknownFieldError => None,
DeserializeError::MissingFieldError => None,
} }
} }
} }
@ -88,23 +81,15 @@ impl From<ByteOrderError> for DeserializeError {
fn from(err: ByteOrderError) -> DeserializeError { fn from(err: ByteOrderError) -> DeserializeError {
match err { match err {
ByteOrderError::Io(ioe) => DeserializeError::IoError(ioe), ByteOrderError::Io(ioe) => DeserializeError::IoError(ioe),
ByteOrderError::UnexpectedEOF => DeserializeError::EndOfStreamError, ByteOrderError::UnexpectedEOF => DeserializeError::Serde(
serde::de::value::Error::EndOfStream),
} }
} }
} }
impl From<serde::de::value::Error> for DeserializeError { impl From<serde::de::value::Error> for DeserializeError {
fn from(err: serde::de::value::Error) -> DeserializeError { fn from(err: serde::de::value::Error) -> DeserializeError {
use serde_crate::de::value::Error; DeserializeError::Serde(err)
match err {
Error::SyntaxError => DeserializeError::SyntaxError("syntax error".to_string()),
Error::EndOfStreamError => {
DeserializeError::EndOfStreamError
}
Error::UnknownFieldError(_) => DeserializeError::UnknownFieldError,
Error::MissingFieldError(_) => DeserializeError::MissingFieldError,
}
} }
} }
@ -117,33 +102,19 @@ impl fmt::Display for DeserializeError {
write!(fmt, "InvalidEncoding: {}", ib), write!(fmt, "InvalidEncoding: {}", ib),
DeserializeError::SizeLimit => DeserializeError::SizeLimit =>
write!(fmt, "SizeLimit"), write!(fmt, "SizeLimit"),
DeserializeError::SyntaxError(ref d) => DeserializeError::Serde(ref s) =>
write!(fmt, "SyntaxError: {}", d), s.fmt(fmt),
DeserializeError::EndOfStreamError =>
write!(fmt, "EndOfStreamError"),
DeserializeError::UnknownFieldError =>
write!(fmt, "UnknownFieldError"),
DeserializeError::MissingFieldError =>
write!(fmt, "MissingFieldError"),
} }
} }
} }
impl serde::de::Error for DeserializeError { impl serde::de::Error for DeserializeError {
fn syntax(desc: &str) -> DeserializeError { fn custom<T: Into<String>>(desc: T) -> DeserializeError {
DeserializeError::SyntaxError(desc.into()) DeserializeError::Serde(serde::de::value::Error::Custom(desc.into()))
} }
fn end_of_stream() -> DeserializeError { fn end_of_stream() -> DeserializeError {
DeserializeError::EndOfStreamError DeserializeError::Serde(serde::de::value::Error::EndOfStream)
}
fn unknown_field(_field: &str) -> DeserializeError {
DeserializeError::UnknownFieldError
}
fn missing_field(_field: &'static str) -> DeserializeError {
DeserializeError::MissingFieldError
} }
} }
@ -198,9 +169,9 @@ impl <'a, A> Deserializer<'a, A> {
} }
macro_rules! impl_nums { macro_rules! impl_nums {
($ty:ty, $visitor_method:ident, $reader_method:ident) => { ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
#[inline] #[inline]
fn $visitor_method<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn $dser_method<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
try!(self.read_type::<$ty>()); try!(self.read_type::<$ty>());
@ -215,13 +186,14 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
type Error = DeserializeError; type Error = DeserializeError;
#[inline] #[inline]
fn visit<V>(&mut self, _visitor: V) -> DeserializeResult<V::Value> fn deserialize<V>(&mut self, _visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
Err(serde::de::Error::syntax("bincode does not support Deserializer::visit")) let message = "bincode does not support Deserializer::deserialize";
Err(DeserializeError::Serde(serde::de::value::Error::Custom(message.into())))
} }
fn visit_bool<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_bool<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
let value: u8 = try!(serde::Deserialize::deserialize(self)); let value: u8 = try!(serde::Deserialize::deserialize(self));
@ -237,64 +209,63 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
} }
} }
impl_nums!(u16, deserialize_u16, visit_u16, read_u16);
impl_nums!(u32, deserialize_u32, visit_u32, read_u32);
impl_nums!(u64, deserialize_u64, visit_u64, read_u64);
impl_nums!(i16, deserialize_i16, visit_i16, read_i16);
impl_nums!(i32, deserialize_i32, visit_i32, read_i32);
impl_nums!(i64, deserialize_i64, visit_i64, read_i64);
impl_nums!(f32, deserialize_f32, visit_f32, read_f32);
impl_nums!(f64, deserialize_f64, visit_f64, read_f64);
#[inline] #[inline]
fn visit_u8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_u8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
try!(self.read_type::<u8>()); try!(self.read_type::<u8>());
visitor.visit_u8(try!(self.reader.read_u8())) visitor.visit_u8(try!(self.reader.read_u8()))
} }
impl_nums!(u16, visit_u16, read_u16);
impl_nums!(u32, visit_u32, read_u32);
impl_nums!(u64, visit_u64, read_u64);
#[inline] #[inline]
fn visit_usize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_usize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
try!(self.read_type::<u64>()); try!(self.read_type::<u64>());
let value = try!(self.reader.read_u64::<BigEndian>()); let value = try!(self.reader.read_u64::<BigEndian>());
match num::cast(value) { match num::cast(value) {
Some(value) => visitor.visit_usize(value), Some(value) => visitor.visit_usize(value),
None => Err(serde::de::Error::syntax("expected usize")), None => Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected usize".into())))
} }
} }
#[inline] #[inline]
fn visit_i8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_i8<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
try!(self.read_type::<i8>()); try!(self.read_type::<i8>());
visitor.visit_i8(try!(self.reader.read_i8())) visitor.visit_i8(try!(self.reader.read_i8()))
} }
impl_nums!(i16, visit_i16, read_i16);
impl_nums!(i32, visit_i32, read_i32);
impl_nums!(i64, visit_i64, read_i64);
#[inline] #[inline]
fn visit_isize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_isize<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
try!(self.read_type::<i64>()); try!(self.read_type::<i64>());
let value = try!(self.reader.read_i64::<BigEndian>()); let value = try!(self.reader.read_i64::<BigEndian>());
match num::cast(value) { match num::cast(value) {
Some(value) => visitor.visit_isize(value), Some(value) => visitor.visit_isize(value),
None => Err(serde::de::Error::syntax("expected isize")), None => Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected isize".into()))),
} }
} }
impl_nums!(f32, visit_f32, read_f32); fn deserialize_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
impl_nums!(f64, visit_f64, read_f64);
fn visit_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
visitor.visit_unit() visitor.visit_unit()
} }
fn visit_char<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_char<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
use std::str; use std::str;
@ -333,7 +304,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_char(res) visitor.visit_char(res)
} }
fn visit_string<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_string<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
let len = try!(serde::Deserialize::deserialize(self)); let len = try!(serde::Deserialize::deserialize(self));
@ -351,7 +322,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
} }
} }
fn visit_enum<V>(&mut self, fn deserialize_enum<V>(&mut self,
_enum: &'static str, _enum: &'static str,
_variants: &'static [&'static str], _variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value, Self::Error> mut visitor: V) -> Result<V::Value, Self::Error>
@ -360,7 +331,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit(self) visitor.visit(self)
} }
fn visit_tuple<V>(&mut self, fn deserialize_tuple<V>(&mut self,
_len: usize, _len: usize,
mut visitor: V) -> DeserializeResult<V::Value> mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
@ -385,7 +356,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_seq(TupleVisitor(self)) visitor.visit_seq(TupleVisitor(self))
} }
fn visit_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
let value: u8 = try!(serde::de::Deserialize::deserialize(self)); let value: u8 = try!(serde::de::Deserialize::deserialize(self));
@ -399,7 +370,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
} }
} }
fn visit_seq<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_seq<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
struct SeqVisitor<'a, 'b: 'a, R: Read + 'b> { struct SeqVisitor<'a, 'b: 'a, R: Read + 'b> {
@ -426,7 +397,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
if self.len == 0 { if self.len == 0 {
Ok(()) Ok(())
} else { } else {
Err(serde::de::Error::syntax("expected end")) Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected end".into())))
} }
} }
} }
@ -436,7 +407,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_seq(SeqVisitor { deserializer: self, len: len }) visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
} }
fn visit_map<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn deserialize_map<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
struct MapVisitor<'a, 'b: 'a, R: Read + 'b> { struct MapVisitor<'a, 'b: 'a, R: Read + 'b> {
@ -470,7 +441,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
if self.len == 0 { if self.len == 0 {
Ok(()) Ok(())
} else { } else {
Err(serde::de::Error::syntax("expected end")) Err(DeserializeError::Serde(serde::de::value::Error::Custom("expected end".into())))
} }
} }
} }
@ -480,16 +451,16 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_map(MapVisitor { deserializer: self, len: len }) visitor.visit_map(MapVisitor { deserializer: self, len: len })
} }
fn visit_struct<V>(&mut self, fn deserialize_struct<V>(&mut self,
_name: &str, _name: &str,
fields: &'static [&'static str], fields: &'static [&'static str],
visitor: V) -> DeserializeResult<V::Value> visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
self.visit_tuple(fields.len(), visitor) self.deserialize_tuple(fields.len(), visitor)
} }
fn visit_newtype_struct<V>(&mut self, fn deserialize_newtype_struct<V>(&mut self,
_name: &str, _name: &str,
mut visitor: V) -> Result<V::Value, Self::Error> mut visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::Visitor, where V: serde::de::Visitor,
@ -506,7 +477,8 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
{ {
let index: u32 = try!(serde::Deserialize::deserialize(self)); let index: u32 = try!(serde::Deserialize::deserialize(self));
let mut deserializer = (index as usize).into_deserializer(); let mut deserializer = (index as usize).into_deserializer();
Ok(try!(serde::Deserialize::deserialize(&mut deserializer))) let attempt: Result<V, serde::de::value::Error> = serde::Deserialize::deserialize(&mut deserializer);
Ok(try!(attempt))
} }
fn visit_unit(&mut self) -> Result<(), Self::Error> { fn visit_unit(&mut self) -> Result<(), Self::Error> {
@ -524,7 +496,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
visitor: V) -> Result<V::Value, Self::Error> visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
serde::de::Deserializer::visit_tuple(self, len, visitor) serde::de::Deserializer::deserialize_tuple(self, len, visitor)
} }
fn visit_struct<V>(&mut self, fn visit_struct<V>(&mut self,
@ -532,7 +504,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
visitor: V) -> Result<V::Value, Self::Error> visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
serde::de::Deserializer::visit_tuple(self, fields.len(), visitor) serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
} }
} }
static UTF8_CHAR_WIDTH: [u8; 256] = [ static UTF8_CHAR_WIDTH: [u8; 256] = [

135
src/serde/writer.rs
View File

@ -22,7 +22,9 @@ pub enum SerializeError {
/// ///
/// This error is returned before any bytes are written to the /// This error is returned before any bytes are written to the
/// output `Writer`. /// output `Writer`.
SizeLimit SizeLimit,
/// A custom error message
Custom(String)
} }
/// An Serializer that encodes values directly into a Writer. /// An Serializer that encodes values directly into a Writer.
@ -42,11 +44,18 @@ fn wrap_io(err: ByteOrderError) -> SerializeError {
} }
} }
impl serde::ser::Error for SerializeError {
fn custom<T: Into<String>>(msg: T) -> Self {
SerializeError::Custom(msg.into())
}
}
impl fmt::Display for SerializeError { impl fmt::Display for SerializeError {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self { match *self {
SerializeError::IoError(ref err) => write!(f, "IoError: {}", err), SerializeError::IoError(ref err) => write!(f, "IoError: {}", err),
SerializeError::SizeLimit => write!(f, "SizeLimit") SerializeError::Custom(ref s) => write!(f, "Custom Error {}", s),
SerializeError::SizeLimit => write!(f, "SizeLimit"),
} }
} }
} }
@ -55,14 +64,16 @@ impl Error for SerializeError {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
SerializeError::IoError(ref err) => Error::description(err), SerializeError::IoError(ref err) => Error::description(err),
SerializeError::SizeLimit => "the size limit for decoding has been reached" SerializeError::SizeLimit => "the size limit for decoding has been reached",
SerializeError::Custom(_) => "a custom serialization error was reported",
} }
} }
fn cause(&self) -> Option<&Error> { fn cause(&self) -> Option<&Error> {
match *self { match *self {
SerializeError::IoError(ref err) => err.cause(), SerializeError::IoError(ref err) => err.cause(),
SerializeError::SizeLimit => None SerializeError::SizeLimit => None,
SerializeError::Custom(_) => None,
} }
} }
} }
@ -79,76 +90,76 @@ impl<'a, W: Write> Serializer<'a, W> {
panic!("Variant tag doesn't fit in a u32") panic!("Variant tag doesn't fit in a u32")
} }
serde::Serializer::visit_u32(self, tag as u32) serde::Serializer::serialize_u32(self, tag as u32)
} }
} }
impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
type Error = SerializeError; type Error = SerializeError;
fn visit_unit(&mut self) -> SerializeResult<()> { Ok(()) } fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
fn visit_bool(&mut self, v: bool) -> SerializeResult<()> { fn serialize_bool(&mut self, v: bool) -> SerializeResult<()> {
self.writer.write_u8(if v {1} else {0}).map_err(wrap_io) self.writer.write_u8(if v {1} else {0}).map_err(wrap_io)
} }
fn visit_u8(&mut self, v: u8) -> SerializeResult<()> { fn serialize_u8(&mut self, v: u8) -> SerializeResult<()> {
self.writer.write_u8(v).map_err(wrap_io) self.writer.write_u8(v).map_err(wrap_io)
} }
fn visit_u16(&mut self, v: u16) -> SerializeResult<()> { fn serialize_u16(&mut self, v: u16) -> SerializeResult<()> {
self.writer.write_u16::<BigEndian>(v).map_err(wrap_io) self.writer.write_u16::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_u32(&mut self, v: u32) -> SerializeResult<()> { fn serialize_u32(&mut self, v: u32) -> SerializeResult<()> {
self.writer.write_u32::<BigEndian>(v).map_err(wrap_io) self.writer.write_u32::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_u64(&mut self, v: u64) -> SerializeResult<()> { fn serialize_u64(&mut self, v: u64) -> SerializeResult<()> {
self.writer.write_u64::<BigEndian>(v).map_err(wrap_io) self.writer.write_u64::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_i8(&mut self, v: i8) -> SerializeResult<()> { fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
self.writer.write_i8(v).map_err(wrap_io) self.writer.write_i8(v).map_err(wrap_io)
} }
fn visit_i16(&mut self, v: i16) -> SerializeResult<()> { fn serialize_i16(&mut self, v: i16) -> SerializeResult<()> {
self.writer.write_i16::<BigEndian>(v).map_err(wrap_io) self.writer.write_i16::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_i32(&mut self, v: i32) -> SerializeResult<()> { fn serialize_i32(&mut self, v: i32) -> SerializeResult<()> {
self.writer.write_i32::<BigEndian>(v).map_err(wrap_io) self.writer.write_i32::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_i64(&mut self, v: i64) -> SerializeResult<()> { fn serialize_i64(&mut self, v: i64) -> SerializeResult<()> {
self.writer.write_i64::<BigEndian>(v).map_err(wrap_io) self.writer.write_i64::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_f32(&mut self, v: f32) -> SerializeResult<()> { fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
self.writer.write_f32::<BigEndian>(v).map_err(wrap_io) self.writer.write_f32::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_f64(&mut self, v: f64) -> SerializeResult<()> { fn serialize_f64(&mut self, v: f64) -> SerializeResult<()> {
self.writer.write_f64::<BigEndian>(v).map_err(wrap_io) self.writer.write_f64::<BigEndian>(v).map_err(wrap_io)
} }
fn visit_str(&mut self, v: &str) -> SerializeResult<()> { fn serialize_str(&mut self, v: &str) -> SerializeResult<()> {
try!(self.visit_usize(v.len())); try!(self.serialize_usize(v.len()));
self.writer.write_all(v.as_bytes()).map_err(SerializeError::IoError) self.writer.write_all(v.as_bytes()).map_err(SerializeError::IoError)
} }
fn visit_none(&mut self) -> SerializeResult<()> { fn serialize_none(&mut self) -> SerializeResult<()> {
self.writer.write_u8(0).map_err(wrap_io) self.writer.write_u8(0).map_err(wrap_io)
} }
fn visit_some<T>(&mut self, v: T) -> SerializeResult<()> fn serialize_some<T>(&mut self, v: T) -> SerializeResult<()>
where T: serde::Serialize, where T: serde::Serialize,
{ {
try!(self.writer.write_u8(1).map_err(wrap_io)); try!(self.writer.write_u8(1).map_err(wrap_io));
v.serialize(self) v.serialize(self)
} }
fn visit_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor, where V: serde::ser::SeqVisitor,
{ {
let len = match visitor.len() { let len = match visitor.len() {
@ -156,14 +167,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
None => panic!("do not know how to serialize a sequence with no length"), None => panic!("do not know how to serialize a sequence with no length"),
}; };
try!(self.visit_usize(len)); try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
Ok(()) Ok(())
} }
fn visit_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor, where V: serde::ser::SeqVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -171,13 +182,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()> fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_map<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
let len = match visitor.len() { let len = match visitor.len() {
@ -185,14 +196,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
None => panic!("do not know how to serialize a map with no length"), None => panic!("do not know how to serialize a map with no length"),
}; };
try!(self.visit_usize(len)); try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
Ok(()) Ok(())
} }
fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()> fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
where K: serde::Serialize, where K: serde::Serialize,
V: serde::Serialize, V: serde::Serialize,
{ {
@ -200,7 +211,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
value.serialize(self) value.serialize(self)
} }
fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -208,13 +219,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()> fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_newtype_struct<T>(&mut self, fn serialize_newtype_struct<T>(&mut self,
_name: &str, _name: &str,
value: T) -> SerializeResult<()> value: T) -> SerializeResult<()>
where T: serde::ser::Serialize, where T: serde::ser::Serialize,
@ -222,14 +233,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
value.serialize(self) value.serialize(self)
} }
fn visit_unit_variant(&mut self, fn serialize_unit_variant(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str) -> SerializeResult<()> { _variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index) self.add_enum_tag(variant_index)
} }
fn visit_tuple_variant<V>(&mut self, fn serialize_tuple_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
@ -243,7 +254,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_struct_variant<V>(&mut self, fn serialize_struct_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
@ -297,69 +308,69 @@ impl SizeChecker {
impl serde::Serializer for SizeChecker { impl serde::Serializer for SizeChecker {
type Error = SerializeError; type Error = SerializeError;
fn visit_unit(&mut self) -> SerializeResult<()> { Ok(()) } fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
fn visit_bool(&mut self, _: bool) -> SerializeResult<()> { fn serialize_bool(&mut self, _: bool) -> SerializeResult<()> {
self.add_value(0 as u8) self.add_value(0 as u8)
} }
fn visit_u8(&mut self, v: u8) -> SerializeResult<()> { fn serialize_u8(&mut self, v: u8) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_u16(&mut self, v: u16) -> SerializeResult<()> { fn serialize_u16(&mut self, v: u16) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_u32(&mut self, v: u32) -> SerializeResult<()> { fn serialize_u32(&mut self, v: u32) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_u64(&mut self, v: u64) -> SerializeResult<()> { fn serialize_u64(&mut self, v: u64) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_i8(&mut self, v: i8) -> SerializeResult<()> { fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_i16(&mut self, v: i16) -> SerializeResult<()> { fn serialize_i16(&mut self, v: i16) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_i32(&mut self, v: i32) -> SerializeResult<()> { fn serialize_i32(&mut self, v: i32) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_i64(&mut self, v: i64) -> SerializeResult<()> { fn serialize_i64(&mut self, v: i64) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_f32(&mut self, v: f32) -> SerializeResult<()> { fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_f64(&mut self, v: f64) -> SerializeResult<()> { fn serialize_f64(&mut self, v: f64) -> SerializeResult<()> {
self.add_value(v) self.add_value(v)
} }
fn visit_str(&mut self, v: &str) -> SerializeResult<()> { fn serialize_str(&mut self, v: &str) -> SerializeResult<()> {
try!(self.add_value(0 as u64)); try!(self.add_value(0 as u64));
self.add_raw(v.len()) self.add_raw(v.len())
} }
fn visit_none(&mut self) -> SerializeResult<()> { fn serialize_none(&mut self) -> SerializeResult<()> {
self.add_value(0 as u8) self.add_value(0 as u8)
} }
fn visit_some<T>(&mut self, v: T) -> SerializeResult<()> fn serialize_some<T>(&mut self, v: T) -> SerializeResult<()>
where T: serde::Serialize, where T: serde::Serialize,
{ {
try!(self.add_value(1 as u8)); try!(self.add_value(1 as u8));
v.serialize(self) v.serialize(self)
} }
fn visit_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor, where V: serde::ser::SeqVisitor,
{ {
let len = match visitor.len() { let len = match visitor.len() {
@ -367,14 +378,14 @@ impl serde::Serializer for SizeChecker {
None => panic!("do not know how to serialize a sequence with no length"), None => panic!("do not know how to serialize a sequence with no length"),
}; };
try!(self.visit_usize(len)); try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
Ok(()) Ok(())
} }
fn visit_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor, where V: serde::ser::SeqVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -382,13 +393,13 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()> fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_map<V>(&mut self, mut visitor: V) -> SerializeResult<()> fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
let len = match visitor.len() { let len = match visitor.len() {
@ -396,14 +407,14 @@ impl serde::Serializer for SizeChecker {
None => panic!("do not know how to serialize a map with no length"), None => panic!("do not know how to serialize a map with no length"),
}; };
try!(self.visit_usize(len)); try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
Ok(()) Ok(())
} }
fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()> fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
where K: serde::Serialize, where K: serde::Serialize,
V: serde::Serialize, V: serde::Serialize,
{ {
@ -411,7 +422,7 @@ impl serde::Serializer for SizeChecker {
value.serialize(self) value.serialize(self)
} }
fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -419,20 +430,20 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()> fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_unit_variant(&mut self, fn serialize_unit_variant(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str) -> SerializeResult<()> { _variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index) self.add_enum_tag(variant_index)
} }
fn visit_tuple_variant<V>(&mut self, fn serialize_tuple_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
@ -446,7 +457,7 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_struct_variant<V>(&mut self, fn serialize_struct_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,

3
tests/test.rs
View File

@ -243,7 +243,8 @@ fn deserializing_errors() {
fn isize_invalid_deserialize<T: Debug>(res: DeserializeResult<T>) { fn isize_invalid_deserialize<T: Debug>(res: DeserializeResult<T>) {
match res { match res {
Err(DeserializeError::InvalidEncoding(_)) => {}, Err(DeserializeError::InvalidEncoding(_)) => {},
Err(DeserializeError::SyntaxError(_)) => {}, Err(DeserializeError::Serde(serde::de::value::Error::UnknownVariant(_))) => {},
Err(DeserializeError::Serde(serde::de::value::Error::InvalidValue(_))) => {},
_ => panic!("Expecting InvalidEncoding, got {:?}", res), _ => panic!("Expecting InvalidEncoding, got {:?}", res),
} }
} }