itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-03 15:55:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

update to rust HEAD (20a415)

Browse Source 
struct decoder: 2417ns
struct deserializer: 1640ns
This commit is contained in:
Erick Tryzelaar 2014-05-26 07:18:18 -07:00
parent 41eb7293d2
commit ada088eb85
4 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
bench_enum.rs
View File

@ -9,7 +9,7 @@ use de::{Deserializer, Deserializable, Token};
#[deriving(Clone, Eq, Show, Decodable)] #[deriving(Clone, Eq, Show, Decodable)]
enum Animal { enum Animal {
Dog, Dog,
Frog(StrBuf, int) Frog(String, int)
} }
impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal { impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal {
@ -53,7 +53,7 @@ mod decoder {
DogState, DogState,
FrogState, FrogState,
IntState(int), IntState(int),
StrState(StrBuf), StringState(String),
} }
pub struct AnimalDecoder { pub struct AnimalDecoder {
@ -94,9 +94,9 @@ mod decoder {
fn read_f32(&mut self) -> Result<f32, 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_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
#[inline] #[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StrState(x)) => Ok(x), Some(StringState(x)) => Ok(x),
_ => Err(SyntaxError), _ => Err(SyntaxError),
} }
} }
@ -123,7 +123,7 @@ mod decoder {
Some(AnimalState(Dog)) => "Dog", Some(AnimalState(Dog)) => "Dog",
Some(AnimalState(Frog(x0, x1))) => { Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(IntState(x1)); self.stack.push(IntState(x1));
self.stack.push(StrState(x0)); self.stack.push(StringState(x0));
"Frog" "Frog"
} }
_ => { return Err(SyntaxError); } _ => { return Err(SyntaxError); }
@ -194,12 +194,12 @@ mod deserializer {
use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError}; use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError};
use de::Deserializer; use de::Deserializer;
use de::{Token, Int, StrBuf, EnumStart, End}; use de::{Token, Int, String, EnumStart, End};
enum State { enum State {
AnimalState(Animal), AnimalState(Animal),
IntState(int), IntState(int),
StrState(StrBuf), StringState(String),
EndState, EndState,
} }
@ -228,14 +228,14 @@ mod deserializer {
Some(AnimalState(Frog(x0, x1))) => { Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(EndState); self.stack.push(EndState);
self.stack.push(IntState(x1)); self.stack.push(IntState(x1));
self.stack.push(StrState(x0)); self.stack.push(StringState(x0));
Some(Ok(EnumStart("Animal", "Frog"))) Some(Ok(EnumStart("Animal", "Frog")))
} }
Some(IntState(x)) => { Some(IntState(x)) => {
Some(Ok(Int(x))) Some(Ok(Int(x)))
} }
Some(StrState(x)) => { Some(StringState(x)) => {
Some(Ok(StrBuf(x))) Some(Ok(String(x)))
} }
Some(EndState) => { Some(EndState) => {
Some(Ok(End)) Some(Ok(End))

22
bench_struct.rs
View File

@ -11,7 +11,7 @@ use de::{Token, Deserializer, Deserializable};
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
c: HashMap<StrBuf, Option<char>>, c: HashMap<String, Option<char>>,
} }
impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner { impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner {
@ -64,10 +64,10 @@ mod decoder {
NullState, NullState,
UintState(uint), UintState(uint),
CharState(char), CharState(char),
StrState(StrBuf), StringState(String),
FieldState(&'static str), FieldState(&'static str),
VecState(Vec<Inner>), VecState(Vec<Inner>),
MapState(HashMap<StrBuf, Option<char>>), MapState(HashMap<String, Option<char>>),
OptionState(bool), OptionState(bool),
} }
@ -121,9 +121,9 @@ mod decoder {
} }
} }
#[inline] #[inline]
fn read_str(&mut self) -> Result<StrBuf, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StrState(value)) => Ok(value), Some(StringState(value)) => Ok(value),
_ => Err(SyntaxError), _ => Err(SyntaxError),
} }
} }
@ -248,7 +248,7 @@ mod decoder {
self.stack.push(OptionState(false)); self.stack.push(OptionState(false));
} }
} }
self.stack.push(StrState(key)); self.stack.push(StringState(key));
} }
f(self, len) f(self, len)
} }
@ -271,7 +271,7 @@ mod decoder {
mod deserializer { mod deserializer {
use super::{Outer, Inner, Error, EndOfStream, SyntaxError}; use super::{Outer, Inner, Error, EndOfStream, SyntaxError};
use de::Deserializer; use de::Deserializer;
use de::{Token, Uint, Char, StrBuf, Null, TupleStart, StructStart, StructField, SeqStart, MapStart, End, Option}; use de::{Token, Uint, Char, String, Null, TupleStart, StructStart, StructField, SeqStart, MapStart, End, Option};
enum State { enum State {
OuterState(Outer), OuterState(Outer),
@ -280,7 +280,7 @@ mod deserializer {
NullState, NullState,
UintState(uint), UintState(uint),
CharState(char), CharState(char),
StrState(StrBuf), StringState(String),
OptionState(bool), OptionState(bool),
TupleState(uint), TupleState(uint),
VecState(uint), VecState(uint),
@ -346,7 +346,7 @@ mod deserializer {
} }
} }
self.stack.push(StrState(k)); self.stack.push(StringState(k));
self.stack.push(TupleState(2)); self.stack.push(TupleState(2));
} }
self.stack.push(MapState(len)); self.stack.push(MapState(len));
@ -402,9 +402,9 @@ mod deserializer {
_ => Some(Err(self.syntax_error())), _ => Some(Err(self.syntax_error())),
} }
} }
Some(&StrState(_)) => { Some(&StringState(_)) => {
match self.stack.pop() { match self.stack.pop() {
Some(StrState(x)) => Some(Ok(StrBuf(x))), Some(StringState(x)) => Some(Ok(String(x))),
_ => Some(Err(self.syntax_error())), _ => Some(Err(self.syntax_error())),
} }
} }

