mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-22 06:48:00 +00:00
Move the benchmarks out of de.rs
This commit is contained in:
Erick Tryzelaar
+293
@@ -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);
|
||||
})
|
||||
}
|
||||
+549
@@ -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);
|
||||
})
|
||||
}
|
||||
+248
@@ -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));
|
||||
})
|
||||
}
|
||||
@@ -424,12 +424,10 @@ deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::num;
|
||||
use std::vec;
|
||||
use collections::HashMap;
|
||||
use test::Bencher;
|
||||
|
||||
use serialize::{Decoder, Decodable};
|
||||
use serialize::Decoder;
|
||||
|
||||
use super::{Token, Null, Int, Uint, Str, StrBuf, Char, Option};
|
||||
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]
|
||||
fn test_tokens_int() {
|
||||
let tokens = vec!(
|
||||
@@ -1772,98 +900,4 @@ mod tests {
|
||||
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);
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user