mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix serde to compile on master again

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-11-22 16:27:01 -08:00
parent ff8c8c77cc
commit 857723dff6
15 changed files with 1115 additions and 1094 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
benches/bench_enum.rs
View File

@ -13,6 +13,8 @@ use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserialize}; use serde::de::{Deserializer, Deserialize};
use Animal::{Dog, Frog};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
@ -36,7 +38,10 @@ pub enum Error {
mod decoder { mod decoder {
use serialize::Decoder; use serialize::Decoder;
use super::{Animal, Dog, Frog, Error, SyntaxError, OtherError}; use super::{Animal, Error};
use super::Animal::{Dog, Frog};
use super::Error::{SyntaxError, OtherError};
use self::State::{AnimalState, IntState, StringState};
enum State { enum State {
AnimalState(Animal), AnimalState(Animal),
@ -184,7 +189,10 @@ mod decoder {
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
mod deserializer { mod deserializer {
use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError}; use super::{Animal, Error};
use super::Animal::{Dog, Frog};
use super::Error::{EndOfStream, SyntaxError};
use self::State::{AnimalState, IntState, StringState, EndState};
use serde::de; use serde::de;

84
benches/bench_log.rs
View File

@ -456,13 +456,13 @@ impl Log {
Log { Log {
timestamp: 2837513946597, timestamp: 2837513946597,
zone_id: 123456, zone_id: 123456,
zone_plan: FREE, zone_plan: ZonePlan::FREE,
http: Http { http: Http {
protocol: HTTP11, protocol: HttpProtocol::HTTP11,
status: 200, status: 200,
host_status: 503, host_status: 503,
up_status: 520, up_status: 520,
method: GET, method: HttpMethod::GET,
content_type: "text/html".to_string(), content_type: "text/html".to_string(),
user_agent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36".to_string(), user_agent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36".to_string(),
referer: "https://www.cloudflare.com/".to_string(), referer: "https://www.cloudflare.com/".to_string(),
@ -472,10 +472,10 @@ impl Log {
ip: "1.2.3.4".to_string(), ip: "1.2.3.4".to_string(),
port: 8000, port: 8000,
hostname: "www.example.com".to_string(), hostname: "www.example.com".to_string(),
protocol: HTTPS, protocol: OriginProtocol::HTTPS,
}, },
country: US, country: Country::US,
cache_status: Hit, cache_status: CacheStatus::Hit,
server_ip: "192.168.1.1".to_string(), server_ip: "192.168.1.1".to_string(),
server_name: "metal.cloudflare.com".to_string(), server_name: "metal.cloudflare.com".to_string(),
remote_ip: "10.1.2.3".to_string(), remote_ip: "10.1.2.3".to_string(),
@ -673,58 +673,58 @@ fn bench_copy(b: &mut Bencher) {
fn manual_no_escape<W: Writer>(mut wr: W, log: &Log) { fn manual_no_escape<W: Writer>(mut wr: W, log: &Log) {
wr.write_str("{\"timestamp\":").unwrap(); wr.write_str("{\"timestamp\":").unwrap();
(write!(wr, "{}", log.timestamp)).unwrap(); (write!(&mut wr, "{}", log.timestamp)).unwrap();
wr.write_str(",\"zone_id\":").unwrap(); wr.write_str(",\"zone_id\":").unwrap();
(write!(wr, "{}", log.zone_id)).unwrap(); (write!(&mut wr, "{}", log.zone_id)).unwrap();
wr.write_str(",\"zone_plan\":").unwrap(); wr.write_str(",\"zone_plan\":").unwrap();
(write!(wr, "{}", log.zone_plan as uint)).unwrap(); (write!(&mut wr, "{}", log.zone_plan as uint)).unwrap();
wr.write_str(",\"http\":{\"protocol\":").unwrap(); wr.write_str(",\"http\":{\"protocol\":").unwrap();
(write!(wr, "{}", log.http.protocol as uint)).unwrap(); (write!(&mut wr, "{}", log.http.protocol as uint)).unwrap();
wr.write_str(",\"status\":").unwrap(); wr.write_str(",\"status\":").unwrap();
(write!(wr, "{}", log.http.status)).unwrap(); (write!(&mut wr, "{}", log.http.status)).unwrap();
wr.write_str(",\"host_status\":").unwrap(); wr.write_str(",\"host_status\":").unwrap();
(write!(wr, "{}", log.http.host_status)).unwrap(); (write!(&mut wr, "{}", log.http.host_status)).unwrap();
wr.write_str(",\"up_status\":").unwrap(); wr.write_str(",\"up_status\":").unwrap();
(write!(wr, "{}", log.http.up_status)).unwrap(); (write!(&mut wr, "{}", log.http.up_status)).unwrap();
wr.write_str(",\"method\":").unwrap(); wr.write_str(",\"method\":").unwrap();
(write!(wr, "{}", log.http.method as uint)).unwrap(); (write!(&mut wr, "{}", log.http.method as uint)).unwrap();
wr.write_str(",\"content_type\":").unwrap(); wr.write_str(",\"content_type\":").unwrap();
(write!(wr, "\"{}\"", log.http.content_type)).unwrap(); (write!(&mut wr, "\"{}\"", log.http.content_type)).unwrap();
wr.write_str(",\"user_agent\":").unwrap(); wr.write_str(",\"user_agent\":").unwrap();
(write!(wr, "\"{}\"", log.http.user_agent)).unwrap(); (write!(&mut wr, "\"{}\"", log.http.user_agent)).unwrap();
wr.write_str(",\"referer\":").unwrap(); wr.write_str(",\"referer\":").unwrap();
(write!(wr, "\"{}\"", log.http.referer)).unwrap(); (write!(&mut wr, "\"{}\"", log.http.referer)).unwrap();
wr.write_str(",\"request_uri\":").unwrap(); wr.write_str(",\"request_uri\":").unwrap();
(write!(wr, "\"{}\"", log.http.request_uri)).unwrap(); (write!(&mut wr, "\"{}\"", log.http.request_uri)).unwrap();
wr.write_str("},\"origin\":{").unwrap(); wr.write_str("},\"origin\":{").unwrap();
wr.write_str("\"ip\":").unwrap(); wr.write_str("\"ip\":").unwrap();
(write!(wr, "\"{}\"", log.origin.ip)).unwrap(); (write!(&mut wr, "\"{}\"", log.origin.ip)).unwrap();
wr.write_str(",\"port\":").unwrap(); wr.write_str(",\"port\":").unwrap();
(write!(wr, "{}", log.origin.port)).unwrap(); (write!(&mut wr, "{}", log.origin.port)).unwrap();
wr.write_str(",\"hostname\":").unwrap(); wr.write_str(",\"hostname\":").unwrap();
(write!(wr, "\"{}\"", log.origin.hostname)).unwrap(); (write!(&mut wr, "\"{}\"", log.origin.hostname)).unwrap();
wr.write_str(",\"protocol\":").unwrap(); wr.write_str(",\"protocol\":").unwrap();
(write!(wr, "{}", log.origin.protocol as uint)).unwrap(); (write!(&mut wr, "{}", log.origin.protocol as uint)).unwrap();
wr.write_str("},\"country\":").unwrap(); wr.write_str("},\"country\":").unwrap();
(write!(wr, "{}", log.country as uint)).unwrap(); (write!(&mut wr, "{}", log.country as uint)).unwrap();
wr.write_str(",\"cache_status\":").unwrap(); wr.write_str(",\"cache_status\":").unwrap();
(write!(wr, "{}", log.cache_status as uint)).unwrap(); (write!(&mut wr, "{}", log.cache_status as uint)).unwrap();
wr.write_str(",\"server_ip\":").unwrap(); wr.write_str(",\"server_ip\":").unwrap();
(write!(wr, "\"{}\"", log.server_ip)).unwrap(); (write!(&mut wr, "\"{}\"", log.server_ip)).unwrap();
wr.write_str(",\"server_name\":").unwrap(); wr.write_str(",\"server_name\":").unwrap();
(write!(wr, "\"{}\"", log.server_name)).unwrap(); (write!(&mut wr, "\"{}\"", log.server_name)).unwrap();
wr.write_str(",\"remote_ip\":").unwrap(); wr.write_str(",\"remote_ip\":").unwrap();
(write!(wr, "\"{}\"", log.remote_ip)).unwrap(); (write!(&mut wr, "\"{}\"", log.remote_ip)).unwrap();
wr.write_str(",\"bytes_dlv\":").unwrap(); wr.write_str(",\"bytes_dlv\":").unwrap();
(write!(wr, "{}", log.bytes_dlv)).unwrap(); (write!(&mut wr, "{}", log.bytes_dlv)).unwrap();
wr.write_str(",\"ray_id\":").unwrap(); wr.write_str(",\"ray_id\":").unwrap();
(write!(wr, "\"{}\"", log.ray_id)).unwrap(); (write!(&mut wr, "\"{}\"", log.ray_id)).unwrap();
wr.write_str("}").unwrap(); wr.write_str("}").unwrap();
} }
@ -732,38 +732,38 @@ fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
wr.write_str("{").unwrap(); wr.write_str("{").unwrap();
escape_str(&mut wr, "timestamp").unwrap(); escape_str(&mut wr, "timestamp").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.timestamp)).unwrap(); (write!(&mut wr, "{}", log.timestamp)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "zone_id").unwrap(); escape_str(&mut wr, "zone_id").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.zone_id)).unwrap(); (write!(&mut wr, "{}", log.zone_id)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "zone_plan").unwrap(); escape_str(&mut wr, "zone_plan").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.zone_plan as int)).unwrap(); (write!(&mut wr, "{}", log.zone_plan as int)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "http").unwrap(); escape_str(&mut wr, "http").unwrap();
wr.write_str(":{").unwrap(); wr.write_str(":{").unwrap();
escape_str(&mut wr, "protocol").unwrap(); escape_str(&mut wr, "protocol").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.http.protocol as uint)).unwrap(); (write!(&mut wr, "{}", log.http.protocol as uint)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "status").unwrap(); escape_str(&mut wr, "status").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.http.status)).unwrap(); (write!(&mut wr, "{}", log.http.status)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "host_status").unwrap(); escape_str(&mut wr, "host_status").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.http.host_status)).unwrap(); (write!(&mut wr, "{}", log.http.host_status)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "up_status").unwrap(); escape_str(&mut wr, "up_status").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.http.up_status)).unwrap(); (write!(&mut wr, "{}", log.http.up_status)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "method").unwrap(); escape_str(&mut wr, "method").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.http.method as uint)).unwrap(); (write!(&mut wr, "{}", log.http.method as uint)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "content_type").unwrap(); escape_str(&mut wr, "content_type").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
@ -791,7 +791,7 @@ fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "port").unwrap(); escape_str(&mut wr, "port").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.origin.port)).unwrap(); (write!(&mut wr, "{}", log.origin.port)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "hostname").unwrap(); escape_str(&mut wr, "hostname").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
@ -799,16 +799,16 @@ fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "protocol").unwrap(); escape_str(&mut wr, "protocol").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.origin.protocol as uint)).unwrap(); (write!(&mut wr, "{}", log.origin.protocol as uint)).unwrap();
wr.write_str("},").unwrap(); wr.write_str("},").unwrap();
escape_str(&mut wr, "country").unwrap(); escape_str(&mut wr, "country").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.country as uint)).unwrap(); (write!(&mut wr, "{}", log.country as uint)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "cache_status").unwrap(); escape_str(&mut wr, "cache_status").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.cache_status as uint)).unwrap(); (write!(&mut wr, "{}", log.cache_status as uint)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "server_ip").unwrap(); escape_str(&mut wr, "server_ip").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
@ -824,7 +824,7 @@ fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "bytes_dlv").unwrap(); escape_str(&mut wr, "bytes_dlv").unwrap();
wr.write_str(":").unwrap(); wr.write_str(":").unwrap();
(write!(wr, "{}", log.bytes_dlv)).unwrap(); (write!(&mut wr, "{}", log.bytes_dlv)).unwrap();
wr.write_str(",").unwrap(); wr.write_str(",").unwrap();
escape_str(&mut wr, "ray_id").unwrap(); escape_str(&mut wr, "ray_id").unwrap();