4
bench_vec.rs
View File

@ -59,7 +59,7 @@ mod decoder {
fn read_f64(&mut self) -> Result<f64, 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_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) } fn read_str(&mut self) -> Result<String, Error> { Err(SyntaxError) }
// Compound types: // Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) } fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
@ -160,7 +160,7 @@ mod decoder {
fn read_f64(&mut self) -> Result<f64, 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_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) } fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) } fn read_str(&mut self) -> Result<String, Error> { Err(SyntaxError) }
// Compound types: // Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) } fn read_enum<T>(&mut self, _name: &str, _f: |&mut U8Decoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }

36
de.rs
View File

@ -22,7 +22,7 @@ pub enum Token {
F64(f64), F64(f64),
Char(char), Char(char),
Str(&'static str), Str(&'static str),
StrBuf(StrBuf), String(String),
Option(bool), Option(bool),
TupleStart(uint), TupleStart(uint),
@ -131,10 +131,10 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
} }
#[inline] #[inline]
fn expect_strbuf(&mut self, token: Token) -> Result<StrBuf, E> { fn expect_strbuf(&mut self, token: Token) -> Result<String, E> {
match token { match token {
Str(value) => Ok(value.to_strbuf()), Str(value) => Ok(value.to_strbuf()),
StrBuf(value) => Ok(value), String(value) => Ok(value),
_ => Err(self.syntax_error()), _ => Err(self.syntax_error()),
} }
} }
@ -342,7 +342,7 @@ impl_deserializable!(f32, expect_num)
impl_deserializable!(f64, expect_num) impl_deserializable!(f64, expect_num)
impl_deserializable!(char, expect_char) impl_deserializable!(char, expect_char)
impl_deserializable!(&'static str, expect_str) impl_deserializable!(&'static str, expect_str)
impl_deserializable!(StrBuf, expect_strbuf) impl_deserializable!(String, expect_strbuf)
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -491,7 +491,7 @@ mod tests {
use serialize::Decoder; use serialize::Decoder;
use super::{Token, Null, Int, Uint, Str, StrBuf, Char, Option}; use super::{Token, Null, Int, Uint, Str, String, Char, Option};
use super::{TupleStart, StructStart, StructField, EnumStart}; use super::{TupleStart, StructStart, StructField, EnumStart};
use super::{SeqStart, MapStart, End}; use super::{SeqStart, MapStart, End};
use super::{Deserializer, Deserializable}; use super::{Deserializer, Deserializable};
@ -502,7 +502,7 @@ mod tests {
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
c: HashMap<StrBuf, Option<char>>, c: HashMap<String, Option<char>>,
} }
impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner { impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner {
@ -539,7 +539,7 @@ mod tests {
#[deriving(Clone, Eq, Show, Decodable)] #[deriving(Clone, Eq, Show, Decodable)]
enum Animal { enum Animal {
Dog, Dog,
Frog(StrBuf, int) Frog(String, int)
} }
impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal { impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal {
@ -635,11 +635,11 @@ mod tests {
#[test] #[test]
fn test_tokens_strbuf() { fn test_tokens_strbuf() {
let tokens = vec!( let tokens = vec!(
StrBuf("a".to_strbuf()), String("a".to_strbuf()),
); );
let mut deserializer = TokenDeserializer::new(tokens); let mut deserializer = TokenDeserializer::new(tokens);
let value: StrBuf = Deserializable::deserialize(&mut deserializer).unwrap(); let value: String = Deserializable::deserialize(&mut deserializer).unwrap();
assert_eq!(value, "a".to_strbuf()); assert_eq!(value, "a".to_strbuf());
} }
@ -700,12 +700,12 @@ mod tests {
TupleStart(2), TupleStart(2),
Int(5), Int(5),
StrBuf("a".to_strbuf()), String("a".to_strbuf()),
End, End,
); );
let mut deserializer = TokenDeserializer::new(tokens); let mut deserializer = TokenDeserializer::new(tokens);
let value: (int, StrBuf) = Deserializable::deserialize(&mut deserializer).unwrap(); let value: (int, String) = Deserializable::deserialize(&mut deserializer).unwrap();
assert_eq!(value, (5, "a".to_strbuf())); assert_eq!(value, (5, "a".to_strbuf()));
} }
@ -722,13 +722,13 @@ mod tests {
TupleStart(2), TupleStart(2),
Int(5), Int(5),
StrBuf("a".to_strbuf()), String("a".to_strbuf()),
End, End,
End, End,
); );
let mut deserializer = TokenDeserializer::new(tokens); let mut deserializer = TokenDeserializer::new(tokens);
let value: ((), (), (int, StrBuf)) = Deserializable::deserialize(&mut deserializer).unwrap(); let value: ((), (), (int, String)) = Deserializable::deserialize(&mut deserializer).unwrap();
assert_eq!(value, ((), (), (5, "a".to_strbuf()))); assert_eq!(value, ((), (), (5, "a".to_strbuf())));
} }
@ -765,7 +765,7 @@ mod tests {
StructField("c"), StructField("c"),
MapStart(1), MapStart(1),
TupleStart(2), TupleStart(2),
StrBuf("abc".to_strbuf()), String("abc".to_strbuf()),
Option(true), Option(true),
Char('c'), Char('c'),
@ -809,7 +809,7 @@ mod tests {
let tokens = vec!( let tokens = vec!(
EnumStart("Animal", "Frog"), EnumStart("Animal", "Frog"),
StrBuf("Henry".to_strbuf()), String("Henry".to_strbuf()),
Int(349), Int(349),
End, End,
); );
@ -888,19 +888,19 @@ mod tests {
TupleStart(2), TupleStart(2),
Int(5), Int(5),
StrBuf("a".to_strbuf()), String("a".to_strbuf()),
End, End,
TupleStart(2), TupleStart(2),
Int(6), Int(6),
StrBuf("b".to_strbuf()), String("b".to_strbuf()),
End, End,
End, End,
); );
let mut deserializer = TokenDeserializer::new(tokens); let mut deserializer = TokenDeserializer::new(tokens);
let value: HashMap<int, StrBuf> = Deserializable::deserialize(&mut deserializer).unwrap(); let value: HashMap<int, String> = Deserializable::deserialize(&mut deserializer).unwrap();
let mut map = HashMap::new(); let mut map = HashMap::new();
map.insert(5, "a".to_strbuf()); map.insert(5, "a".to_strbuf());