berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues 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]
name = "bincode"
version = "0.4.1"
version = "0.5.0"
authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>"]
repository = "https://github.com/TyOverby/bincode"
@ -14,7 +14,7 @@ description = "A binary serialization / deserialization strategy and implementat
rustc-serialize = "0.3.*"
byteorder = "0.4.*"
num = "0.1.*"
serde = "0.6.*"
serde = "0.7.*"
[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 serde_crate as serde;
use serde_crate::de::value::ValueDeserializer;
use serde_crate::de::Deserializer as SerdeDeserializer;
use ::SizeLimit;
@ -46,10 +47,7 @@ pub enum DeserializeError {
/// If decoding a message takes more than the provided size limit, this
/// error is returned.
SizeLimit,
SyntaxError(String),
EndOfStreamError,
UnknownFieldError,
MissingFieldError,
Serde(serde::de::value::Error)
}
impl Error for DeserializeError {
@ -58,10 +56,8 @@ impl Error for DeserializeError {
DeserializeError::IoError(ref err) => Error::description(err),
DeserializeError::InvalidEncoding(ref ib) => ib.desc,
DeserializeError::SizeLimit => "the size limit for decoding has been reached",
DeserializeError::SyntaxError(ref s) => &*s,
DeserializeError::EndOfStreamError => "Unexpected EOF while reading a multi-byte number",
DeserializeError::UnknownFieldError => "unknown field error",
DeserializeError::MissingFieldError => "missing field error",
DeserializeError::Serde(ref s) => s.description(),
}
}
@ -70,10 +66,7 @@ impl Error for DeserializeError {
DeserializeError::IoError(ref err) => err.cause(),
DeserializeError::InvalidEncoding(_) => None,
DeserializeError::SizeLimit => None,
DeserializeError::SyntaxError(_) => None,
DeserializeError::EndOfStreamError => None,
DeserializeError::UnknownFieldError => None,
DeserializeError::MissingFieldError => None,
DeserializeError::Serde(ref s) => s.cause(),
}
}
}
@ -88,23 +81,15 @@ impl From<ByteOrderError> for DeserializeError {
fn from(err: ByteOrderError) -> DeserializeError {
match err {
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 {
fn from(err: serde::de::value::Error) -> DeserializeError {
use serde_crate::de::value::Error;
match err {
Error::SyntaxError => DeserializeError::SyntaxError("syntax error".to_string()),
Error::EndOfStreamError => {
DeserializeError::EndOfStreamError
}
Error::UnknownFieldError(_) => DeserializeError::UnknownFieldError,
Error::MissingFieldError(_) => DeserializeError::MissingFieldError,
}
DeserializeError::Serde(err)
}
}
@ -117,33 +102,19 @@ impl fmt::Display for DeserializeError {
write!(fmt, "InvalidEncoding: {}", ib),
DeserializeError::SizeLimit =>
write!(fmt, "SizeLimit"),
DeserializeError::SyntaxError(ref d) =>
write!(fmt, "SyntaxError: {}", d),
DeserializeError::EndOfStreamError =>
write!(fmt, "EndOfStreamError"),
DeserializeError::UnknownFieldError =>
write!(fmt, "UnknownFieldError"),
DeserializeError::MissingFieldError =>
write!(fmt, "MissingFieldError"),
DeserializeError::Serde(ref s) =>
s.fmt(fmt),
}
}
}
impl serde::de::Error for DeserializeError {
fn syntax(desc: &str) -> DeserializeError {
DeserializeError::SyntaxError(desc.into())
fn custom<T: Into<String>>(desc: T) -> DeserializeError {
DeserializeError::Serde(serde::de::value::Error::Custom(desc.into()))
}
fn end_of_stream() -> DeserializeError {
DeserializeError::EndOfStreamError
}
fn unknown_field(_field: &str) -> DeserializeError {
DeserializeError::UnknownFieldError
}
fn missing_field(_field: &'static str) -> DeserializeError {
DeserializeError::MissingFieldError
DeserializeError::Serde(serde::de::value::Error::EndOfStream)
}
}
@ -198,9 +169,9 @@ impl <'a, A> Deserializer<'a, A> {
}
macro_rules! impl_nums {
($ty:ty, $visitor_method:ident, $reader_method:ident) => {
($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
#[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,
{
try!(self.read_type::<$ty>());
@ -215,13 +186,14 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
type Error = DeserializeError;
#[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,
{
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,
{
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]
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,
{
try!(self.read_type::<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]
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,
{
try!(self.read_type::<u64>());
let value = try!(self.reader.read_u64::<BigEndian>());
match num::cast(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]
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,
{
try!(self.read_type::<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]
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,
{
try!(self.read_type::<i64>());
let value = try!(self.reader.read_i64::<BigEndian>());
match num::cast(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);
impl_nums!(f64, visit_f64, read_f64);
fn visit_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
fn deserialize_unit<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor,
{
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,
{
use std::str;
@ -333,7 +304,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
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,
{
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,
_variants: &'static [&'static str],
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)
}
fn visit_tuple<V>(&mut self,
fn deserialize_tuple<V>(&mut self,
_len: usize,
mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor,
@ -385,7 +356,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
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,
{
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,
{
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 {
Ok(())
} 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 })
}
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,
{
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 {
Ok(())
} 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 })
}
fn visit_struct<V>(&mut self,
fn deserialize_struct<V>(&mut self,
_name: &str,
fields: &'static [&'static str],
visitor: V) -> DeserializeResult<V::Value>
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,
mut visitor: V) -> Result<V::Value, Self::Error>
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 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> {
@ -524,7 +496,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
visitor: V) -> Result<V::Value, Self::Error>
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,
@ -532,7 +504,7 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
visitor: V) -> Result<V::Value, Self::Error>
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] = [

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
/// output `Writer`.
SizeLimit
SizeLimit,
/// A custom error message
Custom(String)
}
/// 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 {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self {
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 {
match *self {
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> {
match *self {
SerializeError::IoError(ref err) => err.cause(),
SerializeError::SizeLimit => None
SerializeError::IoError(ref err) => err.cause(),
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")
}
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> {
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
fn visit_str(&mut self, v: &str) -> SerializeResult<()> {
try!(self.visit_usize(v.len()));
fn serialize_str(&mut self, v: &str) -> SerializeResult<()> {
try!(self.serialize_usize(v.len()));
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)
}
fn visit_some<T>(&mut self, v: T) -> SerializeResult<()>
fn serialize_some<T>(&mut self, v: T) -> SerializeResult<()>
where T: serde::Serialize,
{
try!(self.writer.write_u8(1).map_err(wrap_io));
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,
{
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"),
};
try!(self.visit_usize(len));
try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { }
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,
{
while let Some(()) = try!(visitor.visit(self)) { }
@ -171,13 +182,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
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,
{
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,
{
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"),
};
try!(self.visit_usize(len));
try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { }
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,
V: serde::Serialize,
{
@ -200,7 +211,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
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,
{
while let Some(()) = try!(visitor.visit(self)) { }
@ -208,13 +219,13 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
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,
{
value.serialize(self)
}
fn visit_newtype_struct<T>(&mut self,
fn serialize_newtype_struct<T>(&mut self,
_name: &str,
value: T) -> SerializeResult<()>
where T: serde::ser::Serialize,
@ -222,14 +233,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
value.serialize(self)
}
fn visit_unit_variant(&mut self,
fn serialize_unit_variant(&mut self,
_name: &str,
variant_index: usize,
_variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index)
}
fn visit_tuple_variant<V>(&mut self,
fn serialize_tuple_variant<V>(&mut self,
_name: &str,
variant_index: usize,
_variant: &str,
@ -243,7 +254,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(())
}
fn visit_struct_variant<V>(&mut self,
fn serialize_struct_variant<V>(&mut self,
_name: &str,
variant_index: usize,
_variant: &str,
@ -297,69 +308,69 @@ impl SizeChecker {
impl serde::Serializer for SizeChecker {
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)
}
fn visit_u8(&mut self, v: u8) -> SerializeResult<()> {
fn serialize_u8(&mut self, v: u8) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_u16(&mut self, v: u16) -> SerializeResult<()> {
fn serialize_u16(&mut self, v: u16) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_u32(&mut self, v: u32) -> SerializeResult<()> {
fn serialize_u32(&mut self, v: u32) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_u64(&mut self, v: u64) -> SerializeResult<()> {
fn serialize_u64(&mut self, v: u64) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_i8(&mut self, v: i8) -> SerializeResult<()> {
fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_i16(&mut self, v: i16) -> SerializeResult<()> {
fn serialize_i16(&mut self, v: i16) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_i32(&mut self, v: i32) -> SerializeResult<()> {
fn serialize_i32(&mut self, v: i32) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_i64(&mut self, v: i64) -> SerializeResult<()> {
fn serialize_i64(&mut self, v: i64) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_f32(&mut self, v: f32) -> SerializeResult<()> {
fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
self.add_value(v)
}
fn visit_f64(&mut self, v: f64) -> SerializeResult<()> {
fn serialize_f64(&mut self, v: f64) -> SerializeResult<()> {
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));
self.add_raw(v.len())
}
fn visit_none(&mut self) -> SerializeResult<()> {
fn serialize_none(&mut self) -> SerializeResult<()> {
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,
{
try!(self.add_value(1 as u8));
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,
{
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"),
};
try!(self.visit_usize(len));
try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { }
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,
{
while let Some(()) = try!(visitor.visit(self)) { }
@ -382,13 +393,13 @@ impl serde::Serializer for SizeChecker {
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,
{
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,
{
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"),
};
try!(self.visit_usize(len));
try!(self.serialize_usize(len));
while let Some(()) = try!(visitor.visit(self)) { }
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,
V: serde::Serialize,
{
@ -411,7 +422,7 @@ impl serde::Serializer for SizeChecker {
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,
{
while let Some(()) = try!(visitor.visit(self)) { }
@ -419,20 +430,20 @@ impl serde::Serializer for SizeChecker {
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,
{
value.serialize(self)
}
fn visit_unit_variant(&mut self,
fn serialize_unit_variant(&mut self,
_name: &str,
variant_index: usize,
_variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index)
}
fn visit_tuple_variant<V>(&mut self,
fn serialize_tuple_variant<V>(&mut self,
_name: &str,
variant_index: usize,
_variant: &str,
@ -446,7 +457,7 @@ impl serde::Serializer for SizeChecker {
Ok(())
}
fn visit_struct_variant<V>(&mut self,
fn serialize_struct_variant<V>(&mut self,
_name: &str,
variant_index: usize,
_variant: &str,

3
tests/test.rs
View File

@ -243,7 +243,8 @@ fn deserializing_errors() {
fn isize_invalid_deserialize<T: Debug>(res: DeserializeResult<T>) {
match res {
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),
}
}