8
benches/bench_map.rs
View File

@ -31,7 +31,9 @@ mod decoder {
use std::collections::hash_map::MoveEntries; use std::collections::hash_map::MoveEntries;
use serialize; use serialize;
use super::{Error, EndOfStream, SyntaxError, OtherError}; use super::Error;
use super::Error::{EndOfStream, SyntaxError, OtherError};
use self::Value::{StringValue, IntValue};
enum Value { enum Value {
StringValue(String), StringValue(String),
@ -172,7 +174,9 @@ mod deserializer {
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::MoveEntries; use std::collections::hash_map::MoveEntries;
use super::{Error, EndOfStream, SyntaxError}; use super::Error;
use super::Error::{EndOfStream, SyntaxError};
use self::State::{StartState, KeyOrEndState, ValueState, EndState};
use serde::de; use serde::de;

111
benches/bench_struct.rs
View File

@ -48,7 +48,20 @@ mod decoder {
use std::collections::HashMap; use std::collections::HashMap;
use serialize::Decoder; use serialize::Decoder;
use super::{Outer, Inner, Error, SyntaxError, OtherError}; use super::{Outer, Inner, Error};
use self::State::{
OuterState,
InnerState,
NullState,
UintState,
CharState,
StringState,
FieldState,
VecState,
MapState,
OptionState,
};
#[deriving(Show)] #[deriving(Show)]
enum State { enum State {
@ -80,7 +93,7 @@ mod decoder {
impl Decoder<Error> for OuterDecoder { impl Decoder<Error> for OuterDecoder {
fn error(&mut self, msg: &str) -> Error { fn error(&mut self, msg: &str) -> Error {
OtherError(msg.to_string()) Error::OtherError(msg.to_string())
} }
// Primitive types: // Primitive types:
@ -88,64 +101,64 @@ mod decoder {
fn read_nil(&mut self) -> Result<(), Error> { fn read_nil(&mut self) -> Result<(), Error> {
match self.stack.pop() { match self.stack.pop() {
Some(NullState) => Ok(()), Some(NullState) => Ok(()),
_ => Err(SyntaxError("NullState".to_string())), _ => Err(Error::SyntaxError("NullState".to_string())),
} }
} }
#[inline] #[inline]
fn read_uint(&mut self) -> Result<uint, Error> { fn read_uint(&mut self) -> Result<uint, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(UintState(value)) => Ok(value), Some(UintState(value)) => Ok(value),
_ => Err(SyntaxError("UintState".to_string())), _ => Err(Error::SyntaxError("UintState".to_string())),
} }
} }
fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError("".to_string())) } fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError("".to_string())) } fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError("".to_string())) } fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError("".to_string())) } fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_int(&mut self) -> Result<int, Error> { Err(SyntaxError("".to_string())) } fn read_int(&mut self) -> Result<int, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError("".to_string())) } fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError("".to_string())) } fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError("".to_string())) } fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError("".to_string())) } fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError("".to_string())) } fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError("".to_string())) } fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError("".to_string())) } fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError("".to_string())) }
#[inline] #[inline]
fn read_char(&mut self) -> Result<char, Error> { fn read_char(&mut self) -> Result<char, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(CharState(c)) => Ok(c), Some(CharState(c)) => Ok(c),
_ => Err(SyntaxError("".to_string())), _ => Err(Error::SyntaxError("".to_string())),
} }
} }
#[inline] #[inline]
fn read_str(&mut self) -> Result<String, Error> { fn read_str(&mut self) -> Result<String, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(StringState(value)) => Ok(value), Some(StringState(value)) => Ok(value),
_ => Err(SyntaxError("".to_string())), _ => Err(Error::SyntaxError("".to_string())),
} }
} }
// Compound types: // Compound types:
fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError("".to_string())) } fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_enum_variant<T>(&mut self, fn read_enum_variant<T>(&mut self,
_names: &[&str], _names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>) _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_enum_variant_arg<T>(&mut self, fn read_enum_variant_arg<T>(&mut self,
_a_idx: uint, _a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>) _f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_enum_struct_variant<T>(&mut self, fn read_enum_struct_variant<T>(&mut self,
_names: &[&str], _names: &[&str],
_f: |&mut OuterDecoder, uint| -> Result<T, Error>) _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_enum_struct_variant_field<T>(&mut self, fn read_enum_struct_variant_field<T>(&mut self,
_f_name: &str, _f_name: &str,
_f_idx: uint, _f_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>) _f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
#[inline] #[inline]
fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
@ -156,7 +169,7 @@ mod decoder {
self.stack.push(FieldState("inner")); self.stack.push(FieldState("inner"));
f(self) f(self)
} else { } else {
Err(SyntaxError("expected Outer".to_string())) Err(Error::SyntaxError("expected Outer".to_string()))
} }
} }
Some(InnerState(Inner { a: (), b, c })) => { Some(InnerState(Inner { a: (), b, c })) => {
@ -171,10 +184,10 @@ mod decoder {
self.stack.push(FieldState("a")); self.stack.push(FieldState("a"));
f(self) f(self)
} else { } else {
Err(SyntaxError("expected Inner".to_string())) Err(Error::SyntaxError("expected Inner".to_string()))
} }
} }
_ => Err(SyntaxError("expected InnerState or OuterState".to_string())), _ => Err(Error::SyntaxError("expected InnerState or OuterState".to_string())),
} }
} }
#[inline] #[inline]
@ -184,32 +197,32 @@ mod decoder {
if f_name == name { if f_name == name {
f(self) f(self)
} else { } else {
Err(SyntaxError("expected FieldState".to_string())) Err(Error::SyntaxError("expected FieldState".to_string()))
} }
} }
_ => Err(SyntaxError("expected FieldState".to_string())) _ => Err(Error::SyntaxError("expected FieldState".to_string()))
} }
} }
fn read_tuple<T>(&mut self, _len: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError("".to_string())) } fn read_tuple<T>(&mut self, _len: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError("".to_string())) } fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_tuple_struct<T>(&mut self, fn read_tuple_struct<T>(&mut self,
_s_name: &str, _s_name: &str,
_len: uint, _len: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>) _f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
fn read_tuple_struct_arg<T>(&mut self, fn read_tuple_struct_arg<T>(&mut self,
_a_idx: uint, _a_idx: uint,
_f: |&mut OuterDecoder| -> Result<T, Error>) _f: |&mut OuterDecoder| -> Result<T, Error>)
-> Result<T, Error> { Err(SyntaxError("".to_string())) } -> Result<T, Error> { Err(Error::SyntaxError("".to_string())) }
// Specialized types: // Specialized types:
#[inline] #[inline]
fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> {
match self.stack.pop() { match self.stack.pop() {
Some(OptionState(b)) => f(self, b), Some(OptionState(b)) => f(self, b),
_ => Err(SyntaxError("expected OptionState".to_string())), _ => Err(Error::SyntaxError("expected OptionState".to_string())),
} }
} }
@ -223,7 +236,7 @@ mod decoder {
} }
f(self, len) f(self, len)
} }
_ => Err(SyntaxError("expected VecState".to_string())) _ => Err(Error::SyntaxError("expected VecState".to_string()))
} }
} }
#[inline] #[inline]
@ -250,7 +263,7 @@ mod decoder {
} }
f(self, len) f(self, len)
} }
_ => Err(SyntaxError("expected MapState".to_string())), _ => Err(Error::SyntaxError("expected MapState".to_string())),
} }
} }
#[inline] #[inline]
@ -269,9 +282,24 @@ mod decoder {
mod deserializer { mod deserializer {
use std::collections::HashMap; use std::collections::HashMap;
use super::{Outer, Inner}; use super::{Outer, Inner};
use super::{Error, EndOfStream, SyntaxError, UnexpectedName, MissingField}; use super::Error;
use serde::de; use serde::de;
use self::State::{
OuterState,
InnerState,
FieldState,
NullState,
UintState,
CharState,
StringState,
OptionState,
//TupleState(uint),
VecState,
MapState,
EndState,
};
#[deriving(Show)] #[deriving(Show)]
enum State { enum State {
OuterState(Outer), OuterState(Outer),
@ -286,7 +314,6 @@ mod deserializer {
VecState(Vec<Inner>), VecState(Vec<Inner>),
MapState(HashMap<String, Option<char>>), MapState(HashMap<String, Option<char>>),
EndState, EndState,
} }
pub struct OuterDeserializer { pub struct OuterDeserializer {
@ -367,29 +394,29 @@ mod deserializer {
impl de::Deserializer<Error> for OuterDeserializer { impl de::Deserializer<Error> for OuterDeserializer {
#[inline] #[inline]
fn end_of_stream_error(&mut self) -> Error { fn end_of_stream_error(&mut self) -> Error {
EndOfStream Error::EndOfStream
} }
#[inline] #[inline]
fn syntax_error(&mut self, token: de::Token, expected: &[de::TokenKind]) -> Error { fn syntax_error(&mut self, token: de::Token, expected: &[de::TokenKind]) -> Error {
SyntaxError(format!("expected {}, found {}", expected, token)) Error::SyntaxError(format!("expected {}, found {}", expected, token))
} }
#[inline] #[inline]
fn unexpected_name_error(&mut self, token: de::Token) -> Error { fn unexpected_name_error(&mut self, token: de::Token) -> Error {
UnexpectedName(format!("found {}", token)) Error::UnexpectedName(format!("found {}", token))
} }
#[inline] #[inline]
fn conversion_error(&mut self, token: de::Token) -> Error { fn conversion_error(&mut self, token: de::Token) -> Error {
UnexpectedName(format!("found {}", token)) Error::UnexpectedName(format!("found {}", token))
} }
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserialize<OuterDeserializer, Error> T: de::Deserialize<OuterDeserializer, Error>
>(&mut self, field: &'static str) -> Result<T, Error> { >(&mut self, field: &'static str) -> Result<T, Error> {
Err(MissingField(field)) Err(Error::MissingField(field))
} }
} }
} }

7
benches/bench_vec.rs
View File

@ -29,7 +29,8 @@ mod decoder {
use std::vec; use std::vec;
use serialize; use serialize;
use super::{Error, EndOfStream, SyntaxError, OtherError}; use super::Error;
use super::Error::{EndOfStream, SyntaxError, OtherError};
pub struct IntDecoder { pub struct IntDecoder {
len: uint, len: uint,
@ -250,7 +251,9 @@ mod deserializer {
//use std::num; //use std::num;
use std::vec; use std::vec;
use super::{Error, EndOfStream, SyntaxError}; use super::Error;
use super::Error::{EndOfStream, SyntaxError};
use self::State::{StartState, SepOrEndState, EndState};
use serde::de; use serde::de;

14
serde_macros/src/lib.rs
View File

@ -409,10 +409,11 @@ fn deserialize_enum(
let arms: Vec<ast::Arm> = fields.iter() let arms: Vec<ast::Arm> = fields.iter()
.enumerate() .enumerate()
.map(|(i, &(name, span, ref parts))| { .map(|(i, &(name, span, ref parts))| {
let path = cx.path(span, vec![type_ident, name]);
let call = deserialize_static_fields( let call = deserialize_static_fields(
cx, cx,
span, span,
name, path,
serial_names.as_slice(), serial_names.as_slice(),
parts, parts,
|cx, _, _| { |cx, _, _| {
@ -425,7 +426,7 @@ fn deserialize_enum(
.collect(); .collect();
quote_expr!(cx, { quote_expr!(cx, {
let i = try!($deserializer.expect_enum_start($token, $type_name, $variants)); let i = try!($deserializer.expect_enum_start($token, $type_name, &$variants));
let result = match i { let result = match i {
$arms $arms
@ -444,15 +445,16 @@ fn deserialize_enum(
fn deserialize_static_fields( fn deserialize_static_fields(
cx: &ExtCtxt, cx: &ExtCtxt,
span: Span, span: Span,
outer_pat_ident: Ident, outer_pat_path: ast::Path,
serial_names: &[Option<token::InternedString>], serial_names: &[Option<token::InternedString>],
fields: &StaticFields, fields: &StaticFields,
getarg: |&ExtCtxt, Span, token::InternedString| -> P<Expr> getarg: |&ExtCtxt, Span, token::InternedString| -> P<Expr>
) -> P<Expr> { ) -> P<Expr> {
match *fields { match *fields {
Unnamed(ref fields) => { Unnamed(ref fields) => {
let path_expr = cx.expr_path(outer_pat_path);
if fields.is_empty() { if fields.is_empty() {
cx.expr_ident(span, outer_pat_ident) path_expr
} else { } else {
let fields = fields.iter().enumerate().map(|(i, &span)| { let fields = fields.iter().enumerate().map(|(i, &span)| {
getarg( getarg(
@ -462,7 +464,7 @@ fn deserialize_static_fields(
) )
}).collect(); }).collect();
cx.expr_call_ident(span, outer_pat_ident, fields) cx.expr_call(span, path_expr, fields)
} }
} }
Named(ref fields) => { Named(ref fields) => {
@ -480,7 +482,7 @@ fn deserialize_static_fields(
cx.field_imm(span, name, arg) cx.field_imm(span, name, arg)
}).collect(); }).collect();
cx.expr_struct_ident(span, outer_pat_ident, fields) cx.expr_struct(span, outer_pat_path, fields)
} }
} }
} }

618
src/de.rs
View File

File diff suppressed because it is too large Load Diff

28
src/json/builder.rs
View File

@ -11,7 +11,7 @@
use std::collections::TreeMap; use std::collections::TreeMap;
use std::str::StrAllocating; use std::str::StrAllocating;
use json::value::{Value, List, Object, ToJson}; use json::value::{ToJson, Value};
pub struct ListBuilder { pub struct ListBuilder {
list: Vec<Value>, list: Vec<Value>,
@ -23,7 +23,7 @@ impl ListBuilder {
} }
pub fn unwrap(self) -> Value { pub fn unwrap(self) -> Value {
List(self.list) Value::List(self.list)
} }
pub fn push<T: ToJson>(self, value: T) -> ListBuilder { pub fn push<T: ToJson>(self, value: T) -> ListBuilder {
@ -53,7 +53,7 @@ impl ObjectBuilder {
} }
pub fn unwrap(self) -> Value { pub fn unwrap(self) -> Value {
Object(self.object) Value::Object(self.object)
} }
pub fn insert<K: StrAllocating, V: ToJson>(self, key: K, value: V) -> ObjectBuilder { pub fn insert<K: StrAllocating, V: ToJson>(self, key: K, value: V) -> ObjectBuilder {
@ -77,25 +77,25 @@ impl ObjectBuilder {
mod tests { mod tests {
use std::collections::TreeMap; use std::collections::TreeMap;
use json::value::{Integer, List, Object}; use json::value::Value;
use super::{ListBuilder, ObjectBuilder}; use super::{ListBuilder, ObjectBuilder};
#[test] #[test]
fn test_list_builder() { fn test_list_builder() {
let value = ListBuilder::new().unwrap(); let value = ListBuilder::new().unwrap();
assert_eq!(value, List(Vec::new())); assert_eq!(value, Value::List(Vec::new()));
let value = ListBuilder::new() let value = ListBuilder::new()
.push(1i) .push(1i)
.push(2i) .push(2i)
.push(3i) .push(3i)
.unwrap(); .unwrap();
assert_eq!(value, List(vec!(Integer(1), Integer(2), Integer(3)))); assert_eq!(value, Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
let value = ListBuilder::new() let value = ListBuilder::new()
.push_list(|bld| bld.push(1i).push(2i).push(3i)) .push_list(|bld| bld.push(1i).push(2i).push(3i))
.unwrap(); .unwrap();
assert_eq!(value, List(vec!(List(vec!(Integer(1), Integer(2), Integer(3)))))); assert_eq!(value, Value::List(vec!(Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
let value = ListBuilder::new() let value = ListBuilder::new()
.push_object(|bld| .push_object(|bld|
@ -105,15 +105,15 @@ mod tests {
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = TreeMap::new();
map.insert("a".to_string(), Integer(1)); map.insert("a".to_string(), Value::Integer(1));
map.insert("b".to_string(), Integer(2)); map.insert("b".to_string(), Value::Integer(2));
assert_eq!(value, List(vec!(Object(map)))); assert_eq!(value, Value::List(vec!(Value::Object(map))));
} }
#[test] #[test]
fn test_object_builder() { fn test_object_builder() {
let value = ObjectBuilder::new().unwrap(); let value = ObjectBuilder::new().unwrap();
assert_eq!(value, Object(TreeMap::new())); assert_eq!(value, Value::Object(TreeMap::new()));
let value = ObjectBuilder::new() let value = ObjectBuilder::new()
.insert("a".to_string(), 1i) .insert("a".to_string(), 1i)
@ -121,8 +121,8 @@ mod tests {
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = TreeMap::new();
map.insert("a".to_string(), Integer(1)); map.insert("a".to_string(), Value::Integer(1));
map.insert("b".to_string(), Integer(2)); map.insert("b".to_string(), Value::Integer(2));
assert_eq!(value, Object(map)); assert_eq!(value, Value::Object(map));
} }
} }

67
src/json/de.rs
View File

@ -5,8 +5,8 @@ use std::char;
use de; use de;
use super::{Error, ErrorCode}; use super::error::{Error, ErrorCode};
use super::{ use super::error::ErrorCode::{
ConversionError, ConversionError,
EOFWhileParsingList, EOFWhileParsingList,
EOFWhileParsingObject, EOFWhileParsingObject,
@ -33,10 +33,19 @@ use super::{
UnexpectedName, UnexpectedName,
UnknownVariant, UnknownVariant,
}; };
use super::{ use super::error::Error::{
SyntaxError, SyntaxError,
}; };
use self::ParserState::{
ParseValue,
ParseListStart,
ParseListCommaOrEnd,
ParseObjectStart,
ParseObjectCommaOrEnd,
ParseObjectValue,
};
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
enum ParserState { enum ParserState {
// Parse a value. // Parse a value.
@ -92,15 +101,15 @@ impl<Iter: Iterator<u8>> Iterator<Result<de::Token, Error>> for Parser<Iter> {
ParseListCommaOrEnd => Some(self.parse_list_comma_or_end()), ParseListCommaOrEnd => Some(self.parse_list_comma_or_end()),
ParseObjectStart => { ParseObjectStart => {
match self.parse_object_start() { match self.parse_object_start() {
Ok(Some(s)) => Some(Ok(de::String(s.to_string()))), Ok(Some(s)) => Some(Ok(de::Token::String(s.to_string()))),
Ok(None) => Some(Ok(de::End)), Ok(None) => Some(Ok(de::Token::End)),
Err(err) => Some(Err(err)), Err(err) => Some(Err(err)),
} }
} }
ParseObjectCommaOrEnd => { ParseObjectCommaOrEnd => {
match self.parse_object_comma_or_end() { match self.parse_object_comma_or_end() {
Ok(Some(s)) => Some(Ok(de::String(s.to_string()))), Ok(Some(s)) => Some(Ok(de::Token::String(s.to_string()))),
Ok(None) => Some(Ok(de::End)), Ok(None) => Some(Ok(de::Token::End)),
Err(err) => Some(Err(err)), Err(err) => Some(Err(err)),
} }
} }
@ -191,9 +200,9 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
res = try!(self.parse_exponent(res)); res = try!(self.parse_exponent(res));
} }
Ok(de::F64(neg * res)) Ok(de::Token::F64(neg * res))
} else { } else {
Ok(de::I64(neg * res)) Ok(de::Token::I64(neg * res))
} }
} }
@ -361,7 +370,7 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
_ => return self.error(UnexpectedEndOfHexEscape), _ => return self.error(UnexpectedEndOfHexEscape),
} }
let buf = [n1, try!(self.decode_hex_escape())]; let buf = &[n1, try!(self.decode_hex_escape())];
match str::utf16_items(buf.as_slice()).next() { match str::utf16_items(buf.as_slice()).next() {
Some(ScalarValue(c)) => c, Some(ScalarValue(c)) => c,
_ => return self.error(LoneLeadingSurrogateInHexEscape), _ => return self.error(LoneLeadingSurrogateInHexEscape),
@ -374,7 +383,7 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
} }
}; };
let mut buf = [0u8, .. 4]; let buf = &mut [0u8, .. 4];
let len = c.encode_utf8(buf).unwrap_or(0); let len = c.encode_utf8(buf).unwrap_or(0);
self.buf.extend(buf.slice_to(len).iter().map(|b| *b)); self.buf.extend(buf.slice_to(len).iter().map(|b| *b));
} }
@ -404,7 +413,7 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
if self.ch_is(b']') { if self.ch_is(b']') {
self.bump(); self.bump();
Ok(de::End) Ok(de::Token::End)
} else { } else {
self.state_stack.push(ParseListCommaOrEnd); self.state_stack.push(ParseListCommaOrEnd);
self.parse_value() self.parse_value()
@ -421,7 +430,7 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
self.parse_value() self.parse_value()
} else if self.ch_is(b']') { } else if self.ch_is(b']') {
self.bump(); self.bump();
Ok(de::End) Ok(de::Token::End)
} else if self.eof() { } else if self.eof() {
self.error_event(EOFWhileParsingList) self.error_event(EOFWhileParsingList)
} else { } else {
@ -500,22 +509,22 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
} }
match self.ch_or_null() { match self.ch_or_null() {
b'n' => self.parse_ident(b"ull", de::Null), b'n' => self.parse_ident(b"ull", de::Token::Null),
b't' => self.parse_ident(b"rue", de::Bool(true)), b't' => self.parse_ident(b"rue", de::Token::Bool(true)),
b'f' => self.parse_ident(b"alse", de::Bool(false)), b'f' => self.parse_ident(b"alse", de::Token::Bool(false)),
b'0' ... b'9' | b'-' => self.parse_number(), b'0' ... b'9' | b'-' => self.parse_number(),
b'"' => { b'"' => {
Ok(de::String(try!(self.parse_string()).to_string())) Ok(de::Token::String(try!(self.parse_string()).to_string()))
} }
b'[' => { b'[' => {
self.bump(); self.bump();
self.state_stack.push(ParseListStart); self.state_stack.push(ParseListStart);
Ok(de::SeqStart(0)) Ok(de::Token::SeqStart(0))
} }
b'{' => { b'{' => {
self.bump(); self.bump();
self.state_stack.push(ParseObjectStart); self.state_stack.push(ParseObjectStart);
Ok(de::MapStart(0)) Ok(de::Token::MapStart(0))
} }
_ => { _ => {
self.error_event(ExpectedSomeValue) self.error_event(ExpectedSomeValue)
@ -563,7 +572,7 @@ impl<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
// JSON can represent `null` values as a missing value, so this isn't // JSON can represent `null` values as a missing value, so this isn't
// necessarily an error. // necessarily an error.
de::Deserialize::deserialize_token(self, de::Null) de::Deserialize::deserialize_token(self, de::Token::Null)
} }
// Special case treating options as a nullable value. // Special case treating options as a nullable value.
@ -572,7 +581,7 @@ impl<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
U: de::Deserialize<Parser<Iter>, Error> U: de::Deserialize<Parser<Iter>, Error>
>(&mut self, token: de::Token) -> Result<Option<U>, Error> { >(&mut self, token: de::Token) -> Result<Option<U>, Error> {
match token { match token {
de::Null => Ok(None), de::Token::Null => Ok(None),
token => { token => {
let value: U = try!(de::Deserialize::deserialize_token(self, token)); let value: U = try!(de::Deserialize::deserialize_token(self, token));
Ok(Some(value)) Ok(Some(value))
@ -587,19 +596,19 @@ impl<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
_name: &str, _name: &str,
variants: &[&str]) -> Result<uint, Error> { variants: &[&str]) -> Result<uint, Error> {
match token { match token {
de::MapStart(_) => { } de::Token::MapStart(_) => { }
_ => { return self.error(ExpectedEnumMapStart); } _ => { return self.error(ExpectedEnumMapStart); }
}; };
// Enums only have one field in them, which is the variant name. // Enums only have one field in them, which is the variant name.
let variant = match try!(self.expect_token()) { let variant = match try!(self.expect_token()) {
de::String(variant) => variant, de::Token::String(variant) => variant,
_ => { return self.error(ExpectedEnumVariantString); } _ => { return self.error(ExpectedEnumVariantString); }
}; };
// The variant's field is a list of the values. // The variant's field is a list of the values.
match try!(self.expect_token()) { match try!(self.expect_token()) {
de::SeqStart(_) => { } de::Token::SeqStart(_) => { }
_ => { return self.error(ExpectedEnumToken); } _ => { return self.error(ExpectedEnumToken); }
} }
@ -612,9 +621,9 @@ impl<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
fn expect_enum_end(&mut self) -> Result<(), Error> { fn expect_enum_end(&mut self) -> Result<(), Error> {
// There will be one `End` for the list, and one for the object. // There will be one `End` for the list, and one for the object.
match try!(self.expect_token()) { match try!(self.expect_token()) {
de::End => { de::Token::End => {
match try!(self.expect_token()) { match try!(self.expect_token()) {
de::End => Ok(()), de::Token::End => Ok(()),
_ => self.error(ExpectedEnumEndToken), _ => self.error(ExpectedEnumEndToken),
} }
} }
@ -625,10 +634,10 @@ impl<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
#[inline] #[inline]
fn expect_struct_start(&mut self, token: de::Token, _name: &str) -> Result<(), Error> { fn expect_struct_start(&mut self, token: de::Token, _name: &str) -> Result<(), Error> {
match token { match token {
de::MapStart(_) => Ok(()), de::Token::MapStart(_) => Ok(()),
_ => { _ => {
static EXPECTED_TOKENS: &'static [de::TokenKind] = [ static EXPECTED_TOKENS: &'static [de::TokenKind] = &[
de::MapStartKind, de::TokenKind::MapStartKind,
]; ];
Err(self.syntax_error(token, EXPECTED_TOKENS)) Err(self.syntax_error(token, EXPECTED_TOKENS))
} }

125
src/json/error.rs Normal file
View File

@ -0,0 +1,125 @@
use std::error;
use std::fmt;
use std::io;
use de::{Token, TokenKind};
/// The errors that can arise while parsing a JSON stream.
#[deriving(Clone, PartialEq)]
pub enum ErrorCode {
ConversionError(Token),
EOFWhileParsingList,
EOFWhileParsingObject,
EOFWhileParsingString,
EOFWhileParsingValue,
ExpectedColon,
ExpectedConversion,
ExpectedEnumEnd,
ExpectedEnumEndToken,
ExpectedEnumMapStart,
ExpectedEnumToken,
ExpectedEnumVariantString,
ExpectedListCommaOrEnd,
ExpectedName,
ExpectedObjectCommaOrEnd,
ExpectedSomeIdent,
ExpectedSomeValue,
ExpectedTokens(Token, &'static [TokenKind]),
InvalidEscape,
InvalidNumber,
InvalidUnicodeCodePoint,
KeyMustBeAString,
LoneLeadingSurrogateInHexEscape,
MissingField(&'static str),
NotFourDigit,
NotUtf8,
TrailingCharacters,
UnexpectedEndOfHexEscape,
UnexpectedName(Token),
UnknownVariant,
UnrecognizedHex,
}
impl fmt::Show for ErrorCode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ErrorCode::ConversionError(ref token) => write!(f, "failed to convert {}", token),
ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
ErrorCode::ExpectedColon => "expected `:`".fmt(f),
ErrorCode::ExpectedConversion => "expected conversion".fmt(f),
ErrorCode::ExpectedEnumEnd => "expected enum end".fmt(f),
ErrorCode::ExpectedEnumEndToken => "expected enum map end".fmt(f),
ErrorCode::ExpectedEnumMapStart => "expected enum map start".fmt(f),
ErrorCode::ExpectedEnumToken => "expected enum token".fmt(f),
ErrorCode::ExpectedEnumVariantString => "expected variant".fmt(f),
ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
ErrorCode::ExpectedName => "expected name".fmt(f),
ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),
ErrorCode::ExpectedSomeIdent => "expected ident".fmt(f),
ErrorCode::ExpectedSomeValue => "expected value".fmt(f),
ErrorCode::ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token),
ErrorCode::InvalidEscape => "invalid escape".fmt(f),
ErrorCode::InvalidNumber => "invalid number".fmt(f),
ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
ErrorCode::UnexpectedName(ref name) => write!(f, "unexpected name {}", name),
ErrorCode::UnknownVariant => "unknown variant".fmt(f),
ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
}
}
}
#[deriving(Clone, PartialEq, Show)]
pub enum Error {
/// msg, line, col
SyntaxError(ErrorCode, uint, uint),
IoError(io::IoError),
ExpectedError(String, String),
MissingFieldError(String),
UnknownVariantError(String),
}
impl error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::SyntaxError(..) => "syntax error",
Error::IoError(ref error) => error.description(),
Error::ExpectedError(ref expected, _) => expected.as_slice(),
Error::MissingFieldError(_) => "missing field",
Error::UnknownVariantError(_) => "unknown variant",
}
}
fn detail(&self) -> Option<String> {
match *self {
Error::SyntaxError(ref code, line, col) => {
Some(format!("{} at line {} column {}", code, line, col))
}
Error::IoError(ref error) => error.detail(),
Error::ExpectedError(ref expected, ref found) => {
Some(format!("expected {}, found {}", expected, found))
}
Error::MissingFieldError(ref field) => {
Some(format!("missing field {}", field))
}
Error::UnknownVariantError(ref variant) => {
Some(format!("unknown variant {}", variant))
}
}
}
}
impl error::FromError<io::IoError> for Error {
fn from_error(error: io::IoError) -> Error {
Error::IoError(error)
}
}

556
src/json/mod.rs
View File

File diff suppressed because it is too large Load Diff

44
src/json/ser.rs
View File

@ -44,7 +44,7 @@ pub fn escape_str<W: Writer>(wr: &mut W, v: &str) -> IoResult<()> {
} }
fn escape_char<W: Writer>(wr: &mut W, v: char) -> IoResult<()> { fn escape_char<W: Writer>(wr: &mut W, v: char) -> IoResult<()> {
let mut buf = [0, .. 4]; let buf = &mut [0, .. 4];
v.encode_utf8(buf); v.encode_utf8(buf);
escape_bytes(wr, buf) escape_bytes(wr, buf)
} }
@ -65,7 +65,7 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, v: f64) -> IoResult<()> {
fn spaces<W: Writer>(wr: &mut W, mut n: uint) -> IoResult<()> { fn spaces<W: Writer>(wr: &mut W, mut n: uint) -> IoResult<()> {
const LEN: uint = 16; const LEN: uint = 16;
const BUF: [u8, ..LEN] = [b' ', ..LEN]; const BUF: &'static [u8, ..LEN] = &[b' ', ..LEN];
while n >= LEN { while n >= LEN {
try!(wr.write(BUF)); try!(wr.write(BUF));
@ -128,52 +128,52 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_int(&mut self, v: int) -> IoResult<()> { fn serialize_int(&mut self, v: int) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i8(&mut self, v: i8) -> IoResult<()> { fn serialize_i8(&mut self, v: i8) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i16(&mut self, v: i16) -> IoResult<()> { fn serialize_i16(&mut self, v: i16) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i32(&mut self, v: i32) -> IoResult<()> { fn serialize_i32(&mut self, v: i32) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i64(&mut self, v: i64) -> IoResult<()> { fn serialize_i64(&mut self, v: i64) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_uint(&mut self, v: uint) -> IoResult<()> { fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u8(&mut self, v: u8) -> IoResult<()> { fn serialize_u8(&mut self, v: u8) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u16(&mut self, v: u16) -> IoResult<()> { fn serialize_u16(&mut self, v: u16) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u32(&mut self, v: u32) -> IoResult<()> { fn serialize_u32(&mut self, v: u32) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u64(&mut self, v: u64) -> IoResult<()> { fn serialize_u64(&mut self, v: u64) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
@ -391,52 +391,52 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_int(&mut self, v: int) -> IoResult<()> { fn serialize_int(&mut self, v: int) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i8(&mut self, v: i8) -> IoResult<()> { fn serialize_i8(&mut self, v: i8) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i16(&mut self, v: i16) -> IoResult<()> { fn serialize_i16(&mut self, v: i16) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i32(&mut self, v: i32) -> IoResult<()> { fn serialize_i32(&mut self, v: i32) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_i64(&mut self, v: i64) -> IoResult<()> { fn serialize_i64(&mut self, v: i64) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_uint(&mut self, v: uint) -> IoResult<()> { fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u8(&mut self, v: u8) -> IoResult<()> { fn serialize_u8(&mut self, v: u8) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u16(&mut self, v: u16) -> IoResult<()> { fn serialize_u16(&mut self, v: u16) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u32(&mut self, v: u32) -> IoResult<()> { fn serialize_u32(&mut self, v: u32) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]
fn serialize_u64(&mut self, v: u64) -> IoResult<()> { fn serialize_u64(&mut self, v: u64) -> IoResult<()> {
write!(self.wr, "{}", v) write!(&mut self.wr, "{}", v)
} }
#[inline] #[inline]

303
src/json/value.rs
View File

@ -6,23 +6,12 @@ use std::str;
use std::string; use std::string;
use std::vec; use std::vec;
use de; use de::{mod, Token, TokenKind};
use ser::Serialize; use ser::Serialize;
use ser; use ser;
use super::PrettySerializer; use super::ser::{Serializer, PrettySerializer};
use super::Serializer; use super::error::{Error, ErrorCode};
use super::Error;
use super::{
ConversionError,
EOFWhileParsingValue,
ExpectedError,
ExpectedTokens,
MissingFieldError,
SyntaxError,
UnexpectedName,
UnknownVariantError,
};
/// Represents a JSON value /// Represents a JSON value
#[deriving(Clone, PartialEq, PartialOrd)] #[deriving(Clone, PartialEq, PartialOrd)]
@ -61,7 +50,7 @@ impl Value {
/// Otherwise, returns None. /// Otherwise, returns None.
pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Value>{ pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Value>{
match self { match self {
&Object(ref map) => map.get(key), &Value::Object(ref map) => map.get(key),
_ => None _ => None
} }
} }
@ -85,7 +74,7 @@ impl Value {
/// or the Json value is not an Object, returns None. /// or the Json value is not an Object, returns None.
pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Value> { pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Value> {
match self { match self {
&Object(ref map) => { &Value::Object(ref map) => {
match map.get(key) { match map.get(key) {
Some(json_value) => Some(json_value), Some(json_value) => Some(json_value),
None => { None => {
@ -113,7 +102,7 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_object<'a>(&'a self) -> Option<&'a TreeMap<string::String, Value>> { pub fn as_object<'a>(&'a self) -> Option<&'a TreeMap<string::String, Value>> {
match *self { match *self {
Object(ref map) => Some(map), Value::Object(ref map) => Some(map),
_ => None _ => None
} }
} }
@ -127,7 +116,7 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_list<'a>(&'a self) -> Option<&'a Vec<Value>> { pub fn as_list<'a>(&'a self) -> Option<&'a Vec<Value>> {
match *self { match *self {
List(ref list) => Some(list), Value::List(ref list) => Some(list),
_ => None _ => None
} }
} }
@ -141,7 +130,7 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_string<'a>(&'a self) -> Option<&'a str> { pub fn as_string<'a>(&'a self) -> Option<&'a str> {
match *self { match *self {
String(ref s) => Some(s.as_slice()), Value::String(ref s) => Some(s.as_slice()),
_ => None _ => None
} }
} }
@ -149,7 +138,7 @@ impl Value {
/// Returns true if the Json value is a i64 or f64. Returns false otherwise. /// Returns true if the Json value is a i64 or f64. Returns false otherwise.
pub fn is_number(&self) -> bool { pub fn is_number(&self) -> bool {
match *self { match *self {
Integer(_) | Floating(_) => true, Value::Integer(_) | Value::Floating(_) => true,
_ => false, _ => false,
} }
} }
@ -157,7 +146,7 @@ impl Value {
/// Returns true if the Json value is a i64. Returns false otherwise. /// Returns true if the Json value is a i64. Returns false otherwise.
pub fn is_i64(&self) -> bool { pub fn is_i64(&self) -> bool {
match *self { match *self {
Integer(_) => true, Value::Integer(_) => true,
_ => false, _ => false,
} }
} }
@ -165,7 +154,7 @@ impl Value {
/// Returns true if the Json value is a f64. Returns false otherwise. /// Returns true if the Json value is a f64. Returns false otherwise.
pub fn is_f64(&self) -> bool { pub fn is_f64(&self) -> bool {
match *self { match *self {
Floating(_) => true, Value::Floating(_) => true,
_ => false, _ => false,
} }
} }
@ -174,8 +163,8 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_i64(&self) -> Option<i64> { pub fn as_i64(&self) -> Option<i64> {
match *self { match *self {
Integer(n) => Some(n), Value::Integer(n) => Some(n),
Floating(n) => Some(n as i64), Value::Floating(n) => Some(n as i64),
_ => None _ => None
} }
} }
@ -184,8 +173,8 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_f64(&self) -> Option<f64> { pub fn as_f64(&self) -> Option<f64> {
match *self { match *self {
Integer(n) => Some(n as f64), Value::Integer(n) => Some(n as f64),
Floating(n) => Some(n), Value::Floating(n) => Some(n),
_ => None _ => None
} }
} }
@ -199,7 +188,7 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_boolean(&self) -> Option<bool> { pub fn as_boolean(&self) -> Option<bool> {
match *self { match *self {
Boolean(b) => Some(b), Value::Boolean(b) => Some(b),
_ => None _ => None
} }
} }
@ -213,7 +202,7 @@ impl Value {
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_null(&self) -> Option<()> { pub fn as_null(&self) -> Option<()> {
match *self { match *self {
Null => Some(()), Value::Null => Some(()),
_ => None _ => None
} }
} }
@ -231,7 +220,7 @@ impl<'a, 'b> Writer for WriterFormatter<'a, 'b> {
impl fmt::Show for Value { impl fmt::Show for Value {
/// Serializes a json value into a string /// Serializes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.to_writer(WriterFormatter(f)).map_err(|_| fmt::WriteError) self.to_writer(WriterFormatter(f)).map_err(|_| fmt::Error)
} }
} }
@ -239,25 +228,25 @@ impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Value {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
match *self { match *self {
Null => { Value::Null => {
().serialize(s) ().serialize(s)
} }
Boolean(v) => { Value::Boolean(v) => {
v.serialize(s) v.serialize(s)
} }
Integer(v) => { Value::Integer(v) => {
v.serialize(s) v.serialize(s)
} }
Floating(v) => { Value::Floating(v) => {
v.serialize(s) v.serialize(s)
} }
String(ref v) => { Value::String(ref v) => {
v.serialize(s) v.serialize(s)
} }
List(ref v) => { Value::List(ref v) => {
v.serialize(s) v.serialize(s)
} }
Object(ref v) => { Value::Object(ref v) => {
v.serialize(s) v.serialize(s)
} }
} }
@ -266,124 +255,124 @@ impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Value {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value { impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Value, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<Value, E> {
match token { match token {
de::Null => Ok(Null), Token::Null => Ok(Value::Null),
de::Bool(x) => Ok(Boolean(x)), Token::Bool(x) => Ok(Value::Boolean(x)),
de::Int(x) => Ok(Integer(x as i64)), Token::Int(x) => Ok(Value::Integer(x as i64)),
de::I8(x) => Ok(Integer(x as i64)), Token::I8(x) => Ok(Value::Integer(x as i64)),
de::I16(x) => Ok(Integer(x as i64)), Token::I16(x) => Ok(Value::Integer(x as i64)),
de::I32(x) => Ok(Integer(x as i64)), Token::I32(x) => Ok(Value::Integer(x as i64)),
de::I64(x) => Ok(Integer(x)), Token::I64(x) => Ok(Value::Integer(x)),
de::Uint(x) => Ok(Integer(x as i64)), Token::Uint(x) => Ok(Value::Integer(x as i64)),
de::U8(x) => Ok(Integer(x as i64)), Token::U8(x) => Ok(Value::Integer(x as i64)),
de::U16(x) => Ok(Integer(x as i64)), Token::U16(x) => Ok(Value::Integer(x as i64)),
de::U32(x) => Ok(Integer(x as i64)), Token::U32(x) => Ok(Value::Integer(x as i64)),
de::U64(x) => Ok(Integer(x as i64)), Token::U64(x) => Ok(Value::Integer(x as i64)),
de::F32(x) => Ok(Floating(x as f64)), Token::F32(x) => Ok(Value::Floating(x as f64)),
de::F64(x) => Ok(Floating(x)), Token::F64(x) => Ok(Value::Floating(x)),
de::Char(x) => Ok(String(x.to_string())), Token::Char(x) => Ok(Value::String(x.to_string())),
de::Str(x) => Ok(String(x.to_string())), Token::Str(x) => Ok(Value::String(x.to_string())),
de::String(x) => Ok(String(x)), Token::String(x) => Ok(Value::String(x)),
de::Option(false) => Ok(Null), Token::Option(false) => Ok(Value::Null),
de::Option(true) => de::Deserialize::deserialize(d), Token::Option(true) => de::Deserialize::deserialize(d),
de::TupleStart(_) | de::SeqStart(_) => { Token::TupleStart(_) | Token::SeqStart(_) => {
let list = try!(de::Deserialize::deserialize_token(d, token)); let list = try!(de::Deserialize::deserialize_token(d, token));
Ok(List(list)) Ok(Value::List(list))
} }
de::StructStart(_, _) | de::MapStart(_) => { Token::StructStart(_, _) | Token::MapStart(_) => {
let object = try!(de::Deserialize::deserialize_token(d, token)); let object = try!(de::Deserialize::deserialize_token(d, token));
Ok(Object(object)) Ok(Value::Object(object))
} }
de::EnumStart(_, name, len) => { Token::EnumStart(_, name, len) => {
let token = de::SeqStart(len); let token = Token::SeqStart(len);
let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token)); let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token));
let mut object = TreeMap::new(); let mut object = TreeMap::new();
object.insert(name.to_string(), List(fields)); object.insert(name.to_string(), Value::List(fields));
Ok(Object(object)) Ok(Value::Object(object))
} }
de::End => { Token::End => {
static EXPECTED_TOKENS: &'static [de::TokenKind] = [ static EXPECTED_TOKENS: &'static [TokenKind] = &[
de::EndKind, TokenKind::EndKind,
]; ];
Err(d.syntax_error(de::End, EXPECTED_TOKENS)) Err(d.syntax_error(Token::End, EXPECTED_TOKENS))
} }
} }
} }
} }
enum DeserializerState { enum State {
DeserializerValueState(Value), Value(Value),
DeserializerListState(vec::MoveItems<Value>), List(vec::MoveItems<Value>),
DeserializerObjectState(tree_map::MoveEntries<string::String, Value>), Object(tree_map::MoveEntries<string::String, Value>),
DeserializerEndState, End,
} }
pub struct Deserializer { pub struct Deserializer {
stack: Vec<DeserializerState>, stack: Vec<State>,
} }
impl Deserializer { impl Deserializer {
/// Creates a new deserializer instance for deserializing the specified JSON value. /// Creates a new deserializer instance for deserializing the specified JSON value.
pub fn new(json: Value) -> Deserializer { pub fn new(json: Value) -> Deserializer {
Deserializer { Deserializer {
stack: vec!(DeserializerValueState(json)), stack: vec!(State::Value(json)),
} }
} }
} }
impl Iterator<Result<de::Token, Error>> for Deserializer { impl Iterator<Result<Token, Error>> for Deserializer {
#[inline] #[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> { fn next(&mut self) -> Option<Result<Token, Error>> {
loop { loop {
match self.stack.pop() { match self.stack.pop() {
Some(DeserializerValueState(value)) => { Some(State::Value(value)) => {
let token = match value { let token = match value {
Null => de::Null, Value::Null => Token::Null,
Boolean(x) => de::Bool(x), Value::Boolean(x) => Token::Bool(x),
Integer(x) => de::I64(x), Value::Integer(x) => Token::I64(x),
Floating(x) => de::F64(x), Value::Floating(x) => Token::F64(x),
String(x) => de::String(x), Value::String(x) => Token::String(x),
List(x) => { Value::List(x) => {
let len = x.len(); let len = x.len();
self.stack.push(DeserializerListState(x.into_iter())); self.stack.push(State::List(x.into_iter()));
de::SeqStart(len) Token::SeqStart(len)
} }
Object(x) => { Value::Object(x) => {
let len = x.len(); let len = x.len();
self.stack.push(DeserializerObjectState(x.into_iter())); self.stack.push(State::Object(x.into_iter()));
de::MapStart(len) Token::MapStart(len)
} }
}; };
return Some(Ok(token)); return Some(Ok(token));
} }
Some(DeserializerListState(mut iter)) => { Some(State::List(mut iter)) => {
match iter.next() { match iter.next() {
Some(value) => { Some(value) => {
self.stack.push(DeserializerListState(iter)); self.stack.push(State::List(iter));
self.stack.push(DeserializerValueState(value)); self.stack.push(State::Value(value));
// loop around. // loop around.
} }
None => { None => {
return Some(Ok(de::End)); return Some(Ok(Token::End));
} }
} }
} }
Some(DeserializerObjectState(mut iter)) => { Some(State::Object(mut iter)) => {
match iter.next() { match iter.next() {
Some((key, value)) => { Some((key, value)) => {
self.stack.push(DeserializerObjectState(iter)); self.stack.push(State::Object(iter));
self.stack.push(DeserializerValueState(value)); self.stack.push(State::Value(value));
return Some(Ok(de::String(key))); return Some(Ok(Token::String(key)));
} }
None => { None => {
return Some(Ok(de::End)); return Some(Ok(Token::End));
} }
} }
} }
Some(DeserializerEndState) => { Some(State::End) => {
return Some(Ok(de::End)); return Some(Ok(Token::End));
} }
None => { return None; } None => { return None; }
} }
@ -393,21 +382,21 @@ impl Iterator<Result<de::Token, Error>> for Deserializer {
impl de::Deserializer<Error> for Deserializer { impl de::Deserializer<Error> for Deserializer {
fn end_of_stream_error(&mut self) -> Error { fn end_of_stream_error(&mut self) -> Error {
SyntaxError(EOFWhileParsingValue, 0, 0) Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0)
} }
fn syntax_error(&mut self, fn syntax_error(&mut self,
token: de::Token, token: Token,
expected: &'static [de::TokenKind]) -> Error { expected: &'static [TokenKind]) -> Error {
SyntaxError(ExpectedTokens(token, expected), 0, 0) Error::SyntaxError(ErrorCode::ExpectedTokens(token, expected), 0, 0)
} }
fn unexpected_name_error(&mut self, token: de::Token) -> Error { fn unexpected_name_error(&mut self, token: Token) -> Error {
SyntaxError(UnexpectedName(token), 0, 0) Error::SyntaxError(ErrorCode::UnexpectedName(token), 0, 0)
} }
fn conversion_error(&mut self, token: de::Token) -> Error { fn conversion_error(&mut self, token: Token) -> Error {
SyntaxError(ConversionError(token), 0, 0) Error::SyntaxError(ErrorCode::ConversionError(token), 0, 0)
} }
#[inline] #[inline]
@ -416,16 +405,16 @@ impl de::Deserializer<Error> for Deserializer {
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
// JSON can represent `null` values as a missing value, so this isn't // JSON can represent `null` values as a missing value, so this isn't
// necessarily an error. // necessarily an error.
de::Deserialize::deserialize_token(self, de::Null) de::Deserialize::deserialize_token(self, Token::Null)
} }
// Special case treating options as a nullable value. // Special case treating options as a nullable value.
#[inline] #[inline]
fn expect_option< fn expect_option<
U: de::Deserialize<Deserializer, Error> U: de::Deserialize<Deserializer, Error>
>(&mut self, token: de::Token) -> Result<Option<U>, Error> { >(&mut self, token: Token) -> Result<Option<U>, Error> {
match token { match token {
de::Null => Ok(None), Token::Null => Ok(None),
token => { token => {
let value: U = try!(de::Deserialize::deserialize_token(self, token)); let value: U = try!(de::Deserialize::deserialize_token(self, token));
Ok(Some(value)) Ok(Some(value))
@ -436,64 +425,80 @@ impl de::Deserializer<Error> for Deserializer {
// Special case treating enums as a String or a `{"variant": "...", "fields": [...]}`. // Special case treating enums as a String or a `{"variant": "...", "fields": [...]}`.
#[inline] #[inline]
fn expect_enum_start(&mut self, fn expect_enum_start(&mut self,
token: de::Token, token: Token,
_name: &str, _name: &str,
variants: &[&str]) -> Result<uint, Error> { variants: &[&str]) -> Result<uint, Error> {
let variant = match token { let variant = match token {
de::MapStart(_) => { Token::MapStart(_) => {
let state = match self.stack.pop() { let state = match self.stack.pop() {
Some(state) => state, Some(state) => state,
None => { panic!("state machine error, state stack empty"); } None => { panic!("state machine error, state stack empty"); }
}; };
let mut iter = match state { let mut iter = match state {
DeserializerObjectState(iter) => iter, State::Object(iter) => iter,
_ => { panic!("state machine error, expected an object"); } _ => { panic!("state machine error, expected an object"); }
}; };
let (variant, fields) = match iter.next() { let (variant, fields) = match iter.next() {
Some((variant, List(fields))) => (variant, fields), Some((variant, Value::List(fields))) => (variant, fields),
Some((key, value)) => { Some((key, value)) => {
return Err(ExpectedError("List".to_string(), format!("{} => {}", key, value))); return Err(
Error::ExpectedError(
"List".to_string(),
format!("{} => {}", key, value)
)
);
}
None => {
return Err(Error::MissingFieldError("<variant-name>".to_string()));
} }
None => { return Err(MissingFieldError("<variant-name>".to_string())); }
}; };
// Error out if there are other fields in the enum. // Error out if there are other fields in the enum.
match iter.next() { match iter.next() {
Some((key, value)) => { Some((key, value)) => {
return Err(ExpectedError("None".to_string(), format!("{} => {}", key, value))); return Err(
Error::ExpectedError(
"None".to_string(),
format!("{} => {}", key, value)
)
);
} }
None => { } None => { }
} }
self.stack.push(DeserializerEndState); self.stack.push(State::End);
for field in fields.into_iter().rev() { for field in fields.into_iter().rev() {
self.stack.push(DeserializerValueState(field)); self.stack.push(State::Value(field));
} }
variant variant
} }
token => { token => {
return Err(ExpectedError("String or Object".to_string(), return Err(
format!("{}", token))) Error::ExpectedError(
"String or Object".to_string(),
format!("{}", token)
)
);
} }
}; };
match variants.iter().position(|v| *v == variant.as_slice()) { match variants.iter().position(|v| *v == variant.as_slice()) {
Some(idx) => Ok(idx), Some(idx) => Ok(idx),
None => Err(UnknownVariantError(variant)), None => Err(Error::UnknownVariantError(variant)),
} }
} }
#[inline] #[inline]
fn expect_struct_start(&mut self, token: de::Token, _name: &str) -> Result<(), Error> { fn expect_struct_start(&mut self, token: Token, _name: &str) -> Result<(), Error> {
match token { match token {
de::MapStart(_) => Ok(()), Token::MapStart(_) => Ok(()),
_ => { _ => {
static EXPECTED_TOKENS: &'static [de::TokenKind] = [ static EXPECTED_TOKENS: &'static [TokenKind] = &[
de::MapStartKind TokenKind::MapStartKind
]; ];
Err(self.syntax_error(token, EXPECTED_TOKENS)) Err(self.syntax_error(token, EXPECTED_TOKENS))
} }
@ -520,63 +525,63 @@ impl ToJson for Value {
} }
impl ToJson for int { impl ToJson for int {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for i8 { impl ToJson for i8 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for i16 { impl ToJson for i16 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for i32 { impl ToJson for i32 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for i64 { impl ToJson for i64 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for uint { impl ToJson for uint {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for u8 { impl ToJson for u8 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for u16 { impl ToJson for u16 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for u32 { impl ToJson for u32 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for u64 { impl ToJson for u64 {
fn to_json(&self) -> Value { Integer(*self as i64) } fn to_json(&self) -> Value { Value::Integer(*self as i64) }
} }
impl ToJson for f32 { impl ToJson for f32 {
fn to_json(&self) -> Value { Floating(*self as f64) } fn to_json(&self) -> Value { Value::Floating(*self as f64) }
} }
impl ToJson for f64 { impl ToJson for f64 {
fn to_json(&self) -> Value { Floating(*self) } fn to_json(&self) -> Value { Value::Floating(*self) }
} }
impl ToJson for bool { impl ToJson for bool {
fn to_json(&self) -> Value { Boolean(*self) } fn to_json(&self) -> Value { Value::Boolean(*self) }
} }
impl<'a> ToJson for &'a str { impl<'a> ToJson for &'a str {
fn to_json(&self) -> Value { String(self.to_string()) } fn to_json(&self) -> Value { Value::String(self.to_string()) }
} }
impl ToJson for string::String { impl ToJson for string::String {
fn to_json(&self) -> Value { String((*self).clone()) } fn to_json(&self) -> Value { Value::String((*self).clone()) }
} }
macro_rules! peel_to_json_tuple { macro_rules! peel_to_json_tuple {
@ -588,7 +593,7 @@ macro_rules! impl_to_json_tuple {
impl<> ToJson for () { impl<> ToJson for () {
#[inline] #[inline]
fn to_json(&self) -> Value { fn to_json(&self) -> Value {
Null Value::Null
} }
} }
}; };
@ -608,7 +613,7 @@ macro_rules! impl_to_json_tuple {
list.push($name.to_json()); list.push($name.to_json());
)* )*
List(list) Value::List(list)
} }
} }
peel_to_json_tuple!($($name,)*) peel_to_json_tuple!($($name,)*)
@ -618,7 +623,9 @@ macro_rules! impl_to_json_tuple {
impl_to_json_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, } impl_to_json_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
impl<A:ToJson> ToJson for Vec<A> { impl<A:ToJson> ToJson for Vec<A> {
fn to_json(&self) -> Value { List(self.iter().map(|elt| elt.to_json()).collect()) } fn to_json(&self) -> Value {
Value::List(self.iter().map(|elt| elt.to_json()).collect())
}
} }
impl<A:ToJson> ToJson for TreeMap<string::String, A> { impl<A:ToJson> ToJson for TreeMap<string::String, A> {
@ -627,7 +634,7 @@ impl<A:ToJson> ToJson for TreeMap<string::String, A> {
for (key, value) in self.iter() { for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json()); d.insert((*key).clone(), value.to_json());
} }
Object(d) Value::Object(d)
} }
} }
@ -637,14 +644,14 @@ impl<A:ToJson> ToJson for HashMap<string::String, A> {
for (key, value) in self.iter() { for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json()); d.insert((*key).clone(), value.to_json());
} }
Object(d) Value::Object(d)
} }
} }
impl<A:ToJson> ToJson for Option<A> { impl<A:ToJson> ToJson for Option<A> {
fn to_json(&self) -> Value { fn to_json(&self) -> Value {
match *self { match *self {
None => Null, None => Value::Null,
Some(ref value) => value.to_json() Some(ref value) => value.to_json()
} }
} }

2
src/lib.rs
View File

@ -12,8 +12,8 @@ extern crate serde_macros;
#[cfg(test)] #[cfg(test)]
extern crate serialize; extern crate serialize;
pub use ser::{Serializer, Serialize};
pub use de::{Deserializer, Deserialize}; pub use de::{Deserializer, Deserialize};
pub use ser::{Serializer, Serialize};
pub mod de; pub mod de;
pub mod ser; pub mod ser;

230
src/ser.rs
View File

@ -428,110 +428,110 @@ mod tests {
impl<'a, Iter: Iterator<Token<'a>>> Serializer<Error> for AssertSerializer<Iter> { impl<'a, Iter: Iterator<Token<'a>>> Serializer<Error> for AssertSerializer<Iter> {
fn serialize_null(&mut self) -> Result<(), Error> { fn serialize_null(&mut self) -> Result<(), Error> {
self.serialize(Null) self.serialize(Token::Null)
} }
fn serialize_bool(&mut self, v: bool) -> Result<(), Error> { fn serialize_bool(&mut self, v: bool) -> Result<(), Error> {
self.serialize(Bool(v)) self.serialize(Token::Bool(v))
} }
fn serialize_int(&mut self, v: int) -> Result<(), Error> { fn serialize_int(&mut self, v: int) -> Result<(), Error> {
self.serialize(Int(v)) self.serialize(Token::Int(v))
} }
fn serialize_i8(&mut self, v: i8) -> Result<(), Error> { fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
self.serialize(I8(v)) self.serialize(Token::I8(v))
} }
fn serialize_i16(&mut self, v: i16) -> Result<(), Error> { fn serialize_i16(&mut self, v: i16) -> Result<(), Error> {
self.serialize(I16(v)) self.serialize(Token::I16(v))
} }
fn serialize_i32(&mut self, v: i32) -> Result<(), Error> { fn serialize_i32(&mut self, v: i32) -> Result<(), Error> {
self.serialize(I32(v)) self.serialize(Token::I32(v))
} }
fn serialize_i64(&mut self, v: i64) -> Result<(), Error> { fn serialize_i64(&mut self, v: i64) -> Result<(), Error> {
self.serialize(I64(v)) self.serialize(Token::I64(v))
} }
fn serialize_uint(&mut self, v: uint) -> Result<(), Error> { fn serialize_uint(&mut self, v: uint) -> Result<(), Error> {
self.serialize(Uint(v)) self.serialize(Token::Uint(v))
} }
fn serialize_u8(&mut self, v: u8) -> Result<(), Error> { fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
self.serialize(U8(v)) self.serialize(Token::U8(v))
} }
fn serialize_u16(&mut self, v: u16) -> Result<(), Error> { fn serialize_u16(&mut self, v: u16) -> Result<(), Error> {
self.serialize(U16(v)) self.serialize(Token::U16(v))
} }
fn serialize_u32(&mut self, v: u32) -> Result<(), Error> { fn serialize_u32(&mut self, v: u32) -> Result<(), Error> {
self.serialize(U32(v)) self.serialize(Token::U32(v))
} }
fn serialize_u64(&mut self, v: u64) -> Result<(), Error> { fn serialize_u64(&mut self, v: u64) -> Result<(), Error> {
self.serialize(U64(v)) self.serialize(Token::U64(v))
} }
fn serialize_f32(&mut self, v: f32) -> Result<(), Error> { fn serialize_f32(&mut self, v: f32) -> Result<(), Error> {
self.serialize(F32(v)) self.serialize(Token::F32(v))
} }
fn serialize_f64(&mut self, v: f64) -> Result<(), Error> { fn serialize_f64(&mut self, v: f64) -> Result<(), Error> {
self.serialize(F64(v)) self.serialize(Token::F64(v))
} }
fn serialize_char(&mut self, v: char) -> Result<(), Error> { fn serialize_char(&mut self, v: char) -> Result<(), Error> {
self.serialize(Char(v)) self.serialize(Token::Char(v))
} }
fn serialize_str(&mut self, v: &str) -> Result<(), Error> { fn serialize_str(&mut self, v: &str) -> Result<(), Error> {
self.serialize(Str(v)) self.serialize(Token::Str(v))
} }
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), Error> { fn serialize_tuple_start(&mut self, len: uint) -> Result<(), Error> {
self.serialize(TupleStart(len)) self.serialize(Token::TupleStart(len))
} }
fn serialize_tuple_elt< fn serialize_tuple_elt<
T: Serialize<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, value: &T) -> Result<(), Error> { >(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(TupleSep)); try!(self.serialize(Token::TupleSep));
value.serialize(self) value.serialize(self)
} }
fn serialize_tuple_end(&mut self) -> Result<(), Error> { fn serialize_tuple_end(&mut self) -> Result<(), Error> {
self.serialize(TupleEnd) self.serialize(Token::TupleEnd)
} }
fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), Error> { fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), Error> {
self.serialize(StructStart(name, len)) self.serialize(Token::StructStart(name, len))
} }
fn serialize_struct_elt< fn serialize_struct_elt<
T: Serialize<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, name: &str, value: &T) -> Result<(), Error> { >(&mut self, name: &str, value: &T) -> Result<(), Error> {
try!(self.serialize(StructSep(name))); try!(self.serialize(Token::StructSep(name)));
value.serialize(self) value.serialize(self)
} }
fn serialize_struct_end(&mut self) -> Result<(), Error> { fn serialize_struct_end(&mut self) -> Result<(), Error> {
self.serialize(StructEnd) self.serialize(Token::StructEnd)
} }
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), Error> { fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), Error> {
self.serialize(EnumStart(name, variant, len)) self.serialize(Token::EnumStart(name, variant, len))
} }
fn serialize_enum_elt< fn serialize_enum_elt<
T: Serialize<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, value: &T) -> Result<(), Error> { >(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(EnumSep)); try!(self.serialize(Token::EnumSep));
value.serialize(self) value.serialize(self)
} }
fn serialize_enum_end(&mut self) -> Result<(), Error> { fn serialize_enum_end(&mut self) -> Result<(), Error> {
self.serialize(EnumEnd) self.serialize(Token::EnumEnd)
} }
fn serialize_option< fn serialize_option<
@ -539,11 +539,11 @@ mod tests {
>(&mut self, v: &option::Option<T>) -> Result<(), Error> { >(&mut self, v: &option::Option<T>) -> Result<(), Error> {
match *v { match *v {
Some(ref v) => { Some(ref v) => {
try!(self.serialize(Option(true))); try!(self.serialize(Token::Option(true)));
v.serialize(self) v.serialize(self)
} }
None => { None => {
self.serialize(Option(false)) self.serialize(Token::Option(false))
} }
} }
} }
@ -553,11 +553,11 @@ mod tests {
SeqIter: Iterator<T> SeqIter: Iterator<T>
>(&mut self, mut iter: SeqIter) -> Result<(), Error> { >(&mut self, mut iter: SeqIter) -> Result<(), Error> {
let (len, _) = iter.size_hint(); let (len, _) = iter.size_hint();
try!(self.serialize(SeqStart(len))); try!(self.serialize(Token::SeqStart(len)));
for elt in iter { for elt in iter {
try!(elt.serialize(self)); try!(elt.serialize(self));
} }
self.serialize(SeqEnd) self.serialize(Token::SeqEnd)
} }
fn serialize_map< fn serialize_map<
@ -566,12 +566,12 @@ mod tests {
MapIter: Iterator<(K, V)> MapIter: Iterator<(K, V)>
>(&mut self, mut iter: MapIter) -> Result<(), Error> { >(&mut self, mut iter: MapIter) -> Result<(), Error> {
let (len, _) = iter.size_hint(); let (len, _) = iter.size_hint();
try!(self.serialize(MapStart(len))); try!(self.serialize(Token::MapStart(len)));
for (key, value) in iter { for (key, value) in iter {
try!(key.serialize(self)); try!(key.serialize(self));
try!(value.serialize(self)); try!(value.serialize(self));
} }
self.serialize(MapEnd) self.serialize(Token::MapEnd)
} }
} }
@ -580,7 +580,7 @@ mod tests {
#[test] #[test]
fn test_tokens_int() { fn test_tokens_int() {
let tokens = vec!( let tokens = vec!(
Int(5) Token::Int(5)
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
5i.serialize(&mut serializer).unwrap(); 5i.serialize(&mut serializer).unwrap();
@ -590,7 +590,7 @@ mod tests {
#[test] #[test]
fn test_tokens_str() { fn test_tokens_str() {
let tokens = vec!( let tokens = vec!(
Str("a"), Token::Str("a"),
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -601,7 +601,7 @@ mod tests {
#[test] #[test]
fn test_tokens_null() { fn test_tokens_null() {
let tokens = vec!( let tokens = vec!(
Null, Token::Null,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -612,7 +612,7 @@ mod tests {
#[test] #[test]
fn test_tokens_option_none() { fn test_tokens_option_none() {
let tokens = vec!( let tokens = vec!(
Option(false), Token::Option(false),
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -623,8 +623,8 @@ mod tests {
#[test] #[test]
fn test_tokens_option_some() { fn test_tokens_option_some() {
let tokens = vec!( let tokens = vec!(
Option(true), Token::Option(true),
Int(5), Token::Int(5),
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -635,13 +635,13 @@ mod tests {
#[test] #[test]
fn test_tokens_tuple() { fn test_tokens_tuple() {
let tokens = vec!( let tokens = vec!(
TupleStart(2), Token::TupleStart(2),
TupleSep, Token::TupleSep,
Int(5), Token::Int(5),
TupleSep, Token::TupleSep,
Str("a"), Token::Str("a"),
TupleEnd, Token::TupleEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -652,22 +652,22 @@ mod tests {
#[test] #[test]
fn test_tokens_tuple_compound() { fn test_tokens_tuple_compound() {
let tokens = vec!( let tokens = vec!(
TupleStart(3), Token::TupleStart(3),
TupleSep, Token::TupleSep,
Null, Token::Null,
TupleSep, Token::TupleSep,
Null, Token::Null,
TupleSep, Token::TupleSep,
TupleStart(2), Token::TupleStart(2),
TupleSep, Token::TupleSep,
Int(5), Token::Int(5),
TupleSep, Token::TupleSep,
Str("a"), Token::Str("a"),
TupleEnd, Token::TupleEnd,
TupleEnd, Token::TupleEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -678,11 +678,11 @@ mod tests {
#[test] #[test]
fn test_tokens_struct_empty() { fn test_tokens_struct_empty() {
let tokens = vec!( let tokens = vec!(
StructStart("Outer", 1), Token::StructStart("Outer", 1),
StructSep("inner"), Token::StructSep("inner"),
SeqStart(0), Token::SeqStart(0),
SeqEnd, Token::SeqEnd,
StructEnd, Token::StructEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -693,25 +693,25 @@ mod tests {
#[test] #[test]
fn test_tokens_struct() { fn test_tokens_struct() {
let tokens = vec!( let tokens = vec!(
StructStart("Outer", 1), Token::StructStart("Outer", 1),
StructSep("inner"), Token::StructSep("inner"),
SeqStart(1), Token::SeqStart(1),
StructStart("Inner", 3), Token::StructStart("Inner", 3),
StructSep("a"), Token::StructSep("a"),
Null, Token::Null,
StructSep("b"), Token::StructSep("b"),
Uint(5), Token::Uint(5),
StructSep("c"), Token::StructSep("c"),
MapStart(1), Token::MapStart(1),
Str("abc"), Token::Str("abc"),
Option(true), Token::Option(true),
Char('c'), Token::Char('c'),
MapEnd, Token::MapEnd,
StructEnd, Token::StructEnd,
SeqEnd, Token::SeqEnd,
StructEnd, Token::StructEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -734,34 +734,34 @@ mod tests {
#[test] #[test]
fn test_tokens_enum() { fn test_tokens_enum() {
let tokens = vec!( let tokens = vec!(
EnumStart("Animal", "Dog", 0), Token::EnumStart("Animal", "Dog", 0),
EnumEnd, Token::EnumEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
Dog.serialize(&mut serializer).unwrap(); Animal::Dog.serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None); assert_eq!(serializer.iter.next(), None);
let tokens = vec!( let tokens = vec!(
EnumStart("Animal", "Frog", 2), Token::EnumStart("Animal", "Frog", 2),
EnumSep, Token::EnumSep,
Str("Henry"), Token::Str("Henry"),
EnumSep, Token::EnumSep,
Int(349), Token::Int(349),
EnumEnd, Token::EnumEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
Frog("Henry".to_string(), 349).serialize(&mut serializer).unwrap(); Animal::Frog("Henry".to_string(), 349).serialize(&mut serializer).unwrap();
assert_eq!(serializer.iter.next(), None); assert_eq!(serializer.iter.next(), None);
} }
#[test] #[test]
fn test_tokens_vec_empty() { fn test_tokens_vec_empty() {
let tokens = vec!( let tokens = vec!(
SeqStart(0), Token::SeqStart(0),
SeqEnd, Token::SeqEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -773,11 +773,11 @@ mod tests {
#[test] #[test]
fn test_tokens_vec() { fn test_tokens_vec() {
let tokens = vec!( let tokens = vec!(
SeqStart(3), Token::SeqStart(3),
Int(5), Token::Int(5),
Int(6), Token::Int(6),
Int(7), Token::Int(7),
SeqEnd, Token::SeqEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -788,22 +788,22 @@ mod tests {
#[test] #[test]
fn test_tokens_vec_compound() { fn test_tokens_vec_compound() {
let tokens = vec!( let tokens = vec!(
SeqStart(3), Token::SeqStart(3),
SeqStart(1), Token::SeqStart(1),
Int(1), Token::Int(1),
SeqEnd, Token::SeqEnd,
SeqStart(2), Token::SeqStart(2),
Int(2), Token::Int(2),
Int(3), Token::Int(3),
SeqEnd, Token::SeqEnd,
SeqStart(3), Token::SeqStart(3),
Int(4), Token::Int(4),
Int(5), Token::Int(5),
Int(6), Token::Int(6),
SeqEnd, Token::SeqEnd,
SeqEnd, Token::SeqEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
@ -814,13 +814,13 @@ mod tests {
#[test] #[test]
fn test_tokens_treemap() { fn test_tokens_treemap() {
let tokens = vec!( let tokens = vec!(
MapStart(2), Token::MapStart(2),
Int(5), Token::Int(5),
Str("a"), Token::Str("a"),
Int(6), Token::Int(6),
Str("b"), Token::Str("b"),
MapEnd, Token::MapEnd,
); );
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());