Move the benchmarks into a benches/ directory

src/bench_enum.rs

@@ -1,310 +0,0 @@
-use test::Bencher;
-
-use serialize::{Decoder, Decodable};
-
-use de::{Deserializer, Deserializable};
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
-enum Animal {
-    Dog,
-    Frog(String, int)
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Show)]
-enum Error {
-    EndOfStream,
-    SyntaxError,
-    OtherError(String),
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod decoder {
-    use serialize::Decoder;
-
-    use super::{Animal, Dog, Frog, Error, SyntaxError, OtherError};
-
-    enum State {
-        AnimalState(Animal),
-        DogState,
-        FrogState,
-        IntState(int),
-        StringState(String),
-    }
-
-    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 {
-        fn error(&mut self, msg: &str) -> Error {
-            OtherError(msg.to_string())
-        }
-
-        // 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<String, Error> {
-            match self.stack.pop() {
-                Some(StringState(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(StringState(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;
-
-    enum State {
-        AnimalState(Animal),
-        IntState(int),
-        StringState(String),
-        EndState,
-
-    }
-
-    pub struct AnimalDeserializer {
-        stack: Vec<State>,
-    }
-
-    impl AnimalDeserializer {
-        #[inline]
-        pub fn new(animal: Animal) -> AnimalDeserializer {
-            AnimalDeserializer {
-                stack: vec!(AnimalState(animal)),
-            }
-        }
-    }
-
-    impl Iterator<Result<de::Token, Error>> for AnimalDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            match self.stack.pop() {
-                Some(AnimalState(Dog)) => {
-                    self.stack.push(EndState);
-                    Some(Ok(de::EnumStart("Animal", "Dog", 0)))
-                }
-                Some(AnimalState(Frog(x0, x1))) => {
-                    self.stack.push(EndState);
-                    self.stack.push(IntState(x1));
-                    self.stack.push(StringState(x0));
-                    Some(Ok(de::EnumStart("Animal", "Frog", 2)))
-                }
-                Some(IntState(x)) => {
-                    Some(Ok(de::Int(x)))
-                }
-                Some(StringState(x)) => {
-                    Some(Ok(de::String(x)))
-                }
-                Some(EndState) => {
-                    Some(Ok(de::End))
-                }
-                None => None,
-            }
-        }
-    }
-
-    impl de::Deserializer<Error> for AnimalDeserializer {
-        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn missing_field<
-            T: de::Deserializable<AnimalDeserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(SyntaxError)
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[bench]
-fn bench_decoder_dog(b: &mut Bencher) {
-    b.iter(|| {
-        let animal = Dog;
-
-        let mut d = decoder::AnimalDecoder::new(animal.clone());
-        let value: Animal = Decodable::decode(&mut d).unwrap();
-
-        assert_eq!(value, animal);
-    })
-}
-
-#[bench]
-fn bench_decoder_frog(b: &mut Bencher) {
-    b.iter(|| {
-        let animal = Frog("Henry".to_string(), 349);
-
-        let mut d = decoder::AnimalDecoder::new(animal.clone());
-        let value: Animal = Decodable::decode(&mut d).unwrap();
-
-        assert_eq!(value, animal);
-    })
-}
-
-#[bench]
-fn bench_deserializer_dog(b: &mut Bencher) {
-    b.iter(|| {
-        let animal = Dog;
-
-        let mut d = deserializer::AnimalDeserializer::new(animal.clone());
-        let value: Animal = Deserializable::deserialize(&mut d).unwrap();
-
-        assert_eq!(value, animal);
-    })
-}
-
-#[bench]
-fn bench_deserializer_frog(b: &mut Bencher) {
-    b.iter(|| {
-        let animal = Frog("Henry".to_string(), 349);
-
-        let mut d = deserializer::AnimalDeserializer::new(animal.clone());
-        let value: Animal = Deserializable::deserialize(&mut d).unwrap();
-
-        assert_eq!(value, animal);
-    })
-}

src/bench_map.rs

@@ -1,338 +0,0 @@
-use std::fmt::Show;
-use std::collections::HashMap;
-use test::Bencher;
-
-use serialize::{Decoder, Decodable};
-
-use de::{Deserializer, Deserializable};
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Show)]
-enum Error {
-    EndOfStream,
-    SyntaxError,
-    OtherError(String),
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod decoder {
-    use std::collections::HashMap;
-    use std::collections::hashmap::MoveEntries;
-    use serialize;
-
-    use super::{Error, EndOfStream, SyntaxError, OtherError};
-
-    enum Value {
-        StringValue(String),
-        IntValue(int),
-    }
-
-    pub struct IntDecoder {
-        len: uint,
-        iter: MoveEntries<String, int>,
-        stack: Vec<Value>,
-    }
-
-    impl IntDecoder {
-        #[inline]
-        pub fn new(values: HashMap<String, int>) -> IntDecoder {
-            IntDecoder {
-                len: values.len(),
-                iter: values.move_iter(),
-                stack: vec!(),
-            }
-        }
-    }
-
-    impl serialize::Decoder<Error> for IntDecoder {
-        fn error(&mut self, msg: &str) -> Error {
-            OtherError(msg.to_string())
-        }
-
-        // 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(IntValue(x)) => Ok(x),
-                Some(_) => Err(SyntaxError),
-                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) }
-        #[inline]
-        fn read_str(&mut self) -> Result<String, Error> {
-            match self.stack.pop() {
-                Some(StringValue(x)) => Ok(x),
-                Some(_) => Err(SyntaxError),
-                None => Err(EndOfStream),
-            }
-        }
-
-        // Compound types:
-        fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_variant<T>(&mut self,
-                                _names: &[&str],
-                                _f: |&mut IntDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_variant_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut IntDecoder, 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 IntDecoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntDecoder| -> Result<T, Error>)
-                          -> Result<T, Error> { Err(SyntaxError) }
-        fn read_struct_field<T>(&mut self,
-                                _f_name: &str,
-                                _f_idx: uint,
-                                _f: |&mut IntDecoder| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple<T>(&mut self, _f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut IntDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        fn read_option<T>(&mut self, _f: |&mut IntDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_seq<T>(&mut self, _f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_seq_elt<T>(&mut self, _idx: uint, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_map<T>(&mut self, f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_map_elt_key<T>(&mut self, _idx: uint, f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            match self.iter.next() {
-                Some((key, value)) => {
-                    self.stack.push(IntValue(value));
-                    self.stack.push(StringValue(key));
-                    f(self)
-                }
-                None => {
-                    Err(SyntaxError)
-                }
-            }
-        }
-        #[inline]
-        fn read_map_elt_val<T>(&mut self, _idx: uint, f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod deserializer {
-    use std::collections::HashMap;
-    use std::collections::hashmap::MoveEntries;
-
-    use super::{Error, EndOfStream, SyntaxError};
-
-    use de;
-
-    #[deriving(PartialEq, Show)]
-    enum State {
-        StartState,
-        KeyOrEndState,
-        ValueState(int),
-        EndState,
-    }
-
-    pub struct IntDeserializer {
-        stack: Vec<State>,
-        len: uint,
-        iter: MoveEntries<String, int>,
-    }
-
-    impl IntDeserializer {
-        #[inline]
-        pub fn new(values: HashMap<String, int>) -> IntDeserializer {
-            IntDeserializer {
-                stack: vec!(StartState),
-                len: values.len(),
-                iter: values.move_iter(),
-            }
-        }
-    }
-
-    impl Iterator<Result<de::Token, Error>> for IntDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            match self.stack.pop() {
-                Some(StartState) => {
-                    self.stack.push(KeyOrEndState);
-                    Some(Ok(de::MapStart(self.len)))
-                }
-                Some(KeyOrEndState) => {
-                    match self.iter.next() {
-                        Some((key, value)) => {
-                            self.stack.push(ValueState(value));
-                            Some(Ok(de::String(key)))
-                        }
-                        None => {
-                            self.stack.push(EndState);
-                            Some(Ok(de::End))
-                        }
-                    }
-                }
-                Some(ValueState(x)) => {
-                    self.stack.push(KeyOrEndState);
-                    Some(Ok(de::Int(x)))
-                }
-                Some(EndState) => {
-                    None
-                }
-                None => {
-                    None
-                }
-            }
-        }
-    }
-
-    impl de::Deserializer<Error> for IntDeserializer {
-        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn missing_field<
-            T: de::Deserializable<IntDeserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(SyntaxError)
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-fn run_decoder<
-    E: Show,
-    D: Decoder<E>,
-    T: Clone + PartialEq + Show + Decodable<D, E>
->(mut d: D, value: T) {
-    let v: T = Decodable::decode(&mut d).unwrap();
-
-    assert_eq!(value, v);
-}
-
-#[bench]
-fn bench_decoder_000(b: &mut Bencher) {
-    b.iter(|| {
-        let m: HashMap<String, int> = HashMap::new();
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_decoder_003(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 3) {
-            m.insert(i.to_string(), i);
-        }
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_decoder_100(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 100) {
-            m.insert(i.to_string(), i);
-        }
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
-    })
-}
-
-fn run_deserializer<
-    D: Deserializer<E>,
-    E: Show,
-    T: Clone + PartialEq + Show + Deserializable<D, E>
->(mut d: D, value: T) {
-    let v: T = Deserializable::deserialize(&mut d).unwrap();
-
-    assert_eq!(value, v);
-}
-
-#[bench]
-fn bench_deserializer_000(b: &mut Bencher) {
-    b.iter(|| {
-        let m: HashMap<String, int> = HashMap::new();
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_deserializer_003(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 3) {
-            m.insert(i.to_string(), i);
-        }
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_deserializer_100(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 100) {
-            m.insert(i.to_string(), i);
-        }
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
-    })
-}

src/bench_struct.rs

@@ -1,512 +0,0 @@
-use std::collections::HashMap;
-use test::Bencher;
-
-use serialize::{Decoder, Decodable};
-
-use de::{Deserializer, Deserializable};
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
-struct Inner {
-    a: (),
-    b: uint,
-    c: HashMap<String, Option<char>>,
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
-struct Outer {
-    inner: Vec<Inner>,
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Show)]
-enum Error {
-    EndOfStream,
-    SyntaxError,
-    OtherError(String),
-}
-
-mod decoder {
-    use std::collections::HashMap;
-    use serialize::Decoder;
-
-    use super::{Outer, Inner, Error, SyntaxError, OtherError};
-
-    #[deriving(Show)]
-    enum State {
-        OuterState(Outer),
-        InnerState(Inner),
-        NullState,
-        UintState(uint),
-        CharState(char),
-        StringState(String),
-        FieldState(&'static str),
-        VecState(Vec<Inner>),
-        MapState(HashMap<String, 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 {
-        fn error(&mut self, msg: &str) -> Error {
-            OtherError(msg.to_string())
-        }
-
-        // 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<String, Error> {
-            match self.stack.pop() {
-                Some(StringState(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(StringState(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 std::collections::HashMap;
-    use super::{Outer, Inner, Error, EndOfStream, SyntaxError};
-    use de;
-
-    enum State {
-        OuterState(Outer),
-        InnerState(Inner),
-        FieldState(&'static str),
-        NullState,
-        UintState(uint),
-        CharState(char),
-        StringState(String),
-        OptionState(bool),
-        TupleState(uint),
-        VecState(Vec<Inner>),
-        MapState(HashMap<String, Option<char>>),
-        EndState,
-
-    }
-
-    pub struct OuterDeserializer {
-        stack: Vec<State>,
-    }
-
-    impl OuterDeserializer {
-        #[inline]
-        pub fn new(outer: Outer) -> OuterDeserializer {
-            OuterDeserializer {
-                stack: vec!(OuterState(outer)),
-            }
-        }
-    }
-
-    impl Iterator<Result<de::Token, Error>> for OuterDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            match self.stack.pop() {
-                Some(OuterState(Outer { inner })) => {
-                    self.stack.push(EndState);
-                    self.stack.push(VecState(inner));
-                    self.stack.push(FieldState("inner"));
-                    Some(Ok(de::StructStart("Outer", 1)))
-                }
-                Some(InnerState(Inner { a: (), b, c })) => {
-                    self.stack.push(EndState);
-                    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"));
-                    Some(Ok(de::StructStart("Inner", 3)))
-                }
-                Some(FieldState(name)) => Some(Ok(de::Str(name))),
-                Some(VecState(value)) => {
-                    self.stack.push(EndState);
-                    let len = value.len();
-                    for inner in value.move_iter().rev() {
-                        self.stack.push(InnerState(inner));
-                    }
-                    Some(Ok(de::SeqStart(len)))
-                }
-                Some(MapState(value)) => {
-                    self.stack.push(EndState);
-                    let len = value.len();
-                    for (key, value) in value.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(StringState(key));
-                    }
-                    Some(Ok(de::MapStart(len)))
-                }
-                Some(TupleState(len)) => Some(Ok(de::TupleStart(len))),
-                Some(NullState) => Some(Ok(de::Null)),
-                Some(UintState(x)) => Some(Ok(de::Uint(x))),
-                Some(CharState(x)) => Some(Ok(de::Char(x))),
-                Some(StringState(x)) => Some(Ok(de::String(x))),
-                Some(OptionState(x)) => Some(Ok(de::Option(x))),
-                Some(EndState) => {
-                    Some(Ok(de::End))
-                }
-                None => None,
-            }
-        }
-    }
-
-    impl de::Deserializer<Error> for OuterDeserializer {
-        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn missing_field<
-            T: de::Deserializable<OuterDeserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(SyntaxError)
-        }
-    }
-}
-
-#[bench]
-fn bench_decoder_0_0(b: &mut Bencher) {
-    b.iter(|| {
-        let mut map = HashMap::new();
-        map.insert("abc".to_string(), Some('c'));
-
-        let outer = Outer {
-            inner: vec!(),
-        };
-
-        let mut d = decoder::OuterDecoder::new(outer.clone());
-        let value: Outer = Decodable::decode(&mut d).unwrap();
-
-        assert_eq!(value, outer);
-    })
-}
-
-#[bench]
-fn bench_decoder_1_0(b: &mut Bencher) {
-    b.iter(|| {
-        let map = HashMap::new();
-
-        let outer = Outer {
-            inner: vec!(
-                Inner {
-                    a: (),
-                    b: 5,
-                    c: map,
-                },
-            )
-        };
-
-        let mut d = decoder::OuterDecoder::new(outer.clone());
-        let value: Outer = Decodable::decode(&mut d).unwrap();
-
-        assert_eq!(value, outer);
-    })
-}
-
-#[bench]
-fn bench_decoder_1_5(b: &mut Bencher) {
-    b.iter(|| {
-        let mut map = HashMap::new();
-        map.insert("1".to_string(), Some('a'));
-        map.insert("2".to_string(), None);
-        map.insert("3".to_string(), Some('b'));
-        map.insert("4".to_string(), None);
-        map.insert("5".to_string(), 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_deserializer_0_0(b: &mut Bencher) {
-    b.iter(|| {
-        let mut map = HashMap::new();
-        map.insert("abc".to_string(), Some('c'));
-
-        let outer = Outer {
-            inner: vec!(),
-        };
-
-        let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
-
-        assert_eq!(value, outer);
-    })
-}
-
-#[bench]
-fn bench_deserializer_1_0(b: &mut Bencher) {
-    b.iter(|| {
-        let map = HashMap::new();
-
-        let outer = Outer {
-            inner: vec!(
-                Inner {
-                    a: (),
-                    b: 5,
-                    c: map,
-                },
-            )
-        };
-
-        let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
-
-        assert_eq!(value, outer);
-    })
-}
-
-#[bench]
-fn bench_deserializer_1_5(b: &mut Bencher) {
-    b.iter(|| {
-        let mut map = HashMap::new();
-        map.insert("1".to_string(), Some('a'));
-        map.insert("2".to_string(), None);
-        map.insert("3".to_string(), Some('b'));
-        map.insert("4".to_string(), None);
-        map.insert("5".to_string(), 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);
-    })
-}

src/bench_vec.rs

@@ -1,514 +0,0 @@
-use std::fmt::Show;
-use test::Bencher;
-
-use serialize::{Decoder, Decodable};
-
-use de::{Deserializer, Deserializable};
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[deriving(Show)]
-enum Error {
-    EndOfStream,
-    SyntaxError,
-    OtherError(String),
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod decoder {
-    use std::vec;
-    use serialize;
-
-    use super::{Error, EndOfStream, SyntaxError, OtherError};
-
-    pub struct IntDecoder {
-        len: uint,
-        iter: vec::MoveItems<int>,
-    }
-
-    impl IntDecoder {
-        #[inline]
-        pub fn new(values: Vec<int>) -> IntDecoder {
-            IntDecoder {
-                len: values.len(),
-                iter: values.move_iter(),
-            }
-        }
-    }
-
-    impl serialize::Decoder<Error> for IntDecoder {
-        fn error(&mut self, msg: &str) -> Error {
-            OtherError(msg.to_string())
-        }
-
-        // 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<String, Error> { Err(SyntaxError) }
-
-        // Compound types:
-        fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_variant<T>(&mut self,
-                                _names: &[&str],
-                                _f: |&mut IntDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_variant_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut IntDecoder, 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 IntDecoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntDecoder| -> Result<T, Error>)
-                          -> Result<T, Error> { Err(SyntaxError) }
-        fn read_struct_field<T>(&mut self,
-                                _f_name: &str,
-                                _f_idx: uint,
-                                _f: |&mut IntDecoder| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple<T>(&mut self, _f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut IntDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        fn read_option<T>(&mut self, _f: |&mut IntDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_seq<T>(&mut self, f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-
-        fn read_map<T>(&mut self, _f: |&mut IntDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-    }
-
-
-    pub struct U8Decoder {
-        len: uint,
-        iter: vec::MoveItems<u8>,
-    }
-
-    impl U8Decoder {
-        #[inline]
-        pub fn new(values: Vec<u8>) -> U8Decoder {
-            U8Decoder {
-                len: values.len(),
-                iter: values.move_iter(),
-            }
-        }
-    }
-
-    impl serialize::Decoder<Error> for U8Decoder {
-        fn error(&mut self, msg: &str) -> Error {
-            OtherError(msg.to_string())
-        }
-
-        // 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) }
-        #[inline]
-        fn read_u8(&mut self) -> Result<u8, Error> {
-            match self.iter.next() {
-                Some(value) => Ok(value),
-                None => Err(EndOfStream),
-            }
-        }
-        #[inline]
-        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) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
-        fn read_str(&mut self) -> Result<String, Error> { Err(SyntaxError) }
-
-        // Compound types:
-        fn read_enum<T>(&mut self, _name: &str, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_variant<T>(&mut self,
-                                _names: &[&str],
-                                _f: |&mut U8Decoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_variant_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut U8Decoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut U8Decoder, 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 U8Decoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut U8Decoder| -> Result<T, Error>)
-                          -> Result<T, Error> { Err(SyntaxError) }
-        fn read_struct_field<T>(&mut self,
-                                _f_name: &str,
-                                _f_idx: uint,
-                                _f: |&mut U8Decoder| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple<T>(&mut self, _f: |&mut U8Decoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut U8Decoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut U8Decoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        fn read_option<T>(&mut self, _f: |&mut U8Decoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_seq<T>(&mut self, f: |&mut U8Decoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-
-        fn read_map<T>(&mut self, _f: |&mut U8Decoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod deserializer {
-    //use std::num;
-    use std::vec;
-
-    use super::{Error, EndOfStream, SyntaxError};
-
-    use de;
-
-    #[deriving(PartialEq, Show)]
-    enum State {
-        StartState,
-        SepOrEndState,
-        EndState,
-    }
-
-    pub struct IntDeserializer {
-        state: State,
-        len: uint,
-        iter: vec::MoveItems<int>,
-    }
-
-    impl IntDeserializer {
-        #[inline]
-        pub fn new(values: Vec<int>) -> IntDeserializer {
-            IntDeserializer {
-                state: StartState,
-                len: values.len(),
-                iter: values.move_iter(),
-            }
-        }
-    }
-
-    impl Iterator<Result<de::Token, Error>> for IntDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            match self.state {
-                StartState => {
-                    self.state = SepOrEndState;
-                    Some(Ok(de::SeqStart(self.len)))
-                }
-                SepOrEndState => {
-                    match self.iter.next() {
-                        Some(value) => {
-                            Some(Ok(de::Int(value)))
-                        }
-                        None => {
-                            self.state = EndState;
-                            Some(Ok(de::End))
-                        }
-                    }
-                }
-                EndState => {
-                    None
-                }
-            }
-        }
-    }
-
-    impl de::Deserializer<Error> for IntDeserializer {
-        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn missing_field<
-            T: de::Deserializable<IntDeserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(SyntaxError)
-        }
-    }
-
-    pub struct U8Deserializer {
-        state: State,
-        len: uint,
-        iter: vec::MoveItems<u8>,
-    }
-
-    impl U8Deserializer {
-        #[inline]
-        pub fn new(values: Vec<u8>) -> U8Deserializer {
-            U8Deserializer {
-                state: StartState,
-                len: values.len(),
-                iter: values.move_iter(),
-            }
-        }
-    }
-
-    impl Iterator<Result<de::Token, Error>> for U8Deserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            match self.state {
-                StartState => {
-                    self.state = SepOrEndState;
-                    Some(Ok(de::SeqStart(self.len)))
-                }
-                SepOrEndState => {
-                    match self.iter.next() {
-                        Some(value) => {
-                            Some(Ok(de::U8(value)))
-                        }
-                        None => {
-                            self.state = EndState;
-                            Some(Ok(de::End))
-                        }
-                    }
-                }
-                EndState => {
-                    None
-                }
-            }
-        }
-    }
-
-    impl de::Deserializer<Error> for U8Deserializer {
-        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn missing_field<
-            T: de::Deserializable<U8Deserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(SyntaxError)
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-fn run_decoder<
-    D: Decoder<E>,
-    E: Show,
-    T: Clone + PartialEq + Show + Decodable<D, E>
->(mut d: D, value: T) {
-    let v: T = Decodable::decode(&mut d).unwrap();
-
-    assert_eq!(value, v);
-}
-
-fn run_deserializer<
-    D: Deserializer<E>,
-    E: Show,
-    T: Clone + PartialEq + Show + Deserializable<D, E>
->(mut d: D, value: T) {
-    let v: T = Deserializable::deserialize(&mut d).unwrap();
-
-    assert_eq!(value, v);
-}
-
-#[bench]
-fn bench_decoder_int_000(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = vec!();
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_int_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = vec!(1, 2, 3);
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_int_100(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = range(0i, 100).collect();
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_u8_000(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = vec!();
-        run_decoder(decoder::U8Decoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_u8_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = vec!(1, 2, 3);
-        run_decoder(decoder::U8Decoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_u8_100(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = range(0u8, 100).collect();
-        run_decoder(decoder::U8Decoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_int_000(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = vec!();
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_int_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = vec!(1, 2, 3);
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_int_100(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<int> = range(0i, 100).collect();
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_u8_000(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = vec!();
-        run_deserializer(deserializer::U8Deserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_u8_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = vec!(1, 2, 3);
-        run_deserializer(deserializer::U8Deserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_u8_100(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = range(0u8, 100).collect();
-        run_deserializer(deserializer::U8Deserializer::new(v.clone()), v)
-    })
-}

src/lib.rs

@@ -6,15 +6,9 @@
 #[cfg(test)]
 extern crate test;
 
-#[phase(plugin, link)]
-extern crate log;
-
 #[phase(plugin)]
 extern crate serde_macros;
 
-#[cfg(test)]
-extern crate debug;
-
 #[cfg(test)]
 extern crate serialize;
 
@@ -25,21 +19,6 @@ pub mod de;
 pub mod ser;
 pub mod json;
 
-#[cfg(test)]
-pub mod bench_enum;
-
-#[cfg(test)]
-pub mod bench_struct;
-
-#[cfg(test)]
-pub mod bench_vec;
-
-#[cfg(test)]
-pub mod bench_map;
-
-#[cfg(test)]
-pub mod bench_log;
-
 // an inner module so we can use serde_macros.
 mod serde {
     pub use de;