diff --git a/serde/Cargo.toml b/serde/Cargo.toml index be52d384..27ea433c 100644 --- a/serde/Cargo.toml +++ b/serde/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "A generic serialization/deserialization framework" diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 58a1683e..5653a717 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -313,11 +313,6 @@ impl Serialize for () { /////////////////////////////////////////////////////////////////////////////// -// FIXME(rust #19630) Remove this work-around -macro_rules! e { - ($e:expr) => { $e } -} - macro_rules! tuple_impls { ($( $TupleVisitor:ident ($len:expr, $($T:ident),+) { @@ -334,7 +329,7 @@ macro_rules! tuple_impls { { let mut state = try!(serializer.serialize_tuple($len)); $( - try!(serializer.serialize_tuple_elt(&mut state, &e!(self.$idx))); + try!(serializer.serialize_tuple_elt(&mut state, &self.$idx)); )+ serializer.serialize_tuple_end(state) } diff --git a/serde_codegen/Cargo.toml b/serde_codegen/Cargo.toml index 85718720..4b2b12fe 100644 --- a/serde_codegen/Cargo.toml +++ b/serde_codegen/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_codegen" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Macros to auto-generate implementations for the serde framework" diff --git a/serde_codegen/src/lib.rs b/serde_codegen/src/lib.rs index 2b2bca94..371cd841 100644 --- a/serde_codegen/src/lib.rs +++ b/serde_codegen/src/lib.rs @@ -172,8 +172,8 @@ macro_rules! shim { use syntax::parse; let name = stringify!($name).to_string(); let cfg = Vec::new(); - let sess = parse::ParseSess::new(); - let impl_item = parse::parse_item_from_source_str(name, expanded, cfg, &sess); + let sess = cx.parse_sess; + let impl_item = parse::parse_item_from_source_str(name, expanded, cfg, sess); push(::syntax::ext::base::Annotatable::Item(impl_item.unwrap().unwrap())); } }; diff --git a/serde_derive/Cargo.toml b/serde_derive/Cargo.toml index 29f9b4d5..5d1e4176 100644 --- a/serde_derive/Cargo.toml +++ b/serde_derive/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_derive" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]" @@ -18,7 +18,7 @@ proc-macro = true post-expansion = "0.0.2" [dependencies.serde_codegen] -version = "=0.8.13" +version = "=0.8.14" path = "../serde_codegen" default-features = false features = ["with-syn"] @@ -26,5 +26,5 @@ features = ["with-syn"] [dev-dependencies] compiletest_rs = "^0.2.0" fnv = "1.0" -serde = { version = "0.8.13", path = "../serde" } -serde_test = { version = "0.8.13", path = "../serde_test" } +serde = { version = "0.8.14", path = "../serde" } +serde_test = { version = "0.8.14", path = "../serde_test" } diff --git a/serde_test/Cargo.toml b/serde_test/Cargo.toml index 63ae9b53..558569d9 100644 --- a/serde_test/Cargo.toml +++ b/serde_test/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_test" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Token De/Serializer for testing De/Serialize implementations" @@ -12,4 +12,4 @@ keywords = ["serde", "serialization"] include = ["Cargo.toml", "src/**/*.rs"] [dependencies] -serde = { version = "0.8.13", path = "../serde" } +serde = { version = "0.8.14", path = "../serde" } diff --git a/testing/Cargo.toml b/testing/Cargo.toml index c44975b6..f03987e6 100644 --- a/testing/Cargo.toml +++ b/testing/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_testing" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "A generic serialization/deserialization framework" @@ -29,7 +29,3 @@ clippy = { version = "^0.*", optional = true } [[test]] name = "test" path = "tests/test.rs" - -[[bench]] -name = "bench" -path = "benches/bench.rs" diff --git a/testing/benches/bench.rs b/testing/benches/bench.rs deleted file mode 100644 index e5b10c57..00000000 --- a/testing/benches/bench.rs +++ /dev/null @@ -1,9 +0,0 @@ -#![feature(test)] -#![cfg_attr(feature = "clippy", feature(plugin))] -#![cfg_attr(feature = "clippy", plugin(clippy))] - -extern crate rustc_serialize; -extern crate serde; -extern crate test; - -include!(concat!(env!("OUT_DIR"), "/bench.rs")); diff --git a/testing/benches/bench.rs.in b/testing/benches/bench.rs.in deleted file mode 100644 index d79b35f0..00000000 --- a/testing/benches/bench.rs.in +++ /dev/null @@ -1,4 +0,0 @@ -mod bench_enum; -mod bench_map; -mod bench_struct; -mod bench_vec; diff --git a/testing/benches/bench_enum.rs b/testing/benches/bench_enum.rs deleted file mode 100644 index 8badbb49..00000000 --- a/testing/benches/bench_enum.rs +++ /dev/null @@ -1,466 +0,0 @@ -use test::Bencher; -use std::error; -use std::fmt; -use rustc_serialize::Decodable; -use serde; -use serde::de::Deserialize; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub enum Animal { - Dog, - Frog(String, isize) -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Debug)] -pub enum Error { - EndOfStream, - Syntax, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { Error::Syntax } -} - -impl fmt::Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { - formatter.write_str(format!("{:?}", self).as_ref()) - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - "Serde Deserialization Error" - } - - fn cause(&self) -> Option<&error::Error> { - None - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod decoder { - use rustc_serialize::Decoder; - - use super::{Animal, Error}; - use super::Animal::{Dog, Frog}; - - enum State { - Animal(Animal), - Isize(isize), - String(String), - } - - pub struct AnimalDecoder { - stack: Vec, - - } - - impl AnimalDecoder { - #[inline] - pub fn new(animal: Animal) -> AnimalDecoder { - AnimalDecoder { - stack: vec!(State::Animal(animal)), - } - } - } - - impl Decoder for AnimalDecoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_isize(&mut self) -> Result { - match self.stack.pop() { - Some(State::Isize(x)) => Ok(x), - _ => Err(Error::Syntax), - } - } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(State::String(x)) => Ok(x), - _ => Err(Error::Syntax), - } - } - - // Compound types: - #[inline] - fn read_enum(&mut self, name: &str, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Animal(animal)) => { - self.stack.push(State::Animal(animal)); - if name == "Animal" { - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax) - } - } - - #[inline] - fn read_enum_variant(&mut self, names: &[&str], f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - let name = match self.stack.pop() { - Some(State::Animal(Dog)) => "Dog", - Some(State::Animal(Frog(x0, x1))) => { - self.stack.push(State::Isize(x1)); - self.stack.push(State::String(x0)); - "Frog" - } - _ => { return Err(Error::Syntax); } - }; - - let idx = match names.iter().position(|n| *n == name) { - Some(idx) => idx, - None => { return Err(Error::Syntax); } - }; - - f(self, idx) - } - - #[inline] - fn read_enum_variant_arg(&mut self, _a_idx: usize, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - f(self) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - f(self, 3) - } - - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use super::{Animal, Error}; - - use serde::de; - - #[derive(Debug)] - enum State { - Animal(Animal), - Isize(isize), - Str(&'static str), - String(String), - UnitState, - } - - pub struct AnimalDeserializer { - stack: Vec, - } - - impl AnimalDeserializer { - #[inline] - pub fn new(animal: Animal) -> AnimalDeserializer { - AnimalDeserializer { - stack: vec!(State::Animal(animal)), - } - } - } - - impl de::Deserializer for AnimalDeserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Isize(value)) => { - visitor.visit_isize(value) - } - Some(State::String(value)) => { - visitor.visit_string(value) - } - Some(State::Str(value)) => { - visitor.visit_str(value) - } - Some(State::UnitState) => { - visitor.visit_unit() - } - Some(_) => { - Err(Error::Syntax) - } - None => { - Err(Error::EndOfStream) - } - } - } - - #[inline] - fn deserialize_enum(&mut self, - _name: &str, - _variants: &[&str], - mut visitor: V) -> Result - where V: de::EnumVisitor, - { - match self.stack.pop() { - Some(State::Animal(Animal::Dog)) => { - self.stack.push(State::UnitState); - self.stack.push(State::Str("Dog")); - visitor.visit(DogVisitor { - de: self, - }) - } - Some(State::Animal(Animal::Frog(x0, x1))) => { - self.stack.push(State::Isize(x1)); - self.stack.push(State::String(x0)); - self.stack.push(State::Str("Frog")); - visitor.visit(FrogVisitor { - de: self, - state: 0, - }) - } - Some(_) => { - Err(Error::Syntax) - } - None => { - Err(Error::EndOfStream) - } - } - } - } - - struct DogVisitor<'a> { - de: &'a mut AnimalDeserializer, - } - - impl<'a> de::VariantVisitor for DogVisitor<'a> { - type Error = Error; - - fn visit_variant(&mut self) -> Result - where V: de::Deserialize - { - de::Deserialize::deserialize(self.de) - } - - fn visit_unit(&mut self) -> Result<(), Error> { - de::Deserialize::deserialize(self.de) - } - } - - struct FrogVisitor<'a> { - de: &'a mut AnimalDeserializer, - state: usize, - } - - impl<'a> de::VariantVisitor for FrogVisitor<'a> { - type Error = Error; - - fn visit_variant(&mut self) -> Result - where V: de::Deserialize - { - de::Deserialize::deserialize(self.de) - } - - fn visit_tuple(&mut self, - _len: usize, - mut visitor: V) -> Result - where V: de::Visitor, - { - visitor.visit_seq(self) - } - } - - impl<'a> de::SeqVisitor for FrogVisitor<'a> { - type Error = Error; - - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.state { - 0 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - 1 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 2 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 2 - self.state; - (len, Some(len)) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -#[bench] -fn bench_decoder_dog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Dog; - - let mut d = decoder::AnimalDecoder::new(animal.clone()); - let value: Animal = Decodable::decode(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_decoder_frog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Frog("Henry".to_owned(), 349); - - let mut d = decoder::AnimalDecoder::new(animal.clone()); - let value: Animal = Decodable::decode(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_deserializer_dog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Dog; - - let mut d = deserializer::AnimalDeserializer::new(animal.clone()); - let value: Animal = Deserialize::deserialize(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_deserializer_frog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Frog("Henry".to_owned(), 349); - - let mut d = deserializer::AnimalDeserializer::new(animal.clone()); - let value: Animal = Deserialize::deserialize(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} diff --git a/testing/benches/bench_map.rs b/testing/benches/bench_map.rs deleted file mode 100644 index 32bc4415..00000000 --- a/testing/benches/bench_map.rs +++ /dev/null @@ -1,474 +0,0 @@ -use std::fmt::Debug; -use std::fmt; -use std::error; -use std::collections::HashMap; -use test::Bencher; - -use rustc_serialize::{Decoder, Decodable}; - -use serde; -use serde::de::{Deserializer, Deserialize}; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(PartialEq, Debug)] -pub enum Error { - EndOfStream, - Syntax, - MissingField, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { - Error::MissingField - } -} - -impl fmt::Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { - formatter.write_str(format!("{:?}", self).as_ref()) - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - "Serde Deserialization Error" - } - - fn cause(&self) -> Option<&error::Error> { - None - } -} -////////////////////////////////////////////////////////////////////////////// - -mod decoder { - use std::collections::HashMap; - use std::collections::hash_map::IntoIter; - use rustc_serialize; - - use super::Error; - - enum Value { - String(String), - Isize(isize), - } - - pub struct IsizeDecoder { - len: usize, - iter: IntoIter, - stack: Vec, - } - - impl IsizeDecoder { - #[inline] - pub fn new(values: HashMap) -> IsizeDecoder { - IsizeDecoder { - len: values.len(), - iter: values.into_iter(), - stack: vec!(), - } - } - } - - impl rustc_serialize::Decoder for IsizeDecoder { - type Error = Error; - - fn error(&mut self, _msg: &str) -> Error { - Error::Syntax - } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_isize(&mut self) -> Result { - match self.stack.pop() { - Some(Value::Isize(x)) => Ok(x), - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(Value::String(x)) => Ok(x), - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - fn read_seq(&mut self, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_seq_elt(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_map(&mut self, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_map_elt_key(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(Value::Isize(value)); - self.stack.push(Value::String(key)); - f(self) - } - None => { - Err(Error::Syntax) - } - } - } - - #[inline] - fn read_map_elt_val(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - f(self) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use std::collections::HashMap; - use std::collections::hash_map; - - use super::Error; - - use serde::de; - - #[derive(PartialEq, Debug)] - enum State { - StartState, - Key(String), - Value(isize), - } - - pub struct IsizeDeserializer { - stack: Vec, - iter: hash_map::IntoIter, - } - - impl IsizeDeserializer { - #[inline] - pub fn new(values: HashMap) -> IsizeDeserializer { - IsizeDeserializer { - stack: vec!(State::StartState), - iter: values.into_iter(), - } - } - } - - impl de::Deserializer for IsizeDeserializer { - type Error = Error; - - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::StartState) => { - visitor.visit_map(self) - } - Some(State::Key(key)) => { - visitor.visit_string(key) - } - Some(State::Value(value)) => { - visitor.visit_isize(value) - } - None => { - Err(Error::EndOfStream) - } - } - } - } - - impl de::MapVisitor for IsizeDeserializer { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(State::Value(value)); - self.stack.push(State::Key(key)); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self) - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } - -/* - impl Iterator for IsizeDeserializer { - type Item = Result; - - #[inline] - fn next(&mut self) -> Option> { - match self.stack.pop() { - Some(State::StartState) => { - self.stack.push(KeyOrEndState); - Some(Ok(de::Token::MapStart(self.len))) - } - Some(State::KeyOrEndState) => { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(Value(value)); - Some(Ok(de::Token::String(key))) - } - None => { - self.stack.push(EndState); - Some(Ok(de::Token::End)) - } - } - } - Some(State::Value(x)) => { - self.stack.push(KeyOrEndState); - Some(Ok(de::Token::Isize(x))) - } - Some(EndState) => { - None - } - None => { - None - } - } - } - } - - impl de::Deserializer for IsizeDeserializer { - #[inline] - fn end_of_stream(&mut self) -> Error { - EndOfStream - } - - #[inline] - fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error { - Syntax - } - - #[inline] - fn unexpected_name(&mut self, _token: de::Token) -> Error { - Syntax - } - - #[inline] - fn conversion_error(&mut self, _token: de::Token) -> Error { - Syntax - } - - #[inline] - fn missing_field< - T: de::Deserialize - >(&mut self, _field: &'static str) -> Result { - Err(Error::Syntax) - } - } -*/ -} - -////////////////////////////////////////////////////////////////////////////// - -fn run_decoder< - D: Decoder, - T: Clone + PartialEq + Debug + Decodable ->(mut d: D, value: T) { - let v = Decodable::decode(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_decoder_000(b: &mut Bencher) { - b.iter(|| { - let m: HashMap = HashMap::new(); - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -#[bench] -fn bench_decoder_003(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 3 { - m.insert(i.to_string(), i); - } - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -#[bench] -fn bench_decoder_100(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 100 { - m.insert(i.to_string(), i); - } - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -fn run_deserializer(mut d: D, value: T) - where D: Deserializer, - D::Error: Debug + PartialEq, - T: Clone + PartialEq + Debug + Deserialize -{ - let v = T::deserialize(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_deserializer_000(b: &mut Bencher) { - b.iter(|| { - let m: HashMap = HashMap::new(); - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} - -#[bench] -fn bench_deserializer_003(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 3 { - m.insert(i.to_string(), i); - } - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} - -#[bench] -fn bench_deserializer_100(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 100 { - m.insert(i.to_string(), i); - } - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} diff --git a/testing/benches/bench_struct.rs b/testing/benches/bench_struct.rs deleted file mode 100644 index 82b189e1..00000000 --- a/testing/benches/bench_struct.rs +++ /dev/null @@ -1,745 +0,0 @@ -use std::collections::HashMap; -use test::Bencher; -use std::fmt; -use std::error; - -use rustc_serialize::Decodable; - -use serde; -use serde::de::Deserialize; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub struct Inner { - a: (), - b: usize, - c: HashMap>, -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub struct Outer { - inner: Vec, -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Debug, PartialEq)] -pub enum Error { - EndOfStream, - Syntax, - MissingField, - OtherError, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { - Error::MissingField - } -} - -impl fmt::Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { - formatter.write_str(format!("{:?}", self).as_ref()) - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - "Serde Deserialization Error" - } - - fn cause(&self) -> Option<&error::Error> { - None - } -} - -mod decoder { - use std::collections::HashMap; - use rustc_serialize::Decoder; - - use super::{Outer, Inner, Error}; - - #[derive(Debug)] - enum State { - Outer(Outer), - Inner(Inner), - Null, - Usize(usize), - Char(char), - String(String), - Field(&'static str), - Vec(Vec), - Map(HashMap>), - Option(bool), - } - - pub struct OuterDecoder { - stack: Vec, - - } - - impl OuterDecoder { - #[inline] - pub fn new(animal: Outer) -> OuterDecoder { - OuterDecoder { - stack: vec!(State::Outer(animal)), - } - } - } - - impl Decoder for OuterDecoder { - type Error = Error; - - fn error(&mut self, _msg: &str) -> Error { - Error::OtherError - } - - // Primitive types: - #[inline] - fn read_nil(&mut self) -> Result<(), Error> { - match self.stack.pop() { - Some(State::Null) => Ok(()), - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_usize(&mut self) -> Result { - match self.stack.pop() { - Some(State::Usize(value)) => Ok(value), - _ => Err(Error::Syntax), - } - } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_char(&mut self) -> Result { - match self.stack.pop() { - Some(State::Char(c)) => Ok(c), - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(State::String(value)) => Ok(value), - _ => Err(Error::Syntax), - } - } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_struct(&mut self, s_name: &str, _len: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Outer(Outer { inner })) => { - if s_name == "Outer" { - self.stack.push(State::Vec(inner)); - self.stack.push(State::Field("inner")); - f(self) - } else { - Err(Error::Syntax) - } - } - Some(State::Inner(Inner { a: (), b, c })) => { - if s_name == "Inner" { - self.stack.push(State::Map(c)); - self.stack.push(State::Field("c")); - - self.stack.push(State::Usize(b)); - self.stack.push(State::Field("b")); - - self.stack.push(State::Null); - self.stack.push(State::Field("a")); - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_struct_field(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Field(name)) => { - if f_name == name { - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax) - } - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - #[inline] - fn read_option(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, bool) -> Result, - { - match self.stack.pop() { - Some(State::Option(b)) => f(self, b), - _ => Err(Error::Syntax), - } - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - match self.stack.pop() { - Some(State::Vec(value)) => { - let len = value.len(); - for inner in value.into_iter().rev() { - self.stack.push(State::Inner(inner)); - } - f(self, len) - } - _ => Err(Error::Syntax) - } - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - - #[inline] - fn read_map(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - match self.stack.pop() { - Some(State::Map(map)) => { - let len = map.len(); - for (key, value) in map { - match value { - Some(c) => { - self.stack.push(State::Char(c)); - self.stack.push(State::Option(true)); - } - None => { - self.stack.push(State::Option(false)); - } - } - self.stack.push(State::String(key)); - } - f(self, len) - } - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_map_elt_key(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - - #[inline] - fn read_map_elt_val(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use std::collections::HashMap; - use std::collections::hash_map; - use std::vec; - use super::{Outer, Inner}; - use super::Error; - use serde::de; - - #[derive(Debug)] - enum State { - Outer(Outer), - Inner(Inner), - Str(&'static str), - Null, - Usize(usize), - Char(char), - String(String), - Option(bool), - Vec(Vec), - Map(HashMap>), - } - - pub struct OuterDeserializer { - stack: Vec, - } - - impl OuterDeserializer { - #[inline] - pub fn new(outer: Outer) -> OuterDeserializer { - OuterDeserializer { - stack: vec!(State::Outer(outer)), - } - } - } - - impl de::Deserializer for OuterDeserializer { - type Error = Error; - - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Vec(value)) => { - visitor.visit_seq(OuterSeqVisitor { - de: self, - iter: value.into_iter(), - }) - } - Some(State::Map(value)) => { - visitor.visit_map(MapVisitor { - de: self, - iter: value.into_iter(), - }) - } - Some(State::Null) => { - visitor.visit_unit() - } - Some(State::Usize(x)) => { - visitor.visit_usize(x) - } - Some(State::Char(x)) => { - visitor.visit_char(x) - } - Some(State::Str(x)) => { - visitor.visit_str(x) - } - Some(State::String(x)) => { - visitor.visit_string(x) - } - Some(State::Option(false)) => { - visitor.visit_none() - } - Some(State::Option(true)) => { - visitor.visit_some(self) - } - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - - fn deserialize_struct(&mut self, - name: &str, - _fields: &'static [&'static str], - mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Outer(Outer { inner })) => { - if name != "Outer" { - return Err(Error::Syntax); - } - - self.stack.push(State::Vec(inner)); - self.stack.push(State::Str("inner")); - - visitor.visit_map(OuterMapVisitor { - de: self, - state: 0, - }) - } - Some(State::Inner(Inner { a: (), b, c })) => { - if name != "Inner" { - return Err(Error::Syntax); - } - - self.stack.push(State::Map(c)); - self.stack.push(State::Str("c")); - - self.stack.push(State::Usize(b)); - self.stack.push(State::Str("b")); - - self.stack.push(State::Null); - self.stack.push(State::Str("a")); - - visitor.visit_map(InnerMapVisitor { - de: self, - state: 0, - }) - } - _ => { - Err(Error::Syntax) - } - } - } - } - - struct OuterMapVisitor<'a> { - de: &'a mut OuterDeserializer, - state: usize, - } - - impl<'a> de::MapVisitor for OuterMapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.state { - 0 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 1 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 1 - self.state; - (len, Some(len)) - } - } - - struct OuterSeqVisitor<'a> { - de: &'a mut OuterDeserializer, - iter: vec::IntoIter, - } - - impl<'a> de::SeqVisitor for OuterSeqVisitor<'a> { - type Error = Error; - - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.de.stack.push(State::Inner(value)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - None => { - Ok(None) - } - } - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } - - struct InnerMapVisitor<'a> { - de: &'a mut OuterDeserializer, - state: usize, - } - - impl<'a> de::MapVisitor for InnerMapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.state { - 0 ... 2 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 3 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 1 - self.state; - (len, Some(len)) - } - } - - struct MapVisitor<'a> { - de: &'a mut OuterDeserializer, - iter: hash_map::IntoIter>, - } - - impl<'a> de::MapVisitor for MapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.iter.next() { - Some((key, Some(value))) => { - self.de.stack.push(State::Char(value)); - self.de.stack.push(State::Option(true)); - self.de.stack.push(State::String(key)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - Some((key, None)) => { - self.de.stack.push(State::Option(false)); - self.de.stack.push(State::String(key)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - None => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } -} - -#[bench] -fn bench_decoder_0_0(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("abc".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!(), - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_decoder_1_0(b: &mut Bencher) { - b.iter(|| { - let map = HashMap::new(); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_decoder_1_5(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("1".to_owned(), Some('a')); - map.insert("2".to_owned(), None); - map.insert("3".to_owned(), Some('b')); - map.insert("4".to_owned(), None); - map.insert("5".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_0_0(b: &mut Bencher) { - b.iter(|| { - let outer = Outer { - inner: vec!(), - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_1_0(b: &mut Bencher) { - b.iter(|| { - let map = HashMap::new(); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_1_5(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("1".to_owned(), Some('a')); - map.insert("2".to_owned(), None); - map.insert("3".to_owned(), Some('b')); - map.insert("4".to_owned(), None); - map.insert("5".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} diff --git a/testing/benches/bench_vec.rs b/testing/benches/bench_vec.rs deleted file mode 100644 index 96a4e637..00000000 --- a/testing/benches/bench_vec.rs +++ /dev/null @@ -1,628 +0,0 @@ -use std::fmt::Debug; -use std::fmt; -use std::error; -use test::Bencher; - -use rustc_serialize::{Decoder, Decodable}; - -use serde; -use serde::de::{Deserializer, Deserialize}; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(PartialEq, Debug)] -pub enum Error { - EndOfStream, - Syntax, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { Error::Syntax } -} - -impl fmt::Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { - formatter.write_str(format!("{:?}", self).as_ref()) - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - "Serde Deserialization Error" - } - - fn cause(&self) -> Option<&error::Error> { - None - } -} -////////////////////////////////////////////////////////////////////////////// - -mod decoder { - use std::vec; - use rustc_serialize; - - use super::Error; - - pub struct UsizeDecoder { - len: usize, - iter: vec::IntoIter, - } - - impl UsizeDecoder { - #[inline] - pub fn new(values: Vec) -> UsizeDecoder { - UsizeDecoder { - len: values.len(), - iter: values.into_iter(), - } - } - } - - impl rustc_serialize::Decoder for UsizeDecoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - #[inline] - fn read_usize(&mut self) -> Result { - match self.iter.next() { - Some(value) => Ok(value), - None => Err(Error::EndOfStream), - } - } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - fn read_str(&mut self) -> Result { Err(Error::Syntax) } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - } - - - pub struct U8Decoder { - len: usize, - iter: vec::IntoIter, - } - - impl U8Decoder { - #[inline] - pub fn new(values: Vec) -> U8Decoder { - U8Decoder { - len: values.len(), - iter: values.into_iter(), - } - } - } - - impl rustc_serialize::Decoder for U8Decoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_u8(&mut self) -> Result { - match self.iter.next() { - Some(value) => Ok(value), - None => Err(Error::EndOfStream), - } - } - #[inline] - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - fn read_str(&mut self) -> Result { Err(Error::Syntax) } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut U8Decoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - //use std::num; - use std::vec; - - use super::Error; - - use serde::de; - - #[derive(PartialEq, Debug)] - enum State { - Start, - SepOrEnd, - End, - } - - pub struct Deserializer { - state: State, - iter: vec::IntoIter, - len: usize, - value: Option, - } - - impl Deserializer { - #[inline] - pub fn new(values: Vec) -> Deserializer { - let len = values.len(); - Deserializer { - state: State::Start, - iter: values.into_iter(), - len: len, - value: None, - } - } - } - - impl de::Deserializer for Deserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.state { - State::Start => { - self.state = State::SepOrEnd; - visitor.visit_seq(self) - } - State::SepOrEnd => { - visitor.visit_usize(self.value.take().unwrap()) - } - State::End => { - Err(Error::EndOfStream) - } - } - } - } - - impl de::SeqVisitor for Deserializer { - type Error = Error; - - #[inline] - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.len -= 1; - self.value = Some(value); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - self.state = State::End; - Ok(None) - } - } - } - - #[inline] - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => { - self.state = State::End; - Ok(()) - } - } - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) - } - } - - impl de::Deserializer for Deserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.state { - State::Start => { - self.state = State::SepOrEnd; - visitor.visit_seq(self) - } - State::SepOrEnd => { - visitor.visit_u8(self.value.take().unwrap()) - } - State::End => { - Err(Error::EndOfStream) - } - } - } - } - - impl de::SeqVisitor for Deserializer { - type Error = Error; - - #[inline] - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.len -= 1; - self.value = Some(value); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - self.state = State::End; - Ok(None) - } - } - } - - #[inline] - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => { - self.state = State::End; - Ok(()) - } - } - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -fn run_decoder< - D: Decoder, - T: Clone + PartialEq + Debug + Decodable ->(mut d: D, value: T) { - let v = Decodable::decode(&mut d); - - assert_eq!(Ok(value), v); -} - -fn run_deserializer(mut d: D, value: T) - where D: Deserializer, - D::Error: Debug + PartialEq, - T: Clone + PartialEq + Debug + Deserialize -{ - let v = T::deserialize(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_decoder_usize_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_usize_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_usize_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} diff --git a/testing/build.rs b/testing/build.rs index ad175e85..bf4a763b 100644 --- a/testing/build.rs +++ b/testing/build.rs @@ -5,13 +5,7 @@ use std::path::Path; fn main() { let out_dir = env::var_os("OUT_DIR").unwrap(); - - for &(src, dst) in &[ - ("tests/test.rs.in", "test.rs"), - ("benches/bench.rs.in", "bench.rs"), - ] { - let src = Path::new(src); - let dst = Path::new(&out_dir).join(dst); - serde_codegen::expand(&src, &dst).unwrap(); - } + let src = Path::new("tests/test.rs.in"); + let dst = Path::new(&out_dir).join("test.rs"); + serde_codegen::expand(&src, &dst).unwrap(); }