pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-13 07:51:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace serde1 with serde2!

Browse Source 
Closes #26!
This commit is contained in:
Erick Tryzelaar
2015-03-08 22:56:33 -07:00
parent 6726bd12ae
commit 805a3435cf
48 changed files with 4635 additions and 15428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benches/bench_enum.rs
+118 -77
View File
@@ -1,4 +1,4 @@
#![feature(plugin, test)]
#![feature(custom_derive, plugin, test)]
#![plugin(serde_macros)]
extern crate serde;
@@ -26,9 +26,16 @@ enum Animal {
#[derive(Debug)]
pub enum Error {
EndOfStream,
EndOfStreamError,
SyntaxError,
OtherError(String),
}
impl serde::de::Error for Error {
fn syntax_error() -> Error { Error::SyntaxError }
fn end_of_stream_error() -> Error { Error::EndOfStreamError }
fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
}
//////////////////////////////////////////////////////////////////////////////
@@ -38,7 +45,6 @@ mod decoder {
use super::{Animal, Error};
use super::Animal::{Dog, Frog};
use super::Error::{SyntaxError, OtherError};
use self::State::{AnimalState, IsizeState, StringState};
enum State {
@@ -64,37 +70,35 @@ mod decoder {
impl Decoder for AnimalDecoder {
type Error = Error;
fn error(&mut self, msg: &str) -> Error {
OtherError(msg.to_string())
}
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_usize(&mut self) -> Result<usize, 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) }
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
#[inline]
fn read_isize(&mut self) -> Result<isize, Error> {
match self.stack.pop() {
Some(IsizeState(x)) => Ok(x),
_ => Err(SyntaxError),
_ => Err(Error::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_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
#[inline]
fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() {
Some(StringState(x)) => Ok(x),
_ => Err(SyntaxError),
_ => Err(Error::SyntaxError),
}
}
@@ -109,10 +113,10 @@ mod decoder {
if name == "Animal" {
f(self)
} else {
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
_ => Err(SyntaxError)
_ => Err(Error::SyntaxError)
}
}
@@ -127,12 +131,12 @@ mod decoder {
self.stack.push(StringState(x0));
"Frog"
}
_ => { return Err(SyntaxError); }
_ => { return Err(Error::SyntaxError); }
};
let idx = match names.iter().position(|n| *n == name) {
Some(idx) => idx,
None => { return Err(SyntaxError); }
None => { return Err(Error::SyntaxError); }
};
f(self, idx)
@@ -197,7 +201,7 @@ mod decoder {
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
#[inline]
@@ -217,19 +221,19 @@ mod decoder {
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
}
@@ -238,9 +242,6 @@ mod decoder {
mod deserializer {
use super::{Animal, Error};
use super::Animal::{Dog, Frog};
use super::Error::{EndOfStream, SyntaxError};
use self::State::{AnimalState, IsizeState, StringState, EndState};
use serde::de;
@@ -248,8 +249,7 @@ mod deserializer {
AnimalState(Animal),
IsizeState(isize),
StringState(String),
EndState,
UnitState,
}
pub struct AnimalDeserializer {
@@ -260,67 +260,108 @@ mod deserializer {
#[inline]
pub fn new(animal: Animal) -> AnimalDeserializer {
AnimalDeserializer {
stack: vec!(AnimalState(animal)),
stack: vec!(State::AnimalState(animal)),
}
}
}
impl Iterator for AnimalDeserializer {
type Item = Result<de::Token, Error>;
impl de::Deserializer for AnimalDeserializer {
type Error = Error;
#[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> {
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.stack.pop() {
Some(AnimalState(Dog)) => {
self.stack.push(EndState);
Some(Ok(de::Token::EnumStart("Animal", "Dog", 0)))
Some(State::AnimalState(Animal::Dog)) => {
self.stack.push(State::UnitState);
visitor.visit_enum("Animal", "Dog", DogVisitor {
de: self,
})
}
Some(AnimalState(Frog(x0, x1))) => {
self.stack.push(EndState);
self.stack.push(IsizeState(x1));
self.stack.push(StringState(x0));
Some(Ok(de::Token::EnumStart("Animal", "Frog", 2)))
Some(State::AnimalState(Animal::Frog(x0, x1))) => {
self.stack.push(State::IsizeState(x1));
self.stack.push(State::StringState(x0));
visitor.visit_enum("Animal", "Frog", FrogVisitor {
de: self,
state: 0,
})
}
Some(IsizeState(x)) => {
Some(Ok(de::Token::Isize(x)))
Some(State::IsizeState(value)) => {
visitor.visit_isize(value)
}
Some(StringState(x)) => {
Some(Ok(de::Token::String(x)))
Some(State::StringState(value)) => {
visitor.visit_string(value)
}
Some(EndState) => {
Some(Ok(de::Token::End))
Some(State::UnitState) => {
visitor.visit_unit()
}
None => {
Err(Error::EndOfStreamError)
}
None => None,
}
}
}
impl de::Deserializer<Error> for AnimalDeserializer {
#[inline]
fn end_of_stream_error(&mut self) -> Error {
EndOfStream
struct DogVisitor<'a> {
de: &'a mut AnimalDeserializer,
}
impl<'a> de::EnumVisitor for DogVisitor<'a> {
type Error = Error;
fn visit_unit(&mut self) -> Result<(), Error> {
de::Deserialize::deserialize(self.de)
}
}
struct FrogVisitor<'a> {
de: &'a mut AnimalDeserializer,
state: usize,
}
impl<'a> de::EnumVisitor for FrogVisitor<'a> {
type Error = Error;
fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::EnumSeqVisitor,
{
visitor.visit(self)
}
}
impl<'a> de::SeqVisitor for FrogVisitor<'a> {
type Error = Error;
fn visit<T>(&mut self) -> Result<Option<T>, Error>
where T: de::Deserialize,
{
match self.state {
0 => {
self.state += 1;
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
1 => {
self.state += 1;
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
_ => {
Ok(None)
}
}
}
#[inline]
fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
SyntaxError
fn end(&mut self) -> Result<(), Error> {
if self.state == 2 {
Ok(())
} else {
Err(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::Deserialize<AnimalDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
fn size_hint(&self) -> (usize, Option<usize>) {
let len = 2 - self.state;
(len, Some(len))
}
}
}
benches/bench_log.rs
+91 -573
View File
@@ -1,4 +1,4 @@
#![feature(collections, core, io, plugin, test)]
#![feature(custom_derive, collections, core, io, plugin, test)]
#![allow(non_camel_case_types)]
#![plugin(serde_macros)]
@@ -10,11 +10,10 @@ use std::io::{self, ReadExt, WriteExt};
use std::num::FromPrimitive;
use test::Bencher;
use serde::de;
use serde::de::{self, Deserialize, Deserializer};
use serde::json::ser::escape_str;
use serde::json;
use serde::ser::Serialize;
use serde::ser;
use serde::ser::{self, Serialize, Serializer};
use rustc_serialize::Encodable;
@@ -48,24 +47,28 @@ impl rustc_serialize::Encodable for HttpProtocol {
impl rustc_serialize::Decodable for HttpProtocol {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpProtocol, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) {
match FromPrimitive::from_usize(try!(d.read_usize())) {
Some(value) => Ok(value),
None => Err(d.error("cannot convert from usize")),
}
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpProtocol {
impl ser::Serialize for HttpProtocol {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_u8(*self as u8)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpProtocol {
impl de::Deserialize for HttpProtocol {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> {
d.expect_from_primitive(token)
fn deserialize<
S: Deserializer,
>(state: &mut S) -> Result<HttpProtocol, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -92,24 +95,28 @@ impl rustc_serialize::Encodable for HttpMethod {
impl rustc_serialize::Decodable for HttpMethod {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpMethod, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) {
match FromPrimitive::from_usize(try!(d.read_usize())) {
Some(value) => Ok(value),
None => Err(d.error("cannot convert from usize")),
}
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpMethod {
impl ser::Serialize for HttpMethod {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_u8(*self as u8)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpMethod {
impl de::Deserialize for HttpMethod {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> {
d.expect_from_primitive(token)
fn deserialize<
S: de::Deserializer,
>(state: &mut S) -> Result<HttpMethod, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -136,17 +143,21 @@ impl rustc_serialize::Decodable for CacheStatus {
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for CacheStatus {
impl ser::Serialize for CacheStatus {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_usize(*self as usize)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for CacheStatus {
impl de::Deserialize for CacheStatus {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> {
d.expect_from_primitive(token)
fn deserialize<
S: de::Deserializer,
>(state: &mut S) -> Result<CacheStatus, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -182,17 +193,21 @@ impl rustc_serialize::Decodable for OriginProtocol {
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for OriginProtocol {
impl ser::Serialize for OriginProtocol {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_u8(*self as u8)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for OriginProtocol {
impl de::Deserialize for OriginProtocol {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> {
d.expect_from_primitive(token)
fn deserialize<
S: de::Deserializer,
>(state: &mut S) -> Result<OriginProtocol, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -220,17 +235,21 @@ impl rustc_serialize::Decodable for ZonePlan {
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for ZonePlan {
impl ser::Serialize for ZonePlan {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_u8(*self as u8)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for ZonePlan {
impl de::Deserialize for ZonePlan {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> {
d.expect_from_primitive(token)
fn deserialize<
S: de::Deserializer,
>(state: &mut S) -> Result<ZonePlan, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -509,17 +528,21 @@ impl rustc_serialize::Decodable for Country {
}
}
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Country {
impl ser::Serialize for Country {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_u8(*self as u8)
fn visit<
V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_u8(*self as u8)
}
}
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Country {
impl de::Deserialize for Country {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> {
d.expect_from_primitive(token)
fn deserialize<
S: de::Deserializer,
>(state: &mut S) -> Result<Country, S::Error> {
state.visit(de::PrimitiveVisitor::new())
}
}
@@ -652,7 +675,7 @@ fn push_all_bytes(dst: &mut Vec<u8>, src: &[u8]) {
// we would have failed if `reserve` overflowed.
dst.set_len(dst_len + src_len);
::std::ptr::copy_nonoverlapping_memory(
::std::ptr::copy_nonoverlapping(
dst.as_mut_ptr().offset(dst_len as isize),
src.as_ptr(),
src_len);
@@ -687,7 +710,7 @@ fn test_encoder() {
log.encode(&mut encoder).unwrap();
}
assert_eq!(&wr[], JSON_STR);
assert_eq!(&wr, &JSON_STR);
}
#[bench]
@@ -734,10 +757,10 @@ fn test_serializer_vec() {
let log = Log::new();
let wr = Vec::with_capacity(1024);
let mut serializer = json::Serializer::new(wr);
log.serialize(&mut serializer).unwrap();
serializer.visit(&log).unwrap();
let json = serializer.unwrap();
assert_eq!(&json[], JSON_STR.as_bytes());
let json = serializer.into_inner();
assert_eq!(&json, &JSON_STR.as_bytes());
}
#[bench]
@@ -752,8 +775,8 @@ fn bench_serializer_vec(b: &mut Bencher) {
wr.clear();
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
let _json = serializer.unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
});
}
@@ -767,11 +790,11 @@ fn bench_serializer_slice(b: &mut Bencher) {
b.iter(|| {
for item in buf.iter_mut(){ *item = 0; }
let mut wr = &mut buf[];
let mut wr = &mut buf[..];
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
let _json = serializer.unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
});
}
@@ -783,10 +806,11 @@ fn test_serializer_my_mem_writer0() {
{
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
}
assert_eq!(&wr.buf[], JSON_STR.as_bytes());
assert_eq!(&wr.buf, &JSON_STR.as_bytes());
}
#[bench]
@@ -801,8 +825,8 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
wr.buf.clear();
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
let _json = serializer.unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
});
}
@@ -814,10 +838,11 @@ fn test_serializer_my_mem_writer1() {
{
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
}
assert_eq!(&wr.buf[], JSON_STR.as_bytes());
assert_eq!(&wr.buf, &JSON_STR.as_bytes());
}
#[bench]
@@ -832,8 +857,8 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
wr.buf.clear();
let mut serializer = json::Serializer::new(wr.by_ref());
log.serialize(&mut serializer).unwrap();
let _json = serializer.unwrap();
serializer.visit(&log).unwrap();
let _json = serializer.into_inner();
});
}
@@ -1017,7 +1042,7 @@ fn test_manual_serialize_vec_no_escape() {
manual_serialize_no_escape(&mut wr, &log);
let json = String::from_utf8(wr).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1042,7 +1067,7 @@ fn test_manual_serialize_vec_escape() {
manual_serialize_escape(&mut wr, &log);
let json = String::from_utf8(wr).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1068,7 +1093,7 @@ fn test_manual_serialize_my_mem_writer0_no_escape() {
manual_serialize_no_escape(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1094,7 +1119,7 @@ fn test_manual_serialize_my_mem_writer0_escape() {
manual_serialize_escape(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1120,7 +1145,7 @@ fn test_manual_serialize_my_mem_writer1_no_escape() {
manual_serialize_no_escape(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1146,7 +1171,7 @@ fn test_manual_serialize_my_mem_writer1_escape() {
manual_serialize_escape(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
assert_eq!(&JSON_STR, &json);
}
#[bench]
@@ -1164,116 +1189,6 @@ fn bench_manual_serialize_my_mem_writer1_escape(b: &mut Bencher) {
});
}
fn direct<W: io::Write>(wr: &mut W, log: &Log) {
use serde::ser::Serializer;
let mut serializer = json::Serializer::new(wr.by_ref());
serializer.serialize_struct_start("Log", 12).unwrap();
serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap();
serializer.serialize_struct_elt("zone_id", &log.zone_id).unwrap();
serializer.serialize_struct_elt("zone_plan", &(log.zone_plan as usize)).unwrap();
serializer.serialize_struct_elt("http", &log.http).unwrap();
serializer.serialize_struct_elt("origin", &log.origin).unwrap();
serializer.serialize_struct_elt("country", &(log.country as usize)).unwrap();
serializer.serialize_struct_elt("cache_status", &(log.cache_status as usize)).unwrap();
serializer.serialize_struct_elt("server_ip", &log.server_ip).unwrap();
serializer.serialize_struct_elt("server_name", &log.server_name).unwrap();
serializer.serialize_struct_elt("remote_ip", &log.remote_ip).unwrap();
serializer.serialize_struct_elt("bytes_dlv", &log.bytes_dlv).unwrap();
serializer.serialize_struct_elt("ray_id", &log.ray_id).unwrap();
serializer.serialize_struct_end().unwrap();
}
#[test]
fn test_direct_vec() {
let log = Log::new();
let mut wr = Vec::with_capacity(1024);
direct(&mut wr, &log);
let json = String::from_utf8(wr).unwrap();
assert_eq!(JSON_STR, &json[]);
}
#[bench]
fn bench_direct_vec(b: &mut Bencher) {
let log = Log::new();
let mut wr = Vec::with_capacity(1024);
direct(&mut wr, &log);
b.bytes = wr.len() as u64;
b.iter(|| {
let mut wr = Vec::with_capacity(1024);
direct(&mut wr, &log);
});
}
#[test]
fn test_direct_my_mem_writer0() {
let log = Log::new();
let mut wr = MyMemWriter0::with_capacity(1024);
direct(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
}
#[bench]
fn bench_direct_my_mem_writer0(b: &mut Bencher) {
let log = Log::new();
let mut wr = MyMemWriter0::with_capacity(1024);
direct(&mut wr, &log);
b.bytes = wr.buf.len() as u64;
b.iter(|| {
wr.buf.clear();
direct(&mut wr, &log);
});
}
#[test]
fn test_direct_my_mem_writer1() {
let log = Log::new();
let mut wr = MyMemWriter1::with_capacity(1024);
direct(&mut wr, &log);
let json = String::from_utf8(wr.buf).unwrap();
assert_eq!(JSON_STR, &json[]);
}
#[bench]
fn bench_direct_my_mem_writer1(b: &mut Bencher) {
let log = Log::new();
let mut wr = MyMemWriter1::with_capacity(1024);
direct(&mut wr, &log);
b.bytes = wr.buf.len() as u64;
b.iter(|| {
wr.buf.clear();
direct(&mut wr, &log);
});
}
#[test]
fn test_decoder() {
use rustc_serialize::json::Json;
let json = Json::from_str(JSON_STR).unwrap();
let mut decoder = rustc_serialize::json::Decoder::new(json);
let log: Log = rustc_serialize::Decodable::decode(&mut decoder).unwrap();
assert_eq!(log, Log::new());
}
#[bench]
fn bench_decoder(b: &mut Bencher) {
use rustc_serialize::json::Json;
@@ -1287,299 +1202,6 @@ fn bench_decoder(b: &mut Bencher) {
});
}
#[test]
fn test_deserializer() {
let log: Log = json::from_str(JSON_STR).unwrap();
assert_eq!(log, Log::new());
}
//////////////////////////////////////////////////////////////////////////////
#[inline]
fn manual_reader_ignore<R: Reader>(rdr: &mut R, buf: &mut [u8], key: &[u8]) {
let buf = &mut buf[0..key.len()];
rdr.read(buf).unwrap();
assert_eq!(buf, key);
}
#[inline]
fn manual_reader_field<R: Reader>(rdr: &mut R, buf: &mut [u8], key: &[u8]) {
let b = rdr.read_byte().unwrap();
assert_eq!(b, b'"');
manual_reader_ignore(rdr, buf, key);
let b = rdr.read_byte().unwrap();
assert_eq!(b, b'"');
let b = rdr.read_byte().unwrap();
assert_eq!(b, b':');
}
#[inline]
fn manual_reader_int<R: Reader>(rdr: &mut R, buf: &mut [u8], key: &[u8]) -> i64 {
manual_reader_field(rdr, buf, key);
let mut res = 0;
loop {
let byte = rdr.read_byte().unwrap();
match byte {
b'0' ... b'9' => {
res *= 10;
res += (byte as i64) - (b'0' as i64);
}
_ => { break; }
}
}
res
}
#[inline]
fn manual_reader_string<R: Reader>(rdr: &mut R, buf: &mut [u8], key: &[u8]) -> String {
manual_reader_field(rdr, buf, key);
manual_reader_ignore(rdr, buf, b"\"");
let mut idx = 0;
loop {
let byte = rdr.read_byte().unwrap();
match byte {
b'"' => { break; }
byte => { buf[idx] = byte; }
};
idx += 1;
}
let b = rdr.read_byte().unwrap();
assert!(b == b',' || b == b']' || b == b'}');
String::from_utf8(buf[..idx].to_vec()).unwrap()
}
#[inline]
fn manual_reader_deserialize<R: Reader>(rdr: &mut R) -> Log {
let mut buf = [0; 128];
manual_reader_ignore(rdr, &mut buf, b"{");
let timestamp = manual_reader_int(rdr, &mut buf, b"timestamp");
let zone_id = manual_reader_int(rdr, &mut buf, b"zone_id");
let zone_plan = manual_reader_int(rdr, &mut buf, b"zone_plan");
manual_reader_field(rdr, &mut buf, b"http");
manual_reader_ignore(rdr, &mut buf, b"{");
let protocol = manual_reader_int(rdr, &mut buf, b"protocol");
let status = manual_reader_int(rdr, &mut buf, b"status");
let host_status = manual_reader_int(rdr, &mut buf, b"host_status");
let up_status = manual_reader_int(rdr, &mut buf, b"up_status");
let method = manual_reader_int(rdr, &mut buf, b"method");
let content_type = manual_reader_string(rdr, &mut buf, b"content_type");
let user_agent = manual_reader_string(rdr, &mut buf, b"user_agent");
let referer = manual_reader_string(rdr, &mut buf, b"referer");
let request_uri = manual_reader_string(rdr, &mut buf, b"request_uri");
let http = Http {
protocol: FromPrimitive::from_i64(protocol).unwrap(),
status: FromPrimitive::from_i64(status).unwrap(),
host_status: FromPrimitive::from_i64(host_status).unwrap(),
up_status: FromPrimitive::from_i64(up_status).unwrap(),
method: FromPrimitive::from_i64(method).unwrap(),
content_type: content_type,
user_agent: user_agent,
referer: referer,
request_uri: request_uri,
};
manual_reader_ignore(rdr, &mut buf, b",");
manual_reader_field(rdr, &mut buf, b"origin");
manual_reader_ignore(rdr, &mut buf, b"{");
let ip = manual_reader_string(rdr, &mut buf, b"ip");
let port = manual_reader_int(rdr, &mut buf, b"port");
let hostname = manual_reader_string(rdr, &mut buf, b"hostname");
let protocol = manual_reader_int(rdr, &mut buf, b"protocol");
let origin = Origin {
ip: ip,
port: FromPrimitive::from_i64(port).unwrap(),
hostname: hostname,
protocol: FromPrimitive::from_i64(protocol).unwrap(),
};
manual_reader_ignore(rdr, &mut buf, b",");
let country = manual_reader_int(rdr, &mut buf, b"country");
let cache_status = manual_reader_int(rdr, &mut buf, b"cache_status");
let server_ip = manual_reader_string(rdr, &mut buf, b"server_ip");
let server_name = manual_reader_string(rdr, &mut buf, b"server_name");
let remote_ip = manual_reader_string(rdr, &mut buf, b"remote_ip");
let bytes_dlv = manual_reader_int(rdr, &mut buf, b"bytes_dlv");
let ray_id = manual_reader_string(rdr, &mut buf, b"ray_id");
Log {
timestamp: timestamp,
zone_id: FromPrimitive::from_i64(zone_id).unwrap(),
zone_plan: FromPrimitive::from_i64(zone_plan).unwrap(),
http: http,
origin: origin,
country: FromPrimitive::from_i64(country).unwrap(),
cache_status: FromPrimitive::from_i64(cache_status).unwrap(),
server_ip: server_ip,
server_name: server_name,
remote_ip: remote_ip,
bytes_dlv: FromPrimitive::from_i64(bytes_dlv).unwrap(),
ray_id: ray_id,
}
}
//////////////////////////////////////////////////////////////////////////////
#[inline]
fn manual_iter_ignore<R: Iterator<Item=u8>>(mut rdr: R, buf: &mut [u8], key: &[u8]) {
let buf = &mut buf[0..key.len()];
for idx in range(0, key.len()) {
buf[idx] = rdr.next().unwrap();
}
assert_eq!(buf, key);
}
#[inline]
fn manual_iter_field<R: Iterator<Item=u8>>(mut rdr: R, buf: &mut [u8], key: &[u8]) {
let b = rdr.next().unwrap();
assert_eq!(b, b'"');
manual_iter_ignore(rdr.by_ref(), buf, key);
let b = rdr.next().unwrap();
assert_eq!(b, b'"');
let b = rdr.next().unwrap();
assert_eq!(b, b':');
}
#[inline]
fn manual_iter_int<R: Iterator<Item=u8>>(mut rdr: R, buf: &mut [u8], key: &[u8]) -> i64 {
manual_iter_field(rdr.by_ref(), buf, key);
let mut res = 0;
loop {
let byte = rdr.next().unwrap();
match byte {
b'0' ... b'9' => {
res *= 10;
res += (byte as i64) - (b'0' as i64);
}
_ => { break; }
}
}
res
}
#[inline]
fn manual_iter_string<R: Iterator<Item=u8>>(mut rdr: R, buf: &mut [u8], key: &[u8]) -> String {
manual_iter_field(rdr.by_ref(), buf, key);
manual_iter_ignore(rdr.by_ref(), buf, b"\"");
let mut idx = 0;
loop {
let byte = rdr.next().unwrap();
match byte {
b'"' => { break; }
byte => { buf[idx] = byte; }
};
idx += 1;
}
let b = rdr.next().unwrap();
assert!(b == b',' || b == b']' || b == b'}');
String::from_utf8(buf[..idx].to_vec()).unwrap()
}
#[inline]
fn manual_iter_deserialize<R: Iterator<Item=u8>>(mut rdr: R) -> Log {
let mut buf = [0u8; 128];
manual_iter_ignore(rdr.by_ref(), &mut buf, b"{");
let timestamp = manual_iter_int(rdr.by_ref(), &mut buf, b"timestamp");
let zone_id = manual_iter_int(rdr.by_ref(), &mut buf, b"zone_id");
let zone_plan = manual_iter_int(rdr.by_ref(), &mut buf, b"zone_plan");
manual_iter_field(rdr.by_ref(), &mut buf, b"http");
manual_iter_ignore(rdr.by_ref(), &mut buf, b"{");
let protocol = manual_iter_int(rdr.by_ref(), &mut buf, b"protocol");
let status = manual_iter_int(rdr.by_ref(), &mut buf, b"status");
let host_status = manual_iter_int(rdr.by_ref(), &mut buf, b"host_status");
let up_status = manual_iter_int(rdr.by_ref(), &mut buf, b"up_status");
let method = manual_iter_int(rdr.by_ref(), &mut buf, b"method");
let content_type = manual_iter_string(rdr.by_ref(), &mut buf, b"content_type");
let user_agent = manual_iter_string(rdr.by_ref(), &mut buf, b"user_agent");
let referer = manual_iter_string(rdr.by_ref(), &mut buf, b"referer");
let request_uri = manual_iter_string(rdr.by_ref(), &mut buf, b"request_uri");
let http = Http {
protocol: FromPrimitive::from_i64(protocol).unwrap(),
status: FromPrimitive::from_i64(status).unwrap(),
host_status: FromPrimitive::from_i64(host_status).unwrap(),
up_status: FromPrimitive::from_i64(up_status).unwrap(),
method: FromPrimitive::from_i64(method).unwrap(),
content_type: content_type,
user_agent: user_agent,
referer: referer,
request_uri: request_uri,
};
manual_iter_ignore(rdr.by_ref(), &mut buf, b",");
manual_iter_field(rdr.by_ref(), &mut buf, b"origin");
manual_iter_ignore(rdr.by_ref(), &mut buf, b"{");
let ip = manual_iter_string(rdr.by_ref(), &mut buf, b"ip");
let port = manual_iter_int(rdr.by_ref(), &mut buf, b"port");
let hostname = manual_iter_string(rdr.by_ref(), &mut buf, b"hostname");
let protocol = manual_iter_int(rdr.by_ref(), &mut buf, b"protocol");
let origin = Origin {
ip: ip,
port: FromPrimitive::from_i64(port).unwrap(),
hostname: hostname,
protocol: FromPrimitive::from_i64(protocol).unwrap(),
};
manual_iter_ignore(rdr.by_ref(), &mut buf, b",");
let country = manual_iter_int(rdr.by_ref(), &mut buf, b"country");
let cache_status = manual_iter_int(rdr.by_ref(), &mut buf, b"cache_status");
let server_ip = manual_iter_string(rdr.by_ref(), &mut buf, b"server_ip");
let server_name = manual_iter_string(rdr.by_ref(), &mut buf, b"server_name");
let remote_ip = manual_iter_string(rdr.by_ref(), &mut buf, b"remote_ip");
let bytes_dlv = manual_iter_int(rdr.by_ref(), &mut buf, b"bytes_dlv");
let ray_id = manual_iter_string(rdr.by_ref(), &mut buf, b"ray_id");
Log {
timestamp: timestamp,
zone_id: FromPrimitive::from_i64(zone_id).unwrap(),
zone_plan: FromPrimitive::from_i64(zone_plan).unwrap(),
http: http,
origin: origin,
country: FromPrimitive::from_i64(country).unwrap(),
cache_status: FromPrimitive::from_i64(cache_status).unwrap(),
server_ip: server_ip,
server_name: server_name,
remote_ip: remote_ip,
bytes_dlv: FromPrimitive::from_i64(bytes_dlv).unwrap(),
ray_id: ray_id,
}
}
//////////////////////////////////////////////////////////////////////////////
#[bench]
fn bench_deserializer(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
@@ -1588,107 +1210,3 @@ fn bench_deserializer(b: &mut Bencher) {
let _log: Log = json::from_str(JSON_STR).unwrap();
});
}
#[bench]
fn bench_deserializers(b: &mut Bencher) {
let s = r#"{"timestamp":25469139677502,"zone_id":123456,"zone_plan":1,"http":{"protocol":2,"status":200,"host_status":503,"up_status":520,"method":1,"content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":2},"country":238,"cache_status":3,"server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
b.bytes = s.len() as u64;
for _ in range(0is, 10000) {
let _log: Log = json::from_str(s).unwrap();
}
}
//////////////////////////////////////////////////////////////////////////////
#[test]
fn test_reader_manual_deserializer() {
let mut rdr = JSON_STR.as_bytes();
let log = manual_reader_deserialize(&mut rdr);
assert_eq!(log, Log::new());
}
#[bench]
fn bench_reader_manual_reader_deserializer(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
b.iter(|| {
let mut rdr = JSON_STR.as_bytes();
let _ = manual_reader_deserialize(&mut rdr);
});
}
#[bench]
fn bench_reader_manual_reader_deserializers(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
for _ in range(0is, 100000) {
let mut rdr = JSON_STR.as_bytes();
let _ = manual_reader_deserialize(&mut rdr);
}
}
//////////////////////////////////////////////////////////////////////////////
#[test]
fn test_iter_manual_iter_deserializer() {
let log = manual_iter_deserialize(JSON_STR.bytes());
assert_eq!(log, Log::new());
}
#[bench]
fn bench_iter_manual_iter_deserializer(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
b.iter(|| {
let _ = manual_iter_deserialize(JSON_STR.bytes());
});
}
#[bench]
fn bench_iter_manual_iter_deserializers(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
for _ in range(0is, 10000) {
let _ = manual_iter_deserialize(JSON_STR.bytes());
}
}
//////////////////////////////////////////////////////////////////////////////
#[test]
fn test_iter_manual_reader_as_iter_deserializer() {
let rdr = JSON_STR.as_bytes();
let iter = rdr.bytes().map(|x| x.unwrap());
let log = manual_iter_deserialize(iter);
assert_eq!(log, Log::new());
}
#[bench]
fn bench_iter_manual_reader_as_iter_deserializer(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
b.iter(|| {
let rdr = JSON_STR.as_bytes();
let iter = rdr.bytes().map(|x| x.unwrap());
let _ = manual_iter_deserialize(iter);
});
}
#[bench]
fn bench_iter_manual_reader_as_iter_deserializers(b: &mut Bencher) {
b.bytes = JSON_STR.len() as u64;
for _ in range(0is, 10000) {
let rdr = JSON_STR.as_bytes();
let iter = rdr.bytes().map(|x| x.unwrap());
let _ = manual_iter_deserialize(iter);
}
}
benches/bench_map.rs
+108 -43
View File
@@ -1,4 +1,4 @@
#![feature(core, plugin, test)]
#![feature(custom_derive, core, plugin, test)]
#![plugin(serde_macros)]
extern crate serde;
@@ -19,7 +19,17 @@ use serde::de::{Deserializer, Deserialize};
pub enum Error {
EndOfStream,
SyntaxError,
OtherError(String),
MissingField,
}
impl serde::de::Error for Error {
fn syntax_error() -> Error { Error::SyntaxError }
fn end_of_stream_error() -> Error { Error::EndOfStream }
fn missing_field_error(_: &'static str) -> Error {
Error::MissingField
}
}
//////////////////////////////////////////////////////////////////////////////
@@ -30,7 +40,6 @@ mod decoder {
use rustc_serialize;
use super::Error;
use super::Error::{EndOfStream, SyntaxError, OtherError};
use self::Value::{StringValue, IsizeValue};
enum Value {
@@ -58,39 +67,39 @@ mod decoder {
impl rustc_serialize::Decoder for IsizeDecoder {
type Error = Error;
fn error(&mut self, msg: &str) -> Error {
OtherError(msg.to_string())
fn error(&mut self, _msg: &str) -> Error {
Error::SyntaxError
}
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_usize(&mut self) -> Result<usize, 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) }
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
#[inline]
fn read_isize(&mut self) -> Result<isize, Error> {
match self.stack.pop() {
Some(IsizeValue(x)) => Ok(x),
Some(_) => Err(SyntaxError),
None => Err(EndOfStream),
Some(_) => Err(Error::SyntaxError),
None => Err(Error::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_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::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),
Some(_) => Err(Error::SyntaxError),
None => Err(Error::EndOfStream),
}
}
@@ -165,19 +174,19 @@ mod decoder {
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
#[inline]
@@ -198,7 +207,7 @@ mod decoder {
f(self)
}
None => {
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
}
@@ -216,39 +225,94 @@ mod decoder {
mod deserializer {
use std::collections::HashMap;
use std::collections::hash_map::IntoIter;
use std::collections::hash_map;
use super::Error;
use super::Error::{EndOfStream, SyntaxError};
use self::State::{StartState, KeyOrEndState, ValueState, EndState};
use serde::de;
#[derive(PartialEq, Debug)]
enum State {
StartState,
KeyOrEndState,
KeyState(String),
ValueState(isize),
EndState,
}
pub struct IsizeDeserializer {
stack: Vec<State>,
len: usize,
iter: IntoIter<String, isize>,
iter: hash_map::IntoIter<String, isize>,
}
impl IsizeDeserializer {
#[inline]
pub fn new(values: HashMap<String, isize>) -> IsizeDeserializer {
IsizeDeserializer {
stack: vec!(StartState),
len: values.len(),
stack: vec!(State::StartState),
iter: values.into_iter(),
}
}
}
impl de::Deserializer for IsizeDeserializer {
type Error = Error;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.stack.pop() {
Some(State::StartState) => {
visitor.visit_map(self)
}
Some(State::KeyState(key)) => {
visitor.visit_string(key)
}
Some(State::ValueState(value)) => {
visitor.visit_isize(value)
}
None => {
Err(Error::EndOfStream)
}
}
}
}
impl de::MapVisitor for IsizeDeserializer {
type Error = Error;
fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
where K: de::Deserialize,
{
match self.iter.next() {
Some((key, value)) => {
self.stack.push(State::ValueState(value));
self.stack.push(State::KeyState(key));
Ok(Some(try!(de::Deserialize::deserialize(self))))
}
None => {
Ok(None)
}
}
}
fn visit_value<V>(&mut self) -> Result<V, Error>
where V: de::Deserialize,
{
de::Deserialize::deserialize(self)
}
fn end(&mut self) -> Result<(), Error> {
match self.iter.next() {
Some(_) => Err(Error::SyntaxError),
None => Ok(()),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
/*
impl Iterator for IsizeDeserializer {
type Item = Result<de::Token, Error>;
@@ -310,9 +374,10 @@ mod deserializer {
fn missing_field<
T: de::Deserialize<IsizeDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
*/
}
//////////////////////////////////////////////////////////////////////////////
@@ -338,7 +403,7 @@ fn bench_decoder_000(b: &mut Bencher) {
fn bench_decoder_003(b: &mut Bencher) {
b.iter(|| {
let mut m: HashMap<String, isize> = HashMap::new();
for i in range(0is, 3) {
for i in range(0, 3) {
m.insert(i.to_string(), i);
}
run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -349,7 +414,7 @@ fn bench_decoder_003(b: &mut Bencher) {
fn bench_decoder_100(b: &mut Bencher) {
b.iter(|| {
let mut m: HashMap<String, isize> = HashMap::new();
for i in range(0is, 100) {
for i in range(0, 100) {
m.insert(i.to_string(), i);
}
run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -357,9 +422,9 @@ fn bench_decoder_100(b: &mut Bencher) {
}
fn run_deserializer<
D: Deserializer<E>,
D: Deserializer<Error=E>,
E: Debug,
T: Clone + PartialEq + Debug + Deserialize<D, E>
T: Clone + PartialEq + Debug + Deserialize
>(mut d: D, value: T) {
let v: T = Deserialize::deserialize(&mut d).unwrap();
@@ -378,7 +443,7 @@ fn bench_deserializer_000(b: &mut Bencher) {
fn bench_deserializer_003(b: &mut Bencher) {
b.iter(|| {
let mut m: HashMap<String, isize> = HashMap::new();
for i in range(0is, 3) {
for i in range(0, 3) {
m.insert(i.to_string(), i);
}
run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
@@ -389,7 +454,7 @@ fn bench_deserializer_003(b: &mut Bencher) {
fn bench_deserializer_100(b: &mut Bencher) {
b.iter(|| {
let mut m: HashMap<String, isize> = HashMap::new();
for i in range(0is, 100) {
for i in range(0, 100) {
m.insert(i.to_string(), i);
}
run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
benches/bench_struct.rs
+266 -130
View File
@@ -1,4 +1,4 @@
#![feature(plugin, test)]
#![feature(custom_derive, plugin, test)]
#![plugin(serde_macros)]
extern crate serde;
@@ -35,11 +35,21 @@ struct Outer {
#[derive(Debug)]
pub enum Error {
EndOfStream,
SyntaxError(String),
UnexpectedName(String),
ConversionError(String),
MissingField(&'static str),
OtherError(String),
SyntaxError,
UnexpectedName,
ConversionError,
MissingField,
OtherError,
}
impl serde::de::Error for Error {
fn syntax_error() -> Error { Error::SyntaxError }
fn end_of_stream_error() -> Error { Error::EndOfStream }
fn missing_field_error(_: &'static str) -> Error {
Error::MissingField
}
}
mod decoder {
@@ -92,8 +102,8 @@ mod decoder {
impl Decoder for OuterDecoder {
type Error = Error;
fn error(&mut self, msg: &str) -> Error {
Error::OtherError(msg.to_string())
fn error(&mut self, _msg: &str) -> Error {
Error::OtherError
}
// Primitive types:
@@ -101,40 +111,40 @@ mod decoder {
fn read_nil(&mut self) -> Result<(), Error> {
match self.stack.pop() {
Some(NullState) => Ok(()),
_ => Err(Error::SyntaxError("NullState".to_string())),
_ => Err(Error::SyntaxError),
}
}
#[inline]
fn read_usize(&mut self) -> Result<usize, Error> {
match self.stack.pop() {
Some(UsizeState(value)) => Ok(value),
_ => Err(Error::SyntaxError("UintState".to_string())),
_ => Err(Error::SyntaxError),
}
}
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
#[inline]
fn read_char(&mut self) -> Result<char, Error> {
match self.stack.pop() {
Some(CharState(c)) => Ok(c),
_ => Err(Error::SyntaxError("".to_string())),
_ => Err(Error::SyntaxError),
}
}
#[inline]
fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() {
Some(StringState(value)) => Ok(value),
_ => Err(Error::SyntaxError("".to_string())),
_ => Err(Error::SyntaxError),
}
}
@@ -142,31 +152,31 @@ mod decoder {
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
#[inline]
@@ -180,7 +190,7 @@ mod decoder {
self.stack.push(FieldState("inner"));
f(self)
} else {
Err(Error::SyntaxError("expected Outer".to_string()))
Err(Error::SyntaxError)
}
}
Some(InnerState(Inner { a: (), b, c })) => {
@@ -195,10 +205,10 @@ mod decoder {
self.stack.push(FieldState("a"));
f(self)
} else {
Err(Error::SyntaxError("expected Inner".to_string()))
Err(Error::SyntaxError)
}
}
_ => Err(Error::SyntaxError("expected InnerState or OuterState".to_string())),
_ => Err(Error::SyntaxError),
}
}
#[inline]
@@ -210,35 +220,35 @@ mod decoder {
if f_name == name {
f(self)
} else {
Err(Error::SyntaxError("expected FieldState".to_string()))
Err(Error::SyntaxError)
}
}
_ => Err(Error::SyntaxError("expected FieldState".to_string()))
_ => Err(Error::SyntaxError)
}
}
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError("".to_string()))
Err(Error::SyntaxError)
}
// Specialized types:
@@ -248,7 +258,7 @@ mod decoder {
{
match self.stack.pop() {
Some(OptionState(b)) => f(self, b),
_ => Err(Error::SyntaxError("expected OptionState".to_string())),
_ => Err(Error::SyntaxError),
}
}
@@ -264,7 +274,7 @@ mod decoder {
}
f(self, len)
}
_ => Err(Error::SyntaxError("expected VecState".to_string()))
_ => Err(Error::SyntaxError)
}
}
#[inline]
@@ -295,7 +305,7 @@ mod decoder {
}
f(self, len)
}
_ => Err(Error::SyntaxError("expected MapState".to_string())),
_ => Err(Error::SyntaxError),
}
}
#[inline]
@@ -318,39 +328,24 @@ mod decoder {
mod deserializer {
use std::collections::HashMap;
use std::collections::hash_map;
use std::vec;
use super::{Outer, Inner};
use super::Error;
use serde::de;
use self::State::{
OuterState,
InnerState,
FieldState,
NullState,
UsizeState,
CharState,
StringState,
OptionState,
//TupleState(usize),
VecState,
MapState,
EndState,
};
#[derive(Debug)]
enum State {
OuterState(Outer),
InnerState(Inner),
FieldState(&'static str),
StrState(&'static str),
NullState,
UsizeState(usize),
CharState(char),
StringState(String),
OptionState(bool),
//TupleState(uint),
VecState(Vec<Inner>),
MapState(HashMap<String, Option<char>>),
EndState,
}
pub struct OuterDeserializer {
@@ -361,101 +356,242 @@ mod deserializer {
#[inline]
pub fn new(outer: Outer) -> OuterDeserializer {
OuterDeserializer {
stack: vec!(OuterState(outer)),
stack: vec!(State::OuterState(outer)),
}
}
}
impl Iterator for OuterDeserializer {
type Item = Result<de::Token, Error>;
impl de::Deserializer for OuterDeserializer {
type Error = Error;
#[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> {
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
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::Token::StructStart("Outer", 1)))
}
Some(InnerState(Inner { a: (), b, c })) => {
self.stack.push(EndState);
self.stack.push(MapState(c));
self.stack.push(FieldState("c"));
Some(State::OuterState(Outer { inner })) => {
self.stack.push(State::VecState(inner));
self.stack.push(State::StrState("inner"));
self.stack.push(UsizeState(b));
self.stack.push(FieldState("b"));
visitor.visit_named_map("Outer", OuterMapVisitor {
de: self,
state: 0,
})
}
Some(State::InnerState(Inner { a: (), b, c })) => {
self.stack.push(State::MapState(c));
self.stack.push(State::StrState("c"));
self.stack.push(NullState);
self.stack.push(FieldState("a"));
Some(Ok(de::Token::StructStart("Inner", 3)))
self.stack.push(State::UsizeState(b));
self.stack.push(State::StrState("b"));
self.stack.push(State::NullState);
self.stack.push(State::StrState("a"));
visitor.visit_named_map("Inner", InnerMapVisitor {
de: self,
state: 0,
})
}
Some(FieldState(name)) => Some(Ok(de::Token::Str(name))),
Some(VecState(value)) => {
self.stack.push(EndState);
let len = value.len();
for inner in value.into_iter().rev() {
self.stack.push(InnerState(inner));
}
Some(Ok(de::Token::SeqStart(len)))
Some(State::VecState(value)) => {
visitor.visit_seq(OuterSeqVisitor {
de: self,
iter: value.into_iter(),
})
}
Some(MapState(value)) => {
self.stack.push(EndState);
let len = value.len();
for (key, value) in value {
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::Token::MapStart(len)))
Some(State::MapState(value)) => {
visitor.visit_map(MapVisitor {
de: self,
iter: value.into_iter(),
})
}
//Some(TupleState(len)) => Some(Ok(de::Token::TupleStart(len))),
Some(NullState) => Some(Ok(de::Token::Null)),
Some(UsizeState(x)) => Some(Ok(de::Token::Usize(x))),
Some(CharState(x)) => Some(Ok(de::Token::Char(x))),
Some(StringState(x)) => Some(Ok(de::Token::String(x))),
Some(OptionState(x)) => Some(Ok(de::Token::Option(x))),
Some(EndState) => {
Some(Ok(de::Token::End))
Some(State::NullState) => {
visitor.visit_unit()
}
None => None,
Some(State::UsizeState(x)) => {
visitor.visit_usize(x)
}
Some(State::CharState(x)) => {
visitor.visit_char(x)
}
Some(State::StrState(x)) => {
visitor.visit_str(x)
}
Some(State::StringState(x)) => {
visitor.visit_string(x)
}
Some(State::OptionState(false)) => {
visitor.visit_none()
}
Some(State::OptionState(true)) => {
visitor.visit_some(self)
}
None => Err(Error::EndOfStream),
}
}
}
impl de::Deserializer<Error> for OuterDeserializer {
#[inline]
fn end_of_stream_error(&mut self) -> Error {
Error::EndOfStream
struct OuterMapVisitor<'a> {
de: &'a mut OuterDeserializer,
state: usize,
}
impl<'a> de::MapVisitor for OuterMapVisitor<'a> {
type Error = Error;
fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
where K: de::Deserialize,
{
match self.state {
0 => {
self.state += 1;
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
_ => {
Ok(None)
}
}
}
#[inline]
fn syntax_error(&mut self, token: de::Token, expected: &[de::TokenKind]) -> Error {
Error::SyntaxError(format!("expected {:?}, found {:?}", expected, token))
fn visit_value<V>(&mut self) -> Result<V, Error>
where V: de::Deserialize,
{
de::Deserialize::deserialize(self.de)
}
#[inline]
fn unexpected_name_error(&mut self, token: de::Token) -> Error {
Error::UnexpectedName(format!("found {:?}", token))
fn end(&mut self) -> Result<(), Error> {
if self.state == 1 {
Ok(())
} else {
Err(Error::SyntaxError)
}
}
#[inline]
fn conversion_error(&mut self, token: de::Token) -> Error {
Error::UnexpectedName(format!("found {:?}", token))
fn size_hint(&self) -> (usize, Option<usize>) {
let len = 1 - self.state;
(len, Some(len))
}
}
struct OuterSeqVisitor<'a> {
de: &'a mut OuterDeserializer,
iter: vec::IntoIter<Inner>,
}
impl<'a> de::SeqVisitor for OuterSeqVisitor<'a> {
type Error = Error;
fn visit<T>(&mut self) -> Result<Option<T>, Error>
where T: de::Deserialize,
{
match self.iter.next() {
Some(value) => {
self.de.stack.push(State::InnerState(value));
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
None => {
Ok(None)
}
}
}
#[inline]
fn missing_field<
T: de::Deserialize<OuterDeserializer, Error>
>(&mut self, field: &'static str) -> Result<T, Error> {
Err(Error::MissingField(field))
fn end(&mut self) -> Result<(), Error> {
match self.iter.next() {
Some(_) => Err(Error::SyntaxError),
None => Ok(()),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
struct InnerMapVisitor<'a> {
de: &'a mut OuterDeserializer,
state: usize,
}
impl<'a> de::MapVisitor for InnerMapVisitor<'a> {
type Error = Error;
fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
where K: de::Deserialize,
{
match self.state {
0 ... 2 => {
self.state += 1;
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
_ => {
Ok(None)
}
}
}
fn visit_value<V>(&mut self) -> Result<V, Error>
where V: de::Deserialize,
{
de::Deserialize::deserialize(self.de)
}
fn end(&mut self) -> Result<(), Error> {
if self.state == 1 {
Ok(())
} else {
Err(Error::SyntaxError)
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
let len = 1 - self.state;
(len, Some(len))
}
}
struct MapVisitor<'a> {
de: &'a mut OuterDeserializer,
iter: hash_map::IntoIter<String, Option<char>>,
}
impl<'a> de::MapVisitor for MapVisitor<'a> {
type Error = Error;
fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
where K: de::Deserialize,
{
match self.iter.next() {
Some((key, Some(value))) => {
self.de.stack.push(State::CharState(value));
self.de.stack.push(State::OptionState(true));
self.de.stack.push(State::StringState(key));
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
Some((key, None)) => {
self.de.stack.push(State::OptionState(false));
self.de.stack.push(State::StringState(key));
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
None => {
Ok(None)
}
}
}
fn visit_value<V>(&mut self) -> Result<V, Error>
where V: de::Deserialize,
{
de::Deserialize::deserialize(self.de)
}
fn end(&mut self) -> Result<(), Error> {
match self.iter.next() {
Some(_) => Err(Error::SyntaxError),
None => Ok(()),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
}
benches/bench_vec.rs
+192 -202
View File
@@ -16,9 +16,16 @@ use serde::de::{Deserializer, Deserialize};
#[derive(PartialEq, Debug)]
pub enum Error {
EndOfStream,
EndOfStreamError,
SyntaxError,
OtherError(String),
}
impl serde::de::Error for Error {
fn syntax_error() -> Error { Error::SyntaxError }
fn end_of_stream_error() -> Error { Error::EndOfStreamError }
fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
}
//////////////////////////////////////////////////////////////////////////////
@@ -28,158 +35,155 @@ mod decoder {
use rustc_serialize;
use super::Error;
use super::Error::{EndOfStream, SyntaxError, OtherError};
pub struct IsizeDecoder {
pub struct UsizeDecoder {
len: usize,
iter: vec::IntoIter<isize>,
iter: vec::IntoIter<usize>,
}
impl IsizeDecoder {
impl UsizeDecoder {
#[inline]
pub fn new(values: Vec<isize>) -> IsizeDecoder {
IsizeDecoder {
pub fn new(values: Vec<usize>) -> UsizeDecoder {
UsizeDecoder {
len: values.len(),
iter: values.into_iter(),
}
}
}
impl rustc_serialize::Decoder for IsizeDecoder {
impl rustc_serialize::Decoder for UsizeDecoder {
type Error = Error;
fn error(&mut self, msg: &str) -> Error {
OtherError(msg.to_string())
}
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_usize(&mut self) -> Result<usize, 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) }
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
#[inline]
fn read_isize(&mut self) -> Result<isize, Error> {
fn read_usize(&mut self) -> Result<usize, Error> {
match self.iter.next() {
Some(value) => Ok(value),
None => Err(EndOfStream),
None => Err(Error::EndOfStreamError),
}
}
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) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) }
// Compound types:
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(Error::SyntaxError)
}
// Specialized types:
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
#[inline]
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{
let len = self.len;
f(self, len)
}
#[inline]
fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
f(self)
}
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
@@ -202,34 +206,32 @@ mod decoder {
impl rustc_serialize::Decoder for U8Decoder {
type Error = Error;
fn error(&mut self, msg: &str) -> Error {
OtherError(msg.to_string())
}
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
// Primitive types:
fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
fn read_usize(&mut self) -> Result<usize, 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_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
#[inline]
fn read_u8(&mut self) -> Result<u8, Error> {
match self.iter.next() {
Some(value) => Ok(value),
None => Err(EndOfStream),
None => Err(Error::EndOfStreamError),
}
}
#[inline]
fn read_isize(&mut self) -> Result<isize, 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) }
fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) }
// Compound types:
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
@@ -302,7 +304,7 @@ mod decoder {
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
#[inline]
@@ -322,19 +324,19 @@ mod decoder {
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
{
Err(SyntaxError)
Err(Error::SyntaxError)
}
}
}
@@ -346,8 +348,6 @@ mod deserializer {
use std::vec;
use super::Error;
use super::Error::{EndOfStream, SyntaxError};
use self::State::{StartState, SepOrEndState, EndState};
use serde::de;
@@ -358,151 +358,141 @@ mod deserializer {
EndState,
}
pub struct IsizeDeserializer {
pub struct Deserializer<A> {
state: State,
iter: vec::IntoIter<A>,
len: usize,
iter: vec::IntoIter<isize>,
value: Option<A>,
}
impl IsizeDeserializer {
impl<A> Deserializer<A> {
#[inline]
pub fn new(values: Vec<isize>) -> IsizeDeserializer {
IsizeDeserializer {
state: StartState,
len: values.len(),
pub fn new(values: Vec<A>) -> Deserializer<A> {
let len = values.len();
Deserializer {
state: State::StartState,
iter: values.into_iter(),
len: len,
value: None,
}
}
}
impl Iterator for IsizeDeserializer {
type Item = Result<de::Token, Error>;
impl de::Deserializer for Deserializer<usize> {
type Error = Error;
#[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> {
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.state {
StartState => {
self.state = SepOrEndState;
Some(Ok(de::Token::SeqStart(self.len)))
State::StartState => {
self.state = State::SepOrEndState;
visitor.visit_seq(self)
}
SepOrEndState => {
match self.iter.next() {
Some(value) => {
Some(Ok(de::Token::Isize(value)))
}
None => {
self.state = EndState;
Some(Ok(de::Token::End))
}
}
State::SepOrEndState => {
visitor.visit_usize(self.value.take().unwrap())
}
EndState => {
None
State::EndState => {
Err(Error::EndOfStreamError)
}
}
}
}
impl de::Deserializer<Error> for IsizeDeserializer {
#[inline]
fn end_of_stream_error(&mut self) -> Error {
EndOfStream
}
impl de::SeqVisitor for Deserializer<usize> {
type Error = Error;
#[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::Deserialize<IsizeDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
}
}
pub struct U8Deserializer {
state: State,
len: usize,
iter: vec::IntoIter<u8>,
}
impl U8Deserializer {
#[inline]
pub fn new(values: Vec<u8>) -> U8Deserializer {
U8Deserializer {
state: StartState,
len: values.len(),
iter: values.into_iter(),
fn visit<T>(&mut self) -> Result<Option<T>, Error>
where T: de::Deserialize,
{
match self.iter.next() {
Some(value) => {
self.len -= 1;
self.value = Some(value);
Ok(Some(try!(de::Deserialize::deserialize(self))))
}
None => {
self.state = State::EndState;
Ok(None)
}
}
}
}
impl Iterator for U8Deserializer {
type Item = Result<de::Token, Error>;
#[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> {
fn end(&mut self) -> Result<(), Error> {
match self.iter.next() {
Some(_) => Err(Error::SyntaxError),
None => {
self.state = State::EndState;
Ok(())
}
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
}
}
impl de::Deserializer for Deserializer<u8> {
type Error = Error;
#[inline]
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.state {
StartState => {
self.state = SepOrEndState;
Some(Ok(de::Token::SeqStart(self.len)))
State::StartState => {
self.state = State::SepOrEndState;
visitor.visit_seq(self)
}
SepOrEndState => {
match self.iter.next() {
Some(value) => {
Some(Ok(de::Token::U8(value)))
}
None => {
self.state = EndState;
Some(Ok(de::Token::End))
}
}
State::SepOrEndState => {
visitor.visit_u8(self.value.take().unwrap())
}
EndState => {
None
State::EndState => {
Err(Error::EndOfStreamError)
}
}
}
}
impl de::Deserializer<Error> for U8Deserializer {
impl de::SeqVisitor for Deserializer<u8> {
type Error = Error;
#[inline]
fn end_of_stream_error(&mut self) -> Error {
EndOfStream
fn visit<T>(&mut self) -> Result<Option<T>, Error>
where T: de::Deserialize,
{
match self.iter.next() {
Some(value) => {
self.len -= 1;
self.value = Some(value);
Ok(Some(try!(de::Deserialize::deserialize(self))))
}
None => {
self.state = State::EndState;
Ok(None)
}
}
}
#[inline]
fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
SyntaxError
fn end(&mut self) -> Result<(), Error> {
match self.iter.next() {
Some(_) => Err(Error::SyntaxError),
None => {
self.state = State::EndState;
Ok(())
}
}
}
#[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::Deserialize<U8Deserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
}
}
}
@@ -519,9 +509,9 @@ fn run_decoder<
}
fn run_deserializer<
D: Deserializer<E>,
D: Deserializer<Error=E>,
E: Debug,
T: Clone + PartialEq + Debug + Deserialize<D, E>
T: Clone + PartialEq + Debug + Deserialize
>(mut d: D, value: T) {
let v: T = Deserialize::deserialize(&mut d).unwrap();
@@ -529,26 +519,26 @@ fn run_deserializer<
}
#[bench]
fn bench_decoder_int_000(b: &mut Bencher) {
fn bench_decoder_usize_000(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = vec!();
run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
let v: Vec<usize> = vec!();
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
})
}
#[bench]
fn bench_decoder_int_003(b: &mut Bencher) {
fn bench_decoder_usize_003(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = vec!(1, 2, 3);
run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
let v: Vec<usize> = vec!(1, 2, 3);
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
})
}
#[bench]
fn bench_decoder_int_100(b: &mut Bencher) {
fn bench_decoder_usize_100(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = range(0is, 100).collect();
run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
let v: Vec<usize> = range(0, 100).collect();
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
})
}
@@ -577,26 +567,26 @@ fn bench_decoder_u8_100(b: &mut Bencher) {
}
#[bench]
fn bench_deserializer_int_000(b: &mut Bencher) {
fn bench_deserializer_usize_000(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = vec!();
run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
let v: Vec<usize> = vec!();
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
#[bench]
fn bench_deserializer_int_003(b: &mut Bencher) {
fn bench_deserializer_usize_003(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = vec!(1, 2, 3);
run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
let v: Vec<usize> = vec!(1, 2, 3);
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
#[bench]
fn bench_deserializer_int_100(b: &mut Bencher) {
fn bench_deserializer_usize_100(b: &mut Bencher) {
b.iter(|| {
let v: Vec<isize> = range(0is, 100).collect();
run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
let v: Vec<usize> = range(0, 100).collect();
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
@@ -604,7 +594,7 @@ fn bench_deserializer_int_100(b: &mut Bencher) {
fn bench_deserializer_u8_000(b: &mut Bencher) {
b.iter(|| {
let v: Vec<u8> = vec!();
run_deserializer(deserializer::U8Deserializer::new(v.clone()), v)
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
@@ -612,7 +602,7 @@ fn bench_deserializer_u8_000(b: &mut Bencher) {
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)
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
@@ -620,6 +610,6 @@ fn bench_deserializer_u8_003(b: &mut Bencher) {
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)
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
})
}
benches/json.rs
-311
View File
@@ -1,311 +0,0 @@
#![feature(core, plugin, test)]
#![plugin(serde_macros)]
extern crate serde;
extern crate "rustc-serialize" as rustc_serialize;
extern crate test;
use std::collections::BTreeMap;
use std::string;
use rustc_serialize as serialize;
use test::Bencher;
use serde::de::Token;
use serde::json::{Parser, Value, from_str};
macro_rules! treemap {
($($k:expr => $v:expr),*) => ({
let mut _m = ::std::collections::BTreeMap::new();
$(_m.insert($k, $v);)*
_m
})
}
fn json_str(count: usize) -> string::String {
let mut src = "[".to_string();
for _ in range(0, count) {
src.push_str(r#"{"a":true,"b":null,"c":3.1415,"d":"Hello world","e":[1,2,3]},"#);
}
src.push_str("{}]");
src
}
fn pretty_json_str(count: usize) -> string::String {
let mut src = "[\n".to_string();
for _ in range(0, count) {
src.push_str(
concat!(
" {\n",
" \"a\": true,\n",
" \"b\": null,\n",
" \"c\": 3.1415,\n",
" \"d\": \"Hello world\",\n",
" \"e\": [\n",
" 1,\n",
" 2,\n",
" 3\n",
" ]\n",
" },\n"
)
);
}
src.push_str(" {}\n]");
src
}
fn encoder_json(count: usize) -> serialize::json::Json {
use rustc_serialize::json::Json;
let mut list = vec!();
for _ in range(0, count) {
list.push(Json::Object(treemap!(
"a".to_string() => Json::Boolean(true),
"b".to_string() => Json::Null,
"c".to_string() => Json::F64(3.1415),
"d".to_string() => Json::String("Hello world".to_string()),
"e".to_string() => Json::Array(vec!(
Json::U64(1),
Json::U64(2),
Json::U64(3)
))
)));
}
list.push(Json::Object(BTreeMap::new()));
Json::Array(list)
}
fn serializer_json(count: usize) -> Value {
let mut list = vec!();
for _ in range(0, count) {
list.push(Value::Object(treemap!(
"a".to_string() => Value::Boolean(true),
"b".to_string() => Value::Null,
"c".to_string() => Value::Floating(3.1415),
"d".to_string() => Value::String("Hello world".to_string()),
"e".to_string() => Value::Array(vec!(
Value::Integer(1),
Value::Integer(2),
Value::Integer(3)
))
)));
}
list.push(Value::Object(BTreeMap::new()));
Value::Array(list)
}
fn bench_encoder(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
b.iter(|| {
assert_eq!(json.to_string(), src);
});
}
fn bench_encoder_pretty(b: &mut Bencher, count: usize) {
let src = pretty_json_str(count);
let json = encoder_json(count);
b.iter(|| {
assert_eq!(json.pretty().to_string(), src);
});
}
fn bench_serializer(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = serializer_json(count);
b.iter(|| {
assert_eq!(json.to_string(), src);
});
}
fn bench_serializer_pretty(b: &mut Bencher, count: usize) {
let src = pretty_json_str(count);
let json = serializer_json(count);
b.iter(|| {
assert_eq!(json.to_pretty_string(), src);
});
}
fn bench_decoder(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
b.iter(|| {
assert_eq!(json, serialize::json::Json::from_str(&src).unwrap());
});
}
fn bench_deserializer(b: &mut Bencher, count: usize) {
let src = json_str(count);
let json = encoder_json(count);
b.iter(|| {
assert_eq!(json, serialize::json::Json::from_str(&src).unwrap());
});
}
fn bench_decoder_streaming(b: &mut Bencher, count: usize) {
let src = json_str(count);
b.iter( || {
use rustc_serialize::json::{Parser, JsonEvent, StackElement};
let mut parser = Parser::new(src.chars());
assert_eq!(parser.next(), Some(JsonEvent::ArrayStart));
for _ in range(0, count) {
assert_eq!(parser.next(), Some(JsonEvent::ObjectStart));
assert_eq!(parser.next(), Some(JsonEvent::BooleanValue(true)));
assert_eq!(parser.stack().top(), Some(StackElement::Key("a")));
assert_eq!(parser.next(), Some(JsonEvent::NullValue));
assert_eq!(parser.stack().top(), Some(StackElement::Key("b")));
assert_eq!(parser.next(), Some(JsonEvent::F64Value(3.1415)));
assert_eq!(parser.stack().top(), Some(StackElement::Key("c")));
assert_eq!(parser.next(), Some(JsonEvent::StringValue("Hello world".to_string())));
assert_eq!(parser.stack().top(), Some(StackElement::Key("d")));
assert_eq!(parser.next(), Some(JsonEvent::ArrayStart));
assert_eq!(parser.stack().top(), Some(StackElement::Key("e")));
assert_eq!(parser.next(), Some(JsonEvent::U64Value(1)));
assert_eq!(parser.next(), Some(JsonEvent::U64Value(2)));
assert_eq!(parser.next(), Some(JsonEvent::U64Value(3)));
assert_eq!(parser.next(), Some(JsonEvent::ArrayEnd));
assert_eq!(parser.next(), Some(JsonEvent::ObjectEnd));
}
assert_eq!(parser.next(), Some(JsonEvent::ObjectStart));
assert_eq!(parser.next(), Some(JsonEvent::ObjectEnd));
assert_eq!(parser.next(), Some(JsonEvent::ArrayEnd));
assert_eq!(parser.next(), None);
});
}
fn bench_deserializer_streaming(b: &mut Bencher, count: usize) {
let src = json_str(count);
b.iter( || {
let mut parser = Parser::new(src.bytes());
assert_eq!(parser.next(), Some(Ok(Token::SeqStart(0))));
for _ in range(0, count) {
assert_eq!(parser.next(), Some(Ok(Token::MapStart(0))));
assert_eq!(parser.next(), Some(Ok(Token::String("a".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::Bool(true))));
assert_eq!(parser.next(), Some(Ok(Token::String("b".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::Null)));
assert_eq!(parser.next(), Some(Ok(Token::String("c".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::F64(3.1415))));
assert_eq!(parser.next(), Some(Ok(Token::String("d".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::String("Hello world".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::String("e".to_string()))));
assert_eq!(parser.next(), Some(Ok(Token::SeqStart(0))));
assert_eq!(parser.next(), Some(Ok(Token::I64(1))));
assert_eq!(parser.next(), Some(Ok(Token::I64(2))));
assert_eq!(parser.next(), Some(Ok(Token::I64(3))));
assert_eq!(parser.next(), Some(Ok(Token::End)));
assert_eq!(parser.next(), Some(Ok(Token::End)));
}
assert_eq!(parser.next(), Some(Ok(Token::MapStart(0))));
assert_eq!(parser.next(), Some(Ok(Token::End)));
assert_eq!(parser.next(), Some(Ok(Token::End)));
assert_eq!(parser.next(), None);
loop {
match parser.next() {
None => return,
Some(Ok(_)) => { }
Some(Err(err)) => { panic!("error: {:?}", err); }
}
}
});
}
#[bench]
fn bench_encoder_001(b: &mut Bencher) {
bench_encoder(b, 1)
}
#[bench]
fn bench_encoder_500(b: &mut Bencher) {
bench_encoder(b, 500)
}
#[bench]
fn bench_encoder_001_pretty(b: &mut Bencher) {
bench_encoder_pretty(b, 1)
}
#[bench]
fn bench_encoder_500_pretty(b: &mut Bencher) {
bench_encoder_pretty(b, 500)
}
#[bench]
fn bench_serializer_001(b: &mut Bencher) {
bench_serializer(b, 1)
}
#[bench]
fn bench_serializer_500(b: &mut Bencher) {
bench_serializer(b, 500)
}
#[bench]
fn bench_serializer_001_pretty(b: &mut Bencher) {
bench_serializer_pretty(b, 1)
}
#[bench]
fn bench_serializer_500_pretty(b: &mut Bencher) {
bench_serializer_pretty(b, 500)
}
#[bench]
fn bench_decoder_001(b: &mut Bencher) {
bench_decoder(b, 1)
}
#[bench]
fn bench_decoder_500(b: &mut Bencher) {
bench_decoder(b, 500)
}
#[bench]
fn bench_deserializer_001(b: &mut Bencher) {
bench_deserializer(b, 1)
}
#[bench]
fn bench_deserializer_500(b: &mut Bencher) {
bench_deserializer(b, 500)
}
#[bench]
fn bench_decoder_001_streaming(b: &mut Bencher) {
bench_decoder_streaming(b, 1)
}
#[bench]
fn bench_decoder_500_streaming(b: &mut Bencher) {
bench_decoder_streaming(b, 500)
}
#[bench]
fn bench_deserializer_001_streaming(b: &mut Bencher) {
bench_deserializer_streaming(b, 1)
}
#[bench]
fn bench_deserializer_500_streaming(b: &mut Bencher) {
bench_deserializer_streaming(b, 500)
}