mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions 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)]
enum Animal {
Dog,
Frog(StrBuf, int)
Frog(String, int)
}
impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal {
@ -53,7 +53,7 @@ mod decoder {
DogState,
FrogState,
IntState(int),
StrState(StrBuf),
StringState(String),
}
pub struct AnimalDecoder {
@ -94,9 +94,9 @@ mod decoder {
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> {
fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() {
Some(StrState(x)) => Ok(x),
Some(StringState(x)) => Ok(x),
_ => Err(SyntaxError),
}
}
@ -123,7 +123,7 @@ mod decoder {
Some(AnimalState(Dog)) => "Dog",
Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(IntState(x1));
self.stack.push(StrState(x0));
self.stack.push(StringState(x0));
"Frog"
}
_ => { return Err(SyntaxError); }
@ -194,12 +194,12 @@ mod deserializer {
use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError};
use de::Deserializer;
use de::{Token, Int, StrBuf, EnumStart, End};
use de::{Token, Int, String, EnumStart, End};
enum State {
AnimalState(Animal),
IntState(int),
StrState(StrBuf),
StringState(String),
EndState,
}
@ -228,14 +228,14 @@ mod deserializer {
Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(EndState);
self.stack.push(IntState(x1));
self.stack.push(StrState(x0));
self.stack.push(StringState(x0));
Some(Ok(EnumStart("Animal", "Frog")))
}
Some(IntState(x)) => {
Some(Ok(Int(x)))
}
Some(StrState(x)) => {
Some(Ok(StrBuf(x)))
Some(StringState(x)) => {
Some(Ok(String(x)))
}
Some(EndState) => {
Some(Ok(End))

22
bench_struct.rs
View File

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

36
de.rs
View File

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