From ada088eb859d5e24032022d8bec472c275fa7ca5 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Mon, 26 May 2014 07:18:18 -0700 Subject: [PATCH] update to rust HEAD (20a415) struct decoder: 2417ns struct deserializer: 1640ns --- bench_enum.rs | 20 ++++++++++---------- bench_struct.rs | 22 +++++++++++----------- bench_vec.rs | 4 ++-- de.rs | 36 ++++++++++++++++++------------------ 4 files changed, 41 insertions(+), 41 deletions(-) diff --git a/bench_enum.rs b/bench_enum.rs index 226bcb5b..20ac0f9d 100644 --- a/bench_enum.rs +++ b/bench_enum.rs @@ -9,7 +9,7 @@ use de::{Deserializer, Deserializable, Token}; #[deriving(Clone, Eq, Show, Decodable)] enum Animal { Dog, - Frog(StrBuf, int) + Frog(String, int) } impl> Deserializable 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 { Err(SyntaxError) } fn read_char(&mut self) -> Result { Err(SyntaxError) } #[inline] - fn read_str(&mut self) -> Result { + fn read_str(&mut self) -> Result { 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)) diff --git a/bench_struct.rs b/bench_struct.rs index 781119b8..d32d5309 100644 --- a/bench_struct.rs +++ b/bench_struct.rs @@ -11,7 +11,7 @@ use de::{Token, Deserializer, Deserializable}; struct Inner { a: (), b: uint, - c: HashMap>, + c: HashMap>, } impl> Deserializable for Inner { @@ -64,10 +64,10 @@ mod decoder { NullState, UintState(uint), CharState(char), - StrState(StrBuf), + StringState(String), FieldState(&'static str), VecState(Vec), - MapState(HashMap>), + MapState(HashMap>), OptionState(bool), } @@ -121,9 +121,9 @@ mod decoder { } } #[inline] - fn read_str(&mut self) -> Result { + fn read_str(&mut self) -> Result { 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())), } } diff --git a/bench_vec.rs b/bench_vec.rs index a3a39cce..dd98c35e 100644 --- a/bench_vec.rs +++ b/bench_vec.rs @@ -59,7 +59,7 @@ mod decoder { fn read_f64(&mut self) -> Result { Err(SyntaxError) } fn read_f32(&mut self) -> Result { Err(SyntaxError) } fn read_char(&mut self) -> Result { Err(SyntaxError) } - fn read_str(&mut self) -> Result { Err(SyntaxError) } + fn read_str(&mut self) -> Result { Err(SyntaxError) } // Compound types: fn read_enum(&mut self, _name: &str, _f: |&mut IntDecoder| -> Result) -> Result { Err(SyntaxError) } @@ -160,7 +160,7 @@ mod decoder { fn read_f64(&mut self) -> Result { Err(SyntaxError) } fn read_f32(&mut self) -> Result { Err(SyntaxError) } fn read_char(&mut self) -> Result { Err(SyntaxError) } - fn read_str(&mut self) -> Result { Err(SyntaxError) } + fn read_str(&mut self) -> Result { Err(SyntaxError) } // Compound types: fn read_enum(&mut self, _name: &str, _f: |&mut U8Decoder| -> Result) -> Result { Err(SyntaxError) } diff --git a/de.rs b/de.rs index f9cb6151..ba8e677f 100644 --- a/de.rs +++ b/de.rs @@ -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: Iterator> { } #[inline] - fn expect_strbuf(&mut self, token: Token) -> Result { + fn expect_strbuf(&mut self, token: Token) -> Result { 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>, + c: HashMap>, } impl> Deserializable for Inner { @@ -539,7 +539,7 @@ mod tests { #[deriving(Clone, Eq, Show, Decodable)] enum Animal { Dog, - Frog(StrBuf, int) + Frog(String, int) } impl> Deserializable 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 = Deserializable::deserialize(&mut deserializer).unwrap(); + let value: HashMap = Deserializable::deserialize(&mut deserializer).unwrap(); let mut map = HashMap::new(); map.insert(5, "a".to_strbuf());