mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-06-13 09:01:01 +00:00
Restructure directories to prep for syntex
This commit is contained in:
Erick Tryzelaar
@@ -0,0 +1,18 @@
|
||||
[package]
|
||||
name = "serde_tests"
|
||||
version = "0.3.3"
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
|
||||
license = "MIT/Apache-2.0"
|
||||
description = "A generic serialization/deserialization framework"
|
||||
repository = "https://github.com/serde-rs/serde"
|
||||
documentation = "http://serde-rs.github.io/serde/serde"
|
||||
readme = "README.md"
|
||||
keywords = ["serialization"]
|
||||
|
||||
[dependencies]
|
||||
num = "*"
|
||||
|
||||
[dev-dependencies]
|
||||
rustc-serialize = "*"
|
||||
serde = { version = "*", path = "../serde" }
|
||||
serde_macros = { version = "*", path = "../serde_macros" }
|
||||
@@ -0,0 +1,454 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate serde;
|
||||
extern crate rustc_serialize;
|
||||
extern crate test;
|
||||
|
||||
use test::Bencher;
|
||||
|
||||
use rustc_serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
use Animal::{Dog, Frog};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
|
||||
pub enum Animal {
|
||||
Dog,
|
||||
Frog(String, isize)
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error {
|
||||
EndOfStreamError,
|
||||
SyntaxError,
|
||||
}
|
||||
|
||||
impl serde::de::Error for Error {
|
||||
fn syntax_error() -> Error { Error::SyntaxError }
|
||||
|
||||
fn end_of_stream_error() -> Error { Error::EndOfStreamError }
|
||||
|
||||
fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod decoder {
|
||||
use rustc_serialize::Decoder;
|
||||
|
||||
use super::{Animal, Error};
|
||||
use super::Animal::{Dog, Frog};
|
||||
use self::State::{AnimalState, IsizeState, StringState};
|
||||
|
||||
enum State {
|
||||
AnimalState(Animal),
|
||||
IsizeState(isize),
|
||||
StringState(String),
|
||||
}
|
||||
|
||||
pub struct AnimalDecoder {
|
||||
stack: Vec<State>,
|
||||
|
||||
}
|
||||
|
||||
impl AnimalDecoder {
|
||||
#[inline]
|
||||
pub fn new(animal: Animal) -> AnimalDecoder {
|
||||
AnimalDecoder {
|
||||
stack: vec!(AnimalState(animal)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Decoder for AnimalDecoder {
|
||||
type Error = Error;
|
||||
|
||||
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
// Primitive types:
|
||||
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(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) }
|
||||
#[inline]
|
||||
fn read_str(&mut self) -> Result<String, Error> {
|
||||
match self.stack.pop() {
|
||||
Some(StringState(x)) => Ok(x),
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
|
||||
// Compound types:
|
||||
#[inline]
|
||||
fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(AnimalState(animal)) => {
|
||||
self.stack.push(AnimalState(animal));
|
||||
if name == "Animal" {
|
||||
f(self)
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
_ => Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
let name = match self.stack.pop() {
|
||||
Some(AnimalState(Dog)) => "Dog",
|
||||
Some(AnimalState(Frog(x0, x1))) => {
|
||||
self.stack.push(IsizeState(x1));
|
||||
self.stack.push(StringState(x0));
|
||||
"Frog"
|
||||
}
|
||||
_ => { return Err(Error::SyntaxError); }
|
||||
};
|
||||
|
||||
let idx = match names.iter().position(|n| *n == name) {
|
||||
Some(idx) => idx,
|
||||
None => { return Err(Error::SyntaxError); }
|
||||
};
|
||||
|
||||
f(self, idx)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder, 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 AnimalDecoder) -> 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 AnimalDecoder) -> 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 AnimalDecoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder) -> 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 AnimalDecoder) -> 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 AnimalDecoder) -> 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 AnimalDecoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
// Specialized types:
|
||||
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
f(self, 3)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
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(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(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod deserializer {
|
||||
use super::{Animal, Error};
|
||||
|
||||
use serde::de;
|
||||
|
||||
#[derive(Debug)]
|
||||
enum State {
|
||||
AnimalState(Animal),
|
||||
IsizeState(isize),
|
||||
StrState(&'static str),
|
||||
StringState(String),
|
||||
UnitState,
|
||||
}
|
||||
|
||||
pub struct AnimalDeserializer {
|
||||
stack: Vec<State>,
|
||||
}
|
||||
|
||||
impl AnimalDeserializer {
|
||||
#[inline]
|
||||
pub fn new(animal: Animal) -> AnimalDeserializer {
|
||||
AnimalDeserializer {
|
||||
stack: vec!(State::AnimalState(animal)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl de::Deserializer for AnimalDeserializer {
|
||||
type Error = Error;
|
||||
|
||||
#[inline]
|
||||
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(State::IsizeState(value)) => {
|
||||
visitor.visit_isize(value)
|
||||
}
|
||||
Some(State::StringState(value)) => {
|
||||
visitor.visit_string(value)
|
||||
}
|
||||
Some(State::StrState(value)) => {
|
||||
visitor.visit_str(value)
|
||||
}
|
||||
Some(State::UnitState) => {
|
||||
visitor.visit_unit()
|
||||
}
|
||||
Some(_) => {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
None => {
|
||||
Err(Error::EndOfStreamError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::EnumVisitor,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(State::AnimalState(Animal::Dog)) => {
|
||||
self.stack.push(State::UnitState);
|
||||
self.stack.push(State::StrState("Dog"));
|
||||
visitor.visit(DogVisitor {
|
||||
de: self,
|
||||
})
|
||||
}
|
||||
Some(State::AnimalState(Animal::Frog(x0, x1))) => {
|
||||
self.stack.push(State::IsizeState(x1));
|
||||
self.stack.push(State::StringState(x0));
|
||||
self.stack.push(State::StrState("Frog"));
|
||||
visitor.visit(FrogVisitor {
|
||||
de: self,
|
||||
state: 0,
|
||||
})
|
||||
}
|
||||
Some(_) => {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
None => {
|
||||
Err(Error::EndOfStreamError)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DogVisitor<'a> {
|
||||
de: &'a mut AnimalDeserializer,
|
||||
}
|
||||
|
||||
impl<'a> de::VariantVisitor for DogVisitor<'a> {
|
||||
type Error = Error;
|
||||
|
||||
fn visit_variant<V>(&mut self) -> Result<V, Error>
|
||||
where V: de::Deserialize
|
||||
{
|
||||
de::Deserialize::deserialize(self.de)
|
||||
}
|
||||
|
||||
fn visit_unit(&mut self) -> Result<(), Error> {
|
||||
de::Deserialize::deserialize(self.de)
|
||||
}
|
||||
}
|
||||
|
||||
struct FrogVisitor<'a> {
|
||||
de: &'a mut AnimalDeserializer,
|
||||
state: usize,
|
||||
}
|
||||
|
||||
impl<'a> de::VariantVisitor for FrogVisitor<'a> {
|
||||
type Error = Error;
|
||||
|
||||
fn visit_variant<V>(&mut self) -> Result<V, Error>
|
||||
where V: de::Deserialize
|
||||
{
|
||||
de::Deserialize::deserialize(self.de)
|
||||
}
|
||||
|
||||
fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
visitor.visit_seq(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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Result<(), Error> {
|
||||
if self.state == 2 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let len = 2 - self.state;
|
||||
(len, Some(len))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_dog(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let animal = Dog;
|
||||
|
||||
let mut d = decoder::AnimalDecoder::new(animal.clone());
|
||||
let value: Animal = Decodable::decode(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_frog(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let animal = Frog("Henry".to_string(), 349);
|
||||
|
||||
let mut d = decoder::AnimalDecoder::new(animal.clone());
|
||||
let value: Animal = Decodable::decode(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_dog(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let animal = Dog;
|
||||
|
||||
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
|
||||
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_frog(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let animal = Frog("Henry".to_string(), 349);
|
||||
|
||||
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
|
||||
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,464 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate serde;
|
||||
extern crate rustc_serialize;
|
||||
extern crate test;
|
||||
|
||||
use std::fmt::Debug;
|
||||
use std::collections::HashMap;
|
||||
use test::Bencher;
|
||||
|
||||
use rustc_serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(PartialEq, Debug)]
|
||||
pub enum Error {
|
||||
EndOfStream,
|
||||
SyntaxError,
|
||||
MissingField,
|
||||
}
|
||||
|
||||
impl serde::de::Error for Error {
|
||||
fn syntax_error() -> Error { Error::SyntaxError }
|
||||
|
||||
fn end_of_stream_error() -> Error { Error::EndOfStream }
|
||||
|
||||
fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
fn missing_field_error(_: &'static str) -> Error {
|
||||
Error::MissingField
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod decoder {
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::IntoIter;
|
||||
use rustc_serialize;
|
||||
|
||||
use super::Error;
|
||||
use self::Value::{StringValue, IsizeValue};
|
||||
|
||||
enum Value {
|
||||
StringValue(String),
|
||||
IsizeValue(isize),
|
||||
}
|
||||
|
||||
pub struct IsizeDecoder {
|
||||
len: usize,
|
||||
iter: IntoIter<String, isize>,
|
||||
stack: Vec<Value>,
|
||||
}
|
||||
|
||||
impl IsizeDecoder {
|
||||
#[inline]
|
||||
pub fn new(values: HashMap<String, isize>) -> IsizeDecoder {
|
||||
IsizeDecoder {
|
||||
len: values.len(),
|
||||
iter: values.into_iter(),
|
||||
stack: vec!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl rustc_serialize::Decoder for IsizeDecoder {
|
||||
type Error = Error;
|
||||
|
||||
fn error(&mut self, _msg: &str) -> Error {
|
||||
Error::SyntaxError
|
||||
}
|
||||
|
||||
// Primitive types:
|
||||
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(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStream),
|
||||
}
|
||||
}
|
||||
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(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStream),
|
||||
}
|
||||
}
|
||||
|
||||
// Compound types:
|
||||
fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut IsizeDecoder) -> 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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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>,
|
||||
{
|
||||
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(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(Error::SyntaxError)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
let len = self.len;
|
||||
f(self, len)
|
||||
}
|
||||
#[inline]
|
||||
fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
|
||||
{
|
||||
match self.iter.next() {
|
||||
Some((key, value)) => {
|
||||
self.stack.push(IsizeValue(value));
|
||||
self.stack.push(StringValue(key));
|
||||
f(self)
|
||||
}
|
||||
None => {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
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(self)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod deserializer {
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map;
|
||||
|
||||
use super::Error;
|
||||
|
||||
use serde::de;
|
||||
|
||||
#[derive(PartialEq, Debug)]
|
||||
enum State {
|
||||
StartState,
|
||||
KeyState(String),
|
||||
ValueState(isize),
|
||||
}
|
||||
|
||||
pub struct IsizeDeserializer {
|
||||
stack: Vec<State>,
|
||||
iter: hash_map::IntoIter<String, isize>,
|
||||
}
|
||||
|
||||
impl IsizeDeserializer {
|
||||
#[inline]
|
||||
pub fn new(values: HashMap<String, isize>) -> IsizeDeserializer {
|
||||
IsizeDeserializer {
|
||||
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>;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Result<de::Token, Error>> {
|
||||
match self.stack.pop() {
|
||||
Some(StartState) => {
|
||||
self.stack.push(KeyOrEndState);
|
||||
Some(Ok(de::Token::MapStart(self.len)))
|
||||
}
|
||||
Some(KeyOrEndState) => {
|
||||
match self.iter.next() {
|
||||
Some((key, value)) => {
|
||||
self.stack.push(ValueState(value));
|
||||
Some(Ok(de::Token::String(key)))
|
||||
}
|
||||
None => {
|
||||
self.stack.push(EndState);
|
||||
Some(Ok(de::Token::End))
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(ValueState(x)) => {
|
||||
self.stack.push(KeyOrEndState);
|
||||
Some(Ok(de::Token::Isize(x)))
|
||||
}
|
||||
Some(EndState) => {
|
||||
None
|
||||
}
|
||||
None => {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl de::Deserializer<Error> for IsizeDeserializer {
|
||||
#[inline]
|
||||
fn end_of_stream_error(&mut self) -> Error {
|
||||
EndOfStream
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
|
||||
SyntaxError
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
|
||||
SyntaxError
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn conversion_error(&mut self, _token: de::Token) -> Error {
|
||||
SyntaxError
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserialize<IsizeDeserializer, Error>
|
||||
>(&mut self, _field: &'static str) -> Result<T, Error> {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
fn run_decoder<
|
||||
D: Decoder<Error=Error>,
|
||||
T: Clone + PartialEq + Debug + Decodable
|
||||
>(mut d: D, value: T) {
|
||||
let v = Decodable::decode(&mut d);
|
||||
|
||||
assert_eq!(Ok(value), v);
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let m: HashMap<String, isize> = HashMap::new();
|
||||
run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut m: HashMap<String, isize> = HashMap::new();
|
||||
for i in (0 .. 3) {
|
||||
m.insert(i.to_string(), i);
|
||||
}
|
||||
run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut m: HashMap<String, isize> = HashMap::new();
|
||||
for i in (0 .. 100) {
|
||||
m.insert(i.to_string(), i);
|
||||
}
|
||||
run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
|
||||
fn run_deserializer<
|
||||
D: Deserializer<Error=E>,
|
||||
E: Debug,
|
||||
T: Clone + PartialEq + Debug + Deserialize
|
||||
>(mut d: D, value: T) {
|
||||
let v: T = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, v);
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let m: HashMap<String, isize> = HashMap::new();
|
||||
run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut m: HashMap<String, isize> = HashMap::new();
|
||||
for i in (0 .. 3) {
|
||||
m.insert(i.to_string(), i);
|
||||
}
|
||||
run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut m: HashMap<String, isize> = HashMap::new();
|
||||
for i in (0 .. 100) {
|
||||
m.insert(i.to_string(), i);
|
||||
}
|
||||
run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,745 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate serde;
|
||||
extern crate rustc_serialize;
|
||||
extern crate test;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use test::Bencher;
|
||||
|
||||
use rustc_serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
|
||||
pub struct Inner {
|
||||
a: (),
|
||||
b: usize,
|
||||
c: HashMap<String, Option<char>>,
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
|
||||
pub struct Outer {
|
||||
inner: Vec<Inner>,
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum Error {
|
||||
EndOfStream,
|
||||
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 unknown_field_error(_: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
fn missing_field_error(_: &'static str) -> Error {
|
||||
Error::MissingField
|
||||
}
|
||||
}
|
||||
|
||||
mod decoder {
|
||||
use std::collections::HashMap;
|
||||
use rustc_serialize::Decoder;
|
||||
|
||||
use super::{Outer, Inner, Error};
|
||||
|
||||
use self::State::{
|
||||
OuterState,
|
||||
InnerState,
|
||||
NullState,
|
||||
UsizeState,
|
||||
CharState,
|
||||
StringState,
|
||||
FieldState,
|
||||
VecState,
|
||||
MapState,
|
||||
OptionState,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
enum State {
|
||||
OuterState(Outer),
|
||||
InnerState(Inner),
|
||||
NullState,
|
||||
UsizeState(usize),
|
||||
CharState(char),
|
||||
StringState(String),
|
||||
FieldState(&'static str),
|
||||
VecState(Vec<Inner>),
|
||||
MapState(HashMap<String, Option<char>>),
|
||||
OptionState(bool),
|
||||
}
|
||||
|
||||
pub struct OuterDecoder {
|
||||
stack: Vec<State>,
|
||||
|
||||
}
|
||||
|
||||
impl OuterDecoder {
|
||||
#[inline]
|
||||
pub fn new(animal: Outer) -> OuterDecoder {
|
||||
OuterDecoder {
|
||||
stack: vec!(OuterState(animal)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Decoder for OuterDecoder {
|
||||
type Error = Error;
|
||||
|
||||
fn error(&mut self, _msg: &str) -> Error {
|
||||
Error::OtherError
|
||||
}
|
||||
|
||||
// Primitive types:
|
||||
#[inline]
|
||||
fn read_nil(&mut self) -> Result<(), Error> {
|
||||
match self.stack.pop() {
|
||||
Some(NullState) => Ok(()),
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn read_usize(&mut self) -> Result<usize, Error> {
|
||||
match self.stack.pop() {
|
||||
Some(UsizeState(value)) => Ok(value),
|
||||
_ => 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) }
|
||||
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),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn read_str(&mut self) -> Result<String, Error> {
|
||||
match self.stack.pop() {
|
||||
Some(StringState(value)) => Ok(value),
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
|
||||
// Compound types:
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_struct<T, F>(&mut self, s_name: &str, _len: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(OuterState(Outer { inner })) => {
|
||||
if s_name == "Outer" {
|
||||
self.stack.push(VecState(inner));
|
||||
self.stack.push(FieldState("inner"));
|
||||
f(self)
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
Some(InnerState(Inner { a: (), b, c })) => {
|
||||
if s_name == "Inner" {
|
||||
self.stack.push(MapState(c));
|
||||
self.stack.push(FieldState("c"));
|
||||
|
||||
self.stack.push(UsizeState(b));
|
||||
self.stack.push(FieldState("b"));
|
||||
|
||||
self.stack.push(NullState);
|
||||
self.stack.push(FieldState("a"));
|
||||
f(self)
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(FieldState(name)) => {
|
||||
if f_name == name {
|
||||
f(self)
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
_ => 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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
// Specialized types:
|
||||
#[inline]
|
||||
fn read_option<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(OptionState(b)) => f(self, b),
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(VecState(value)) => {
|
||||
let len = value.len();
|
||||
for inner in value.into_iter().rev() {
|
||||
self.stack.push(InnerState(inner));
|
||||
}
|
||||
f(self, len)
|
||||
}
|
||||
_ => Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(MapState(map)) => {
|
||||
let len = map.len();
|
||||
for (key, value) in map {
|
||||
match value {
|
||||
Some(c) => {
|
||||
self.stack.push(CharState(c));
|
||||
self.stack.push(OptionState(true));
|
||||
}
|
||||
None => {
|
||||
self.stack.push(OptionState(false));
|
||||
}
|
||||
}
|
||||
self.stack.push(StringState(key));
|
||||
}
|
||||
f(self, len)
|
||||
}
|
||||
_ => Err(Error::SyntaxError),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod deserializer {
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map;
|
||||
use std::vec;
|
||||
use super::{Outer, Inner};
|
||||
use super::Error;
|
||||
use serde::de;
|
||||
|
||||
#[derive(Debug)]
|
||||
enum State {
|
||||
OuterState(Outer),
|
||||
InnerState(Inner),
|
||||
StrState(&'static str),
|
||||
NullState,
|
||||
UsizeState(usize),
|
||||
CharState(char),
|
||||
StringState(String),
|
||||
OptionState(bool),
|
||||
VecState(Vec<Inner>),
|
||||
MapState(HashMap<String, Option<char>>),
|
||||
}
|
||||
|
||||
pub struct OuterDeserializer {
|
||||
stack: Vec<State>,
|
||||
}
|
||||
|
||||
impl OuterDeserializer {
|
||||
#[inline]
|
||||
pub fn new(outer: Outer) -> OuterDeserializer {
|
||||
OuterDeserializer {
|
||||
stack: vec!(State::OuterState(outer)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl de::Deserializer for OuterDeserializer {
|
||||
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::VecState(value)) => {
|
||||
visitor.visit_seq(OuterSeqVisitor {
|
||||
de: self,
|
||||
iter: value.into_iter(),
|
||||
})
|
||||
}
|
||||
Some(State::MapState(value)) => {
|
||||
visitor.visit_map(MapVisitor {
|
||||
de: self,
|
||||
iter: value.into_iter(),
|
||||
})
|
||||
}
|
||||
Some(State::NullState) => {
|
||||
visitor.visit_unit()
|
||||
}
|
||||
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)
|
||||
}
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStream),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_named_map<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.stack.pop() {
|
||||
Some(State::OuterState(Outer { inner })) => {
|
||||
if name != "Outer" {
|
||||
return Err(Error::SyntaxError);
|
||||
}
|
||||
|
||||
self.stack.push(State::VecState(inner));
|
||||
self.stack.push(State::StrState("inner"));
|
||||
|
||||
visitor.visit_map(OuterMapVisitor {
|
||||
de: self,
|
||||
state: 0,
|
||||
})
|
||||
}
|
||||
Some(State::InnerState(Inner { a: (), b, c })) => {
|
||||
if name != "Inner" {
|
||||
return Err(Error::SyntaxError);
|
||||
}
|
||||
|
||||
self.stack.push(State::MapState(c));
|
||||
self.stack.push(State::StrState("c"));
|
||||
|
||||
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_map(InnerMapVisitor {
|
||||
de: self,
|
||||
state: 0,
|
||||
})
|
||||
}
|
||||
_ => {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 == 3 {
|
||||
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()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_0_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut map = HashMap::new();
|
||||
map.insert("abc".to_string(), Some('c'));
|
||||
|
||||
let outer = Outer {
|
||||
inner: vec!(),
|
||||
};
|
||||
|
||||
let mut d = decoder::OuterDecoder::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Decodable::decode(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_1_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let map = HashMap::new();
|
||||
|
||||
let outer = Outer {
|
||||
inner: vec!(
|
||||
Inner {
|
||||
a: (),
|
||||
b: 5,
|
||||
c: map,
|
||||
},
|
||||
)
|
||||
};
|
||||
|
||||
let mut d = decoder::OuterDecoder::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Decodable::decode(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_1_5(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut map = HashMap::new();
|
||||
map.insert("1".to_string(), Some('a'));
|
||||
map.insert("2".to_string(), None);
|
||||
map.insert("3".to_string(), Some('b'));
|
||||
map.insert("4".to_string(), None);
|
||||
map.insert("5".to_string(), Some('c'));
|
||||
|
||||
let outer = Outer {
|
||||
inner: vec!(
|
||||
Inner {
|
||||
a: (),
|
||||
b: 5,
|
||||
c: map,
|
||||
},
|
||||
)
|
||||
};
|
||||
|
||||
let mut d = decoder::OuterDecoder::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Decodable::decode(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_0_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let outer = Outer {
|
||||
inner: vec!(),
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_1_0(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let map = HashMap::new();
|
||||
|
||||
let outer = Outer {
|
||||
inner: vec!(
|
||||
Inner {
|
||||
a: (),
|
||||
b: 5,
|
||||
c: map,
|
||||
},
|
||||
)
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_1_5(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let mut map = HashMap::new();
|
||||
map.insert("1".to_string(), Some('a'));
|
||||
map.insert("2".to_string(), None);
|
||||
map.insert("3".to_string(), Some('b'));
|
||||
map.insert("4".to_string(), None);
|
||||
map.insert("5".to_string(), Some('c'));
|
||||
|
||||
let outer = Outer {
|
||||
inner: vec!(
|
||||
Inner {
|
||||
a: (),
|
||||
b: 5,
|
||||
c: map,
|
||||
},
|
||||
)
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
|
||||
|
||||
assert_eq!(value, Ok(outer));
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,617 @@
|
||||
#![feature(plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate serde;
|
||||
extern crate rustc_serialize;
|
||||
extern crate test;
|
||||
|
||||
use std::fmt::Debug;
|
||||
use test::Bencher;
|
||||
|
||||
use rustc_serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(PartialEq, Debug)]
|
||||
pub enum Error {
|
||||
EndOfStreamError,
|
||||
SyntaxError,
|
||||
}
|
||||
|
||||
impl serde::de::Error for Error {
|
||||
fn syntax_error() -> Error { Error::SyntaxError }
|
||||
|
||||
fn end_of_stream_error() -> Error { Error::EndOfStreamError }
|
||||
|
||||
fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod decoder {
|
||||
use std::vec;
|
||||
use rustc_serialize;
|
||||
|
||||
use super::Error;
|
||||
|
||||
pub struct UsizeDecoder {
|
||||
len: usize,
|
||||
iter: vec::IntoIter<usize>,
|
||||
}
|
||||
|
||||
impl UsizeDecoder {
|
||||
#[inline]
|
||||
pub fn new(values: Vec<usize>) -> UsizeDecoder {
|
||||
UsizeDecoder {
|
||||
len: values.len(),
|
||||
iter: values.into_iter(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl rustc_serialize::Decoder for UsizeDecoder {
|
||||
type Error = Error;
|
||||
|
||||
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
// Primitive types:
|
||||
fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
|
||||
#[inline]
|
||||
fn read_usize(&mut self) -> Result<usize, Error> {
|
||||
match self.iter.next() {
|
||||
Some(value) => Ok(value),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
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 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 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 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 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 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 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 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 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 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 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 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 UsizeDecoder, bool) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
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 UsizeDecoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub struct U8Decoder {
|
||||
len: usize,
|
||||
iter: vec::IntoIter<u8>,
|
||||
}
|
||||
|
||||
impl U8Decoder {
|
||||
#[inline]
|
||||
pub fn new(values: Vec<u8>) -> U8Decoder {
|
||||
U8Decoder {
|
||||
len: values.len(),
|
||||
iter: values.into_iter(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl rustc_serialize::Decoder for U8Decoder {
|
||||
type Error = Error;
|
||||
|
||||
fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
|
||||
|
||||
// Primitive types:
|
||||
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(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
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 U8Decoder) -> 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 U8Decoder, 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 U8Decoder) -> 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 U8Decoder, 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 U8Decoder) -> 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 U8Decoder) -> 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 U8Decoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut U8Decoder) -> 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 U8Decoder) -> 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 U8Decoder) -> 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 U8Decoder) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
// Specialized types:
|
||||
fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
|
||||
{
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut U8Decoder, 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 U8Decoder) -> Result<T, Error>,
|
||||
{
|
||||
f(self)
|
||||
}
|
||||
|
||||
fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
|
||||
F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
|
||||
{
|
||||
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(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(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod deserializer {
|
||||
//use std::num;
|
||||
use std::vec;
|
||||
|
||||
use super::Error;
|
||||
|
||||
use serde::de;
|
||||
|
||||
#[derive(PartialEq, Debug)]
|
||||
enum State {
|
||||
StartState,
|
||||
SepOrEndState,
|
||||
EndState,
|
||||
}
|
||||
|
||||
pub struct Deserializer<A> {
|
||||
state: State,
|
||||
iter: vec::IntoIter<A>,
|
||||
len: usize,
|
||||
value: Option<A>,
|
||||
}
|
||||
|
||||
impl<A> Deserializer<A> {
|
||||
#[inline]
|
||||
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 de::Deserializer for Deserializer<usize> {
|
||||
type Error = Error;
|
||||
|
||||
#[inline]
|
||||
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.state {
|
||||
State::StartState => {
|
||||
self.state = State::SepOrEndState;
|
||||
visitor.visit_seq(self)
|
||||
}
|
||||
State::SepOrEndState => {
|
||||
visitor.visit_usize(self.value.take().unwrap())
|
||||
}
|
||||
State::EndState => {
|
||||
Err(Error::EndOfStreamError)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl de::SeqVisitor for Deserializer<usize> {
|
||||
type Error = Error;
|
||||
|
||||
#[inline]
|
||||
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 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 {
|
||||
State::StartState => {
|
||||
self.state = State::SepOrEndState;
|
||||
visitor.visit_seq(self)
|
||||
}
|
||||
State::SepOrEndState => {
|
||||
visitor.visit_u8(self.value.take().unwrap())
|
||||
}
|
||||
State::EndState => {
|
||||
Err(Error::EndOfStreamError)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl de::SeqVisitor for Deserializer<u8> {
|
||||
type Error = Error;
|
||||
|
||||
#[inline]
|
||||
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 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))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
fn run_decoder<
|
||||
D: Decoder<Error=Error>,
|
||||
T: Clone + PartialEq + Debug + Decodable
|
||||
>(mut d: D, value: T) {
|
||||
let v = Decodable::decode(&mut d);
|
||||
|
||||
assert_eq!(Ok(value), v);
|
||||
}
|
||||
|
||||
fn run_deserializer<
|
||||
D: Deserializer<Error=E>,
|
||||
E: Debug,
|
||||
T: Clone + PartialEq + Debug + Deserialize
|
||||
>(mut d: D, value: T) {
|
||||
let v: T = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, v);
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_usize_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = vec!();
|
||||
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_usize_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = vec!(1, 2, 3);
|
||||
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_usize_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = (0 .. 100).collect();
|
||||
run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_u8_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = vec!();
|
||||
run_decoder(decoder::U8Decoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_u8_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = vec!(1, 2, 3);
|
||||
run_decoder(decoder::U8Decoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_decoder_u8_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = (0 .. 100).collect();
|
||||
run_decoder(decoder::U8Decoder::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_usize_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = vec!();
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_usize_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = vec!(1, 2, 3);
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_usize_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<usize> = (0 .. 100).collect();
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_u8_000(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = vec!();
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_u8_003(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = vec!(1, 2, 3);
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn bench_deserializer_u8_100(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
let v: Vec<u8> = (0 .. 100).collect();
|
||||
run_deserializer(deserializer::Deserializer::new(v.clone()), v)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
#![feature(custom_attribute, custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate test;
|
||||
extern crate serde;
|
||||
|
||||
use serde::json;
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct Default {
|
||||
a1: i32,
|
||||
#[serde(default)]
|
||||
a2: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct Rename {
|
||||
a1: i32,
|
||||
#[serde(rename="a3")]
|
||||
a2: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct FormatRename {
|
||||
a1: i32,
|
||||
#[serde(rename(xml= "a4", json="a5"))]
|
||||
a2: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize, Serialize)]
|
||||
enum SerEnum<A> {
|
||||
Map {
|
||||
a: i8,
|
||||
#[serde(rename(xml= "c", json="d"))]
|
||||
b: A,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_default() {
|
||||
let deserialized_value: Default = json::from_str(&"{\"a1\":1,\"a2\":2}").unwrap();
|
||||
assert_eq!(deserialized_value, Default { a1: 1, a2: 2 });
|
||||
|
||||
let deserialized_value: Default = json::from_str(&"{\"a1\":1}").unwrap();
|
||||
assert_eq!(deserialized_value, Default { a1: 1, a2: 0 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename() {
|
||||
let value = Rename { a1: 1, a2: 2 };
|
||||
let serialized_value = json::to_string(&value).unwrap();
|
||||
assert_eq!(serialized_value, "{\"a1\":1,\"a3\":2}");
|
||||
|
||||
let deserialized_value: Rename = json::from_str(&serialized_value).unwrap();
|
||||
assert_eq!(value, deserialized_value);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_format_rename() {
|
||||
let value = FormatRename { a1: 1, a2: 2 };
|
||||
let serialized_value = json::to_string(&value).unwrap();
|
||||
assert_eq!(serialized_value, "{\"a1\":1,\"a5\":2}");
|
||||
|
||||
let deserialized_value = json::from_str("{\"a1\":1,\"a5\":2}").unwrap();
|
||||
assert_eq!(value, deserialized_value);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_enum_format_rename() {
|
||||
let s1 = String::new();
|
||||
let value = SerEnum::Map { a: 0i8, b: s1 };
|
||||
let serialized_value = json::to_string(&value).unwrap();
|
||||
let ans = "{\"Map\":{\"a\":0,\"d\":\"\"}}";
|
||||
assert_eq!(serialized_value, ans);
|
||||
|
||||
let deserialized_value = json::from_str(ans).unwrap();
|
||||
assert_eq!(value, deserialized_value);
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate test;
|
||||
extern crate serde;
|
||||
|
||||
use serde::Serialize;
|
||||
use serde::bytes::{ByteBuf, Bytes};
|
||||
use serde::json;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
struct Error;
|
||||
|
||||
impl serde::de::Error for Error {
|
||||
fn syntax_error() -> Error { Error }
|
||||
|
||||
fn end_of_stream_error() -> Error { Error }
|
||||
|
||||
fn unknown_field_error(_field: &str) -> Error { Error }
|
||||
|
||||
fn missing_field_error(_field: &'static str) -> Error { Error }
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct BytesSerializer {
|
||||
bytes: Vec<u8>,
|
||||
}
|
||||
|
||||
impl BytesSerializer {
|
||||
fn new(bytes: Vec<u8>) -> Self {
|
||||
BytesSerializer {
|
||||
bytes: bytes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl serde::Serializer for BytesSerializer {
|
||||
type Error = Error;
|
||||
|
||||
fn visit_unit(&mut self) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_bool(&mut self, _v: bool) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_i64(&mut self, _v: i64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_u64(&mut self, _v: u64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_f32(&mut self, _v: f32) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_f64(&mut self, _v: f64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_char(&mut self, _v: char) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_str(&mut self, _v: &str) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_none(&mut self) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_some<V>(&mut self, _value: V) -> Result<(), Error>
|
||||
where V: serde::Serialize,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_seq<V>(&mut self, _visitor: V) -> Result<(), Error>
|
||||
where V: serde::ser::SeqVisitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_seq_elt<T>(&mut self, _value: T) -> Result<(), Error>
|
||||
where T: serde::Serialize
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_map<V>(&mut self, _visitor: V) -> Result<(), Error>
|
||||
where V: serde::ser::MapVisitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_map_elt<K, V>(&mut self, _key: K, _value: V) -> Result<(), Error>
|
||||
where K: serde::Serialize,
|
||||
V: serde::Serialize,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> {
|
||||
assert_eq!(self.bytes, bytes);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct BytesDeserializer {
|
||||
bytes: Option<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl BytesDeserializer {
|
||||
fn new(bytes: Vec<u8>) -> Self {
|
||||
BytesDeserializer {
|
||||
bytes: Some(bytes),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl serde::Deserializer for BytesDeserializer {
|
||||
type Error = Error;
|
||||
|
||||
fn visit<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
|
||||
where V: serde::de::Visitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn visit_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: serde::de::Visitor,
|
||||
{
|
||||
visitor.visit_byte_buf(self.bytes.take().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[test]
|
||||
fn test_bytes_ser_json() {
|
||||
let buf = vec![];
|
||||
let bytes = Bytes::from(&buf);
|
||||
assert_eq!(json::to_string(&bytes).unwrap(), "[]".to_string());
|
||||
|
||||
let buf = vec![1, 2, 3];
|
||||
let bytes = Bytes::from(&buf);
|
||||
assert_eq!(json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_ser_bytes() {
|
||||
let buf = vec![];
|
||||
let bytes = Bytes::from(&buf);
|
||||
let mut ser = BytesSerializer::new(vec![]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
|
||||
let buf = vec![1, 2, 3];
|
||||
let bytes = Bytes::from(&buf);
|
||||
let mut ser = BytesSerializer::new(vec![1, 2, 3]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_byte_buf_ser_json() {
|
||||
let bytes = ByteBuf::new();
|
||||
assert_eq!(json::to_string(&bytes).unwrap(), "[]".to_string());
|
||||
|
||||
let bytes = ByteBuf::from(vec![1, 2, 3]);
|
||||
assert_eq!(json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_byte_buf_ser_bytes() {
|
||||
let bytes = ByteBuf::new();
|
||||
let mut ser = BytesSerializer::new(vec![]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
|
||||
let bytes = ByteBuf::from(vec![1, 2, 3]);
|
||||
let mut ser = BytesSerializer::new(vec![1, 2, 3]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[test]
|
||||
fn test_byte_buf_de_json() {
|
||||
let bytes = ByteBuf::new();
|
||||
let v: ByteBuf = json::from_str("[]").unwrap();
|
||||
assert_eq!(v, bytes);
|
||||
|
||||
let bytes = ByteBuf::from(vec![1, 2, 3]);
|
||||
let v: ByteBuf = json::from_str("[1, 2, 3]").unwrap();
|
||||
assert_eq!(v, bytes);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_byte_buf_de_bytes() {
|
||||
let mut de = BytesDeserializer::new(vec![]);
|
||||
let bytes = serde::Deserialize::deserialize(&mut de);
|
||||
assert_eq!(bytes, Ok(ByteBuf::new()));
|
||||
|
||||
let mut de = BytesDeserializer::new(vec![1, 2, 3]);
|
||||
let bytes = serde::Deserialize::deserialize(&mut de);
|
||||
assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
|
||||
}
|
||||
@@ -0,0 +1,905 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate test;
|
||||
extern crate serde;
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
|
||||
use std::iter;
|
||||
use std::vec;
|
||||
|
||||
use serde::de::{self, Deserialize, Deserializer, Visitor};
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Token {
|
||||
Bool(bool),
|
||||
Isize(isize),
|
||||
I8(i8),
|
||||
I16(i16),
|
||||
I32(i32),
|
||||
I64(i64),
|
||||
Usize(usize),
|
||||
U8(u8),
|
||||
U16(u16),
|
||||
U32(u32),
|
||||
U64(u64),
|
||||
F32(f32),
|
||||
F64(f64),
|
||||
Char(char),
|
||||
Str(&'static str),
|
||||
String(String),
|
||||
|
||||
Option(bool),
|
||||
|
||||
Name(&'static str),
|
||||
|
||||
Unit,
|
||||
|
||||
SeqStart(usize),
|
||||
SeqSep,
|
||||
SeqEnd,
|
||||
|
||||
MapStart(usize),
|
||||
MapSep,
|
||||
MapEnd,
|
||||
|
||||
EnumStart(&'static str),
|
||||
EnumEnd,
|
||||
}
|
||||
|
||||
struct TokenDeserializer {
|
||||
tokens: iter::Peekable<vec::IntoIter<Token>>,
|
||||
}
|
||||
|
||||
impl<'a> TokenDeserializer {
|
||||
fn new(tokens: Vec<Token>) -> TokenDeserializer {
|
||||
TokenDeserializer {
|
||||
tokens: tokens.into_iter().peekable(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Debug)]
|
||||
enum Error {
|
||||
SyntaxError,
|
||||
EndOfStreamError,
|
||||
UnknownFieldError(String),
|
||||
MissingFieldError(&'static str),
|
||||
InvalidName(&'static str),
|
||||
}
|
||||
|
||||
impl de::Error for Error {
|
||||
fn syntax_error() -> Error { Error::SyntaxError }
|
||||
|
||||
fn end_of_stream_error() -> Error { Error::EndOfStreamError }
|
||||
|
||||
fn unknown_field_error(field: &str) -> Error {
|
||||
Error::UnknownFieldError(field.to_string())
|
||||
}
|
||||
|
||||
fn missing_field_error(field: &'static str) -> Error {
|
||||
Error::MissingFieldError(field)
|
||||
}
|
||||
}
|
||||
|
||||
impl Deserializer for TokenDeserializer {
|
||||
type Error = Error;
|
||||
|
||||
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: Visitor,
|
||||
{
|
||||
match self.tokens.next() {
|
||||
Some(Token::Bool(v)) => visitor.visit_bool(v),
|
||||
Some(Token::Isize(v)) => visitor.visit_isize(v),
|
||||
Some(Token::I8(v)) => visitor.visit_i8(v),
|
||||
Some(Token::I16(v)) => visitor.visit_i16(v),
|
||||
Some(Token::I32(v)) => visitor.visit_i32(v),
|
||||
Some(Token::I64(v)) => visitor.visit_i64(v),
|
||||
Some(Token::Usize(v)) => visitor.visit_usize(v),
|
||||
Some(Token::U8(v)) => visitor.visit_u8(v),
|
||||
Some(Token::U16(v)) => visitor.visit_u16(v),
|
||||
Some(Token::U32(v)) => visitor.visit_u32(v),
|
||||
Some(Token::U64(v)) => visitor.visit_u64(v),
|
||||
Some(Token::F32(v)) => visitor.visit_f32(v),
|
||||
Some(Token::F64(v)) => visitor.visit_f64(v),
|
||||
Some(Token::Char(v)) => visitor.visit_char(v),
|
||||
Some(Token::Str(v)) => visitor.visit_str(v),
|
||||
Some(Token::String(v)) => visitor.visit_string(v),
|
||||
Some(Token::Option(false)) => visitor.visit_none(),
|
||||
Some(Token::Option(true)) => visitor.visit_some(self),
|
||||
Some(Token::Unit) => visitor.visit_unit(),
|
||||
Some(Token::SeqStart(len)) => {
|
||||
visitor.visit_seq(TokenDeserializerSeqVisitor {
|
||||
de: self,
|
||||
len: len,
|
||||
})
|
||||
}
|
||||
Some(Token::MapStart(len)) => {
|
||||
visitor.visit_map(TokenDeserializerMapVisitor {
|
||||
de: self,
|
||||
len: len,
|
||||
})
|
||||
}
|
||||
Some(Token::Name(_)) => self.visit(visitor),
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
/// Hook into `Option` deserializing so we can treat `Unit` as a
|
||||
/// `None`, or a regular value as `Some(value)`.
|
||||
fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: Visitor,
|
||||
{
|
||||
match self.tokens.peek() {
|
||||
Some(&Token::Option(false)) => {
|
||||
self.tokens.next();
|
||||
visitor.visit_none()
|
||||
}
|
||||
Some(&Token::Option(true)) => {
|
||||
self.tokens.next();
|
||||
visitor.visit_some(self)
|
||||
}
|
||||
Some(&Token::Unit) => {
|
||||
self.tokens.next();
|
||||
visitor.visit_none()
|
||||
}
|
||||
Some(_) => visitor.visit_some(self),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_enum<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::EnumVisitor,
|
||||
{
|
||||
match self.tokens.next() {
|
||||
Some(Token::EnumStart(n)) => {
|
||||
if name == n {
|
||||
visitor.visit(TokenDeserializerVariantVisitor {
|
||||
de: self,
|
||||
})
|
||||
} else {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
}
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_named_unit<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.tokens.peek() {
|
||||
Some(&Token::Name(n)) => {
|
||||
if name == n {
|
||||
self.tokens.next();
|
||||
self.visit_seq(visitor)
|
||||
} else {
|
||||
Err(Error::InvalidName(n))
|
||||
}
|
||||
}
|
||||
Some(_) => self.visit(visitor),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.tokens.peek() {
|
||||
Some(&Token::Name(n)) => {
|
||||
if name == n {
|
||||
self.tokens.next();
|
||||
self.visit_seq(visitor)
|
||||
} else {
|
||||
Err(Error::InvalidName(n))
|
||||
}
|
||||
}
|
||||
Some(_) => self.visit_seq(visitor),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.tokens.peek() {
|
||||
Some(&Token::Name(n)) => {
|
||||
if name == n {
|
||||
self.tokens.next();
|
||||
self.visit_map(visitor)
|
||||
} else {
|
||||
Err(Error::InvalidName(n))
|
||||
}
|
||||
}
|
||||
Some(_) => self.visit_map(visitor),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct TokenDeserializerSeqVisitor<'a> {
|
||||
de: &'a mut TokenDeserializer,
|
||||
len: usize,
|
||||
}
|
||||
|
||||
impl<'a> de::SeqVisitor for TokenDeserializerSeqVisitor<'a> {
|
||||
type Error = Error;
|
||||
|
||||
fn visit<T>(&mut self) -> Result<Option<T>, Error>
|
||||
where T: Deserialize,
|
||||
{
|
||||
match self.de.tokens.peek() {
|
||||
Some(&Token::SeqSep) => {
|
||||
self.len -= 1;
|
||||
self.de.tokens.next();
|
||||
Ok(Some(try!(Deserialize::deserialize(self.de))))
|
||||
}
|
||||
Some(&Token::SeqEnd) => Ok(None),
|
||||
Some(_) => {
|
||||
Err(Error::SyntaxError)
|
||||
}
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Result<(), Error> {
|
||||
assert_eq!(self.len, 0);
|
||||
match self.de.tokens.next() {
|
||||
Some(Token::SeqEnd) => Ok(()),
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(self.len, Some(self.len))
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct TokenDeserializerMapVisitor<'a> {
|
||||
de: &'a mut TokenDeserializer,
|
||||
len: usize,
|
||||
}
|
||||
|
||||
impl<'a> de::MapVisitor for TokenDeserializerMapVisitor<'a> {
|
||||
type Error = Error;
|
||||
|
||||
fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
|
||||
where K: Deserialize,
|
||||
{
|
||||
match self.de.tokens.peek() {
|
||||
Some(&Token::MapSep) => {
|
||||
self.de.tokens.next();
|
||||
self.len -= 1;
|
||||
Ok(Some(try!(Deserialize::deserialize(self.de))))
|
||||
}
|
||||
Some(&Token::MapEnd) => Ok(None),
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_value<V>(&mut self) -> Result<V, Error>
|
||||
where V: Deserialize,
|
||||
{
|
||||
Ok(try!(Deserialize::deserialize(self.de)))
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Result<(), Error> {
|
||||
assert_eq!(self.len, 0);
|
||||
match self.de.tokens.next() {
|
||||
Some(Token::MapEnd) => Ok(()),
|
||||
Some(_) => Err(Error::SyntaxError),
|
||||
None => Err(Error::EndOfStreamError),
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(self.len, Some(self.len))
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct TokenDeserializerVariantVisitor<'a> {
|
||||
de: &'a mut TokenDeserializer,
|
||||
}
|
||||
|
||||
impl<'a> de::VariantVisitor for TokenDeserializerVariantVisitor<'a> {
|
||||
type Error = Error;
|
||||
|
||||
fn visit_variant<V>(&mut self) -> Result<V, Error>
|
||||
where V: de::Deserialize,
|
||||
{
|
||||
de::Deserialize::deserialize(self.de)
|
||||
}
|
||||
|
||||
fn visit_unit(&mut self) -> Result<(), Error> {
|
||||
de::Deserialize::deserialize(self.de)
|
||||
}
|
||||
|
||||
fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
de::Deserializer::visit(self.de, visitor)
|
||||
}
|
||||
|
||||
fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
de::Deserializer::visit(self.de, visitor)
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
|
||||
struct NamedUnit;
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
struct NamedSeq(i32, i32, i32);
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
struct NamedMap {
|
||||
a: i32,
|
||||
b: i32,
|
||||
c: i32,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
enum Enum {
|
||||
Unit,
|
||||
Seq(i32, i32, i32),
|
||||
Map { a: i32, b: i32, c: i32 }
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! btreeset {
|
||||
() => {
|
||||
BTreeSet::new()
|
||||
};
|
||||
($($value:expr),+) => {
|
||||
{
|
||||
let mut set = BTreeSet::new();
|
||||
$(set.insert($value);)+
|
||||
set
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! btreemap {
|
||||
() => {
|
||||
BTreeMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = BTreeMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! hashset {
|
||||
() => {
|
||||
HashSet::new()
|
||||
};
|
||||
($($value:expr),+) => {
|
||||
{
|
||||
let mut set = HashSet::new();
|
||||
$(set.insert($value);)+
|
||||
set
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! hashmap {
|
||||
() => {
|
||||
HashMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = HashMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_test {
|
||||
($name:ident { $($value:expr => $tokens:expr,)+ }) => {
|
||||
#[test]
|
||||
fn $name() {
|
||||
$(
|
||||
let mut de = TokenDeserializer::new($tokens);
|
||||
let value: Result<_, Error> = Deserialize::deserialize(&mut de);
|
||||
assert_eq!(value, Ok($value));
|
||||
)+
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_tests {
|
||||
($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
|
||||
$(
|
||||
declare_test!($name { $($value => $tokens,)+ });
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
declare_tests! {
|
||||
test_bool {
|
||||
true => vec![Token::Bool(true)],
|
||||
false => vec![Token::Bool(false)],
|
||||
}
|
||||
test_isize {
|
||||
0isize => vec![Token::Isize(0)],
|
||||
0isize => vec![Token::I8(0)],
|
||||
0isize => vec![Token::I16(0)],
|
||||
0isize => vec![Token::I32(0)],
|
||||
0isize => vec![Token::I64(0)],
|
||||
0isize => vec![Token::Usize(0)],
|
||||
0isize => vec![Token::U8(0)],
|
||||
0isize => vec![Token::U16(0)],
|
||||
0isize => vec![Token::U32(0)],
|
||||
0isize => vec![Token::U64(0)],
|
||||
0isize => vec![Token::F32(0.)],
|
||||
0isize => vec![Token::F64(0.)],
|
||||
}
|
||||
test_ints {
|
||||
0isize => vec![Token::Isize(0)],
|
||||
0i8 => vec![Token::I8(0)],
|
||||
0i16 => vec![Token::I16(0)],
|
||||
0i32 => vec![Token::I32(0)],
|
||||
0i64 => vec![Token::I64(0)],
|
||||
}
|
||||
test_uints {
|
||||
0usize => vec![Token::Usize(0)],
|
||||
0u8 => vec![Token::U8(0)],
|
||||
0u16 => vec![Token::U16(0)],
|
||||
0u32 => vec![Token::U32(0)],
|
||||
0u64 => vec![Token::U64(0)],
|
||||
}
|
||||
test_floats {
|
||||
0f32 => vec![Token::F32(0.)],
|
||||
0f64 => vec![Token::F64(0.)],
|
||||
}
|
||||
test_char {
|
||||
'a' => vec![Token::Char('a')],
|
||||
'a' => vec![Token::Str("a")],
|
||||
'a' => vec![Token::String("a".to_string())],
|
||||
}
|
||||
test_string {
|
||||
"abc".to_string() => vec![Token::Str("abc")],
|
||||
"abc".to_string() => vec![Token::String("abc".to_string())],
|
||||
"a".to_string() => vec![Token::Char('a')],
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => vec![Token::Unit],
|
||||
None::<i32> => vec![Token::Option(false)],
|
||||
Some(1) => vec![Token::I32(1)],
|
||||
Some(1) => vec![
|
||||
Token::Option(true),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_unit {
|
||||
() => vec![Token::Unit],
|
||||
() => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_named_unit {
|
||||
NamedUnit => vec![Token::Unit],
|
||||
NamedUnit => vec![
|
||||
Token::Name("NamedUnit"),
|
||||
Token::Unit,
|
||||
],
|
||||
NamedUnit => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_named_seq {
|
||||
NamedSeq(1, 2, 3) => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
NamedSeq(1, 2, 3) => vec![
|
||||
Token::Name("NamedSeq"),
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_btreeset {
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(2),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_hashset {
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![1, 2, 3] => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(2),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
([0; 0], [1], [2, 3]) => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(2),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::SeqStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => vec![
|
||||
Token::SeqStart(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1, 2, 3) => vec![
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_btreemap {
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2] => vec![
|
||||
Token::MapStart(1),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_hashmap {
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2] => vec![
|
||||
Token::MapStart(1),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(2),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::Unit,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::Name("Anything"),
|
||||
Token::MapStart(0),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_named_map {
|
||||
NamedMap { a: 1, b: 2, c: 3 } => vec![
|
||||
Token::MapStart(3),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::MapEnd,
|
||||
],
|
||||
NamedMap { a: 1, b: 2, c: 3 } => vec![
|
||||
Token::Name("NamedMap"),
|
||||
Token::MapStart(3),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_enum_unit {
|
||||
Enum::Unit => vec![
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Str("Unit"),
|
||||
Token::Unit,
|
||||
Token::EnumEnd,
|
||||
],
|
||||
}
|
||||
test_enum_seq {
|
||||
Enum::Seq(1, 2, 3) => vec![
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Str("Seq"),
|
||||
Token::SeqStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::EnumEnd,
|
||||
],
|
||||
}
|
||||
test_enum_map {
|
||||
Enum::Map { a: 1, b: 2, c: 3 } => vec![
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Str("Map"),
|
||||
Token::MapStart(3),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::MapEnd,
|
||||
Token::EnumEnd,
|
||||
],
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,52 @@
|
||||
extern crate serde;
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use serde::json::value::Value;
|
||||
use serde::json::builder::{ArrayBuilder, ObjectBuilder};
|
||||
|
||||
#[test]
|
||||
fn test_array_builder() {
|
||||
let value = ArrayBuilder::new().unwrap();
|
||||
assert_eq!(value, Value::Array(Vec::new()));
|
||||
|
||||
let value = ArrayBuilder::new()
|
||||
.push(1)
|
||||
.push(2)
|
||||
.push(3)
|
||||
.unwrap();
|
||||
assert_eq!(value, Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))));
|
||||
|
||||
let value = ArrayBuilder::new()
|
||||
.push_array(|bld| bld.push(1).push(2).push(3))
|
||||
.unwrap();
|
||||
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))))));
|
||||
|
||||
let value = ArrayBuilder::new()
|
||||
.push_object(|bld|
|
||||
bld
|
||||
.insert("a".to_string(), 1)
|
||||
.insert("b".to_string(), 2))
|
||||
.unwrap();
|
||||
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("a".to_string(), Value::U64(1));
|
||||
map.insert("b".to_string(), Value::U64(2));
|
||||
assert_eq!(value, Value::Array(vec!(Value::Object(map))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_object_builder() {
|
||||
let value = ObjectBuilder::new().unwrap();
|
||||
assert_eq!(value, Value::Object(BTreeMap::new()));
|
||||
|
||||
let value = ObjectBuilder::new()
|
||||
.insert("a".to_string(), 1)
|
||||
.insert("b".to_string(), 2)
|
||||
.unwrap();
|
||||
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("a".to_string(), Value::U64(1));
|
||||
map.insert("b".to_string(), Value::U64(2));
|
||||
assert_eq!(value, Value::Object(map));
|
||||
}
|
||||
@@ -0,0 +1,445 @@
|
||||
#![feature(custom_derive, plugin)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate serde;
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use serde::json::{self, Value};
|
||||
|
||||
macro_rules! btreemap {
|
||||
() => {
|
||||
BTreeMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = BTreeMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
trait Trait {
|
||||
type Type;
|
||||
}
|
||||
*/
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct NamedUnit;
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
struct DeNamedTuple<A, B, C>(A, B, C);
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
|
||||
a: &'a A,
|
||||
b: &'b mut B,
|
||||
c: C,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
struct DeNamedMap<A, B, C> {
|
||||
a: A,
|
||||
b: B,
|
||||
c: C,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
|
||||
Unit,
|
||||
Seq(
|
||||
i8,
|
||||
B,
|
||||
&'a C,
|
||||
//C::Type,
|
||||
&'a mut D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
Map {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: &'a C,
|
||||
//d: C::Type,
|
||||
e: &'a mut D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(
|
||||
i8,
|
||||
B,
|
||||
&'a C,
|
||||
//C::Type,
|
||||
&'a mut D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
_Map2 {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: &'a C,
|
||||
//d: C::Type,
|
||||
e: &'a mut D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
|
||||
Unit,
|
||||
Seq(
|
||||
i8,
|
||||
B,
|
||||
C,
|
||||
//C::Type,
|
||||
D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
Map {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: C,
|
||||
//d: C::Type,
|
||||
e: D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(
|
||||
i8,
|
||||
B,
|
||||
C,
|
||||
//C::Type,
|
||||
D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
_Map2 {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: C,
|
||||
//d: C::Type,
|
||||
e: D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_named_unit() {
|
||||
let named_unit = NamedUnit;
|
||||
|
||||
assert_eq!(
|
||||
json::to_string(&named_unit).unwrap(),
|
||||
"null".to_string()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&named_unit),
|
||||
Value::Null
|
||||
);
|
||||
|
||||
let v: NamedUnit = json::from_str("null").unwrap();
|
||||
assert_eq!(v, named_unit);
|
||||
|
||||
let v: NamedUnit = json::from_value(Value::Null).unwrap();
|
||||
assert_eq!(v, named_unit);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_named_tuple() {
|
||||
let a = 5;
|
||||
let mut b = 6;
|
||||
let c = 7;
|
||||
let named_tuple = SerNamedTuple(&a, &mut b, c);
|
||||
|
||||
assert_eq!(
|
||||
json::to_string(&named_tuple).unwrap(),
|
||||
"[5,6,7]"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&named_tuple),
|
||||
Value::Array(vec![Value::U64(5), Value::U64(6), Value::U64(7)])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_named_tuple() {
|
||||
let v: DeNamedTuple<i32, i32, i32> = json::from_str("[1,2,3]").unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeNamedTuple(1, 2, 3)
|
||||
);
|
||||
|
||||
let v: Value = json::from_str("[1,2,3]").unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
Value::Array(vec![
|
||||
Value::U64(1),
|
||||
Value::U64(2),
|
||||
Value::U64(3),
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_named_map() {
|
||||
let a = 5;
|
||||
let mut b = 6;
|
||||
let c = 7;
|
||||
let named_map = SerNamedMap {
|
||||
a: &a,
|
||||
b: &mut b,
|
||||
c: c,
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
json::to_string(&named_map).unwrap(),
|
||||
"{\"a\":5,\"b\":6,\"c\":7}"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&named_map),
|
||||
Value::Object(btreemap![
|
||||
"a".to_string() => Value::U64(5),
|
||||
"b".to_string() => Value::U64(6),
|
||||
"c".to_string() => Value::U64(7)
|
||||
])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_named_map() {
|
||||
let v = DeNamedMap {
|
||||
a: 5,
|
||||
b: 6,
|
||||
c: 7,
|
||||
};
|
||||
|
||||
let v2: DeNamedMap<i32, i32, i32> = json::from_str(
|
||||
"{\"a\":5,\"b\":6,\"c\":7}"
|
||||
).unwrap();
|
||||
assert_eq!(v, v2);
|
||||
|
||||
let v2 = json::from_value(Value::Object(btreemap![
|
||||
"a".to_string() => Value::U64(5),
|
||||
"b".to_string() => Value::U64(6),
|
||||
"c".to_string() => Value::U64(7)
|
||||
])).unwrap();
|
||||
assert_eq!(v, v2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_unit() {
|
||||
assert_eq!(
|
||||
json::to_string(&SerEnum::Unit::<u32, u32, u32>).unwrap(),
|
||||
"{\"Unit\":[]}"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&SerEnum::Unit::<u32, u32, u32>),
|
||||
Value::Object(btreemap!(
|
||||
"Unit".to_string() => Value::Array(vec![]))
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_seq() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let mut e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_eq!(
|
||||
json::to_string(&SerEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
&c,
|
||||
//d,
|
||||
&mut e,
|
||||
//f,
|
||||
)).unwrap(),
|
||||
"{\"Seq\":[1,2,3,5]}".to_string()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&SerEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
&c,
|
||||
//d,
|
||||
&mut e,
|
||||
//e,
|
||||
)),
|
||||
Value::Object(btreemap!(
|
||||
"Seq".to_string() => Value::Array(vec![
|
||||
Value::U64(1),
|
||||
Value::U64(2),
|
||||
Value::U64(3),
|
||||
//Value::U64(4),
|
||||
Value::U64(5),
|
||||
//Value::U64(6),
|
||||
])
|
||||
))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_map() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let mut e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_eq!(
|
||||
json::to_string(&SerEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: &c,
|
||||
//d: d,
|
||||
e: &mut e,
|
||||
//f: f,
|
||||
}).unwrap(),
|
||||
"{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}".to_string()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
json::to_value(&SerEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: &c,
|
||||
//d: d,
|
||||
e: &mut e,
|
||||
//f: f,
|
||||
}),
|
||||
Value::Object(btreemap!(
|
||||
"Map".to_string() => Value::Object(btreemap![
|
||||
"a".to_string() => Value::U64(1),
|
||||
"b".to_string() => Value::U64(2),
|
||||
"c".to_string() => Value::U64(3),
|
||||
//"d".to_string() => Value::U64(4)
|
||||
"e".to_string() => Value::U64(5)
|
||||
//"f".to_string() => Value::U64(6)
|
||||
])
|
||||
))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_unit() {
|
||||
let v: DeEnum<_, _, _> = json::from_str("{\"Unit\":[]}").unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Unit::<u32, u32, u32>
|
||||
);
|
||||
|
||||
let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
|
||||
"Unit".to_string() => Value::Array(vec![]))
|
||||
)).unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Unit::<u32, u32, u32>
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_seq() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let e = 5;
|
||||
//let f = 6;
|
||||
|
||||
let v: DeEnum<_, _, _> = json::from_str("{\"Seq\":[1,2,3,5]}").unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
c,
|
||||
//d,
|
||||
e,
|
||||
//f,
|
||||
)
|
||||
);
|
||||
|
||||
let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
|
||||
"Seq".to_string() => Value::Array(vec![
|
||||
Value::U64(1),
|
||||
Value::U64(2),
|
||||
Value::U64(3),
|
||||
//Value::U64(4),
|
||||
Value::U64(5),
|
||||
//Value::U64(6),
|
||||
])
|
||||
))).unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
c,
|
||||
//d,
|
||||
e,
|
||||
//e,
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_map() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let e = 5;
|
||||
//let f = 6;
|
||||
|
||||
let v: DeEnum<_, _, _> = json::from_str(
|
||||
"{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}"
|
||||
).unwrap();
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: c,
|
||||
//d: d,
|
||||
e: e,
|
||||
//f: f,
|
||||
}
|
||||
);
|
||||
|
||||
let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
|
||||
"Map".to_string() => Value::Object(btreemap![
|
||||
"a".to_string() => Value::U64(1),
|
||||
"b".to_string() => Value::U64(2),
|
||||
"c".to_string() => Value::U64(3),
|
||||
//"d".to_string() => Value::U64(4)
|
||||
"e".to_string() => Value::U64(5)
|
||||
//"f".to_string() => Value::U64(6)
|
||||
])
|
||||
))).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
v,
|
||||
DeEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: c,
|
||||
//d: d,
|
||||
e: e,
|
||||
//f: f,
|
||||
}
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,546 @@
|
||||
#![feature(custom_derive, plugin, test)]
|
||||
#![plugin(serde_macros)]
|
||||
|
||||
extern crate test;
|
||||
extern crate serde;
|
||||
|
||||
use std::vec;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use serde::ser::{Serialize, Serializer, SeqVisitor, MapVisitor};
|
||||
|
||||
#[derive(Clone, PartialEq, Debug)]
|
||||
pub enum Token<'a> {
|
||||
Bool(bool),
|
||||
Isize(isize),
|
||||
I8(i8),
|
||||
I16(i16),
|
||||
I32(i32),
|
||||
I64(i64),
|
||||
Usize(usize),
|
||||
U8(u8),
|
||||
U16(u16),
|
||||
U32(u32),
|
||||
U64(u64),
|
||||
F32(f32),
|
||||
F64(f64),
|
||||
Char(char),
|
||||
Str(&'a str),
|
||||
|
||||
Option(bool),
|
||||
|
||||
Unit,
|
||||
NamedUnit(&'a str),
|
||||
EnumUnit(&'a str, &'a str),
|
||||
|
||||
SeqStart(Option<usize>),
|
||||
NamedSeqStart(&'a str, Option<usize>),
|
||||
EnumSeqStart(&'a str, &'a str, Option<usize>),
|
||||
SeqSep,
|
||||
SeqEnd,
|
||||
|
||||
MapStart(Option<usize>),
|
||||
NamedMapStart(&'a str, Option<usize>),
|
||||
EnumMapStart(&'a str, &'a str, Option<usize>),
|
||||
MapSep,
|
||||
MapEnd,
|
||||
}
|
||||
|
||||
struct AssertSerializer<'a> {
|
||||
iter: vec::IntoIter<Token<'a>>,
|
||||
}
|
||||
|
||||
impl<'a> AssertSerializer<'a> {
|
||||
fn new(values: Vec<Token<'a>>) -> AssertSerializer {
|
||||
AssertSerializer {
|
||||
iter: values.into_iter(),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), ()>
|
||||
where V: SeqVisitor
|
||||
{
|
||||
while let Some(()) = try!(visitor.visit(self)) { }
|
||||
|
||||
assert_eq!(self.iter.next(), Some(Token::SeqEnd));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()>
|
||||
where V: MapVisitor
|
||||
{
|
||||
while let Some(()) = try!(visitor.visit(self)) { }
|
||||
|
||||
assert_eq!(self.iter.next(), Some(Token::MapEnd));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Serializer for AssertSerializer<'a> {
|
||||
type Error = ();
|
||||
|
||||
fn visit_unit(&mut self) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Unit));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_named_unit(&mut self, name: &str) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next().unwrap(), Token::NamedUnit(name));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_enum_unit(&mut self, name: &str, variant: &str) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next().unwrap(), Token::EnumUnit(name, variant));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Bool(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Isize(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::I8(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::I16(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::I32(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::I64(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Usize(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::U8(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::U16(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::U32(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::U64(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::F32(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::F64(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_char(&mut self, v: char) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Char(v)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_str(&mut self, v: &str) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next().unwrap(), Token::Str(v));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_none(&mut self) -> Result<(), ()> {
|
||||
assert_eq!(self.iter.next(), Some(Token::Option(false)));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
|
||||
where V: Serialize,
|
||||
{
|
||||
assert_eq!(self.iter.next(), Some(Token::Option(true)));
|
||||
value.serialize(self)
|
||||
}
|
||||
|
||||
|
||||
fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
|
||||
where V: SeqVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next(), Some(Token::SeqStart(len)));
|
||||
|
||||
self.visit_sequence(visitor)
|
||||
}
|
||||
|
||||
fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
|
||||
where V: SeqVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next().unwrap(), Token::NamedSeqStart(name, len));
|
||||
|
||||
self.visit_sequence(visitor)
|
||||
}
|
||||
|
||||
fn visit_enum_seq<V>(&mut self,
|
||||
name: &str,
|
||||
variant: &str,
|
||||
visitor: V) -> Result<(), ()>
|
||||
where V: SeqVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next().unwrap(), Token::EnumSeqStart(name, variant, len));
|
||||
|
||||
self.visit_sequence(visitor)
|
||||
}
|
||||
|
||||
fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
|
||||
where T: Serialize
|
||||
{
|
||||
assert_eq!(self.iter.next(), Some(Token::SeqSep));
|
||||
value.serialize(self)
|
||||
}
|
||||
|
||||
fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
|
||||
where V: MapVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next(), Some(Token::MapStart(len)));
|
||||
|
||||
self.visit_mapping(visitor)
|
||||
}
|
||||
|
||||
fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
|
||||
where V: MapVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next().unwrap(), Token::NamedMapStart(name, len));
|
||||
|
||||
self.visit_mapping(visitor)
|
||||
}
|
||||
|
||||
fn visit_enum_map<V>(&mut self, name: &str, variant: &str, visitor: V) -> Result<(), ()>
|
||||
where V: MapVisitor
|
||||
{
|
||||
let len = visitor.len();
|
||||
|
||||
assert_eq!(self.iter.next().unwrap(), Token::EnumMapStart(name, variant, len));
|
||||
|
||||
self.visit_mapping(visitor)
|
||||
}
|
||||
|
||||
fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
|
||||
where K: Serialize,
|
||||
V: Serialize,
|
||||
{
|
||||
assert_eq!(self.iter.next(), Some(Token::MapSep));
|
||||
|
||||
try!(key.serialize(self));
|
||||
value.serialize(self)
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct NamedUnit;
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct NamedSeq(i32, i32, i32);
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct NamedMap {
|
||||
a: i32,
|
||||
b: i32,
|
||||
c: i32,
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
enum Enum {
|
||||
Unit,
|
||||
Seq(i32, i32),
|
||||
Map { a: i32, b: i32 },
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! btreemap {
|
||||
() => {
|
||||
BTreeMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = BTreeMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_test {
|
||||
($name:ident { $($value:expr => $tokens:expr,)+ }) => {
|
||||
#[test]
|
||||
fn $name() {
|
||||
$(
|
||||
let mut ser = AssertSerializer::new($tokens);
|
||||
assert_eq!($value.serialize(&mut ser), Ok(()));
|
||||
)+
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_tests {
|
||||
($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
|
||||
$(
|
||||
declare_test!($name { $($value => $tokens,)+ });
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
declare_tests! {
|
||||
test_unit {
|
||||
() => vec![Token::Unit],
|
||||
}
|
||||
test_bool {
|
||||
true => vec![Token::Bool(true)],
|
||||
false => vec![Token::Bool(false)],
|
||||
}
|
||||
test_isizes {
|
||||
0isize => vec![Token::Isize(0)],
|
||||
0i8 => vec![Token::I8(0)],
|
||||
0i16 => vec![Token::I16(0)],
|
||||
0i32 => vec![Token::I32(0)],
|
||||
0i64 => vec![Token::I64(0)],
|
||||
}
|
||||
test_usizes {
|
||||
0usize => vec![Token::Usize(0)],
|
||||
0u8 => vec![Token::U8(0)],
|
||||
0u16 => vec![Token::U16(0)],
|
||||
0u32 => vec![Token::U32(0)],
|
||||
0u64 => vec![Token::U64(0)],
|
||||
}
|
||||
test_floats {
|
||||
0f32 => vec![Token::F32(0.)],
|
||||
0f64 => vec![Token::F64(0.)],
|
||||
}
|
||||
test_char {
|
||||
'a' => vec![Token::Char('a')],
|
||||
}
|
||||
test_str {
|
||||
"abc" => vec![Token::Str("abc")],
|
||||
"abc".to_string() => vec![Token::Str("abc")],
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => vec![Token::Option(false)],
|
||||
Some(1) => vec![
|
||||
Token::Option(true),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_slice {
|
||||
&[0][..0] => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
&[1, 2, 3][..] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[1, 2, 3] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => vec![
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1, 2, 3) => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_btreemap {
|
||||
btreemap![1 => 2] => vec![
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_named_unit {
|
||||
NamedUnit => vec![Token::NamedUnit("NamedUnit")],
|
||||
}
|
||||
test_named_seq {
|
||||
NamedSeq(1, 2, 3) => vec![
|
||||
Token::NamedSeqStart("NamedSeq", Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_named_map {
|
||||
NamedMap { a: 1, b: 2, c: 3 } => vec![
|
||||
Token::NamedMapStart("NamedMap", Some(3)),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_enum {
|
||||
Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
|
||||
Enum::Seq(1, 2) => vec![
|
||||
Token::EnumSeqStart("Enum", "Seq", Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Enum::Map { a: 1, b: 2 } => vec![
|
||||
Token::EnumMapStart("Enum", "Map", Some(2)),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user