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

Move the benchmarks out of de.rs

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-05-23 20:41:29 -07:00
parent a09694ea5f
commit 79f35c4d48
5 changed files with 1100 additions and 967 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bench_enum.rs
+293
View File
@@ -0,0 +1,293 @@
use test::Bencher;
use serialize::{Decoder, Decodable};
use de::{Deserializer, Deserializable};
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, Eq, Show, Decodable)]
enum Animal {
Dog,
Frog(StrBuf, int)
}
impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal {
#[inline]
fn deserialize(d: &mut D) -> Result<Animal, E> {
match try!(d.expect_enum_start("Animal", ["Dog", "Frog"])) {
0 => {
try!(d.expect_end());
Ok(Dog)
}
1 => {
let x0 = try!(Deserializable::deserialize(d));
let x1 = try!(Deserializable::deserialize(d));
try!(d.expect_end());
Ok(Frog(x0, x1))
}
_ => unreachable!(),
}
}
}
//////////////////////////////////////////////////////////////////////////////
#[deriving(Show)]
enum Error {
EndOfStream,
SyntaxError,
}
//////////////////////////////////////////////////////////////////////////////
mod decoder {
use serialize::Decoder;
use super::{Animal, Dog, Frog, Error, SyntaxError};
enum State {
AnimalState(Animal),
DogState,
FrogState,
IntState(int),
StrState(StrBuf),
}
pub struct AnimalDecoder {
stack: Vec<State>,
}
impl AnimalDecoder {
#[inline]
pub fn new(animal: Animal) -> AnimalDecoder {
AnimalDecoder {
stack: vec!(AnimalState(animal)),
}
}
}
impl Decoder<Error> for AnimalDecoder {
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
#[inline]
fn read_int(&mut self) -> Result<int, Error> {
match self.stack.pop() {
Some(IntState(x)) => Ok(x),
_ => Err(SyntaxError),
}
}
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
#[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> {
match self.stack.pop() {
Some(StrState(x)) => Ok(x),
_ => Err(SyntaxError),
}
}
// Compound types:
#[inline]
fn read_enum<T>(&mut self, name: &str, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(AnimalState(animal)) => {
self.stack.push(AnimalState(animal));
if name == "Animal" {
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError)
}
}
#[inline]
fn read_enum_variant<T>(&mut self, names: &[&str], f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
let name = match self.stack.pop() {
Some(AnimalState(Dog)) => "Dog",
Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(IntState(x1));
self.stack.push(StrState(x0));
"Frog"
}
_ => { return Err(SyntaxError); }
};
let idx = match names.iter().position(|n| *n == name) {
Some(idx) => idx,
None => { return Err(SyntaxError); }
};
f(self, idx)
}
#[inline]
fn read_enum_variant_arg<T>(&mut self, _a_idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
fn read_option<T>(&mut self, _f: |&mut AnimalDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_seq<T>(&mut self, f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
f(self, 3)
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_map<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
}
}
//////////////////////////////////////////////////////////////////////////////
mod deserializer {
use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError};
use de::Deserializer;
use de::{Token, Int, StrBuf, EnumStart, EnumVariant, End};
enum State {
AnimalState(Animal),
DogState,
FrogState,
IntState(int),
StrState(StrBuf),
EndState,
}
pub struct AnimalDeserializer {
stack: Vec<State>,
}
impl AnimalDeserializer {
#[inline]
pub fn new(animal: Animal) -> AnimalDeserializer {
AnimalDeserializer {
stack: vec!(AnimalState(animal)),
}
}
}
impl Iterator<Result<Token, Error>> for AnimalDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.stack.pop() {
Some(AnimalState(Dog)) => {
self.stack.push(EndState);
self.stack.push(DogState);
Some(Ok(EnumStart("Animal")))
}
Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(EndState);
self.stack.push(IntState(x1));
self.stack.push(StrState(x0));
self.stack.push(FrogState);
Some(Ok(EnumStart("Animal")))
}
Some(DogState) => {
Some(Ok(EnumVariant("Dog")))
}
Some(FrogState) => {
Some(Ok(EnumVariant("Frog")))
}
Some(IntState(x)) => {
Some(Ok(Int(x)))
}
Some(StrState(x)) => {
Some(Ok(StrBuf(x)))
}
Some(EndState) => {
Some(Ok(End))
}
None => None,
}
}
}
impl Deserializer<Error> for AnimalDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
}
}
//////////////////////////////////////////////////////////////////////////////
#[bench]
fn bench_enum_decoder(b: &mut Bencher) {
b.iter(|| {
let animal = Frog("Henry".to_strbuf(), 349);
let mut d = decoder::AnimalDecoder::new(animal.clone());
let value: Animal = Decodable::decode(&mut d).unwrap();
assert_eq!(value, animal);
})
}
#[bench]
fn bench_enum_deserializer(b: &mut Bencher) {
b.iter(|| {
let animal = Frog("Henry".to_strbuf(), 349);
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, animal);
})
}
bench_struct.rs
+549
View File
@@ -0,0 +1,549 @@
use collections::HashMap;
use test::Bencher;
use serialize::{Decoder, Decodable};
use de::{Deserializer, Deserializable};
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, Eq, Show, Decodable)]
struct Inner {
a: (),
b: uint,
c: HashMap<StrBuf, Option<char>>,
}
impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner {
#[inline]
fn deserialize(d: &mut D) -> Result<Inner, E> {
try!(d.expect_struct_start("Inner"));
let a = try!(d.expect_struct_field("a"));
let b = try!(d.expect_struct_field("b"));
let c = try!(d.expect_struct_field("c"));
try!(d.expect_end());
Ok(Inner { a: a, b: b, c: c })
}
}
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, Eq, Show, Decodable)]
struct Outer {
inner: Vec<Inner>,
}
impl<E, D: Deserializer<E>> Deserializable<E, D> for Outer {
#[inline]
fn deserialize(d: &mut D) -> Result<Outer, E> {
try!(d.expect_struct_start("Outer"));
let inner = try!(d.expect_struct_field("inner"));
try!(d.expect_end());
Ok(Outer { inner: inner })
}
}
//////////////////////////////////////////////////////////////////////////////
#[deriving(Show)]
enum Error {
EndOfStream,
SyntaxError,
}
mod decoder {
use collections::HashMap;
use serialize::Decoder;
use super::{Outer, Inner, Error, SyntaxError};
#[deriving(Show)]
enum State {
OuterState(Outer),
InnerState(Inner),
NullState,
UintState(uint),
CharState(char),
StrState(StrBuf),
FieldState(&'static str),
VecState(Vec<Inner>),
MapState(HashMap<StrBuf, Option<char>>),
OptionState(bool),
}
pub struct OuterDecoder {
stack: Vec<State>,
}
impl OuterDecoder {
#[inline]
pub fn new(animal: Outer) -> OuterDecoder {
OuterDecoder {
stack: vec!(OuterState(animal)),
}
}
}
impl Decoder<Error> for OuterDecoder {
// Primitive types:
#[inline]
fn read_nil(&mut self) -> Result<(), Error> {
match self.stack.pop() {
Some(NullState) => Ok(()),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_uint(&mut self) -> Result<uint, Error> {
match self.stack.pop() {
Some(UintState(value)) => Ok(value),
_ => Err(SyntaxError),
}
}
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
fn read_int(&mut self) -> Result<int, Error> { Err(SyntaxError) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
#[inline]
fn read_char(&mut self) -> Result<char, Error> {
match self.stack.pop() {
Some(CharState(c)) => Ok(c),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> {
match self.stack.pop() {
Some(StrState(value)) => Ok(value),
_ => Err(SyntaxError),
}
}
// Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant<T>(&mut self,
_names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterState(Outer { inner: inner })) => {
if s_name == "Outer" {
self.stack.push(VecState(inner));
self.stack.push(FieldState("inner"));
f(self)
} else {
Err(SyntaxError)
}
}
Some(InnerState(Inner { a: (), b: b, c: c })) => {
if s_name == "Inner" {
self.stack.push(MapState(c));
self.stack.push(FieldState("c"));
self.stack.push(UintState(b));
self.stack.push(FieldState("b"));
self.stack.push(NullState);
self.stack.push(FieldState("a"));
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError),
}
}
#[inline]
fn read_struct_field<T>(&mut self, f_name: &str, _f_idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(FieldState(name)) => {
if f_name == name {
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError)
}
}
fn read_tuple<T>(&mut self, _f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
#[inline]
fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OptionState(b)) => f(self, b),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_seq<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(VecState(value)) => {
let len = value.len();
for inner in value.move_iter().rev() {
self.stack.push(InnerState(inner));
}
f(self, len)
}
_ => Err(SyntaxError)
}
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
#[inline]
fn read_map<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(MapState(map)) => {
let len = map.len();
for (key, value) in map.move_iter() {
match value {
Some(c) => {
self.stack.push(CharState(c));
self.stack.push(OptionState(true));
}
None => {
self.stack.push(OptionState(false));
}
}
self.stack.push(StrState(key));
}
f(self, len)
}
_ => Err(SyntaxError),
}
}
#[inline]
fn read_map_elt_key<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
#[inline]
fn read_map_elt_val<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
}
}
//////////////////////////////////////////////////////////////////////////////
mod deserializer {
use super::{Outer, Inner, Error, EndOfStream, SyntaxError};
use de::Deserializer;
use de::{Token, Uint, Char, StrBuf, Null, TupleStart, StructStart, StructField, SeqStart, MapStart, Sep, End, Option};
enum State {
OuterState(Outer),
InnerState(Inner),
FieldState(&'static str),
NullState,
UintState(uint),
CharState(char),
StrState(StrBuf),
OptionState(bool),
TupleState(uint),
VecState(uint),
MapState(uint),
SepState,
EndState,
}
pub struct OuterDeserializer {
stack: Vec<State>,
}
impl OuterDeserializer {
#[inline]
pub fn new(outer: Outer) -> OuterDeserializer {
OuterDeserializer {
stack: vec!(OuterState(outer)),
}
}
}
impl Iterator<Result<Token, Error>> for OuterDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.stack.last() {
Some(&OuterState(_)) => {
outer_state(self)
}
Some(&InnerState(_)) => {
inner_state(self)
}
Some(&FieldState(_)) => {
field_state(self)
}
Some(&VecState(_)) => {
vec_state(self)
}
Some(&MapState(_)) => {
map_state(self)
}
Some(&TupleState(_)) => {
tuple_state(self)
}
Some(&SepState) => {
sep_state(self)
}
Some(&NullState) => {
null_state(self)
}
Some(&UintState(_)) => {
uint_state(self)
}
Some(&CharState(_)) => {
char_state(self)
}
Some(&StrState(_)) => {
strbuf_state(self)
}
Some(&OptionState(_)) => {
option_state(self)
}
Some(&EndState) => {
end_state(self)
}
None => None,
}
}
}
impl Deserializer<Error> for OuterDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
}
fn outer_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
let inner = match d.stack.pop() {
Some(OuterState(Outer { inner })) => inner,
_ => { return Some(Err(d.syntax_error())); }
};
d.stack.push(EndState);
d.stack.push(EndState);
let len = inner.len();
for v in inner.move_iter().rev() {
d.stack.push(InnerState(v));
d.stack.push(SepState);
}
d.stack.push(VecState(len));
d.stack.push(FieldState("inner"));
Some(Ok(StructStart("Outer")))
}
fn inner_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
let ((), b, c) = match d.stack.pop() {
Some(InnerState(Inner { a, b, c })) => (a, b, c),
_ => { return Some(Err(d.syntax_error())); }
};
d.stack.push(EndState);
d.stack.push(EndState);
let len = c.len();
for (k, v) in c.move_iter() {
d.stack.push(EndState);
match v {
Some(c) => {
d.stack.push(CharState(c));
d.stack.push(OptionState(true));
}
None => {
d.stack.push(OptionState(false));
}
}
d.stack.push(SepState);
d.stack.push(StrState(k));
d.stack.push(SepState);
d.stack.push(TupleState(2));
d.stack.push(SepState);
}
d.stack.push(MapState(len));
d.stack.push(FieldState("c"));
d.stack.push(UintState(b));
d.stack.push(FieldState("b"));
d.stack.push(NullState);
d.stack.push(FieldState("a"));
Some(Ok(StructStart("Inner")))
}
fn field_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(FieldState(name)) => Some(Ok(StructField(name))),
_ => Some(Err(d.syntax_error())),
}
}
fn vec_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(VecState(len)) => Some(Ok(SeqStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
fn map_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(MapState(len)) => Some(Ok(MapStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
fn tuple_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(TupleState(len)) => Some(Ok(TupleStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
fn sep_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(SepState) => Some(Ok(Sep)),
_ => Some(Err(d.syntax_error())),
}
}
fn null_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(NullState) => Some(Ok(Null)),
_ => Some(Err(d.syntax_error())),
}
}
fn uint_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(UintState(x)) => Some(Ok(Uint(x))),
_ => Some(Err(d.syntax_error())),
}
}
fn char_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(CharState(x)) => Some(Ok(Char(x))),
_ => Some(Err(d.syntax_error())),
}
}
fn strbuf_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(StrState(x)) => Some(Ok(StrBuf(x))),
_ => Some(Err(d.syntax_error())),
}
}
fn option_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OptionState(x)) => Some(Ok(Option(x))),
_ => Some(Err(d.syntax_error())),
}
}
fn end_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(EndState) => Some(Ok(End)),
_ => Some(Err(d.syntax_error())),
}
}
}
#[bench]
fn bench_struct_decoder(b: &mut Bencher) {
b.iter(|| {
let mut map = HashMap::new();
map.insert("abc".to_strbuf(), Some('c'));
let outer = Outer {
inner: vec!(
Inner {
a: (),
b: 5,
c: map,
},
)
};
let mut d = decoder::OuterDecoder::new(outer.clone());
let value: Outer = Decodable::decode(&mut d).unwrap();
assert_eq!(value, outer);
})
}
#[bench]
fn bench_struct_deserializer(b: &mut Bencher) {
b.iter(|| {
let mut map = HashMap::new();
map.insert("abc".to_strbuf(), Some('c'));
let outer = Outer {
inner: vec!(
Inner {
a: (),
b: 5,
c: map,
},
)
};
let mut d = deserializer::OuterDeserializer::new(outer.clone());
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, outer);
})
}
bench_vec.rs
+248
View File
@@ -0,0 +1,248 @@
use test::Bencher;
use serialize::Decodable;
use de::{Deserializable};
//////////////////////////////////////////////////////////////////////////////
#[deriving(Show)]
enum Error {
EndOfStream,
SyntaxError,
}
//////////////////////////////////////////////////////////////////////////////
mod decoder {
use std::vec;
use serialize::Decoder;
use super::{Error, EndOfStream, SyntaxError};
pub struct IntsDecoder {
iter: vec::MoveItems<int>,
}
impl IntsDecoder {
#[inline]
pub fn new(values: Vec<int>) -> IntsDecoder {
IntsDecoder {
iter: values.move_iter()
}
}
}
impl Decoder<Error> for IntsDecoder {
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
#[inline]
fn read_int(&mut self) -> Result<int, Error> {
match self.iter.next() {
Some(value) => Ok(value),
None => Err(EndOfStream),
}
}
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) }
// Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant<T>(&mut self,
_names: &[&str],
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
fn read_option<T>(&mut self, _f: |&mut IntsDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_seq<T>(&mut self, f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
f(self, 3)
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_map<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
}
}
//////////////////////////////////////////////////////////////////////////////
mod deserializer {
use std::num;
use std::vec;
use super::{Error, EndOfStream, SyntaxError};
use de::Deserializer;
use de::{Token, Int, SeqStart, Sep, End};
#[deriving(Eq, Show)]
enum IntsDeserializerState {
IntsDeserializserStartState,
IntsDeserializserSepOrEndState,
IntsDeserializserValueState,
IntsDeserializserEndState,
}
pub struct IntsDeserializer {
state: IntsDeserializerState,
len: uint,
iter: vec::MoveItems<int>,
value: Option<int>
}
impl IntsDeserializer {
#[inline]
pub fn new(values: Vec<int>) -> IntsDeserializer {
IntsDeserializer {
state: IntsDeserializserStartState,
len: values.len(),
iter: values.move_iter(),
value: None,
}
}
}
impl Iterator<Result<Token, Error>> for IntsDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.state {
IntsDeserializserStartState => {
self.state = IntsDeserializserSepOrEndState;
Some(Ok(SeqStart(self.len)))
}
IntsDeserializserSepOrEndState => {
match self.iter.next() {
Some(value) => {
self.state = IntsDeserializserValueState;
self.value = Some(value);
Some(Ok(Sep))
}
None => {
self.state = IntsDeserializserEndState;
Some(Ok(End))
}
}
}
IntsDeserializserValueState => {
self.state = IntsDeserializserSepOrEndState;
match self.value.take() {
Some(value) => Some(Ok(Int(value))),
None => Some(Err(self.end_of_stream_error())),
}
}
IntsDeserializserEndState => {
None
}
}
}
}
impl Deserializer<Error> for IntsDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
#[inline]
fn expect_num<T: NumCast>(&mut self) -> Result<T, Error> {
assert_eq!(self.state, IntsDeserializserValueState);
self.state = IntsDeserializserSepOrEndState;
match self.value.take() {
Some(value) => {
match num::cast(value) {
Some(value) => Ok(value),
None => Err(self.syntax_error()),
}
}
None => Err(self.end_of_stream_error()),
}
}
}
}
//////////////////////////////////////////////////////////////////////////////
#[bench]
fn bench_ints_decoder(b: &mut Bencher) {
b.iter(|| {
let ints = vec!(5, 6, 7);
let mut d = decoder::IntsDecoder::new(ints);
let value: Vec<int> = Decodable::decode(&mut d).unwrap();
assert_eq!(value, vec!(5, 6, 7));
})
}
#[bench]
fn bench_ints_deserializer(b: &mut Bencher) {
b.iter(|| {
let ints = vec!(5, 6, 7);
let mut d = deserializer::IntsDeserializer::new(ints);
let value: Vec<int> = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, vec!(5, 6, 7));
})
}
de.rs
+1 -967
View File
@@ -424,12 +424,10 @@ deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::num;
use std::vec;
use collections::HashMap; use collections::HashMap;
use test::Bencher; use test::Bencher;
use serialize::{Decoder, Decodable}; use serialize::Decoder;
use super::{Token, Null, Int, Uint, Str, StrBuf, Char, Option}; use super::{Token, Null, Int, Uint, Str, StrBuf, Char, Option};
use super::{TupleStart, StructStart, StructField, EnumStart, EnumVariant}; use super::{TupleStart, StructStart, StructField, EnumStart, EnumVariant};
@@ -548,876 +546,6 @@ mod tests {
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Eq, Show)]
enum IntsDeserializerState {
IntsDeserializserStartState,
IntsDeserializserSepOrEndState,
IntsDeserializserValueState,
IntsDeserializserEndState,
}
struct IntsDeserializer {
state: IntsDeserializerState,
len: uint,
iter: vec::MoveItems<int>,
value: Option<int>
}
impl IntsDeserializer {
#[inline]
fn new(values: Vec<int>) -> IntsDeserializer {
IntsDeserializer {
state: IntsDeserializserStartState,
len: values.len(),
iter: values.move_iter(),
value: None,
}
}
}
impl Iterator<Result<Token, Error>> for IntsDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.state {
IntsDeserializserStartState => {
self.state = IntsDeserializserSepOrEndState;
Some(Ok(SeqStart(self.len)))
}
IntsDeserializserSepOrEndState => {
match self.iter.next() {
Some(value) => {
self.state = IntsDeserializserValueState;
self.value = Some(value);
Some(Ok(Sep))
}
None => {
self.state = IntsDeserializserEndState;
Some(Ok(End))
}
}
}
IntsDeserializserValueState => {
self.state = IntsDeserializserSepOrEndState;
match self.value.take() {
Some(value) => Some(Ok(Int(value))),
None => Some(Err(self.end_of_stream_error())),
}
}
IntsDeserializserEndState => {
None
}
}
}
}
impl Deserializer<Error> for IntsDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
#[inline]
fn expect_num<T: NumCast>(&mut self) -> Result<T, Error> {
assert_eq!(self.state, IntsDeserializserValueState);
self.state = IntsDeserializserSepOrEndState;
match self.value.take() {
Some(value) => {
match num::cast(value) {
Some(value) => Ok(value),
None => Err(self.syntax_error()),
}
}
None => Err(self.end_of_stream_error()),
}
}
}
//////////////////////////////////////////////////////////////////////////////
struct IntsDecoder {
iter: vec::MoveItems<int>,
}
impl IntsDecoder {
#[inline]
fn new(values: Vec<int>) -> IntsDecoder {
IntsDecoder {
iter: values.move_iter()
}
}
}
impl Decoder<Error> for IntsDecoder {
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
#[inline]
fn read_int(&mut self) -> Result<int, Error> {
match self.iter.next() {
Some(value) => Ok(value),
None => Err(EndOfStream),
}
}
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) }
// Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant<T>(&mut self,
_names: &[&str],
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut IntsDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
fn read_option<T>(&mut self, _f: |&mut IntsDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_seq<T>(&mut self, f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
f(self, 3)
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_map<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
}
//////////////////////////////////////////////////////////////////////////////
enum AnimalDecoderState {
AnimalDecoderAnimalState(Animal),
AnimalDecoderDogState,
AnimalDecoderFrogState,
AnimalDecoderIntState(int),
AnimalDecoderStrState(StrBuf),
}
struct AnimalDecoder {
stack: Vec<AnimalDecoderState>,
}
impl AnimalDecoder {
#[inline]
fn new(animal: Animal) -> AnimalDecoder {
AnimalDecoder {
stack: vec!(AnimalDecoderAnimalState(animal)),
}
}
}
impl Decoder<Error> for AnimalDecoder {
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
#[inline]
fn read_int(&mut self) -> Result<int, Error> {
match self.stack.pop() {
Some(AnimalDecoderIntState(x)) => Ok(x),
_ => Err(SyntaxError),
}
}
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
#[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> {
match self.stack.pop() {
Some(AnimalDecoderStrState(x)) => Ok(x),
_ => Err(SyntaxError),
}
}
// Compound types:
#[inline]
fn read_enum<T>(&mut self, name: &str, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(AnimalDecoderAnimalState(animal)) => {
self.stack.push(AnimalDecoderAnimalState(animal));
if name == "Animal" {
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError)
}
}
#[inline]
fn read_enum_variant<T>(&mut self, names: &[&str], f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
let name = match self.stack.pop() {
Some(AnimalDecoderAnimalState(Dog)) => "Dog",
Some(AnimalDecoderAnimalState(Frog(x0, x1))) => {
self.stack.push(AnimalDecoderIntState(x1));
self.stack.push(AnimalDecoderStrState(x0));
"Frog"
}
_ => { return Err(SyntaxError); }
};
let idx = match names.iter().position(|n| *n == name) {
Some(idx) => idx,
None => { return Err(SyntaxError); }
};
f(self, idx)
}
#[inline]
fn read_enum_variant_arg<T>(&mut self, _a_idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_struct_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut AnimalDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
fn read_option<T>(&mut self, _f: |&mut AnimalDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_seq<T>(&mut self, f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
f(self, 3)
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
fn read_map<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
}
//////////////////////////////////////////////////////////////////////////////
enum AnimalDeserializerState {
AnimalDeserializerAnimalState(Animal),
AnimalDeserializerDogState,
AnimalDeserializerFrogState,
AnimalDeserializerIntState(int),
AnimalDeserializerStrState(StrBuf),
AnimalDeserializerEndState,
}
struct AnimalDeserializer {
stack: Vec<AnimalDeserializerState>,
}
impl AnimalDeserializer {
#[inline]
fn new(animal: Animal) -> AnimalDeserializer {
AnimalDeserializer {
stack: vec!(AnimalDeserializerAnimalState(animal)),
}
}
}
impl Iterator<Result<Token, Error>> for AnimalDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.stack.pop() {
Some(AnimalDeserializerAnimalState(Dog)) => {
self.stack.push(AnimalDeserializerEndState);
self.stack.push(AnimalDeserializerDogState);
Some(Ok(EnumStart("Animal")))
}
Some(AnimalDeserializerAnimalState(Frog(x0, x1))) => {
self.stack.push(AnimalDeserializerEndState);
self.stack.push(AnimalDeserializerIntState(x1));
self.stack.push(AnimalDeserializerStrState(x0));
self.stack.push(AnimalDeserializerFrogState);
Some(Ok(EnumStart("Animal")))
}
Some(AnimalDeserializerDogState) => {
Some(Ok(EnumVariant("Dog")))
}
Some(AnimalDeserializerFrogState) => {
Some(Ok(EnumVariant("Frog")))
}
Some(AnimalDeserializerIntState(x)) => {
Some(Ok(Int(x)))
}
Some(AnimalDeserializerStrState(x)) => {
Some(Ok(StrBuf(x)))
}
Some(AnimalDeserializerEndState) => {
Some(Ok(End))
}
None => None,
}
}
}
impl Deserializer<Error> for AnimalDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
}
//////////////////////////////////////////////////////////////////////////////
#[deriving(Show)]
enum OuterDecoderState {
OuterDecoderOuterState(Outer),
OuterDecoderInnerState(Inner),
OuterDecoderNullState,
OuterDecoderUintState(uint),
OuterDecoderCharState(char),
OuterDecoderStrState(StrBuf),
OuterDecoderFieldState(&'static str),
OuterDecoderVecState(Vec<Inner>),
OuterDecoderMapState(HashMap<StrBuf, Option<char>>),
OuterDecoderOptionState(bool),
}
struct OuterDecoder {
stack: Vec<OuterDecoderState>,
}
impl OuterDecoder {
#[inline]
fn new(animal: Outer) -> OuterDecoder {
OuterDecoder {
stack: vec!(OuterDecoderOuterState(animal)),
}
}
}
impl Decoder<Error> for OuterDecoder {
// Primitive types:
#[inline]
fn read_nil(&mut self) -> Result<(), Error> {
match self.stack.pop() {
Some(OuterDecoderNullState) => Ok(()),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_uint(&mut self) -> Result<uint, Error> {
match self.stack.pop() {
Some(OuterDecoderUintState(value)) => Ok(value),
_ => Err(SyntaxError),
}
}
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
fn read_int(&mut self) -> Result<int, Error> { Err(SyntaxError) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
#[inline]
fn read_char(&mut self) -> Result<char, Error> {
match self.stack.pop() {
Some(OuterDecoderCharState(c)) => Ok(c),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> {
match self.stack.pop() {
Some(OuterDecoderStrState(value)) => Ok(value),
_ => Err(SyntaxError),
}
}
// Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant<T>(&mut self,
_names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_variant_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant<T>(&mut self,
_names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str,
_f_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
#[inline]
fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterDecoderOuterState(Outer { inner: inner })) => {
if s_name == "Outer" {
self.stack.push(OuterDecoderVecState(inner));
self.stack.push(OuterDecoderFieldState("inner"));
f(self)
} else {
Err(SyntaxError)
}
}
Some(OuterDecoderInnerState(Inner { a: (), b: b, c: c })) => {
if s_name == "Inner" {
self.stack.push(OuterDecoderMapState(c));
self.stack.push(OuterDecoderFieldState("c"));
self.stack.push(OuterDecoderUintState(b));
self.stack.push(OuterDecoderFieldState("b"));
self.stack.push(OuterDecoderNullState);
self.stack.push(OuterDecoderFieldState("a"));
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError),
}
}
#[inline]
fn read_struct_field<T>(&mut self, f_name: &str, _f_idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterDecoderFieldState(name)) => {
if f_name == name {
f(self)
} else {
Err(SyntaxError)
}
}
_ => Err(SyntaxError)
}
}
fn read_tuple<T>(&mut self, _f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct<T>(&mut self,
_s_name: &str,
_f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError) }
// Specialized types:
#[inline]
fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterDecoderOptionState(b)) => f(self, b),
_ => Err(SyntaxError),
}
}
#[inline]
fn read_seq<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterDecoderVecState(value)) => {
let len = value.len();
for inner in value.move_iter().rev() {
self.stack.push(OuterDecoderInnerState(inner));
}
f(self, len)
}
_ => Err(SyntaxError)
}
}
#[inline]
fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
#[inline]
fn read_map<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() {
Some(OuterDecoderMapState(map)) => {
let len = map.len();
for (key, value) in map.move_iter() {
match value {
Some(c) => {
self.stack.push(OuterDecoderCharState(c));
self.stack.push(OuterDecoderOptionState(true));
}
None => {
self.stack.push(OuterDecoderOptionState(false));
}
}
self.stack.push(OuterDecoderStrState(key));
}
f(self, len)
}
_ => Err(SyntaxError),
}
}
#[inline]
fn read_map_elt_key<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
#[inline]
fn read_map_elt_val<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
f(self)
}
}
//////////////////////////////////////////////////////////////////////////////
enum OuterDeserializerState {
OuterDeserializerOuterState(Outer),
OuterDeserializerInnerState(Inner),
OuterDeserializerFieldState(&'static str),
OuterDeserializerNullState,
OuterDeserializerUintState(uint),
OuterDeserializerCharState(char),
OuterDeserializerStrState(StrBuf),
OuterDeserializerOptionState(bool),
OuterDeserializerTupleState(uint),
OuterDeserializerVecState(uint),
OuterDeserializerMapState(uint),
OuterDeserializerSepState,
OuterDeserializerEndState,
}
struct OuterDeserializer {
stack: Vec<OuterDeserializerState>,
}
impl OuterDeserializer {
#[inline]
fn new(outer: Outer) -> OuterDeserializer {
OuterDeserializer {
stack: vec!(OuterDeserializerOuterState(outer)),
}
}
}
impl Iterator<Result<Token, Error>> for OuterDeserializer {
#[inline]
fn next(&mut self) -> Option<Result<Token, Error>> {
match self.stack.last() {
Some(&OuterDeserializerOuterState(_)) => {
states::outer_state(self)
}
Some(&OuterDeserializerInnerState(_)) => {
states::inner_state(self)
}
Some(&OuterDeserializerFieldState(_)) => {
states::field_state(self)
}
Some(&OuterDeserializerVecState(_)) => {
states::vec_state(self)
}
Some(&OuterDeserializerMapState(_)) => {
states::map_state(self)
}
Some(&OuterDeserializerTupleState(_)) => {
states::tuple_state(self)
}
Some(&OuterDeserializerSepState) => {
states::sep_state(self)
}
Some(&OuterDeserializerNullState) => {
states::null_state(self)
}
Some(&OuterDeserializerUintState(_)) => {
states::uint_state(self)
}
Some(&OuterDeserializerCharState(_)) => {
states::char_state(self)
}
Some(&OuterDeserializerStrState(_)) => {
states::strbuf_state(self)
}
Some(&OuterDeserializerOptionState(_)) => {
states::option_state(self)
}
Some(&OuterDeserializerEndState) => {
states::end_state(self)
}
None => None,
}
}
}
impl Deserializer<Error> for OuterDeserializer {
#[inline]
fn end_of_stream_error(&self) -> Error {
EndOfStream
}
#[inline]
fn syntax_error(&self) -> Error {
SyntaxError
}
}
mod states {
use super::{OuterDeserializer, Error, Outer, Inner};
use super::{
OuterDeserializerOuterState,
OuterDeserializerInnerState,
OuterDeserializerFieldState,
OuterDeserializerNullState,
OuterDeserializerUintState,
OuterDeserializerCharState,
OuterDeserializerStrState,
OuterDeserializerOptionState,
OuterDeserializerTupleState,
OuterDeserializerVecState,
OuterDeserializerMapState,
OuterDeserializerSepState,
OuterDeserializerEndState,
};
use super::super::{Token, Null, Uint, StrBuf, Char, Option};
use super::super::{TupleStart, StructStart, StructField};
use super::super::{SeqStart, MapStart, Sep, End};
use super::super::Deserializer;
pub fn outer_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
let inner = match d.stack.pop() {
Some(OuterDeserializerOuterState(Outer { inner })) => inner,
_ => { return Some(Err(d.syntax_error())); }
};
d.stack.push(OuterDeserializerEndState);
d.stack.push(OuterDeserializerEndState);
let len = inner.len();
for v in inner.move_iter().rev() {
d.stack.push(OuterDeserializerInnerState(v));
d.stack.push(OuterDeserializerSepState);
}
d.stack.push(OuterDeserializerVecState(len));
d.stack.push(OuterDeserializerFieldState("inner"));
Some(Ok(StructStart("Outer")))
}
pub fn inner_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
let ((), b, c) = match d.stack.pop() {
Some(OuterDeserializerInnerState(Inner { a, b, c })) => (a, b, c),
_ => { return Some(Err(d.syntax_error())); }
};
d.stack.push(OuterDeserializerEndState);
d.stack.push(OuterDeserializerEndState);
let len = c.len();
for (k, v) in c.move_iter() {
d.stack.push(OuterDeserializerEndState);
match v {
Some(c) => {
d.stack.push(OuterDeserializerCharState(c));
d.stack.push(OuterDeserializerOptionState(true));
}
None => {
d.stack.push(OuterDeserializerOptionState(false));
}
}
d.stack.push(OuterDeserializerSepState);
d.stack.push(OuterDeserializerStrState(k));
d.stack.push(OuterDeserializerSepState);
d.stack.push(OuterDeserializerTupleState(2));
d.stack.push(OuterDeserializerSepState);
}
d.stack.push(OuterDeserializerMapState(len));
d.stack.push(OuterDeserializerFieldState("c"));
d.stack.push(OuterDeserializerUintState(b));
d.stack.push(OuterDeserializerFieldState("b"));
d.stack.push(OuterDeserializerNullState);
d.stack.push(OuterDeserializerFieldState("a"));
Some(Ok(StructStart("Inner")))
}
pub fn field_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerFieldState(name)) => Some(Ok(StructField(name))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn vec_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerVecState(len)) => Some(Ok(SeqStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn map_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerMapState(len)) => Some(Ok(MapStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn tuple_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerTupleState(len)) => Some(Ok(TupleStart(len))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn sep_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerSepState) => Some(Ok(Sep)),
_ => Some(Err(d.syntax_error())),
}
}
pub fn null_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerNullState) => Some(Ok(Null)),
_ => Some(Err(d.syntax_error())),
}
}
pub fn uint_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerUintState(x)) => Some(Ok(Uint(x))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn char_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerCharState(x)) => Some(Ok(Char(x))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn strbuf_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerStrState(x)) => Some(Ok(StrBuf(x))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn option_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerOptionState(x)) => Some(Ok(Option(x))),
_ => Some(Err(d.syntax_error())),
}
}
pub fn end_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
match d.stack.pop() {
Some(OuterDeserializerEndState) => Some(Ok(End)),
_ => Some(Err(d.syntax_error())),
}
}
}
//////////////////////////////////////////////////////////////////////////////
#[test] #[test]
fn test_tokens_int() { fn test_tokens_int() {
let tokens = vec!( let tokens = vec!(
@@ -1772,98 +900,4 @@ mod tests {
assert_eq!(value, vec!(5, 6, 7)); assert_eq!(value, vec!(5, 6, 7));
}) })
} }
#[bench]
fn bench_ints_deserializer(b: &mut Bencher) {
b.iter(|| {
let ints = vec!(5, 6, 7);
let mut d = IntsDeserializer::new(ints);
let value: Vec<int> = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, vec!(5, 6, 7));
})
}
#[bench]
fn bench_ints_decoder(b: &mut Bencher) {
b.iter(|| {
let ints = vec!(5, 6, 7);
let mut d = IntsDecoder::new(ints);
let value: Vec<int> = Decodable::decode(&mut d).unwrap();
assert_eq!(value, vec!(5, 6, 7));
})
}
#[bench]
fn bench_enum_decoder(b: &mut Bencher) {
b.iter(|| {
let animal = Frog("Henry".to_strbuf(), 349);
let mut d = AnimalDecoder::new(animal.clone());
let value: Animal = Decodable::decode(&mut d).unwrap();
assert_eq!(value, animal);
})
}
#[bench]
fn bench_enum_deserializer(b: &mut Bencher) {
b.iter(|| {
let animal = Frog("Henry".to_strbuf(), 349);
let mut d = AnimalDeserializer::new(animal.clone());
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, animal);
})
}
#[bench]
fn bench_struct_decoder(b: &mut Bencher) {
b.iter(|| {
let mut map = HashMap::new();
map.insert("abc".to_strbuf(), Some('c'));
let outer = Outer {
inner: vec!(
Inner {
a: (),
b: 5,
c: map,
},
)
};
let mut d = OuterDecoder::new(outer.clone());
let value: Outer = Decodable::decode(&mut d).unwrap();
assert_eq!(value, outer);
})
}
#[bench]
fn bench_struct_deserializer(b: &mut Bencher) {
b.iter(|| {
let mut map = HashMap::new();
map.insert("abc".to_strbuf(), Some('c'));
let outer = Outer {
inner: vec!(
Inner {
a: (),
b: 5,
c: map,
},
)
};
let mut d = OuterDeserializer::new(outer.clone());
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
assert_eq!(value, outer);
})
}
} }
serde.rs
+9
View File
@@ -13,3 +13,12 @@ extern crate serialize;
pub mod de; pub mod de;
//pub mod json; //pub mod json;
#[cfg(test)]
pub mod bench_enum;
#[cfg(test)]
pub mod bench_struct;
#[cfg(test)]
pub mod bench_vec;