pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-14 16:21:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(warnings): Fix clippy warnings

Browse Source
This commit is contained in:
Erick Tryzelaar
2016-02-23 20:17:33 -08:00
parent f4c8ad6c3a
commit 3e94bf2d13
4 changed files with 330 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_tests/benches/bench_enum.rs
+70 -71
View File
@@ -17,18 +17,18 @@ pub enum Animal {
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error {
EndOfStreamError, EndOfStream,
SyntaxError, Syntax,
} }
impl serde::de::Error for Error { impl serde::de::Error for Error {
fn custom(_: String) -> Error { Error::SyntaxError } fn custom(_: String) -> Error { Error::Syntax }
fn end_of_stream() -> Error { Error::EndOfStreamError } fn end_of_stream() -> Error { Error::EndOfStream }
fn unknown_field(_: &str) -> Error { Error::SyntaxError } fn unknown_field(_: &str) -> Error { Error::Syntax }
fn missing_field(_: &'static str) -> Error { Error::SyntaxError } fn missing_field(_: &'static str) -> Error { Error::Syntax }
} }
impl fmt::Display for Error { impl fmt::Display for Error {
@@ -54,12 +54,11 @@ mod decoder {
use super::{Animal, Error}; use super::{Animal, Error};
use super::Animal::{Dog, Frog}; use super::Animal::{Dog, Frog};
use self::State::{AnimalState, IsizeState, StringState};
enum State { enum State {
AnimalState(Animal), Animal(Animal),
IsizeState(isize), Isize(isize),
StringState(String), String(String),
} }
pub struct AnimalDecoder { pub struct AnimalDecoder {
@@ -71,7 +70,7 @@ mod decoder {
#[inline] #[inline]
pub fn new(animal: Animal) -> AnimalDecoder { pub fn new(animal: Animal) -> AnimalDecoder {
AnimalDecoder { AnimalDecoder {
stack: vec!(AnimalState(animal)), stack: vec!(State::Animal(animal)),
} }
} }
} }
@@ -79,35 +78,35 @@ mod decoder {
impl Decoder for AnimalDecoder { impl Decoder for AnimalDecoder {
type Error = Error; type Error = Error;
fn error(&mut self, _: &str) -> Error { Error::SyntaxError } fn error(&mut self, _: &str) -> Error { Error::Syntax }
// Primitive types: // Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) } fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) } fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) } fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_isize(&mut self) -> Result<isize, Error> { fn read_isize(&mut self) -> Result<isize, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(IsizeState(x)) => Ok(x), Some(State::Isize(x)) => Ok(x),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_str(&mut self) -> Result<String, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StringState(x)) => Ok(x), Some(State::String(x)) => Ok(x),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
@@ -117,15 +116,15 @@ mod decoder {
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(AnimalState(animal)) => { Some(State::Animal(animal)) => {
self.stack.push(AnimalState(animal)); self.stack.push(State::Animal(animal));
if name == "Animal" { if name == "Animal" {
f(self) f(self)
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
_ => Err(Error::SyntaxError) _ => Err(Error::Syntax)
} }
} }
@@ -134,18 +133,18 @@ mod decoder {
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
{ {
let name = match self.stack.pop() { let name = match self.stack.pop() {
Some(AnimalState(Dog)) => "Dog", Some(State::Animal(Dog)) => "Dog",
Some(AnimalState(Frog(x0, x1))) => { Some(State::Animal(Frog(x0, x1))) => {
self.stack.push(IsizeState(x1)); self.stack.push(State::Isize(x1));
self.stack.push(StringState(x0)); self.stack.push(State::String(x0));
"Frog" "Frog"
} }
_ => { return Err(Error::SyntaxError); } _ => { return Err(Error::Syntax); }
}; };
let idx = match names.iter().position(|n| *n == name) { let idx = match names.iter().position(|n| *n == name) {
Some(idx) => idx, Some(idx) => idx,
None => { return Err(Error::SyntaxError); } None => { return Err(Error::Syntax); }
}; };
f(self, idx) f(self, idx)
@@ -161,56 +160,56 @@ mod decoder {
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
// Specialized types: // Specialized types:
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
#[inline] #[inline]
@@ -230,19 +229,19 @@ mod decoder {
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>, F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
} }
@@ -256,10 +255,10 @@ mod deserializer {
#[derive(Debug)] #[derive(Debug)]
enum State { enum State {
AnimalState(Animal), Animal(Animal),
IsizeState(isize), Isize(isize),
StrState(&'static str), Str(&'static str),
StringState(String), String(String),
UnitState, UnitState,
} }
@@ -271,7 +270,7 @@ mod deserializer {
#[inline] #[inline]
pub fn new(animal: Animal) -> AnimalDeserializer { pub fn new(animal: Animal) -> AnimalDeserializer {
AnimalDeserializer { AnimalDeserializer {
stack: vec!(State::AnimalState(animal)), stack: vec!(State::Animal(animal)),
} }
} }
} }
@@ -284,23 +283,23 @@ mod deserializer {
where V: de::Visitor, where V: de::Visitor,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(State::IsizeState(value)) => { Some(State::Isize(value)) => {
visitor.visit_isize(value) visitor.visit_isize(value)
} }
Some(State::StringState(value)) => { Some(State::String(value)) => {
visitor.visit_string(value) visitor.visit_string(value)
} }
Some(State::StrState(value)) => { Some(State::Str(value)) => {
visitor.visit_str(value) visitor.visit_str(value)
} }
Some(State::UnitState) => { Some(State::UnitState) => {
visitor.visit_unit() visitor.visit_unit()
} }
Some(_) => { Some(_) => {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
None => { None => {
Err(Error::EndOfStreamError) Err(Error::EndOfStream)
} }
} }
} }
@@ -313,27 +312,27 @@ mod deserializer {
where V: de::EnumVisitor, where V: de::EnumVisitor,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(State::AnimalState(Animal::Dog)) => { Some(State::Animal(Animal::Dog)) => {
self.stack.push(State::UnitState); self.stack.push(State::UnitState);
self.stack.push(State::StrState("Dog")); self.stack.push(State::Str("Dog"));
visitor.visit(DogVisitor { visitor.visit(DogVisitor {
de: self, de: self,
}) })
} }
Some(State::AnimalState(Animal::Frog(x0, x1))) => { Some(State::Animal(Animal::Frog(x0, x1))) => {
self.stack.push(State::IsizeState(x1)); self.stack.push(State::Isize(x1));
self.stack.push(State::StringState(x0)); self.stack.push(State::String(x0));
self.stack.push(State::StrState("Frog")); self.stack.push(State::Str("Frog"));
visitor.visit(FrogVisitor { visitor.visit(FrogVisitor {
de: self, de: self,
state: 0, state: 0,
}) })
} }
Some(_) => { Some(_) => {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
None => { None => {
Err(Error::EndOfStreamError) Err(Error::EndOfStream)
} }
} }
} }
@@ -405,7 +404,7 @@ mod deserializer {
if self.state == 2 { if self.state == 2 {
Ok(()) Ok(())
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
serde_tests/benches/bench_map.rs
+56 -57
View File
@@ -14,16 +14,16 @@ use serde::de::{Deserializer, Deserialize};
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub enum Error { pub enum Error {
EndOfStream, EndOfStream,
SyntaxError, Syntax,
MissingField, MissingField,
} }
impl serde::de::Error for Error { impl serde::de::Error for Error {
fn custom(_: String) -> Error { Error::SyntaxError } fn custom(_: String) -> Error { Error::Syntax }
fn end_of_stream() -> Error { Error::EndOfStream } fn end_of_stream() -> Error { Error::EndOfStream }
fn unknown_field(_: &str) -> Error { Error::SyntaxError } fn unknown_field(_: &str) -> Error { Error::Syntax }
fn missing_field(_: &'static str) -> Error { fn missing_field(_: &'static str) -> Error {
Error::MissingField Error::MissingField
@@ -53,11 +53,10 @@ mod decoder {
use rustc_serialize; use rustc_serialize;
use super::Error; use super::Error;
use self::Value::{StringValue, IsizeValue};
enum Value { enum Value {
StringValue(String), String(String),
IsizeValue(isize), Isize(isize),
} }
pub struct IsizeDecoder { pub struct IsizeDecoder {
@@ -81,37 +80,37 @@ mod decoder {
type Error = Error; type Error = Error;
fn error(&mut self, _msg: &str) -> Error { fn error(&mut self, _msg: &str) -> Error {
Error::SyntaxError Error::Syntax
} }
// Primitive types: // Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) } fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) } fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) } fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_isize(&mut self) -> Result<isize, Error> { fn read_isize(&mut self) -> Result<isize, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(IsizeValue(x)) => Ok(x), Some(Value::Isize(x)) => Ok(x),
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Err(Error::EndOfStream), None => Err(Error::EndOfStream),
} }
} }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_str(&mut self) -> Result<String, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StringValue(x)) => Ok(x), Some(Value::String(x)) => Ok(x),
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Err(Error::EndOfStream), None => Err(Error::EndOfStream),
} }
} }
@@ -120,86 +119,86 @@ mod decoder {
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
// Specialized types: // Specialized types:
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
#[inline] #[inline]
@@ -215,12 +214,12 @@ mod decoder {
{ {
match self.iter.next() { match self.iter.next() {
Some((key, value)) => { Some((key, value)) => {
self.stack.push(IsizeValue(value)); self.stack.push(Value::Isize(value));
self.stack.push(StringValue(key)); self.stack.push(Value::String(key));
f(self) f(self)
} }
None => { None => {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
} }
@@ -247,8 +246,8 @@ mod deserializer {
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
enum State { enum State {
StartState, StartState,
KeyState(String), Key(String),
ValueState(isize), Value(isize),
} }
pub struct IsizeDeserializer { pub struct IsizeDeserializer {
@@ -276,10 +275,10 @@ mod deserializer {
Some(State::StartState) => { Some(State::StartState) => {
visitor.visit_map(self) visitor.visit_map(self)
} }
Some(State::KeyState(key)) => { Some(State::Key(key)) => {
visitor.visit_string(key) visitor.visit_string(key)
} }
Some(State::ValueState(value)) => { Some(State::Value(value)) => {
visitor.visit_isize(value) visitor.visit_isize(value)
} }
None => { None => {
@@ -297,8 +296,8 @@ mod deserializer {
{ {
match self.iter.next() { match self.iter.next() {
Some((key, value)) => { Some((key, value)) => {
self.stack.push(State::ValueState(value)); self.stack.push(State::Value(value));
self.stack.push(State::KeyState(key)); self.stack.push(State::Key(key));
Ok(Some(try!(de::Deserialize::deserialize(self)))) Ok(Some(try!(de::Deserialize::deserialize(self))))
} }
None => { None => {
@@ -315,7 +314,7 @@ mod deserializer {
fn end(&mut self) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
match self.iter.next() { match self.iter.next() {
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Ok(()), None => Ok(()),
} }
} }
@@ -332,14 +331,14 @@ mod deserializer {
#[inline] #[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> { fn next(&mut self) -> Option<Result<de::Token, Error>> {
match self.stack.pop() { match self.stack.pop() {
Some(StartState) => { Some(State::StartState) => {
self.stack.push(KeyOrEndState); self.stack.push(KeyOrEndState);
Some(Ok(de::Token::MapStart(self.len))) Some(Ok(de::Token::MapStart(self.len)))
} }
Some(KeyOrEndState) => { Some(State::KeyOrEndState) => {
match self.iter.next() { match self.iter.next() {
Some((key, value)) => { Some((key, value)) => {
self.stack.push(ValueState(value)); self.stack.push(Value(value));
Some(Ok(de::Token::String(key))) Some(Ok(de::Token::String(key)))
} }
None => { None => {
@@ -348,7 +347,7 @@ mod deserializer {
} }
} }
} }
Some(ValueState(x)) => { Some(State::Value(x)) => {
self.stack.push(KeyOrEndState); self.stack.push(KeyOrEndState);
Some(Ok(de::Token::Isize(x))) Some(Ok(de::Token::Isize(x)))
} }
@@ -370,24 +369,24 @@ mod deserializer {
#[inline] #[inline]
fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error { fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
SyntaxError Syntax
} }
#[inline] #[inline]
fn unexpected_name(&mut self, _token: de::Token) -> Error { fn unexpected_name(&mut self, _token: de::Token) -> Error {
SyntaxError Syntax
} }
#[inline] #[inline]
fn conversion_error(&mut self, _token: de::Token) -> Error { fn conversion_error(&mut self, _token: de::Token) -> Error {
SyntaxError Syntax
} }
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserialize<IsizeDeserializer, Error> T: de::Deserialize<IsizeDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
*/ */
serde_tests/benches/bench_struct.rs
+114 -127
View File
@@ -29,17 +29,17 @@ pub struct Outer {
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum Error { pub enum Error {
EndOfStream, EndOfStream,
SyntaxError, Syntax,
MissingField, MissingField,
OtherError, OtherError,
} }
impl serde::de::Error for Error { impl serde::de::Error for Error {
fn custom(_: String) -> Error { Error::SyntaxError } fn custom(_: String) -> Error { Error::Syntax }
fn end_of_stream() -> Error { Error::EndOfStream } fn end_of_stream() -> Error { Error::EndOfStream }
fn unknown_field(_: &str) -> Error { Error::SyntaxError } fn unknown_field(_: &str) -> Error { Error::Syntax }
fn missing_field(_: &'static str) -> Error { fn missing_field(_: &'static str) -> Error {
Error::MissingField Error::MissingField
@@ -68,31 +68,18 @@ mod decoder {
use super::{Outer, Inner, Error}; use super::{Outer, Inner, Error};
use self::State::{
OuterState,
InnerState,
NullState,
UsizeState,
CharState,
StringState,
FieldState,
VecState,
MapState,
OptionState,
};
#[derive(Debug)] #[derive(Debug)]
enum State { enum State {
OuterState(Outer), Outer(Outer),
InnerState(Inner), Inner(Inner),
NullState, Null,
UsizeState(usize), Usize(usize),
CharState(char), Char(char),
StringState(String), String(String),
FieldState(&'static str), Field(&'static str),
VecState(Vec<Inner>), Vec(Vec<Inner>),
MapState(HashMap<String, Option<char>>), Map(HashMap<String, Option<char>>),
OptionState(bool), Option(bool),
} }
pub struct OuterDecoder { pub struct OuterDecoder {
@@ -104,7 +91,7 @@ mod decoder {
#[inline] #[inline]
pub fn new(animal: Outer) -> OuterDecoder { pub fn new(animal: Outer) -> OuterDecoder {
OuterDecoder { OuterDecoder {
stack: vec!(OuterState(animal)), stack: vec!(State::Outer(animal)),
} }
} }
} }
@@ -120,41 +107,41 @@ mod decoder {
#[inline] #[inline]
fn read_nil(&mut self) -> Result<(), Error> { fn read_nil(&mut self) -> Result<(), Error> {
match self.stack.pop() { match self.stack.pop() {
Some(NullState) => Ok(()), Some(State::Null) => Ok(()),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
#[inline] #[inline]
fn read_usize(&mut self) -> Result<usize, Error> { fn read_usize(&mut self) -> Result<usize, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(UsizeState(value)) => Ok(value), Some(State::Usize(value)) => Ok(value),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) } fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) } fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_char(&mut self) -> Result<char, Error> { fn read_char(&mut self) -> Result<char, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(CharState(c)) => Ok(c), Some(State::Char(c)) => Ok(c),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
#[inline] #[inline]
fn read_str(&mut self) -> Result<String, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StringState(value)) => Ok(value), Some(State::String(value)) => Ok(value),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
@@ -162,31 +149,31 @@ mod decoder {
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
#[inline] #[inline]
@@ -194,31 +181,31 @@ mod decoder {
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(OuterState(Outer { inner })) => { Some(State::Outer(Outer { inner })) => {
if s_name == "Outer" { if s_name == "Outer" {
self.stack.push(VecState(inner)); self.stack.push(State::Vec(inner));
self.stack.push(FieldState("inner")); self.stack.push(State::Field("inner"));
f(self) f(self)
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
Some(InnerState(Inner { a: (), b, c })) => { Some(State::Inner(Inner { a: (), b, c })) => {
if s_name == "Inner" { if s_name == "Inner" {
self.stack.push(MapState(c)); self.stack.push(State::Map(c));
self.stack.push(FieldState("c")); self.stack.push(State::Field("c"));
self.stack.push(UsizeState(b)); self.stack.push(State::Usize(b));
self.stack.push(FieldState("b")); self.stack.push(State::Field("b"));
self.stack.push(NullState); self.stack.push(State::Null);
self.stack.push(FieldState("a")); self.stack.push(State::Field("a"));
f(self) f(self)
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
#[inline] #[inline]
@@ -226,39 +213,39 @@ mod decoder {
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(FieldState(name)) => { Some(State::Field(name)) => {
if f_name == name { if f_name == name {
f(self) f(self)
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
_ => Err(Error::SyntaxError) _ => Err(Error::Syntax)
} }
} }
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
// Specialized types: // Specialized types:
@@ -267,8 +254,8 @@ mod decoder {
F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(OptionState(b)) => f(self, b), Some(State::Option(b)) => f(self, b),
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
@@ -277,14 +264,14 @@ mod decoder {
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(VecState(value)) => { Some(State::Vec(value)) => {
let len = value.len(); let len = value.len();
for inner in value.into_iter().rev() { for inner in value.into_iter().rev() {
self.stack.push(InnerState(inner)); self.stack.push(State::Inner(inner));
} }
f(self, len) f(self, len)
} }
_ => Err(Error::SyntaxError) _ => Err(Error::Syntax)
} }
} }
#[inline] #[inline]
@@ -299,23 +286,23 @@ mod decoder {
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(MapState(map)) => { Some(State::Map(map)) => {
let len = map.len(); let len = map.len();
for (key, value) in map { for (key, value) in map {
match value { match value {
Some(c) => { Some(c) => {
self.stack.push(CharState(c)); self.stack.push(State::Char(c));
self.stack.push(OptionState(true)); self.stack.push(State::Option(true));
} }
None => { None => {
self.stack.push(OptionState(false)); self.stack.push(State::Option(false));
} }
} }
self.stack.push(StringState(key)); self.stack.push(State::String(key));
} }
f(self, len) f(self, len)
} }
_ => Err(Error::SyntaxError), _ => Err(Error::Syntax),
} }
} }
#[inline] #[inline]
@@ -346,16 +333,16 @@ mod deserializer {
#[derive(Debug)] #[derive(Debug)]
enum State { enum State {
OuterState(Outer), Outer(Outer),
InnerState(Inner), Inner(Inner),
StrState(&'static str), Str(&'static str),
NullState, Null,
UsizeState(usize), Usize(usize),
CharState(char), Char(char),
StringState(String), String(String),
OptionState(bool), Option(bool),
VecState(Vec<Inner>), Vec(Vec<Inner>),
MapState(HashMap<String, Option<char>>), Map(HashMap<String, Option<char>>),
} }
pub struct OuterDeserializer { pub struct OuterDeserializer {
@@ -366,7 +353,7 @@ mod deserializer {
#[inline] #[inline]
pub fn new(outer: Outer) -> OuterDeserializer { pub fn new(outer: Outer) -> OuterDeserializer {
OuterDeserializer { OuterDeserializer {
stack: vec!(State::OuterState(outer)), stack: vec!(State::Outer(outer)),
} }
} }
} }
@@ -378,40 +365,40 @@ mod deserializer {
where V: de::Visitor, where V: de::Visitor,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(State::VecState(value)) => { Some(State::Vec(value)) => {
visitor.visit_seq(OuterSeqVisitor { visitor.visit_seq(OuterSeqVisitor {
de: self, de: self,
iter: value.into_iter(), iter: value.into_iter(),
}) })
} }
Some(State::MapState(value)) => { Some(State::Map(value)) => {
visitor.visit_map(MapVisitor { visitor.visit_map(MapVisitor {
de: self, de: self,
iter: value.into_iter(), iter: value.into_iter(),
}) })
} }
Some(State::NullState) => { Some(State::Null) => {
visitor.visit_unit() visitor.visit_unit()
} }
Some(State::UsizeState(x)) => { Some(State::Usize(x)) => {
visitor.visit_usize(x) visitor.visit_usize(x)
} }
Some(State::CharState(x)) => { Some(State::Char(x)) => {
visitor.visit_char(x) visitor.visit_char(x)
} }
Some(State::StrState(x)) => { Some(State::Str(x)) => {
visitor.visit_str(x) visitor.visit_str(x)
} }
Some(State::StringState(x)) => { Some(State::String(x)) => {
visitor.visit_string(x) visitor.visit_string(x)
} }
Some(State::OptionState(false)) => { Some(State::Option(false)) => {
visitor.visit_none() visitor.visit_none()
} }
Some(State::OptionState(true)) => { Some(State::Option(true)) => {
visitor.visit_some(self) visitor.visit_some(self)
} }
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Err(Error::EndOfStream), None => Err(Error::EndOfStream),
} }
} }
@@ -423,32 +410,32 @@ mod deserializer {
where V: de::Visitor, where V: de::Visitor,
{ {
match self.stack.pop() { match self.stack.pop() {
Some(State::OuterState(Outer { inner })) => { Some(State::Outer(Outer { inner })) => {
if name != "Outer" { if name != "Outer" {
return Err(Error::SyntaxError); return Err(Error::Syntax);
} }
self.stack.push(State::VecState(inner)); self.stack.push(State::Vec(inner));
self.stack.push(State::StrState("inner")); self.stack.push(State::Str("inner"));
visitor.visit_map(OuterMapVisitor { visitor.visit_map(OuterMapVisitor {
de: self, de: self,
state: 0, state: 0,
}) })
} }
Some(State::InnerState(Inner { a: (), b, c })) => { Some(State::Inner(Inner { a: (), b, c })) => {
if name != "Inner" { if name != "Inner" {
return Err(Error::SyntaxError); return Err(Error::Syntax);
} }
self.stack.push(State::MapState(c)); self.stack.push(State::Map(c));
self.stack.push(State::StrState("c")); self.stack.push(State::Str("c"));
self.stack.push(State::UsizeState(b)); self.stack.push(State::Usize(b));
self.stack.push(State::StrState("b")); self.stack.push(State::Str("b"));
self.stack.push(State::NullState); self.stack.push(State::Null);
self.stack.push(State::StrState("a")); self.stack.push(State::Str("a"));
visitor.visit_map(InnerMapVisitor { visitor.visit_map(InnerMapVisitor {
de: self, de: self,
@@ -456,7 +443,7 @@ mod deserializer {
}) })
} }
_ => { _ => {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
} }
@@ -494,7 +481,7 @@ mod deserializer {
if self.state == 1 { if self.state == 1 {
Ok(()) Ok(())
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
@@ -517,7 +504,7 @@ mod deserializer {
{ {
match self.iter.next() { match self.iter.next() {
Some(value) => { Some(value) => {
self.de.stack.push(State::InnerState(value)); self.de.stack.push(State::Inner(value));
Ok(Some(try!(de::Deserialize::deserialize(self.de)))) Ok(Some(try!(de::Deserialize::deserialize(self.de))))
} }
None => { None => {
@@ -528,7 +515,7 @@ mod deserializer {
fn end(&mut self) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
match self.iter.next() { match self.iter.next() {
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Ok(()), None => Ok(()),
} }
} }
@@ -570,7 +557,7 @@ mod deserializer {
if self.state == 3 { if self.state == 3 {
Ok(()) Ok(())
} else { } else {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
@@ -593,14 +580,14 @@ mod deserializer {
{ {
match self.iter.next() { match self.iter.next() {
Some((key, Some(value))) => { Some((key, Some(value))) => {
self.de.stack.push(State::CharState(value)); self.de.stack.push(State::Char(value));
self.de.stack.push(State::OptionState(true)); self.de.stack.push(State::Option(true));
self.de.stack.push(State::StringState(key)); self.de.stack.push(State::String(key));
Ok(Some(try!(de::Deserialize::deserialize(self.de)))) Ok(Some(try!(de::Deserialize::deserialize(self.de))))
} }
Some((key, None)) => { Some((key, None)) => {
self.de.stack.push(State::OptionState(false)); self.de.stack.push(State::Option(false));
self.de.stack.push(State::StringState(key)); self.de.stack.push(State::String(key));
Ok(Some(try!(de::Deserialize::deserialize(self.de)))) Ok(Some(try!(de::Deserialize::deserialize(self.de))))
} }
None => { None => {
@@ -617,7 +604,7 @@ mod deserializer {
fn end(&mut self) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
match self.iter.next() { match self.iter.next() {
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => Ok(()), None => Ok(()),
} }
} }
serde_tests/benches/bench_vec.rs
+90 -90
View File
@@ -12,18 +12,18 @@ use serde::de::{Deserializer, Deserialize};
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub enum Error { pub enum Error {
EndOfStreamError, EndOfStream,
SyntaxError, Syntax,
} }
impl serde::de::Error for Error { impl serde::de::Error for Error {
fn custom(_: String) -> Error { Error::SyntaxError } fn custom(_: String) -> Error { Error::Syntax }
fn end_of_stream() -> Error { Error::EndOfStreamError } fn end_of_stream() -> Error { Error::EndOfStream }
fn unknown_field(_: &str) -> Error { Error::SyntaxError } fn unknown_field(_: &str) -> Error { Error::Syntax }
fn missing_field(_: &'static str) -> Error { Error::SyntaxError } fn missing_field(_: &'static str) -> Error { Error::Syntax }
} }
impl fmt::Display for Error { impl fmt::Display for Error {
@@ -67,104 +67,104 @@ mod decoder {
impl rustc_serialize::Decoder for UsizeDecoder { impl rustc_serialize::Decoder for UsizeDecoder {
type Error = Error; type Error = Error;
fn error(&mut self, _: &str) -> Error { Error::SyntaxError } fn error(&mut self, _: &str) -> Error { Error::Syntax }
// Primitive types: // Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) } fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_usize(&mut self) -> Result<usize, Error> { fn read_usize(&mut self) -> Result<usize, Error> {
match self.iter.next() { match self.iter.next() {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(Error::EndOfStreamError), None => Err(Error::EndOfStream),
} }
} }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) } fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) } fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) } fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
// Compound types: // Compound types:
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
// Specialized types: // Specialized types:
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
#[inline] #[inline]
@@ -184,19 +184,19 @@ mod decoder {
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>, F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
@@ -219,105 +219,105 @@ mod decoder {
impl rustc_serialize::Decoder for U8Decoder { impl rustc_serialize::Decoder for U8Decoder {
type Error = Error; type Error = Error;
fn error(&mut self, _: &str) -> Error { Error::SyntaxError } fn error(&mut self, _: &str) -> Error { Error::Syntax }
// Primitive types: // Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) } fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) } fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
#[inline] #[inline]
fn read_u8(&mut self) -> Result<u8, Error> { fn read_u8(&mut self) -> Result<u8, Error> {
match self.iter.next() { match self.iter.next() {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(Error::EndOfStreamError), None => Err(Error::EndOfStream),
} }
} }
#[inline] #[inline]
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) } fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) } fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
// Compound types: // Compound types:
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>, F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>, F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
// Specialized types: // Specialized types:
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>, F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
#[inline] #[inline]
@@ -337,19 +337,19 @@ mod decoder {
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>, F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>, F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{ {
Err(Error::SyntaxError) Err(Error::Syntax)
} }
} }
} }
@@ -366,9 +366,9 @@ mod deserializer {
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
enum State { enum State {
StartState, Start,
SepOrEndState, SepOrEnd,
EndState, End,
} }
pub struct Deserializer<A> { pub struct Deserializer<A> {
@@ -383,7 +383,7 @@ mod deserializer {
pub fn new(values: Vec<A>) -> Deserializer<A> { pub fn new(values: Vec<A>) -> Deserializer<A> {
let len = values.len(); let len = values.len();
Deserializer { Deserializer {
state: State::StartState, state: State::Start,
iter: values.into_iter(), iter: values.into_iter(),
len: len, len: len,
value: None, value: None,
@@ -399,15 +399,15 @@ mod deserializer {
where V: de::Visitor, where V: de::Visitor,
{ {
match self.state { match self.state {
State::StartState => { State::Start => {
self.state = State::SepOrEndState; self.state = State::SepOrEnd;
visitor.visit_seq(self) visitor.visit_seq(self)
} }
State::SepOrEndState => { State::SepOrEnd => {
visitor.visit_usize(self.value.take().unwrap()) visitor.visit_usize(self.value.take().unwrap())
} }
State::EndState => { State::End => {
Err(Error::EndOfStreamError) Err(Error::EndOfStream)
} }
} }
} }
@@ -427,7 +427,7 @@ mod deserializer {
Ok(Some(try!(de::Deserialize::deserialize(self)))) Ok(Some(try!(de::Deserialize::deserialize(self))))
} }
None => { None => {
self.state = State::EndState; self.state = State::End;
Ok(None) Ok(None)
} }
} }
@@ -436,9 +436,9 @@ mod deserializer {
#[inline] #[inline]
fn end(&mut self) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
match self.iter.next() { match self.iter.next() {
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => { None => {
self.state = State::EndState; self.state = State::End;
Ok(()) Ok(())
} }
} }
@@ -458,15 +458,15 @@ mod deserializer {
where V: de::Visitor, where V: de::Visitor,
{ {
match self.state { match self.state {
State::StartState => { State::Start => {
self.state = State::SepOrEndState; self.state = State::SepOrEnd;
visitor.visit_seq(self) visitor.visit_seq(self)
} }
State::SepOrEndState => { State::SepOrEnd => {
visitor.visit_u8(self.value.take().unwrap()) visitor.visit_u8(self.value.take().unwrap())
} }
State::EndState => { State::End => {
Err(Error::EndOfStreamError) Err(Error::EndOfStream)
} }
} }
} }
@@ -486,7 +486,7 @@ mod deserializer {
Ok(Some(try!(de::Deserialize::deserialize(self)))) Ok(Some(try!(de::Deserialize::deserialize(self))))
} }
None => { None => {
self.state = State::EndState; self.state = State::End;
Ok(None) Ok(None)
} }
} }
@@ -495,9 +495,9 @@ mod deserializer {
#[inline] #[inline]
fn end(&mut self) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
match self.iter.next() { match self.iter.next() {
Some(_) => Err(Error::SyntaxError), Some(_) => Err(Error::Syntax),
None => { None => {
self.state = State::EndState; self.state = State::End;
Ok(()) Ok(())
} }
} }