diff --git a/benches/bench_enum.rs b/benches/bench_enum.rs index 7aa98712..a7ec4d07 100644 --- a/benches/bench_enum.rs +++ b/benches/bench_enum.rs @@ -13,6 +13,8 @@ use serialize::{Decoder, Decodable}; use serde::de::{Deserializer, Deserialize}; +use Animal::{Dog, Frog}; + ////////////////////////////////////////////////////////////////////////////// #[deriving(Clone, PartialEq, Show, Decodable)] @@ -36,7 +38,10 @@ pub enum Error { mod 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 { AnimalState(Animal), @@ -184,7 +189,10 @@ mod decoder { ////////////////////////////////////////////////////////////////////////////// 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; diff --git a/benches/bench_log.rs b/benches/bench_log.rs index 027bc6c5..25e0bd7a 100644 --- a/benches/bench_log.rs +++ b/benches/bench_log.rs @@ -456,13 +456,13 @@ impl Log { Log { timestamp: 2837513946597, zone_id: 123456, - zone_plan: FREE, + zone_plan: ZonePlan::FREE, http: Http { - protocol: HTTP11, + protocol: HttpProtocol::HTTP11, status: 200, host_status: 503, up_status: 520, - method: GET, + method: HttpMethod::GET, 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(), referer: "https://www.cloudflare.com/".to_string(), @@ -472,10 +472,10 @@ impl Log { ip: "1.2.3.4".to_string(), port: 8000, hostname: "www.example.com".to_string(), - protocol: HTTPS, + protocol: OriginProtocol::HTTPS, }, - country: US, - cache_status: Hit, + country: Country::US, + cache_status: CacheStatus::Hit, server_ip: "192.168.1.1".to_string(), server_name: "metal.cloudflare.com".to_string(), remote_ip: "10.1.2.3".to_string(), @@ -673,58 +673,58 @@ fn bench_copy(b: &mut Bencher) { fn manual_no_escape(mut wr: W, log: &Log) { wr.write_str("{\"timestamp\":").unwrap(); - (write!(wr, "{}", log.timestamp)).unwrap(); + (write!(&mut wr, "{}", log.timestamp)).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(); - (write!(wr, "{}", log.zone_plan as uint)).unwrap(); + (write!(&mut wr, "{}", log.zone_plan as uint)).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(); - (write!(wr, "{}", log.http.status)).unwrap(); + (write!(&mut wr, "{}", log.http.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(); - (write!(wr, "{}", log.http.up_status)).unwrap(); + (write!(&mut wr, "{}", log.http.up_status)).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(); - (write!(wr, "\"{}\"", log.http.content_type)).unwrap(); + (write!(&mut wr, "\"{}\"", log.http.content_type)).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(); - (write!(wr, "\"{}\"", log.http.referer)).unwrap(); + (write!(&mut wr, "\"{}\"", log.http.referer)).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("\"ip\":").unwrap(); - (write!(wr, "\"{}\"", log.origin.ip)).unwrap(); + (write!(&mut wr, "\"{}\"", log.origin.ip)).unwrap(); wr.write_str(",\"port\":").unwrap(); - (write!(wr, "{}", log.origin.port)).unwrap(); + (write!(&mut wr, "{}", log.origin.port)).unwrap(); wr.write_str(",\"hostname\":").unwrap(); - (write!(wr, "\"{}\"", log.origin.hostname)).unwrap(); + (write!(&mut wr, "\"{}\"", log.origin.hostname)).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(); - (write!(wr, "{}", log.country as uint)).unwrap(); + (write!(&mut wr, "{}", log.country as uint)).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(); - (write!(wr, "\"{}\"", log.server_ip)).unwrap(); + (write!(&mut wr, "\"{}\"", log.server_ip)).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(); - (write!(wr, "\"{}\"", log.remote_ip)).unwrap(); + (write!(&mut wr, "\"{}\"", log.remote_ip)).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(); - (write!(wr, "\"{}\"", log.ray_id)).unwrap(); + (write!(&mut wr, "\"{}\"", log.ray_id)).unwrap(); wr.write_str("}").unwrap(); } @@ -732,38 +732,38 @@ fn manual_escape(mut wr: W, log: &Log) { wr.write_str("{").unwrap(); escape_str(&mut wr, "timestamp").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.timestamp)).unwrap(); + (write!(&mut wr, "{}", log.timestamp)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "zone_id").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.zone_id)).unwrap(); + (write!(&mut wr, "{}", log.zone_id)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "zone_plan").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(); escape_str(&mut wr, "http").unwrap(); wr.write_str(":{").unwrap(); escape_str(&mut wr, "protocol").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(); escape_str(&mut wr, "status").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.http.status)).unwrap(); + (write!(&mut wr, "{}", log.http.status)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "host_status").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.http.host_status)).unwrap(); + (write!(&mut wr, "{}", log.http.host_status)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "up_status").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.http.up_status)).unwrap(); + (write!(&mut wr, "{}", log.http.up_status)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "method").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(); escape_str(&mut wr, "content_type").unwrap(); wr.write_str(":").unwrap(); @@ -791,7 +791,7 @@ fn manual_escape(mut wr: W, log: &Log) { wr.write_str(",").unwrap(); escape_str(&mut wr, "port").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.origin.port)).unwrap(); + (write!(&mut wr, "{}", log.origin.port)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "hostname").unwrap(); wr.write_str(":").unwrap(); @@ -799,16 +799,16 @@ fn manual_escape(mut wr: W, log: &Log) { wr.write_str(",").unwrap(); escape_str(&mut wr, "protocol").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(); escape_str(&mut wr, "country").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.country as uint)).unwrap(); + (write!(&mut wr, "{}", log.country as uint)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "cache_status").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(); escape_str(&mut wr, "server_ip").unwrap(); wr.write_str(":").unwrap(); @@ -824,7 +824,7 @@ fn manual_escape(mut wr: W, log: &Log) { wr.write_str(",").unwrap(); escape_str(&mut wr, "bytes_dlv").unwrap(); wr.write_str(":").unwrap(); - (write!(wr, "{}", log.bytes_dlv)).unwrap(); + (write!(&mut wr, "{}", log.bytes_dlv)).unwrap(); wr.write_str(",").unwrap(); escape_str(&mut wr, "ray_id").unwrap(); diff --git a/benches/bench_map.rs b/benches/bench_map.rs index c6674272..06482e36 100644 --- a/benches/bench_map.rs +++ b/benches/bench_map.rs @@ -31,7 +31,9 @@ mod decoder { use std::collections::hash_map::MoveEntries; use serialize; - use super::{Error, EndOfStream, SyntaxError, OtherError}; + use super::Error; + use super::Error::{EndOfStream, SyntaxError, OtherError}; + use self::Value::{StringValue, IntValue}; enum Value { StringValue(String), @@ -172,7 +174,9 @@ mod deserializer { use std::collections::HashMap; 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; diff --git a/benches/bench_struct.rs b/benches/bench_struct.rs index cfdc2a1d..7afa6286 100644 --- a/benches/bench_struct.rs +++ b/benches/bench_struct.rs @@ -48,7 +48,20 @@ mod decoder { use std::collections::HashMap; 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)] enum State { @@ -80,7 +93,7 @@ mod decoder { impl Decoder for OuterDecoder { fn error(&mut self, msg: &str) -> Error { - OtherError(msg.to_string()) + Error::OtherError(msg.to_string()) } // Primitive types: @@ -88,64 +101,64 @@ mod decoder { fn read_nil(&mut self) -> Result<(), Error> { match self.stack.pop() { Some(NullState) => Ok(()), - _ => Err(SyntaxError("NullState".to_string())), + _ => Err(Error::SyntaxError("NullState".to_string())), } } #[inline] fn read_uint(&mut self) -> Result { match self.stack.pop() { Some(UintState(value)) => Ok(value), - _ => Err(SyntaxError("UintState".to_string())), + _ => Err(Error::SyntaxError("UintState".to_string())), } } - fn read_u64(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_u32(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_u16(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_u8(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_int(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_i64(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_i32(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_i16(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_i8(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_bool(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_f64(&mut self) -> Result { Err(SyntaxError("".to_string())) } - fn read_f32(&mut self) -> Result { Err(SyntaxError("".to_string())) } + fn read_u64(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_u32(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_u16(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_u8(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_int(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_i64(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_i32(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_i16(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_i8(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_bool(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_f64(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_f32(&mut self) -> Result { Err(Error::SyntaxError("".to_string())) } #[inline] fn read_char(&mut self) -> Result { match self.stack.pop() { Some(CharState(c)) => Ok(c), - _ => Err(SyntaxError("".to_string())), + _ => Err(Error::SyntaxError("".to_string())), } } #[inline] fn read_str(&mut self) -> Result { match self.stack.pop() { Some(StringState(value)) => Ok(value), - _ => Err(SyntaxError("".to_string())), + _ => Err(Error::SyntaxError("".to_string())), } } // Compound types: - fn read_enum(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result) -> Result { Err(SyntaxError("".to_string())) } + fn read_enum(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result) -> Result { Err(Error::SyntaxError("".to_string())) } fn read_enum_variant(&mut self, _names: &[&str], _f: |&mut OuterDecoder, uint| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } fn read_enum_variant_arg(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } fn read_enum_struct_variant(&mut self, _names: &[&str], _f: |&mut OuterDecoder, uint| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: uint, _f: |&mut OuterDecoder| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } #[inline] fn read_struct(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result) -> Result { @@ -156,7 +169,7 @@ mod decoder { self.stack.push(FieldState("inner")); f(self) } else { - Err(SyntaxError("expected Outer".to_string())) + Err(Error::SyntaxError("expected Outer".to_string())) } } Some(InnerState(Inner { a: (), b, c })) => { @@ -171,10 +184,10 @@ mod decoder { self.stack.push(FieldState("a")); f(self) } 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] @@ -184,32 +197,32 @@ mod decoder { if f_name == name { f(self) } 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(&mut self, _len: uint, _f: |&mut OuterDecoder| -> Result) -> Result { Err(SyntaxError("".to_string())) } - fn read_tuple_arg(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result) -> Result { Err(SyntaxError("".to_string())) } + fn read_tuple(&mut self, _len: uint, _f: |&mut OuterDecoder| -> Result) -> Result { Err(Error::SyntaxError("".to_string())) } + fn read_tuple_arg(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result) -> Result { Err(Error::SyntaxError("".to_string())) } fn read_tuple_struct(&mut self, _s_name: &str, _len: uint, _f: |&mut OuterDecoder| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } fn read_tuple_struct_arg(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result) - -> Result { Err(SyntaxError("".to_string())) } + -> Result { Err(Error::SyntaxError("".to_string())) } // Specialized types: #[inline] fn read_option(&mut self, f: |&mut OuterDecoder, bool| -> Result) -> Result { match self.stack.pop() { 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) } - _ => Err(SyntaxError("expected VecState".to_string())) + _ => Err(Error::SyntaxError("expected VecState".to_string())) } } #[inline] @@ -250,7 +263,7 @@ mod decoder { } f(self, len) } - _ => Err(SyntaxError("expected MapState".to_string())), + _ => Err(Error::SyntaxError("expected MapState".to_string())), } } #[inline] @@ -269,9 +282,24 @@ mod decoder { mod deserializer { use std::collections::HashMap; use super::{Outer, Inner}; - use super::{Error, EndOfStream, SyntaxError, UnexpectedName, MissingField}; + use super::Error; use serde::de; + use self::State::{ + OuterState, + InnerState, + FieldState, + NullState, + UintState, + CharState, + StringState, + OptionState, + //TupleState(uint), + VecState, + MapState, + EndState, + }; + #[deriving(Show)] enum State { OuterState(Outer), @@ -286,7 +314,6 @@ mod deserializer { VecState(Vec), MapState(HashMap>), EndState, - } pub struct OuterDeserializer { @@ -367,29 +394,29 @@ mod deserializer { impl de::Deserializer for OuterDeserializer { #[inline] fn end_of_stream_error(&mut self) -> Error { - EndOfStream + Error::EndOfStream } #[inline] 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] fn unexpected_name_error(&mut self, token: de::Token) -> Error { - UnexpectedName(format!("found {}", token)) + Error::UnexpectedName(format!("found {}", token)) } #[inline] fn conversion_error(&mut self, token: de::Token) -> Error { - UnexpectedName(format!("found {}", token)) + Error::UnexpectedName(format!("found {}", token)) } #[inline] fn missing_field< T: de::Deserialize >(&mut self, field: &'static str) -> Result { - Err(MissingField(field)) + Err(Error::MissingField(field)) } } } diff --git a/benches/bench_vec.rs b/benches/bench_vec.rs index cd572f24..dd776995 100644 --- a/benches/bench_vec.rs +++ b/benches/bench_vec.rs @@ -29,7 +29,8 @@ mod decoder { use std::vec; use serialize; - use super::{Error, EndOfStream, SyntaxError, OtherError}; + use super::Error; + use super::Error::{EndOfStream, SyntaxError, OtherError}; pub struct IntDecoder { len: uint, @@ -250,7 +251,9 @@ mod deserializer { //use std::num; 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; diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs index fd4ec19b..d6ca3ebe 100644 --- a/serde_macros/src/lib.rs +++ b/serde_macros/src/lib.rs @@ -409,10 +409,11 @@ fn deserialize_enum( let arms: Vec = fields.iter() .enumerate() .map(|(i, &(name, span, ref parts))| { + let path = cx.path(span, vec![type_ident, name]); let call = deserialize_static_fields( cx, span, - name, + path, serial_names.as_slice(), parts, |cx, _, _| { @@ -425,7 +426,7 @@ fn deserialize_enum( .collect(); 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 { $arms @@ -444,15 +445,16 @@ fn deserialize_enum( fn deserialize_static_fields( cx: &ExtCtxt, span: Span, - outer_pat_ident: Ident, + outer_pat_path: ast::Path, serial_names: &[Option], fields: &StaticFields, getarg: |&ExtCtxt, Span, token::InternedString| -> P ) -> P { match *fields { Unnamed(ref fields) => { + let path_expr = cx.expr_path(outer_pat_path); if fields.is_empty() { - cx.expr_ident(span, outer_pat_ident) + path_expr } else { let fields = fields.iter().enumerate().map(|(i, &span)| { getarg( @@ -462,7 +464,7 @@ fn deserialize_static_fields( ) }).collect(); - cx.expr_call_ident(span, outer_pat_ident, fields) + cx.expr_call(span, path_expr, fields) } } Named(ref fields) => { @@ -480,7 +482,7 @@ fn deserialize_static_fields( cx.field_imm(span, name, arg) }).collect(); - cx.expr_struct_ident(span, outer_pat_ident, fields) + cx.expr_struct(span, outer_pat_path, fields) } } } diff --git a/src/de.rs b/src/de.rs index 1fd7b28b..d250c339 100644 --- a/src/de.rs +++ b/src/de.rs @@ -34,7 +34,7 @@ pub enum Token { F64(f64), Char(char), Str(&'static str), - String(string::String), + String(String), Option(bool), TupleStart(uint), @@ -49,30 +49,30 @@ pub enum Token { impl Token { pub fn to_kind(&self) -> TokenKind { match *self { - Null => NullKind, - Bool(_) => BoolKind, - Int(_) => IntKind, - I8(_) => I8Kind, - I16(_) => I16Kind, - I32(_) => I32Kind, - I64(_) => I64Kind, - Uint(_) => UintKind, - U8(_) => U8Kind, - U16(_) => U16Kind, - U32(_) => U32Kind, - U64(_) => U64Kind, - F32(_) => F32Kind, - F64(_) => F64Kind, - Char(_) => CharKind, - Str(_) => StrKind, - String(_) => StringKind, - Option(_) => OptionKind, - TupleStart(_) => TupleStartKind, - StructStart(_, _) => StructStartKind, - EnumStart(_, _, _) => EnumStartKind, - SeqStart(_) => SeqStartKind, - MapStart(_) => MapStartKind, - End => EndKind, + Token::Null => TokenKind::NullKind, + Token::Bool(_) => TokenKind::BoolKind, + Token::Int(_) => TokenKind::IntKind, + Token::I8(_) => TokenKind::I8Kind, + Token::I16(_) => TokenKind::I16Kind, + Token::I32(_) => TokenKind::I32Kind, + Token::I64(_) => TokenKind::I64Kind, + Token::Uint(_) => TokenKind::UintKind, + Token::U8(_) => TokenKind::U8Kind, + Token::U16(_) => TokenKind::U16Kind, + Token::U32(_) => TokenKind::U32Kind, + Token::U64(_) => TokenKind::U64Kind, + Token::F32(_) => TokenKind::F32Kind, + Token::F64(_) => TokenKind::F64Kind, + Token::Char(_) => TokenKind::CharKind, + Token::Str(_) => TokenKind::StrKind, + Token::String(_) => TokenKind::StringKind, + Token::Option(_) => TokenKind::OptionKind, + Token::TupleStart(_) => TokenKind::TupleStartKind, + Token::StructStart(_, _) => TokenKind::StructStartKind, + Token::EnumStart(_, _, _) => TokenKind::EnumStartKind, + Token::SeqStart(_) => TokenKind::SeqStartKind, + Token::MapStart(_) => TokenKind::MapStartKind, + Token::End => TokenKind::EndKind, } } } @@ -107,62 +107,62 @@ pub enum TokenKind { EndKind, } -static PRIMITIVE_TOKEN_KINDS: &'static [TokenKind] = [ - IntKind, - I8Kind, - I16Kind, - I32Kind, - I64Kind, - UintKind, - U8Kind, - U16Kind, - U32Kind, - U64Kind, - F32Kind, - F64Kind, +static PRIMITIVE_TOKEN_KINDS: &'static [TokenKind] = &[ + TokenKind::IntKind, + TokenKind::I8Kind, + TokenKind::I16Kind, + TokenKind::I32Kind, + TokenKind::I64Kind, + TokenKind::UintKind, + TokenKind::U8Kind, + TokenKind::U16Kind, + TokenKind::U32Kind, + TokenKind::U64Kind, + TokenKind::F32Kind, + TokenKind::F64Kind, ]; -static STR_TOKEN_KINDS: [TokenKind, .. 2] = [ - StrKind, - StringKind, +static STR_TOKEN_KINDS: &'static [TokenKind] = &[ + TokenKind::StrKind, + TokenKind::StringKind, ]; -static COMPOUND_TOKEN_KINDS: [TokenKind, .. 6] = [ - OptionKind, - EnumStartKind, - StructStartKind, - TupleStartKind, - SeqStartKind, - MapStartKind, +static COMPOUND_TOKEN_KINDS: &'static [TokenKind] = &[ + TokenKind::OptionKind, + TokenKind::EnumStartKind, + TokenKind::StructStartKind, + TokenKind::TupleStartKind, + TokenKind::SeqStartKind, + TokenKind::MapStartKind, ]; impl ::std::fmt::Show for TokenKind { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { match *self { - NullKind => "Null".fmt(f), - BoolKind => "Bool".fmt(f), - IntKind => "Int".fmt(f), - I8Kind => "I8".fmt(f), - I16Kind => "I16".fmt(f), - I32Kind => "I32".fmt(f), - I64Kind => "I64".fmt(f), - UintKind => "Uint".fmt(f), - U8Kind => "U8".fmt(f), - U16Kind => "U16".fmt(f), - U32Kind => "U32".fmt(f), - U64Kind => "U64".fmt(f), - F32Kind => "F32".fmt(f), - F64Kind => "F64".fmt(f), - CharKind => "Char".fmt(f), - StrKind => "Str".fmt(f), - StringKind => "String".fmt(f), - OptionKind => "Option".fmt(f), - TupleStartKind => "TupleStart".fmt(f), - StructStartKind => "StructStart".fmt(f), - EnumStartKind => "EnumStart".fmt(f), - SeqStartKind => "SeqStart".fmt(f), - MapStartKind => "MapStart".fmt(f), - EndKind => "End".fmt(f), + TokenKind::NullKind => "Null".fmt(f), + TokenKind::BoolKind => "Bool".fmt(f), + TokenKind::IntKind => "Int".fmt(f), + TokenKind::I8Kind => "I8".fmt(f), + TokenKind::I16Kind => "I16".fmt(f), + TokenKind::I32Kind => "I32".fmt(f), + TokenKind::I64Kind => "I64".fmt(f), + TokenKind::UintKind => "Uint".fmt(f), + TokenKind::U8Kind => "U8".fmt(f), + TokenKind::U16Kind => "U16".fmt(f), + TokenKind::U32Kind => "U32".fmt(f), + TokenKind::U64Kind => "U64".fmt(f), + TokenKind::F32Kind => "F32".fmt(f), + TokenKind::F64Kind => "F64".fmt(f), + TokenKind::CharKind => "Char".fmt(f), + TokenKind::StrKind => "Str".fmt(f), + TokenKind::StringKind => "String".fmt(f), + TokenKind::OptionKind => "Option".fmt(f), + TokenKind::TupleStartKind => "TupleStart".fmt(f), + TokenKind::StructStartKind => "StructStart".fmt(f), + TokenKind::EnumStartKind => "EnumStart".fmt(f), + TokenKind::SeqStartKind => "SeqStart".fmt(f), + TokenKind::MapStartKind => "MapStart".fmt(f), + TokenKind::EndKind => "Token::End".fmt(f), } } } @@ -214,23 +214,23 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_null(&mut self, token: Token) -> Result<(), E> { match token { - Null => Ok(()), - TupleStart(_) | SeqStart(_) => { + Token::Null => Ok(()), + Token::TupleStart(_) | Token::SeqStart(_) => { match try!(self.expect_token()) { - End => Ok(()), + Token::End => Ok(()), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } } } token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - NullKind, - TupleStartKind, - SeqStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::NullKind, + TokenKind::TupleStartKind, + TokenKind::SeqStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -240,10 +240,10 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_bool(&mut self, token: Token) -> Result { match token { - Bool(value) => Ok(value), + Token::Bool(value) => Ok(value), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - BoolKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::BoolKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -253,18 +253,18 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_num(&mut self, token: Token) -> Result { match token { - Int(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - I8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - I16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - I32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - I64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - Uint(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - U8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - U16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - U32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - U64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - F32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), - F64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::Int(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::I8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::I16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::I32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::I64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::Uint(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::U8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::U16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::U32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::U64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::F32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), + Token::F64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), token => Err(self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), } } @@ -272,18 +272,18 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_from_primitive(&mut self, token: Token) -> Result { match token { - Int(x) => to_result!(num::from_int(x), self.conversion_error(token)), - I8(x) => to_result!(num::from_i8(x), self.conversion_error(token)), - I16(x) => to_result!(num::from_i16(x), self.conversion_error(token)), - I32(x) => to_result!(num::from_i32(x), self.conversion_error(token)), - I64(x) => to_result!(num::from_i64(x), self.conversion_error(token)), - Uint(x) => to_result!(num::from_uint(x), self.conversion_error(token)), - U8(x) => to_result!(num::from_u8(x), self.conversion_error(token)), - U16(x) => to_result!(num::from_u16(x), self.conversion_error(token)), - U32(x) => to_result!(num::from_u32(x), self.conversion_error(token)), - U64(x) => to_result!(num::from_u64(x), self.conversion_error(token)), - F32(x) => to_result!(num::from_f32(x), self.conversion_error(token)), - F64(x) => to_result!(num::from_f64(x), self.conversion_error(token)), + Token::Int(x) => to_result!(num::from_int(x), self.conversion_error(token)), + Token::I8(x) => to_result!(num::from_i8(x), self.conversion_error(token)), + Token::I16(x) => to_result!(num::from_i16(x), self.conversion_error(token)), + Token::I32(x) => to_result!(num::from_i32(x), self.conversion_error(token)), + Token::I64(x) => to_result!(num::from_i64(x), self.conversion_error(token)), + Token::Uint(x) => to_result!(num::from_uint(x), self.conversion_error(token)), + Token::U8(x) => to_result!(num::from_u8(x), self.conversion_error(token)), + Token::U16(x) => to_result!(num::from_u16(x), self.conversion_error(token)), + Token::U32(x) => to_result!(num::from_u32(x), self.conversion_error(token)), + Token::U64(x) => to_result!(num::from_u64(x), self.conversion_error(token)), + Token::F32(x) => to_result!(num::from_f32(x), self.conversion_error(token)), + Token::F64(x) => to_result!(num::from_f64(x), self.conversion_error(token)), token => Err(self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)), } } @@ -291,16 +291,16 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_char(&mut self, token: Token) -> Result { match token { - Char(value) => Ok(value), - Str(value) if value.char_len() == 1 => { + Token::Char(value) => Ok(value), + Token::Str(value) if value.char_len() == 1 => { Ok(value.char_at(0)) } - String(ref value) if value.as_slice().char_len() == 1 => { + Token::String(ref value) if value.as_slice().char_len() == 1 => { Ok(value.as_slice().char_at(0)) } token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - CharKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::CharKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -310,7 +310,7 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_str(&mut self, token: Token) -> Result<&'static str, E> { match token { - Str(value) => Ok(value), + Token::Str(value) => Ok(value), token => Err(self.syntax_error(token, STR_TOKEN_KINDS)), } } @@ -318,9 +318,9 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_string(&mut self, token: Token) -> Result { match token { - Char(value) => Ok(value.to_string()), - Str(value) => Ok(value.to_string()), - String(value) => Ok(value), + Token::Char(value) => Ok(value.to_string()), + Token::Str(value) => Ok(value.to_string()), + Token::String(value) => Ok(value), token => Err(self.syntax_error(token, STR_TOKEN_KINDS)), } } @@ -330,14 +330,14 @@ pub trait Deserializer: Iterator> { T: Deserialize >(&mut self, token: Token) -> Result, E> { match token { - Option(false) => Ok(None), - Option(true) => { + Token::Option(false) => Ok(None), + Token::Option(true) => { let value: T = try!(Deserialize::deserialize(self)); Ok(Some(value)) } token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - OptionKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::OptionKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -347,12 +347,12 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_tuple_start(&mut self, token: Token) -> Result { match token { - TupleStart(len) => Ok(len), - SeqStart(len) => Ok(len), + Token::TupleStart(len) => Ok(len), + Token::SeqStart(len) => Ok(len), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - TupleStartKind, - SeqStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::TupleStartKind, + TokenKind::SeqStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -369,10 +369,10 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_tuple_end(&mut self) -> Result<(), E> { match try!(self.expect_token()) { - End => Ok(()), + Token::End => Ok(()), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -382,7 +382,7 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_struct_start(&mut self, token: Token, name: &str) -> Result<(), E> { match token { - StructStart(n, _) => { + Token::StructStart(n, _) => { if name == n { Ok(()) } else { @@ -390,8 +390,8 @@ pub trait Deserializer: Iterator> { } } _ => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - StructStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::StructStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -403,13 +403,13 @@ pub trait Deserializer: Iterator> { fields: &'static [&'static str] ) -> Result>, E> { match try!(self.expect_token()) { - End => { + Token::End => { Ok(None) } - Str(n) => { + Token::Str(n) => { Ok(Some(fields.iter().position(|field| *field == n))) } - String(n) => { + Token::String(n) => { Ok(Some(fields.iter().position(|field| *field == n.as_slice()))) } token => { @@ -428,10 +428,10 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_struct_end(&mut self) -> Result<(), E> { match try!(self.expect_token()) { - End => Ok(()), + Token::End => Ok(()), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -441,7 +441,7 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_enum_start(&mut self, token: Token, name: &str, variants: &[&str]) -> Result { match token { - EnumStart(n, v, _) => { + Token::EnumStart(n, v, _) => { if name == n { match variants.iter().position(|variant| *variant == v) { Some(position) => Ok(position), @@ -452,8 +452,8 @@ pub trait Deserializer: Iterator> { } } token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EnumStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EnumStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -470,10 +470,10 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_enum_end(&mut self) -> Result<(), E> { match try!(self.expect_token()) { - End => Ok(()), + Token::End => Ok(()), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -483,12 +483,12 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_seq_start(&mut self, token: Token) -> Result { match token { - TupleStart(len) => Ok(len), - SeqStart(len) => Ok(len), + Token::TupleStart(len) => Ok(len), + Token::SeqStart(len) => Ok(len), token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - TupleStartKind, - SeqStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::TupleStartKind, + TokenKind::SeqStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -500,7 +500,7 @@ pub trait Deserializer: Iterator> { T: Deserialize >(&mut self) -> Result, E> { match try!(self.expect_token()) { - End => Ok(None), + Token::End => Ok(None), token => { let value = try!(Deserialize::deserialize_token(self, token)); Ok(Some(value)) @@ -533,10 +533,10 @@ pub trait Deserializer: Iterator> { #[inline] fn expect_map_start(&mut self, token: Token) -> Result { match token { - MapStart(len) => Ok(len), + Token::MapStart(len) => Ok(len), _ => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - MapStartKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::MapStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -549,7 +549,7 @@ pub trait Deserializer: Iterator> { V: Deserialize >(&mut self) -> Result, E> { match try!(self.expect_token()) { - End => Ok(None), + Token::End => Ok(None), token => { let key = try!(Deserialize::deserialize_token(self, token)); let value = try!(Deserialize::deserialize(self)); @@ -853,14 +853,14 @@ impl, E> Deserialize for IgnoreTokens { #[inline] fn deserialize_token(d: &mut D, token: Token) -> Result { match token { - Option(true) => { + Token::Option(true) => { Deserialize::deserialize(d) } - EnumStart(_, _, _) => { + Token::EnumStart(_, _, _) => { loop { match try!(d.expect_token()) { - End => { return Ok(IgnoreTokens); } + Token::End => { return Ok(IgnoreTokens); } token => { let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token)); } @@ -868,18 +868,18 @@ impl, E> Deserialize for IgnoreTokens { } } - StructStart(_, _) => { + Token::StructStart(_, _) => { loop { match try!(d.expect_token()) { - End => { return Ok(IgnoreTokens); } - Str(_) | String(_) => { + Token::End => { return Ok(IgnoreTokens); } + Token::Str(_) | Token::String(_) => { let _: IgnoreTokens = try!(Deserialize::deserialize(d)); } _token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, - StrKind, - StringKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, + TokenKind::StrKind, + TokenKind::StringKind, ]; return Err(d.syntax_error(token, EXPECTED_TOKENS)); } @@ -887,10 +887,10 @@ impl, E> Deserialize for IgnoreTokens { } } - TupleStart(_) => { + Token::TupleStart(_) => { loop { match try!(d.expect_token()) { - End => { return Ok(IgnoreTokens); } + Token::End => { return Ok(IgnoreTokens); } token => { let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token)); } @@ -898,10 +898,10 @@ impl, E> Deserialize for IgnoreTokens { } } - SeqStart(_) => { + Token::SeqStart(_) => { loop { match try!(d.expect_token()) { - End => { return Ok(IgnoreTokens); } + Token::End => { return Ok(IgnoreTokens); } token => { let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token)); } @@ -909,10 +909,10 @@ impl, E> Deserialize for IgnoreTokens { } } - MapStart(_) => { + Token::MapStart(_) => { loop { match try!(d.expect_token()) { - End => { return Ok(IgnoreTokens); } + Token::End => { return Ok(IgnoreTokens); } token => { let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token)); let _: IgnoreTokens = try!(Deserialize::deserialize(d)); @@ -921,7 +921,7 @@ impl, E> Deserialize for IgnoreTokens { } } - End => { + Token::End => { Err(d.syntax_error(token, COMPOUND_TOKEN_KINDS)) } @@ -953,36 +953,36 @@ impl GatherTokens { #[inline] fn gather_token, E>(&mut self, d: &mut D, token: Token) -> Result<(), E> { match token { - token @ Option(true) => { + token @ Token::Option(true) => { self.tokens.push(token); self.gather(d) } - EnumStart(name, variant, len) => { + Token::EnumStart(name, variant, len) => { self.tokens.reserve(len + 1); - self.tokens.push(EnumStart(name, variant, len)); + self.tokens.push(Token::EnumStart(name, variant, len)); self.gather_seq(d) } - StructStart(name, len) => { + Token::StructStart(name, len) => { self.tokens.reserve(len + 1); - self.tokens.push(StructStart(name, len)); + self.tokens.push(Token::StructStart(name, len)); self.gather_struct(d) } - TupleStart(len) => { + Token::TupleStart(len) => { self.tokens.reserve(len + 1); - self.tokens.push(TupleStart(len)); + self.tokens.push(Token::TupleStart(len)); self.gather_seq(d) } - SeqStart(len) => { + Token::SeqStart(len) => { self.tokens.reserve(len + 1); - self.tokens.push(SeqStart(len)); + self.tokens.push(Token::SeqStart(len)); self.gather_seq(d) } - MapStart(len) => { + Token::MapStart(len) => { self.tokens.reserve(len + 1); - self.tokens.push(MapStart(len)); + self.tokens.push(Token::MapStart(len)); self.gather_map(d) } - End => { + Token::End => { Err(d.syntax_error(token, COMPOUND_TOKEN_KINDS)) } token => { @@ -996,7 +996,7 @@ impl GatherTokens { fn gather_seq, E>(&mut self, d: &mut D) -> Result<(), E> { loop { match try!(d.expect_token()) { - token @ End => { + token @ Token::End => { self.tokens.push(token); return Ok(()); } @@ -1011,19 +1011,19 @@ impl GatherTokens { fn gather_struct, E>(&mut self, d: &mut D) -> Result<(), E> { loop { match try!(d.expect_token()) { - token @ End => { + token @ Token::End => { self.tokens.push(token); return Ok(()); } - token @ Str(_) | token @ String(_) => { + token @ Token::Str(_) | token @ Token::String(_) => { self.tokens.push(token); try!(self.gather(d)) } token => { - static EXPECTED_TOKENS: &'static [TokenKind] = [ - EndKind, - StrKind, - StringKind, + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, + TokenKind::StrKind, + TokenKind::StringKind, ]; return Err(d.syntax_error(token, EXPECTED_TOKENS)); } @@ -1035,8 +1035,8 @@ impl GatherTokens { fn gather_map, E>(&mut self, d: &mut D) -> Result<(), E> { loop { match try!(d.expect_token()) { - End => { - self.tokens.push(End); + Token::End => { + self.tokens.push(Token::End); return Ok(()); } token => { @@ -1068,32 +1068,6 @@ mod tests { use serialize::Decoder; use super::{Deserializer, Deserialize, Token, TokenKind, IgnoreTokens}; - use super::{ - Null, - Bool, - Int, - I8, - I16, - I32, - I64, - Uint, - U8, - U16, - U32, - U64, - F32, - F64, - Char, - Str, - String, - Option, - TupleStart, - StructStart, - EnumStart, - SeqStart, - MapStart, - End, - }; macro_rules! treemap { ($($k:expr => $v:expr),*) => ({ @@ -1157,7 +1131,7 @@ mod tests { fn deserialize_token(d: &mut D, token: Token) -> Result { try!(d.expect_struct_start(token, "Outer")); - static FIELDS: &'static [&'static str] = ["inner"]; + static FIELDS: &'static [&'static str] = &["inner"]; let mut inner = None; @@ -1189,16 +1163,16 @@ mod tests { impl, E> Deserialize for Animal { #[inline] fn deserialize_token(d: &mut D, token: Token) -> Result { - match try!(d.expect_enum_start(token, "Animal", ["Dog", "Frog"])) { + match try!(d.expect_enum_start(token, "Animal", &["Dog", "Frog"])) { 0 => { try!(d.expect_enum_end()); - Ok(Dog) + Ok(Animal::Dog) } 1 => { let x0 = try!(Deserialize::deserialize(d)); let x1 = try!(Deserialize::deserialize(d)); try!(d.expect_enum_end()); - Ok(Frog(x0, x1)) + Ok(Animal::Frog(x0, x1)) } _ => unreachable!(), } @@ -1243,26 +1217,26 @@ mod tests { impl> Deserializer for TokenDeserializer { fn end_of_stream_error(&mut self) -> Error { - EndOfStream + Error::EndOfStream } fn syntax_error(&mut self, _token: Token, expected: &[TokenKind]) -> Error { - SyntaxError(expected.to_vec()) + Error::SyntaxError(expected.to_vec()) } fn unexpected_name_error(&mut self, _token: Token) -> Error { - UnexpectedName + Error::UnexpectedName } fn conversion_error(&mut self, _token: Token) -> Error { - ConversionError + Error::ConversionError } #[inline] fn missing_field< T: Deserialize, Error> >(&mut self, field: &'static str) -> Result { - Err(MissingField(field)) + Err(Error::MissingField(field)) } } @@ -1283,95 +1257,95 @@ mod tests { } test_value!(test_primitives, [ - vec!(Null) => (): (), - vec!(Bool(true)) => true: bool, - vec!(Bool(false)) => false: bool, - vec!(Int(5)) => 5: int, - vec!(I8(5)) => 5: i8, - vec!(I16(5)) => 5: i16, - vec!(I32(5)) => 5: i32, - vec!(I64(5)) => 5: i64, - vec!(Uint(5)) => 5: uint, - vec!(U8(5)) => 5: u8, - vec!(U16(5)) => 5: u16, - vec!(U32(5)) => 5: u32, - vec!(U64(5)) => 5: u64, - vec!(F32(5.0)) => 5.0: f32, - vec!(F64(5.0)) => 5.0: f64, - vec!(Char('c')) => 'c': char, - vec!(Str("abc")) => "abc": &str, - vec!(String("abc".to_string())) => "abc".to_string(): string::String + vec!(Token::Null) => (): (), + vec!(Token::Bool(true)) => true: bool, + vec!(Token::Bool(false)) => false: bool, + vec!(Token::Int(5)) => 5: int, + vec!(Token::I8(5)) => 5: i8, + vec!(Token::I16(5)) => 5: i16, + vec!(Token::I32(5)) => 5: i32, + vec!(Token::I64(5)) => 5: i64, + vec!(Token::Uint(5)) => 5: uint, + vec!(Token::U8(5)) => 5: u8, + vec!(Token::U16(5)) => 5: u16, + vec!(Token::U32(5)) => 5: u32, + vec!(Token::U64(5)) => 5: u64, + vec!(Token::F32(5.0)) => 5.0: f32, + vec!(Token::F64(5.0)) => 5.0: f64, + vec!(Token::Char('c')) => 'c': char, + vec!(Token::Str("abc")) => "abc": &str, + vec!(Token::String("abc".to_string())) => "abc".to_string(): string::String ]) test_value!(test_tuples, [ vec!( - TupleStart(0), - End, + Token::TupleStart(0), + Token::End, ) => (): (), vec!( - TupleStart(2), - Int(5), + Token::TupleStart(2), + Token::Int(5), - Str("a"), - End, + Token::Str("a"), + Token::End, ) => (5, "a"): (int, &'static str), vec!( - TupleStart(3), - Null, + Token::TupleStart(3), + Token::Null, - TupleStart(0), - End, + Token::TupleStart(0), + Token::End, - TupleStart(2), - Int(5), + Token::TupleStart(2), + Token::Int(5), - Str("a"), - End, - End, + Token::Str("a"), + Token::End, + Token::End, ) => ((), (), (5, "a")): ((), (), (int, &'static str)) ]) test_value!(test_options, [ - vec!(Option(false)) => None: option::Option, + vec!(Token::Option(false)) => None: option::Option, vec!( - Option(true), - Int(5), + Token::Option(true), + Token::Int(5), ) => Some(5): option::Option ]) test_value!(test_structs, [ vec!( - StructStart("Outer", 1), - Str("inner"), - SeqStart(0), - End, - End, + Token::StructStart("Outer", 1), + Token::Str("inner"), + Token::SeqStart(0), + Token::End, + Token::End, ) => Outer { inner: vec!() }: Outer, vec!( - StructStart("Outer", 1), - Str("inner"), - SeqStart(1), - StructStart("Inner", 3), - Str("a"), - Null, + Token::StructStart("Outer", 1), + Token::Str("inner"), + Token::SeqStart(1), + Token::StructStart("Inner", 3), + Token::Str("a"), + Token::Null, - Str("b"), - Uint(5), + Token::Str("b"), + Token::Uint(5), - Str("c"), - MapStart(1), - String("abc".to_string()), + Token::Str("c"), + Token::MapStart(1), + Token::String("abc".to_string()), - Option(true), - Char('c'), - End, - End, - End, - End, + Token::Option(true), + Token::Char('c'), + Token::End, + Token::End, + Token::End, + Token::End, ) => Outer { inner: vec!( Inner { @@ -1385,72 +1359,72 @@ mod tests { test_value!(test_enums, [ vec!( - EnumStart("Animal", "Dog", 0), - End, - ) => Dog: Animal, + Token::EnumStart("Animal", "Dog", 0), + Token::End, + ) => Animal::Dog: Animal, vec!( - EnumStart("Animal", "Frog", 2), - String("Henry".to_string()), - Int(349), - End, - ) => Frog("Henry".to_string(), 349): Animal + Token::EnumStart("Animal", "Frog", 2), + Token::String("Henry".to_string()), + Token::Int(349), + Token::End, + ) => Animal::Frog("Henry".to_string(), 349): Animal ]) test_value!(test_vecs, [ vec!( - SeqStart(0), - End, + Token::SeqStart(0), + Token::End, ) => vec!(): Vec, vec!( - SeqStart(3), - Int(5), + Token::SeqStart(3), + Token::Int(5), - Int(6), + Token::Int(6), - Int(7), - End, + Token::Int(7), + Token::End, ) => vec!(5, 6, 7): Vec, vec!( - SeqStart(3), - SeqStart(1), - Int(1), - End, + Token::SeqStart(3), + Token::SeqStart(1), + Token::Int(1), + Token::End, - SeqStart(2), - Int(2), + Token::SeqStart(2), + Token::Int(2), - Int(3), - End, + Token::Int(3), + Token::End, - SeqStart(3), - Int(4), + Token::SeqStart(3), + Token::Int(4), - Int(5), + Token::Int(5), - Int(6), - End, - End, + Token::Int(6), + Token::End, + Token::End, ) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)): Vec> ]) test_value!(test_treemaps, [ vec!( - MapStart(0), - End, + Token::MapStart(0), + Token::End, ) => treemap!(): TreeMap, vec!( - MapStart(2), - Int(5), - String("a".to_string()), + Token::MapStart(2), + Token::Int(5), + Token::String("a".to_string()), - Int(6), - String("b".to_string()), - End, + Token::Int(6), + Token::String("b".to_string()), + Token::End, ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): TreeMap ]) diff --git a/src/json/builder.rs b/src/json/builder.rs index b42da548..08a82713 100644 --- a/src/json/builder.rs +++ b/src/json/builder.rs @@ -11,7 +11,7 @@ use std::collections::TreeMap; use std::str::StrAllocating; -use json::value::{Value, List, Object, ToJson}; +use json::value::{ToJson, Value}; pub struct ListBuilder { list: Vec, @@ -23,7 +23,7 @@ impl ListBuilder { } pub fn unwrap(self) -> Value { - List(self.list) + Value::List(self.list) } pub fn push(self, value: T) -> ListBuilder { @@ -53,7 +53,7 @@ impl ObjectBuilder { } pub fn unwrap(self) -> Value { - Object(self.object) + Value::Object(self.object) } pub fn insert(self, key: K, value: V) -> ObjectBuilder { @@ -77,25 +77,25 @@ impl ObjectBuilder { mod tests { use std::collections::TreeMap; - use json::value::{Integer, List, Object}; + use json::value::Value; use super::{ListBuilder, ObjectBuilder}; #[test] fn test_list_builder() { let value = ListBuilder::new().unwrap(); - assert_eq!(value, List(Vec::new())); + assert_eq!(value, Value::List(Vec::new())); let value = ListBuilder::new() .push(1i) .push(2i) .push(3i) .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() .push_list(|bld| bld.push(1i).push(2i).push(3i)) .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() .push_object(|bld| @@ -105,15 +105,15 @@ mod tests { .unwrap(); let mut map = TreeMap::new(); - map.insert("a".to_string(), Integer(1)); - map.insert("b".to_string(), Integer(2)); - assert_eq!(value, List(vec!(Object(map)))); + map.insert("a".to_string(), Value::Integer(1)); + map.insert("b".to_string(), Value::Integer(2)); + assert_eq!(value, Value::List(vec!(Value::Object(map)))); } #[test] fn test_object_builder() { let value = ObjectBuilder::new().unwrap(); - assert_eq!(value, Object(TreeMap::new())); + assert_eq!(value, Value::Object(TreeMap::new())); let value = ObjectBuilder::new() .insert("a".to_string(), 1i) @@ -121,8 +121,8 @@ mod tests { .unwrap(); let mut map = TreeMap::new(); - map.insert("a".to_string(), Integer(1)); - map.insert("b".to_string(), Integer(2)); - assert_eq!(value, Object(map)); + map.insert("a".to_string(), Value::Integer(1)); + map.insert("b".to_string(), Value::Integer(2)); + assert_eq!(value, Value::Object(map)); } } diff --git a/src/json/de.rs b/src/json/de.rs index d98603f9..a2160608 100644 --- a/src/json/de.rs +++ b/src/json/de.rs @@ -5,8 +5,8 @@ use std::char; use de; -use super::{Error, ErrorCode}; -use super::{ +use super::error::{Error, ErrorCode}; +use super::error::ErrorCode::{ ConversionError, EOFWhileParsingList, EOFWhileParsingObject, @@ -33,10 +33,19 @@ use super::{ UnexpectedName, UnknownVariant, }; -use super::{ +use super::error::Error::{ SyntaxError, }; +use self::ParserState::{ + ParseValue, + ParseListStart, + ParseListCommaOrEnd, + ParseObjectStart, + ParseObjectCommaOrEnd, + ParseObjectValue, +}; + #[deriving(PartialEq, Show)] enum ParserState { // Parse a value. @@ -92,15 +101,15 @@ impl> Iterator> for Parser { ParseListCommaOrEnd => Some(self.parse_list_comma_or_end()), ParseObjectStart => { match self.parse_object_start() { - Ok(Some(s)) => Some(Ok(de::String(s.to_string()))), - Ok(None) => Some(Ok(de::End)), + Ok(Some(s)) => Some(Ok(de::Token::String(s.to_string()))), + Ok(None) => Some(Ok(de::Token::End)), Err(err) => Some(Err(err)), } } ParseObjectCommaOrEnd => { match self.parse_object_comma_or_end() { - Ok(Some(s)) => Some(Ok(de::String(s.to_string()))), - Ok(None) => Some(Ok(de::End)), + Ok(Some(s)) => Some(Ok(de::Token::String(s.to_string()))), + Ok(None) => Some(Ok(de::Token::End)), Err(err) => Some(Err(err)), } } @@ -191,9 +200,9 @@ impl> Parser { res = try!(self.parse_exponent(res)); } - Ok(de::F64(neg * res)) + Ok(de::Token::F64(neg * res)) } else { - Ok(de::I64(neg * res)) + Ok(de::Token::I64(neg * res)) } } @@ -361,7 +370,7 @@ impl> Parser { _ => 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() { Some(ScalarValue(c)) => c, _ => return self.error(LoneLeadingSurrogateInHexEscape), @@ -374,7 +383,7 @@ impl> Parser { } }; - let mut buf = [0u8, .. 4]; + let buf = &mut [0u8, .. 4]; let len = c.encode_utf8(buf).unwrap_or(0); self.buf.extend(buf.slice_to(len).iter().map(|b| *b)); } @@ -404,7 +413,7 @@ impl> Parser { if self.ch_is(b']') { self.bump(); - Ok(de::End) + Ok(de::Token::End) } else { self.state_stack.push(ParseListCommaOrEnd); self.parse_value() @@ -421,7 +430,7 @@ impl> Parser { self.parse_value() } else if self.ch_is(b']') { self.bump(); - Ok(de::End) + Ok(de::Token::End) } else if self.eof() { self.error_event(EOFWhileParsingList) } else { @@ -500,22 +509,22 @@ impl> Parser { } match self.ch_or_null() { - b'n' => self.parse_ident(b"ull", de::Null), - b't' => self.parse_ident(b"rue", de::Bool(true)), - b'f' => self.parse_ident(b"alse", de::Bool(false)), + b'n' => self.parse_ident(b"ull", de::Token::Null), + b't' => self.parse_ident(b"rue", de::Token::Bool(true)), + b'f' => self.parse_ident(b"alse", de::Token::Bool(false)), b'0' ... b'9' | b'-' => self.parse_number(), b'"' => { - Ok(de::String(try!(self.parse_string()).to_string())) + Ok(de::Token::String(try!(self.parse_string()).to_string())) } b'[' => { self.bump(); self.state_stack.push(ParseListStart); - Ok(de::SeqStart(0)) + Ok(de::Token::SeqStart(0)) } b'{' => { self.bump(); self.state_stack.push(ParseObjectStart); - Ok(de::MapStart(0)) + Ok(de::Token::MapStart(0)) } _ => { self.error_event(ExpectedSomeValue) @@ -563,7 +572,7 @@ impl> de::Deserializer for Parser { >(&mut self, _field: &'static str) -> Result { // JSON can represent `null` values as a missing value, so this isn't // 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. @@ -572,7 +581,7 @@ impl> de::Deserializer for Parser { U: de::Deserialize, Error> >(&mut self, token: de::Token) -> Result, Error> { match token { - de::Null => Ok(None), + de::Token::Null => Ok(None), token => { let value: U = try!(de::Deserialize::deserialize_token(self, token)); Ok(Some(value)) @@ -587,19 +596,19 @@ impl> de::Deserializer for Parser { _name: &str, variants: &[&str]) -> Result { match token { - de::MapStart(_) => { } + de::Token::MapStart(_) => { } _ => { return self.error(ExpectedEnumMapStart); } }; // Enums only have one field in them, which is the variant name. let variant = match try!(self.expect_token()) { - de::String(variant) => variant, + de::Token::String(variant) => variant, _ => { return self.error(ExpectedEnumVariantString); } }; // The variant's field is a list of the values. match try!(self.expect_token()) { - de::SeqStart(_) => { } + de::Token::SeqStart(_) => { } _ => { return self.error(ExpectedEnumToken); } } @@ -612,9 +621,9 @@ impl> de::Deserializer for Parser { fn expect_enum_end(&mut self) -> Result<(), Error> { // There will be one `End` for the list, and one for the object. match try!(self.expect_token()) { - de::End => { + de::Token::End => { match try!(self.expect_token()) { - de::End => Ok(()), + de::Token::End => Ok(()), _ => self.error(ExpectedEnumEndToken), } } @@ -625,10 +634,10 @@ impl> de::Deserializer for Parser { #[inline] fn expect_struct_start(&mut self, token: de::Token, _name: &str) -> Result<(), Error> { match token { - de::MapStart(_) => Ok(()), + de::Token::MapStart(_) => Ok(()), _ => { - static EXPECTED_TOKENS: &'static [de::TokenKind] = [ - de::MapStartKind, + static EXPECTED_TOKENS: &'static [de::TokenKind] = &[ + de::TokenKind::MapStartKind, ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } diff --git a/src/json/error.rs b/src/json/error.rs new file mode 100644 index 00000000..5e0202f6 --- /dev/null +++ b/src/json/error.rs @@ -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 { + 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 for Error { + fn from_error(error: io::IoError) -> Error { + Error::IoError(error) + } +} diff --git a/src/json/mod.rs b/src/json/mod.rs index 51eec078..6226c30a 100644 --- a/src/json/mod.rs +++ b/src/json/mod.rs @@ -28,7 +28,7 @@ Json data are serialized in a form of "key":"value". Data types that can be serialized are JavaScript types : boolean (`true` or `false`), number (`f64`), string, array, object, null. An object is a series of string keys mapping to values, in `"key": value` format. -Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }). +Arrays are enclosed in square brackets (&[ ... ]) and objects in curly brackets ({ ... }). A simple JSON document serializing a person, his/her age, address and phone numbers could look like: ```ignore @@ -65,7 +65,7 @@ To serialize using `Serialize`: extern crate serde_macros; extern crate serde; -use std::io::{MemWriter, AsRefWriter}; +use std::io::ByRefWriter; use serde::json; use serde::Serialize; @@ -79,9 +79,9 @@ fn main() { data_str: "example of string to serialize".to_string() }; - let mut m = MemWriter::new(); + let mut wr = Vec::new(); { - let mut serializer = json::Serializer::new(m.by_ref()); + let mut serializer = json::Serializer::new(wr.by_ref()); match to_serialize_object.serialize(&mut serializer) { Ok(()) => (), Err(e) => panic!("json serialization error: {}", e), @@ -292,11 +292,12 @@ fn main() { */ -use std::error; -use std::fmt; -use std::io; -use std::string; - +pub use self::builder::{ListBuilder, ObjectBuilder}; +pub use self::de::{ + Parser, + from_str, +}; +pub use self::error::{Error, ErrorCode}; pub use self::ser::{ Serializer, PrettySerializer, @@ -307,137 +308,13 @@ pub use self::ser::{ to_pretty_vec, to_pretty_string, }; -pub use self::de::{ - Parser, - from_str, -}; -pub use self::value::{Value, ToJson}; -pub use self::builder::{ListBuilder, ObjectBuilder}; +pub use self::value::{Value, ToJson, from_json}; pub mod builder; pub mod de; pub mod ser; pub mod value; - -/// The errors that can arise while parsing a JSON stream. -#[deriving(Clone, PartialEq)] -pub enum ErrorCode { - ConversionError(super::de::Token), - EOFWhileParsingList, - EOFWhileParsingObject, - EOFWhileParsingString, - EOFWhileParsingValue, - ExpectedColon, - ExpectedConversion, - ExpectedEnumEnd, - ExpectedEnumEndToken, - ExpectedEnumMapStart, - ExpectedEnumToken, - ExpectedEnumVariantString, - ExpectedListCommaOrEnd, - ExpectedName, - ExpectedObjectCommaOrEnd, - ExpectedSomeIdent, - ExpectedSomeValue, - ExpectedTokens(super::de::Token, &'static [super::de::TokenKind]), - InvalidEscape, - InvalidNumber, - InvalidUnicodeCodePoint, - KeyMustBeAString, - LoneLeadingSurrogateInHexEscape, - MissingField(&'static str), - NotFourDigit, - NotUtf8, - TrailingCharacters, - UnexpectedEndOfHexEscape, - UnexpectedName(super::de::Token), - UnknownVariant, - UnrecognizedHex, -} - -impl fmt::Show for ErrorCode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - ConversionError(ref token) => write!(f, "failed to convert {}", token), - EOFWhileParsingList => "EOF While parsing list".fmt(f), - EOFWhileParsingObject => "EOF While parsing object".fmt(f), - EOFWhileParsingString => "EOF While parsing string".fmt(f), - EOFWhileParsingValue => "EOF While parsing value".fmt(f), - ExpectedColon => "expected `:`".fmt(f), - ExpectedConversion => "expected conversion".fmt(f), - ExpectedEnumEnd => "expected enum end".fmt(f), - ExpectedEnumEndToken => "expected enum map end".fmt(f), - ExpectedEnumMapStart => "expected enum map start".fmt(f), - ExpectedEnumToken => "expected enum token".fmt(f), - ExpectedEnumVariantString => "expected variant".fmt(f), - ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f), - ExpectedName => "expected name".fmt(f), - ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f), - ExpectedSomeIdent => "expected ident".fmt(f), - ExpectedSomeValue => "expected value".fmt(f), - ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token), - InvalidEscape => "invalid escape".fmt(f), - InvalidNumber => "invalid number".fmt(f), - InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f), - KeyMustBeAString => "key must be a string".fmt(f), - LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f), - MissingField(ref field) => write!(f, "missing field \"{}\"", field), - NotFourDigit => "invalid \\u escape (not four digits)".fmt(f), - NotUtf8 => "contents not utf-8".fmt(f), - TrailingCharacters => "trailing characters".fmt(f), - UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f), - UnexpectedName(ref name) => write!(f, "unexpected name {}", name), - UnknownVariant => "unknown variant".fmt(f), - 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, string::String), - MissingFieldError(string::String), - UnknownVariantError(string::String), -} - -impl error::Error for Error { - fn description(&self) -> &str { - match *self { - SyntaxError(..) => "syntax error", - IoError(ref error) => error.description(), - ExpectedError(ref expected, _) => expected.as_slice(), - MissingFieldError(_) => "missing field", - UnknownVariantError(_) => "unknown variant", - } - } - - fn detail(&self) -> Option { - match *self { - SyntaxError(ref code, line, col) => { - Some(format!("{} at line {} column {}", code, line, col)) - } - IoError(ref error) => error.detail(), - ExpectedError(ref expected, ref found) => { - Some(format!("expected {}, found {}", expected, found)) - } - MissingFieldError(ref field) => { - Some(format!("missing field {}", field)) - } - UnknownVariantError(ref variant) => { - Some(format!("unknown variant {}", variant)) - } - } - } -} - -impl error::FromError for Error { - fn from_error(error: io::IoError) -> Error { - IoError(error) - } -} +pub mod error; #[cfg(test)] mod tests { @@ -447,19 +324,17 @@ mod tests { use std::string; use std::collections::TreeMap; - use super::value::{ - Value, - Null, - Boolean, - Floating, - String, - List, - Object, + use de; + use ser::{Serialize, Serializer}; + use ser; + + use super::{Error, Parser, ToJson, Value, value, from_str, from_json}; + + use super::error::Error::{ + SyntaxError, }; - use super::{Parser, Error, from_str}; - use super::value; - use super::value::{ToJson, from_json}; - use super::{ + + use super::error::ErrorCode::{ EOFWhileParsingList, EOFWhileParsingObject, EOFWhileParsingString, @@ -471,12 +346,8 @@ mod tests { ExpectedSomeValue, InvalidNumber, KeyMustBeAString, - SyntaxError, TrailingCharacters, }; - use de; - use ser::{Serialize, Serializer}; - use ser; macro_rules! treemap { ($($k:expr => $v:expr),*) => ({ @@ -491,23 +362,23 @@ mod tests { #[deriving_deserialize] enum Animal { Dog, - Frog(string::String, Vec) + Frog(String, Vec) } impl ToJson for Animal { fn to_json(&self) -> Value { match *self { - Dog => { - Object( + Animal::Dog => { + Value::Object( treemap!( - "Dog".to_string() => List(vec!()) + "Dog".to_string() => Value::List(vec!()) ) ) } - Frog(ref x0, ref x1) => { - Object( + Animal::Frog(ref x0, ref x1) => { + Value::Object( treemap!( - "Frog".to_string() => List(vec!(x0.to_json(), x1.to_json())) + "Frog".to_string() => Value::List(vec!(x0.to_json(), x1.to_json())) ) ) } @@ -526,7 +397,7 @@ mod tests { impl ToJson for Inner { fn to_json(&self) -> Value { - Object( + Value::Object( treemap!( "a".to_string() => self.a.to_json(), "b".to_string() => self.b.to_json(), @@ -545,7 +416,7 @@ mod tests { impl ToJson for Outer { fn to_json(&self) -> Value { - Object( + Value::Object( treemap!( "inner".to_string() => self.inner.to_json() ) @@ -583,7 +454,7 @@ mod tests { #[test] fn test_write_null() { - let tests = [ + let tests = &[ ((), "null"), ]; test_encode_ok(tests); @@ -592,7 +463,7 @@ mod tests { #[test] fn test_write_i64() { - let tests = [ + let tests = &[ (3i, "3"), (-2i, "-2"), (-1234i, "-1234"), @@ -603,7 +474,7 @@ mod tests { #[test] fn test_write_f64() { - let tests = [ + let tests = &[ (3.0f64, "3"), (3.1, "3.1"), (-1.5, "-1.5"), @@ -615,7 +486,7 @@ mod tests { #[test] fn test_write_str() { - let tests = [ + let tests = &[ ("", "\"\""), ("foo", "\"foo\""), ]; @@ -625,7 +496,7 @@ mod tests { #[test] fn test_write_bool() { - let tests = [ + let tests = &[ (true, "true"), (false, "false"), ]; @@ -635,13 +506,13 @@ mod tests { #[test] fn test_write_list() { - test_encode_ok([ + test_encode_ok(&[ (vec!(), "[]"), (vec!(true), "[true]"), (vec!(true, false), "[true,false]"), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ (vec!(), "[]"), ( vec!(true), @@ -662,21 +533,21 @@ mod tests { ), ]); - let long_test_list = List(vec![ - Boolean(false), - Null, - List(vec![String("foo\nbar".to_string()), Floating(3.5)])]); + let long_test_list = Value::List(vec![ + Value::Boolean(false), + Value::Null, + Value::List(vec![Value::String("foo\nbar".to_string()), Value::Floating(3.5)])]); - test_encode_ok([ + test_encode_ok(&[ (long_test_list, "[false,null,[\"foo\\nbar\",3.5]]"), ]); - let long_test_list = List(vec![ - Boolean(false), - Null, - List(vec![String("foo\nbar".to_string()), Floating(3.5)])]); + let long_test_list = Value::List(vec![ + Value::Boolean(false), + Value::Null, + Value::List(vec![Value::String("foo\nbar".to_string()), Value::Floating(3.5)])]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ ( long_test_list, concat!( @@ -695,7 +566,7 @@ mod tests { #[test] fn test_write_object() { - test_encode_ok([ + test_encode_ok(&[ (treemap!(), "{}"), (treemap!("a".to_string() => true), "{\"a\":true}"), ( @@ -706,7 +577,7 @@ mod tests { "{\"a\":true,\"b\":false}"), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ (treemap!(), "{}"), ( treemap!("a".to_string() => true), @@ -730,14 +601,14 @@ mod tests { ), ]); - let complex_obj = Object(treemap!( - "b".to_string() => List(vec!( - Object(treemap!("c".to_string() => String("\x0c\r".to_string()))), - Object(treemap!("d".to_string() => String("".to_string()))) + let complex_obj = Value::Object(treemap!( + "b".to_string() => Value::List(vec!( + Value::Object(treemap!("c".to_string() => Value::String("\x0c\r".to_string()))), + Value::Object(treemap!("d".to_string() => Value::String("".to_string()))) )) )); - test_encode_ok([ + test_encode_ok(&[ ( complex_obj.clone(), "{\ @@ -749,7 +620,7 @@ mod tests { ), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ ( complex_obj.clone(), concat!( @@ -770,14 +641,14 @@ mod tests { #[test] fn test_write_tuple() { - test_encode_ok([ + test_encode_ok(&[ ( (5i,), "[5]", ), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ ( (5i,), concat!( @@ -788,14 +659,14 @@ mod tests { ), ]); - test_encode_ok([ + test_encode_ok(&[ ( (5i, (6i, "abc")), "[5,[6,\"abc\"]]", ), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ ( (5i, (6i, "abc")), concat!( @@ -813,16 +684,16 @@ mod tests { #[test] fn test_write_enum() { - test_encode_ok([ - (Dog, "{\"Dog\":[]}"), - (Frog("Henry".to_string(), vec!()), "{\"Frog\":[\"Henry\",[]]}"), - (Frog("Henry".to_string(), vec!(349)), "{\"Frog\":[\"Henry\",[349]]}"), - (Frog("Henry".to_string(), vec!(349, 102)), "{\"Frog\":[\"Henry\",[349,102]]}"), + test_encode_ok(&[ + (Animal::Dog, "{\"Dog\":[]}"), + (Animal::Frog("Henry".to_string(), vec!()), "{\"Frog\":[\"Henry\",[]]}"), + (Animal::Frog("Henry".to_string(), vec!(349)), "{\"Frog\":[\"Henry\",[349]]}"), + (Animal::Frog("Henry".to_string(), vec!(349, 102)), "{\"Frog\":[\"Henry\",[349,102]]}"), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ ( - Dog, + Animal::Dog, concat!( "{\n", " \"Dog\": []\n", @@ -830,7 +701,7 @@ mod tests { ), ), ( - Frog("Henry".to_string(), vec!()), + Animal::Frog("Henry".to_string(), vec!()), concat!( "{\n", " \"Frog\": [\n", @@ -841,7 +712,7 @@ mod tests { ), ), ( - Frog("Henry".to_string(), vec!(349)), + Animal::Frog("Henry".to_string(), vec!(349)), concat!( "{\n", " \"Frog\": [\n", @@ -854,7 +725,7 @@ mod tests { ), ), ( - Frog("Henry".to_string(), vec!(349, 102)), + Animal::Frog("Henry".to_string(), vec!(349, 102)), concat!( "{\n", " \"Frog\": [\n", @@ -872,22 +743,22 @@ mod tests { #[test] fn test_write_option() { - test_encode_ok([ + test_encode_ok(&[ (None, "null"), (Some("jodhpurs"), "\"jodhpurs\""), ]); - test_encode_ok([ + test_encode_ok(&[ (None, "null"), (Some(vec!("foo", "bar")), "[\"foo\",\"bar\"]"), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ (None, "null"), (Some("jodhpurs"), "\"jodhpurs\""), ]); - test_pretty_encode_ok([ + test_pretty_encode_ok(&[ (None, "null"), ( Some(vec!("foo", "bar")), @@ -941,27 +812,27 @@ mod tests { #[test] fn test_parse_null() { - test_parse_err::<()>([ + test_parse_err::<()>(&[ ("n", SyntaxError(ExpectedSomeIdent, 1, 2)), ("nul", SyntaxError(ExpectedSomeIdent, 1, 4)), ("nulla", SyntaxError(TrailingCharacters, 1, 5)), ]); - test_parse_ok([ + test_parse_ok(&[ ("null", ()), ]); } #[test] fn test_json_deserialize_null() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ (), ]); } #[test] fn test_parse_bool() { - test_parse_err::([ + test_parse_err::(&[ ("t", SyntaxError(ExpectedSomeIdent, 1, 2)), ("truz", SyntaxError(ExpectedSomeIdent, 1, 4)), ("f", SyntaxError(ExpectedSomeIdent, 1, 2)), @@ -970,7 +841,7 @@ mod tests { ("falsea", SyntaxError(TrailingCharacters, 1, 6)), ]); - test_parse_ok([ + test_parse_ok(&[ ("true", true), ("false", false), ]); @@ -978,7 +849,7 @@ mod tests { #[test] fn test_json_deserialize_bool() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ true, false, ]); @@ -986,7 +857,7 @@ mod tests { #[test] fn test_parse_number_errors() { - test_parse_err::([ + test_parse_err::(&[ ("+", SyntaxError(ExpectedSomeValue, 1, 1)), (".", SyntaxError(ExpectedSomeValue, 1, 1)), ("-", SyntaxError(InvalidNumber, 1, 2)), @@ -1000,7 +871,7 @@ mod tests { #[test] fn test_parse_i64() { - test_parse_ok([ + test_parse_ok(&[ ("3", 3i64), ("-2", -2), ("-1234", -1234), @@ -1009,7 +880,7 @@ mod tests { #[test] fn test_parse_f64() { - test_parse_ok([ + test_parse_ok(&[ ("3.0", 3.0f64), ("3.1", 3.1), ("-1.2", -1.2), @@ -1022,7 +893,7 @@ mod tests { #[test] fn test_json_deserialize_numbers() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ 3.0f64, 3.1, -1.2, @@ -1035,13 +906,13 @@ mod tests { #[test] fn test_parse_string() { - test_parse_err::([ + test_parse_err::(&[ ("\"", SyntaxError(EOFWhileParsingString, 1, 2)), ("\"lol", SyntaxError(EOFWhileParsingString, 1, 5)), ("\"lol\"a", SyntaxError(TrailingCharacters, 1, 6)), ]); - test_parse_ok([ + test_parse_ok(&[ ("\"\"", "".to_string()), ("\"foo\"", "foo".to_string()), ("\"\\\"\"", "\"".to_string()), @@ -1056,7 +927,7 @@ mod tests { #[test] fn test_json_deserialize_str() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ "".to_string(), "foo".to_string(), "\"".to_string(), @@ -1071,7 +942,7 @@ mod tests { #[test] fn test_parse_list() { - test_parse_err::>([ + test_parse_err::>(&[ ("[", SyntaxError(EOFWhileParsingValue, 1, 2)), ("[ ", SyntaxError(EOFWhileParsingValue, 1, 3)), ("[1", SyntaxError(EOFWhileParsingList, 1, 3)), @@ -1081,57 +952,57 @@ mod tests { ("[]a", SyntaxError(TrailingCharacters, 1, 3)), ]); - test_parse_ok([ + test_parse_ok(&[ ("[]", vec!()), ("[ ]", vec!()), ("[null]", vec!(())), ("[ null ]", vec!(())), ]); - test_parse_ok([ + test_parse_ok(&[ ("[true]", vec!(true)), ]); - test_parse_ok([ + test_parse_ok(&[ ("[3,1]", vec!(3i, 1)), ("[ 3 , 1 ]", vec!(3i, 1)), ]); - test_parse_ok([ + test_parse_ok(&[ ("[[3], [1, 2]]", vec!(vec!(3i), vec!(1, 2))), ]); let v: () = from_str("[]").unwrap(); assert_eq!(v, ()); - test_parse_ok([ + test_parse_ok(&[ ("[1, 2, 3]", (1u, 2u, 3u)), ]); } #[test] fn test_json_deserialize_list() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ vec!(), vec!(()), ]); - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ vec!(true), ]); - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ vec!(3i, 1), ]); - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ vec!(vec!(3i), vec!(1, 2)), ]); } #[test] fn test_parse_object() { - test_parse_err::>([ + test_parse_err::>(&[ ("{", SyntaxError(EOFWhileParsingString, 1, 2)), ("{ ", SyntaxError(EOFWhileParsingString, 1, 3)), ("{1", SyntaxError(KeyMustBeAString, 1, 2)), @@ -1146,7 +1017,7 @@ mod tests { ("{}a", SyntaxError(TrailingCharacters, 1, 3)), ]); - test_parse_ok([ + test_parse_ok(&[ ("{}", treemap!()), ("{ }", treemap!()), ( @@ -1167,7 +1038,7 @@ mod tests { ), ]); - test_parse_ok([ + test_parse_ok(&[ ( "{\"a\": {\"b\": 3, \"c\": 4}}", treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4i)), @@ -1177,20 +1048,20 @@ mod tests { #[test] fn test_json_deserialize_object() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ treemap!(), treemap!("a".to_string() => 3i), treemap!("a".to_string() => 3i, "b".to_string() => 4), ]); - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4)), ]); } #[test] fn test_parse_struct() { - test_parse_ok([ + test_parse_ok(&[ ( "{ \"inner\": [] @@ -1216,7 +1087,7 @@ mod tests { #[test] fn test_json_deserialize_struct() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ Outer { inner: vec![ Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] } @@ -1227,7 +1098,7 @@ mod tests { #[test] fn test_parse_option() { - test_parse_ok([ + test_parse_ok(&[ ("null", None), ("\"jodhpurs\"", Some("jodhpurs".to_string())), ]); @@ -1248,7 +1119,7 @@ mod tests { #[test] fn test_json_deserialize_option() { - test_json_deserialize_ok([ + test_json_deserialize_ok(&[ None, Some("jodhpurs".to_string()), ]); @@ -1256,23 +1127,23 @@ mod tests { #[test] fn test_parse_enum() { - test_parse_ok([ - ("{\"Dog\": []}", Dog), + test_parse_ok(&[ + ("{\"Dog\": []}", Animal::Dog), ( "{\"Frog\": [\"Henry\", []]}", - Frog("Henry".to_string(), vec!()), + Animal::Frog("Henry".to_string(), vec!()), ), ( "{\"Frog\": [\"Henry\", [349]]}", - Frog("Henry".to_string(), vec!(349)), + Animal::Frog("Henry".to_string(), vec!(349)), ), ( "{\"Frog\": [\"Henry\", [349, 102]]}", - Frog("Henry".to_string(), vec!(349, 102)), + Animal::Frog("Henry".to_string(), vec!(349, 102)), ), ]); - test_parse_ok([ + test_parse_ok(&[ ( concat!( "{", @@ -1281,8 +1152,8 @@ mod tests { "}" ), treemap!( - "a".to_string() => Dog, - "b".to_string() => Frog("Henry".to_string(), vec!()) + "a".to_string() => Animal::Dog, + "b".to_string() => Animal::Frog("Henry".to_string(), vec!()) ) ), ]); @@ -1290,17 +1161,17 @@ mod tests { #[test] fn test_json_deserialize_enum() { - test_json_deserialize_ok([ - Dog, - Frog("Henry".to_string(), vec!()), - Frog("Henry".to_string(), vec!(349)), - Frog("Henry".to_string(), vec!(349, 102)), + test_json_deserialize_ok(&[ + Animal::Dog, + Animal::Frog("Henry".to_string(), vec!()), + Animal::Frog("Henry".to_string(), vec!(349)), + Animal::Frog("Henry".to_string(), vec!(349, 102)), ]); } #[test] fn test_multiline_errors() { - test_parse_err::>([ + test_parse_err::>(&[ ("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)), ]); } @@ -1779,20 +1650,20 @@ mod tests { stack.bump_index(); assert!(stack.len() == 1); - assert!(stack.is_equal_to([Index(1)])); - assert!(stack.starts_with([Index(1)])); - assert!(stack.ends_with([Index(1)])); + assert!(stack.is_equal_to(&[Index(1)])); + assert!(stack.starts_with(&[Index(1)])); + assert!(stack.ends_with(&[Index(1)])); assert!(stack.last_is_index()); assert!(stack.get(0) == Index(1)); stack.push_key("foo".to_string()); assert!(stack.len() == 2); - assert!(stack.is_equal_to([Index(1), Key("foo")])); - assert!(stack.starts_with([Index(1), Key("foo")])); - assert!(stack.starts_with([Index(1)])); - assert!(stack.ends_with([Index(1), Key("foo")])); - assert!(stack.ends_with([Key("foo")])); + assert!(stack.is_equal_to(&[Index(1), Key("foo")])); + assert!(stack.starts_with(&[Index(1), Key("foo")])); + assert!(stack.starts_with(&[Index(1)])); + assert!(stack.ends_with(&[Index(1), Key("foo")])); + assert!(stack.ends_with(&[Key("foo")])); assert!(!stack.last_is_index()); assert!(stack.get(0) == Index(1)); assert!(stack.get(1) == Key("foo")); @@ -1800,13 +1671,13 @@ mod tests { stack.push_key("bar".to_string()); assert!(stack.len() == 3); - assert!(stack.is_equal_to([Index(1), Key("foo"), Key("bar")])); - assert!(stack.starts_with([Index(1)])); - assert!(stack.starts_with([Index(1), Key("foo")])); - assert!(stack.starts_with([Index(1), Key("foo"), Key("bar")])); - assert!(stack.ends_with([Key("bar")])); - assert!(stack.ends_with([Key("foo"), Key("bar")])); - assert!(stack.ends_with([Index(1), Key("foo"), Key("bar")])); + assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")])); + assert!(stack.starts_with(&[Index(1)])); + assert!(stack.starts_with(&[Index(1), Key("foo")])); + assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")])); + assert!(stack.ends_with(&[Key("bar")])); + assert!(stack.ends_with(&[Key("foo"), Key("bar")])); + assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")])); assert!(!stack.last_is_index()); assert!(stack.get(0) == Index(1)); assert!(stack.get(1) == Key("foo")); @@ -1815,11 +1686,11 @@ mod tests { stack.pop(); assert!(stack.len() == 2); - assert!(stack.is_equal_to([Index(1), Key("foo")])); - assert!(stack.starts_with([Index(1), Key("foo")])); - assert!(stack.starts_with([Index(1)])); - assert!(stack.ends_with([Index(1), Key("foo")])); - assert!(stack.ends_with([Key("foo")])); + assert!(stack.is_equal_to(&[Index(1), Key("foo")])); + assert!(stack.starts_with(&[Index(1), Key("foo")])); + assert!(stack.starts_with(&[Index(1)])); + assert!(stack.ends_with(&[Index(1), Key("foo")])); + assert!(stack.ends_with(&[Key("foo")])); assert!(!stack.last_is_index()); assert!(stack.get(0) == Index(1)); assert!(stack.get(1) == Key("foo")); @@ -1834,18 +1705,9 @@ mod bench { use serialize; use test::Bencher; - use json::value::{ - Value, - Null, - Boolean, - Integer, - Floating, - String, - List, - Object, - }; - use super::{Parser, from_str}; - use de; + use de::Token; + + use super::{Parser, Value, from_str}; macro_rules! treemap { ($($k:expr => $v:expr),*) => ({ @@ -1888,43 +1750,43 @@ mod bench { } fn encoder_json(count: uint) -> serialize::json::Json { - use serialize::json; + use serialize::json::Json; let mut list = vec!(); for _ in range(0, count) { - list.push(json::Object(treemap!( - "a".to_string() => json::Boolean(true), - "b".to_string() => json::Null, - "c".to_string() => json::F64(3.1415), - "d".to_string() => json::String("Hello world".to_string()), - "e".to_string() => json::List(vec!( - json::U64(1), - json::U64(2), - json::U64(3) + list.push(Json::Object(treemap!( + "a".to_string() => Json::Boolean(true), + "b".to_string() => Json::Null, + "c".to_string() => Json::F64(3.1415), + "d".to_string() => Json::String("Hello world".to_string()), + "e".to_string() => Json::Array(vec!( + Json::U64(1), + Json::U64(2), + Json::U64(3) )) ))); } - list.push(json::Object(TreeMap::new())); - json::List(list) + list.push(Json::Object(TreeMap::new())); + Json::Array(list) } fn serializer_json(count: uint) -> Value { let mut list = vec!(); for _ in range(0, count) { - list.push(Object(treemap!( - "a".to_string() => Boolean(true), - "b".to_string() => Null, - "c".to_string() => Floating(3.1415), - "d".to_string() => String("Hello world".to_string()), - "e".to_string() => List(vec!( - Integer(1), - Integer(2), - Integer(3) + list.push(Value::Object(treemap!( + "a".to_string() => Value::Boolean(true), + "b".to_string() => Value::Null, + "c".to_string() => Value::Floating(3.1415), + "d".to_string() => Value::String("Hello world".to_string()), + "e".to_string() => Value::List(vec!( + Value::Integer(1), + Value::Integer(2), + Value::Integer(3) )) ))); } - list.push(Object(TreeMap::new())); - List(list) + list.push(Value::Object(TreeMap::new())); + Value::List(list) } fn bench_encoder(b: &mut Bencher, count: uint) { @@ -1980,40 +1842,40 @@ mod bench { } fn bench_decoder_streaming(b: &mut Bencher, count: uint) { - use serialize::json; - let src = json_str(count); b.iter( || { - let mut parser = json::Parser::new(src.as_slice().chars()); - assert_eq!(parser.next(), Some(json::ListStart)); + use serialize::json::{Parser, JsonEvent, StackElement}; + + let mut parser = Parser::new(src.as_slice().chars()); + assert_eq!(parser.next(), Some(JsonEvent::ArrayStart)); for _ in range(0, count) { - assert_eq!(parser.next(), Some(json::ObjectStart)); + assert_eq!(parser.next(), Some(JsonEvent::ObjectStart)); - assert_eq!(parser.next(), Some(json::BooleanValue(true))); - assert_eq!(parser.stack().top(), Some(json::Key("a"))); + assert_eq!(parser.next(), Some(JsonEvent::BooleanValue(true))); + assert_eq!(parser.stack().top(), Some(StackElement::Key("a"))); - assert_eq!(parser.next(), Some(json::NullValue)); - assert_eq!(parser.stack().top(), Some(json::Key("b"))); + assert_eq!(parser.next(), Some(JsonEvent::NullValue)); + assert_eq!(parser.stack().top(), Some(StackElement::Key("b"))); - assert_eq!(parser.next(), Some(json::F64Value(3.1415))); - assert_eq!(parser.stack().top(), Some(json::Key("c"))); + assert_eq!(parser.next(), Some(JsonEvent::F64Value(3.1415))); + assert_eq!(parser.stack().top(), Some(StackElement::Key("c"))); - assert_eq!(parser.next(), Some(json::StringValue("Hello world".to_string()))); - assert_eq!(parser.stack().top(), Some(json::Key("d"))); + assert_eq!(parser.next(), Some(JsonEvent::StringValue("Hello world".to_string()))); + assert_eq!(parser.stack().top(), Some(StackElement::Key("d"))); - assert_eq!(parser.next(), Some(json::ListStart)); - assert_eq!(parser.stack().top(), Some(json::Key("e"))); - assert_eq!(parser.next(), Some(json::U64Value(1))); - assert_eq!(parser.next(), Some(json::U64Value(2))); - assert_eq!(parser.next(), Some(json::U64Value(3))); - assert_eq!(parser.next(), Some(json::ListEnd)); + assert_eq!(parser.next(), Some(JsonEvent::ArrayStart)); + assert_eq!(parser.stack().top(), Some(StackElement::Key("e"))); + assert_eq!(parser.next(), Some(JsonEvent::U64Value(1))); + assert_eq!(parser.next(), Some(JsonEvent::U64Value(2))); + assert_eq!(parser.next(), Some(JsonEvent::U64Value(3))); + assert_eq!(parser.next(), Some(JsonEvent::ArrayEnd)); - assert_eq!(parser.next(), Some(json::ObjectEnd)); + assert_eq!(parser.next(), Some(JsonEvent::ObjectEnd)); } - assert_eq!(parser.next(), Some(json::ObjectStart)); - assert_eq!(parser.next(), Some(json::ObjectEnd)); - assert_eq!(parser.next(), Some(json::ListEnd)); + assert_eq!(parser.next(), Some(JsonEvent::ObjectStart)); + assert_eq!(parser.next(), Some(JsonEvent::ObjectEnd)); + assert_eq!(parser.next(), Some(JsonEvent::ArrayEnd)); assert_eq!(parser.next(), None); }); } @@ -2024,34 +1886,34 @@ mod bench { b.iter( || { let mut parser = Parser::new(src.as_slice().bytes()); - assert_eq!(parser.next(), Some(Ok(de::SeqStart(0)))); + assert_eq!(parser.next(), Some(Ok(Token::SeqStart(0)))); for _ in range(0, count) { - assert_eq!(parser.next(), Some(Ok(de::MapStart(0)))); + assert_eq!(parser.next(), Some(Ok(Token::MapStart(0)))); - assert_eq!(parser.next(), Some(Ok(de::String("a".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::Bool(true)))); + assert_eq!(parser.next(), Some(Ok(Token::String("a".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::Bool(true)))); - assert_eq!(parser.next(), Some(Ok(de::String("b".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::Null))); + assert_eq!(parser.next(), Some(Ok(Token::String("b".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::Null))); - assert_eq!(parser.next(), Some(Ok(de::String("c".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::F64(3.1415)))); + assert_eq!(parser.next(), Some(Ok(Token::String("c".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::F64(3.1415)))); - assert_eq!(parser.next(), Some(Ok(de::String("d".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::String("Hello world".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::String("d".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::String("Hello world".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::String("e".to_string())))); - assert_eq!(parser.next(), Some(Ok(de::SeqStart(0)))); - assert_eq!(parser.next(), Some(Ok(de::I64(1)))); - assert_eq!(parser.next(), Some(Ok(de::I64(2)))); - assert_eq!(parser.next(), Some(Ok(de::I64(3)))); - assert_eq!(parser.next(), Some(Ok(de::End))); + assert_eq!(parser.next(), Some(Ok(Token::String("e".to_string())))); + assert_eq!(parser.next(), Some(Ok(Token::SeqStart(0)))); + assert_eq!(parser.next(), Some(Ok(Token::I64(1)))); + assert_eq!(parser.next(), Some(Ok(Token::I64(2)))); + assert_eq!(parser.next(), Some(Ok(Token::I64(3)))); + assert_eq!(parser.next(), Some(Ok(Token::End))); - assert_eq!(parser.next(), Some(Ok(de::End))); + assert_eq!(parser.next(), Some(Ok(Token::End))); } - assert_eq!(parser.next(), Some(Ok(de::MapStart(0)))); - assert_eq!(parser.next(), Some(Ok(de::End))); - assert_eq!(parser.next(), Some(Ok(de::End))); + assert_eq!(parser.next(), Some(Ok(Token::MapStart(0)))); + assert_eq!(parser.next(), Some(Ok(Token::End))); + assert_eq!(parser.next(), Some(Ok(Token::End))); assert_eq!(parser.next(), None); loop { diff --git a/src/json/ser.rs b/src/json/ser.rs index 096915f0..009c709f 100644 --- a/src/json/ser.rs +++ b/src/json/ser.rs @@ -44,7 +44,7 @@ pub fn escape_str(wr: &mut W, v: &str) -> IoResult<()> { } fn escape_char(wr: &mut W, v: char) -> IoResult<()> { - let mut buf = [0, .. 4]; + let buf = &mut [0, .. 4]; v.encode_utf8(buf); escape_bytes(wr, buf) } @@ -65,7 +65,7 @@ fn fmt_f64_or_null(wr: &mut W, v: f64) -> IoResult<()> { fn spaces(wr: &mut W, mut n: uint) -> IoResult<()> { const LEN: uint = 16; - const BUF: [u8, ..LEN] = [b' ', ..LEN]; + const BUF: &'static [u8, ..LEN] = &[b' ', ..LEN]; while n >= LEN { try!(wr.write(BUF)); @@ -128,52 +128,52 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_int(&mut self, v: int) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i8(&mut self, v: i8) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i16(&mut self, v: i16) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i32(&mut self, v: i32) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i64(&mut self, v: i64) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_uint(&mut self, v: uint) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u8(&mut self, v: u8) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u16(&mut self, v: u16) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u32(&mut self, v: u32) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u64(&mut self, v: u64) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] @@ -391,52 +391,52 @@ impl ser::Serializer for PrettySerializer { #[inline] fn serialize_int(&mut self, v: int) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i8(&mut self, v: i8) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i16(&mut self, v: i16) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i32(&mut self, v: i32) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_i64(&mut self, v: i64) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_uint(&mut self, v: uint) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u8(&mut self, v: u8) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u16(&mut self, v: u16) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u32(&mut self, v: u32) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] fn serialize_u64(&mut self, v: u64) -> IoResult<()> { - write!(self.wr, "{}", v) + write!(&mut self.wr, "{}", v) } #[inline] diff --git a/src/json/value.rs b/src/json/value.rs index 5b4e894d..a2408c37 100644 --- a/src/json/value.rs +++ b/src/json/value.rs @@ -6,23 +6,12 @@ use std::str; use std::string; use std::vec; -use de; +use de::{mod, Token, TokenKind}; use ser::Serialize; use ser; -use super::PrettySerializer; -use super::Serializer; -use super::Error; -use super::{ - ConversionError, - EOFWhileParsingValue, - ExpectedError, - ExpectedTokens, - MissingFieldError, - SyntaxError, - UnexpectedName, - UnknownVariantError, -}; +use super::ser::{Serializer, PrettySerializer}; +use super::error::{Error, ErrorCode}; /// Represents a JSON value #[deriving(Clone, PartialEq, PartialOrd)] @@ -61,7 +50,7 @@ impl Value { /// Otherwise, returns None. pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Value>{ match self { - &Object(ref map) => map.get(key), + &Value::Object(ref map) => map.get(key), _ => None } } @@ -85,7 +74,7 @@ impl Value { /// or the Json value is not an Object, returns None. pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Value> { match self { - &Object(ref map) => { + &Value::Object(ref map) => { match map.get(key) { Some(json_value) => Some(json_value), None => { @@ -113,7 +102,7 @@ impl Value { /// Returns None otherwise. pub fn as_object<'a>(&'a self) -> Option<&'a TreeMap> { match *self { - Object(ref map) => Some(map), + Value::Object(ref map) => Some(map), _ => None } } @@ -127,7 +116,7 @@ impl Value { /// Returns None otherwise. pub fn as_list<'a>(&'a self) -> Option<&'a Vec> { match *self { - List(ref list) => Some(list), + Value::List(ref list) => Some(list), _ => None } } @@ -141,7 +130,7 @@ impl Value { /// Returns None otherwise. pub fn as_string<'a>(&'a self) -> Option<&'a str> { match *self { - String(ref s) => Some(s.as_slice()), + Value::String(ref s) => Some(s.as_slice()), _ => None } } @@ -149,7 +138,7 @@ impl Value { /// Returns true if the Json value is a i64 or f64. Returns false otherwise. pub fn is_number(&self) -> bool { match *self { - Integer(_) | Floating(_) => true, + Value::Integer(_) | Value::Floating(_) => true, _ => false, } } @@ -157,7 +146,7 @@ impl Value { /// Returns true if the Json value is a i64. Returns false otherwise. pub fn is_i64(&self) -> bool { match *self { - Integer(_) => true, + Value::Integer(_) => true, _ => false, } } @@ -165,7 +154,7 @@ impl Value { /// Returns true if the Json value is a f64. Returns false otherwise. pub fn is_f64(&self) -> bool { match *self { - Floating(_) => true, + Value::Floating(_) => true, _ => false, } } @@ -174,8 +163,8 @@ impl Value { /// Returns None otherwise. pub fn as_i64(&self) -> Option { match *self { - Integer(n) => Some(n), - Floating(n) => Some(n as i64), + Value::Integer(n) => Some(n), + Value::Floating(n) => Some(n as i64), _ => None } } @@ -184,8 +173,8 @@ impl Value { /// Returns None otherwise. pub fn as_f64(&self) -> Option { match *self { - Integer(n) => Some(n as f64), - Floating(n) => Some(n), + Value::Integer(n) => Some(n as f64), + Value::Floating(n) => Some(n), _ => None } } @@ -199,7 +188,7 @@ impl Value { /// Returns None otherwise. pub fn as_boolean(&self) -> Option { match *self { - Boolean(b) => Some(b), + Value::Boolean(b) => Some(b), _ => None } } @@ -213,7 +202,7 @@ impl Value { /// Returns None otherwise. pub fn as_null(&self) -> Option<()> { match *self { - Null => Some(()), + Value::Null => Some(()), _ => None } } @@ -231,7 +220,7 @@ impl<'a, 'b> Writer for WriterFormatter<'a, 'b> { impl fmt::Show for Value { /// Serializes a json value into a string 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, E> ser::Serialize for Value { #[inline] fn serialize(&self, s: &mut S) -> Result<(), E> { match *self { - Null => { + Value::Null => { ().serialize(s) } - Boolean(v) => { + Value::Boolean(v) => { v.serialize(s) } - Integer(v) => { + Value::Integer(v) => { v.serialize(s) } - Floating(v) => { + Value::Floating(v) => { v.serialize(s) } - String(ref v) => { + Value::String(ref v) => { v.serialize(s) } - List(ref v) => { + Value::List(ref v) => { v.serialize(s) } - Object(ref v) => { + Value::Object(ref v) => { v.serialize(s) } } @@ -266,124 +255,124 @@ impl, E> ser::Serialize for Value { impl, E> de::Deserialize for Value { #[inline] - fn deserialize_token(d: &mut D, token: de::Token) -> Result { + fn deserialize_token(d: &mut D, token: Token) -> Result { match token { - de::Null => Ok(Null), - de::Bool(x) => Ok(Boolean(x)), - de::Int(x) => Ok(Integer(x as i64)), - de::I8(x) => Ok(Integer(x as i64)), - de::I16(x) => Ok(Integer(x as i64)), - de::I32(x) => Ok(Integer(x as i64)), - de::I64(x) => Ok(Integer(x)), - de::Uint(x) => Ok(Integer(x as i64)), - de::U8(x) => Ok(Integer(x as i64)), - de::U16(x) => Ok(Integer(x as i64)), - de::U32(x) => Ok(Integer(x as i64)), - de::U64(x) => Ok(Integer(x as i64)), - de::F32(x) => Ok(Floating(x as f64)), - de::F64(x) => Ok(Floating(x)), - de::Char(x) => Ok(String(x.to_string())), - de::Str(x) => Ok(String(x.to_string())), - de::String(x) => Ok(String(x)), - de::Option(false) => Ok(Null), - de::Option(true) => de::Deserialize::deserialize(d), - de::TupleStart(_) | de::SeqStart(_) => { + Token::Null => Ok(Value::Null), + Token::Bool(x) => Ok(Value::Boolean(x)), + Token::Int(x) => Ok(Value::Integer(x as i64)), + Token::I8(x) => Ok(Value::Integer(x as i64)), + Token::I16(x) => Ok(Value::Integer(x as i64)), + Token::I32(x) => Ok(Value::Integer(x as i64)), + Token::I64(x) => Ok(Value::Integer(x)), + Token::Uint(x) => Ok(Value::Integer(x as i64)), + Token::U8(x) => Ok(Value::Integer(x as i64)), + Token::U16(x) => Ok(Value::Integer(x as i64)), + Token::U32(x) => Ok(Value::Integer(x as i64)), + Token::U64(x) => Ok(Value::Integer(x as i64)), + Token::F32(x) => Ok(Value::Floating(x as f64)), + Token::F64(x) => Ok(Value::Floating(x)), + Token::Char(x) => Ok(Value::String(x.to_string())), + Token::Str(x) => Ok(Value::String(x.to_string())), + Token::String(x) => Ok(Value::String(x)), + Token::Option(false) => Ok(Value::Null), + Token::Option(true) => de::Deserialize::deserialize(d), + Token::TupleStart(_) | Token::SeqStart(_) => { 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)); - Ok(Object(object)) + Ok(Value::Object(object)) } - de::EnumStart(_, name, len) => { - let token = de::SeqStart(len); + Token::EnumStart(_, name, len) => { + let token = Token::SeqStart(len); let fields: Vec = try!(de::Deserialize::deserialize_token(d, token)); let mut object = TreeMap::new(); - object.insert(name.to_string(), List(fields)); - Ok(Object(object)) + object.insert(name.to_string(), Value::List(fields)); + Ok(Value::Object(object)) } - de::End => { - static EXPECTED_TOKENS: &'static [de::TokenKind] = [ - de::EndKind, + Token::End => { + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::EndKind, ]; - Err(d.syntax_error(de::End, EXPECTED_TOKENS)) + Err(d.syntax_error(Token::End, EXPECTED_TOKENS)) } } } } -enum DeserializerState { - DeserializerValueState(Value), - DeserializerListState(vec::MoveItems), - DeserializerObjectState(tree_map::MoveEntries), - DeserializerEndState, +enum State { + Value(Value), + List(vec::MoveItems), + Object(tree_map::MoveEntries), + End, } pub struct Deserializer { - stack: Vec, + stack: Vec, } impl Deserializer { /// Creates a new deserializer instance for deserializing the specified JSON value. pub fn new(json: Value) -> Deserializer { Deserializer { - stack: vec!(DeserializerValueState(json)), + stack: vec!(State::Value(json)), } } } -impl Iterator> for Deserializer { +impl Iterator> for Deserializer { #[inline] - fn next(&mut self) -> Option> { + fn next(&mut self) -> Option> { loop { match self.stack.pop() { - Some(DeserializerValueState(value)) => { + Some(State::Value(value)) => { let token = match value { - Null => de::Null, - Boolean(x) => de::Bool(x), - Integer(x) => de::I64(x), - Floating(x) => de::F64(x), - String(x) => de::String(x), - List(x) => { + Value::Null => Token::Null, + Value::Boolean(x) => Token::Bool(x), + Value::Integer(x) => Token::I64(x), + Value::Floating(x) => Token::F64(x), + Value::String(x) => Token::String(x), + Value::List(x) => { let len = x.len(); - self.stack.push(DeserializerListState(x.into_iter())); - de::SeqStart(len) + self.stack.push(State::List(x.into_iter())); + Token::SeqStart(len) } - Object(x) => { + Value::Object(x) => { let len = x.len(); - self.stack.push(DeserializerObjectState(x.into_iter())); - de::MapStart(len) + self.stack.push(State::Object(x.into_iter())); + Token::MapStart(len) } }; return Some(Ok(token)); } - Some(DeserializerListState(mut iter)) => { + Some(State::List(mut iter)) => { match iter.next() { Some(value) => { - self.stack.push(DeserializerListState(iter)); - self.stack.push(DeserializerValueState(value)); + self.stack.push(State::List(iter)); + self.stack.push(State::Value(value)); // loop around. } None => { - return Some(Ok(de::End)); + return Some(Ok(Token::End)); } } } - Some(DeserializerObjectState(mut iter)) => { + Some(State::Object(mut iter)) => { match iter.next() { Some((key, value)) => { - self.stack.push(DeserializerObjectState(iter)); - self.stack.push(DeserializerValueState(value)); - return Some(Ok(de::String(key))); + self.stack.push(State::Object(iter)); + self.stack.push(State::Value(value)); + return Some(Ok(Token::String(key))); } None => { - return Some(Ok(de::End)); + return Some(Ok(Token::End)); } } } - Some(DeserializerEndState) => { - return Some(Ok(de::End)); + Some(State::End) => { + return Some(Ok(Token::End)); } None => { return None; } } @@ -393,21 +382,21 @@ impl Iterator> for Deserializer { impl de::Deserializer for Deserializer { fn end_of_stream_error(&mut self) -> Error { - SyntaxError(EOFWhileParsingValue, 0, 0) + Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0) } fn syntax_error(&mut self, - token: de::Token, - expected: &'static [de::TokenKind]) -> Error { - SyntaxError(ExpectedTokens(token, expected), 0, 0) + token: Token, + expected: &'static [TokenKind]) -> Error { + Error::SyntaxError(ErrorCode::ExpectedTokens(token, expected), 0, 0) } - fn unexpected_name_error(&mut self, token: de::Token) -> Error { - SyntaxError(UnexpectedName(token), 0, 0) + fn unexpected_name_error(&mut self, token: Token) -> Error { + Error::SyntaxError(ErrorCode::UnexpectedName(token), 0, 0) } - fn conversion_error(&mut self, token: de::Token) -> Error { - SyntaxError(ConversionError(token), 0, 0) + fn conversion_error(&mut self, token: Token) -> Error { + Error::SyntaxError(ErrorCode::ConversionError(token), 0, 0) } #[inline] @@ -416,16 +405,16 @@ impl de::Deserializer for Deserializer { >(&mut self, _field: &'static str) -> Result { // JSON can represent `null` values as a missing value, so this isn't // 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. #[inline] fn expect_option< U: de::Deserialize - >(&mut self, token: de::Token) -> Result, Error> { + >(&mut self, token: Token) -> Result, Error> { match token { - de::Null => Ok(None), + Token::Null => Ok(None), token => { let value: U = try!(de::Deserialize::deserialize_token(self, token)); Ok(Some(value)) @@ -436,64 +425,80 @@ impl de::Deserializer for Deserializer { // Special case treating enums as a String or a `{"variant": "...", "fields": [...]}`. #[inline] fn expect_enum_start(&mut self, - token: de::Token, + token: Token, _name: &str, variants: &[&str]) -> Result { let variant = match token { - de::MapStart(_) => { + Token::MapStart(_) => { let state = match self.stack.pop() { Some(state) => state, None => { panic!("state machine error, state stack empty"); } }; let mut iter = match state { - DeserializerObjectState(iter) => iter, + State::Object(iter) => iter, _ => { panic!("state machine error, expected an object"); } }; let (variant, fields) = match iter.next() { - Some((variant, List(fields))) => (variant, fields), + Some((variant, Value::List(fields))) => (variant, fields), 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("".to_string())); } - None => { return Err(MissingFieldError("".to_string())); } }; // Error out if there are other fields in the enum. match iter.next() { Some((key, value)) => { - return Err(ExpectedError("None".to_string(), format!("{} => {}", key, value))); + return Err( + Error::ExpectedError( + "None".to_string(), + format!("{} => {}", key, value) + ) + ); } None => { } } - self.stack.push(DeserializerEndState); + self.stack.push(State::End); for field in fields.into_iter().rev() { - self.stack.push(DeserializerValueState(field)); + self.stack.push(State::Value(field)); } variant } token => { - return Err(ExpectedError("String or Object".to_string(), - format!("{}", token))) + return Err( + Error::ExpectedError( + "String or Object".to_string(), + format!("{}", token) + ) + ); } }; match variants.iter().position(|v| *v == variant.as_slice()) { Some(idx) => Ok(idx), - None => Err(UnknownVariantError(variant)), + None => Err(Error::UnknownVariantError(variant)), } } #[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 { - de::MapStart(_) => Ok(()), + Token::MapStart(_) => Ok(()), _ => { - static EXPECTED_TOKENS: &'static [de::TokenKind] = [ - de::MapStartKind + static EXPECTED_TOKENS: &'static [TokenKind] = &[ + TokenKind::MapStartKind ]; Err(self.syntax_error(token, EXPECTED_TOKENS)) } @@ -520,63 +525,63 @@ impl ToJson for Value { } 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 { - fn to_json(&self) -> Value { Integer(*self as i64) } + fn to_json(&self) -> Value { Value::Integer(*self as i64) } } 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 { - fn to_json(&self) -> Value { Integer(*self as i64) } + fn to_json(&self) -> Value { Value::Integer(*self as 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 { - fn to_json(&self) -> Value { Integer(*self as i64) } + fn to_json(&self) -> Value { Value::Integer(*self as i64) } } 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 { - fn to_json(&self) -> Value { Integer(*self as i64) } + fn to_json(&self) -> Value { Value::Integer(*self as i64) } } 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 { - fn to_json(&self) -> Value { Integer(*self as i64) } + fn to_json(&self) -> Value { Value::Integer(*self as i64) } } 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 { - fn to_json(&self) -> Value { Floating(*self) } + fn to_json(&self) -> Value { Value::Floating(*self) } } 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 { - fn to_json(&self) -> Value { String(self.to_string()) } + fn to_json(&self) -> Value { Value::String(self.to_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 { @@ -588,7 +593,7 @@ macro_rules! impl_to_json_tuple { impl<> ToJson for () { #[inline] fn to_json(&self) -> Value { - Null + Value::Null } } }; @@ -608,7 +613,7 @@ macro_rules! impl_to_json_tuple { list.push($name.to_json()); )* - List(list) + Value::List(list) } } 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 ToJson for Vec { - 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 ToJson for TreeMap { @@ -627,7 +634,7 @@ impl ToJson for TreeMap { for (key, value) in self.iter() { d.insert((*key).clone(), value.to_json()); } - Object(d) + Value::Object(d) } } @@ -637,14 +644,14 @@ impl ToJson for HashMap { for (key, value) in self.iter() { d.insert((*key).clone(), value.to_json()); } - Object(d) + Value::Object(d) } } impl ToJson for Option { fn to_json(&self) -> Value { match *self { - None => Null, + None => Value::Null, Some(ref value) => value.to_json() } } diff --git a/src/lib.rs b/src/lib.rs index e2a61364..60602976 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,8 +12,8 @@ extern crate serde_macros; #[cfg(test)] extern crate serialize; -pub use ser::{Serializer, Serialize}; pub use de::{Deserializer, Deserialize}; +pub use ser::{Serializer, Serialize}; pub mod de; pub mod ser; diff --git a/src/ser.rs b/src/ser.rs index b338bf06..4f467674 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -428,110 +428,110 @@ mod tests { impl<'a, Iter: Iterator>> Serializer for AssertSerializer { fn serialize_null(&mut self) -> Result<(), Error> { - self.serialize(Null) + self.serialize(Token::Null) } 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> { - self.serialize(Int(v)) + self.serialize(Token::Int(v)) } 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> { - self.serialize(I16(v)) + self.serialize(Token::I16(v)) } 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> { - self.serialize(I64(v)) + self.serialize(Token::I64(v)) } 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> { - self.serialize(U8(v)) + self.serialize(Token::U8(v)) } 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> { - self.serialize(U32(v)) + self.serialize(Token::U32(v)) } 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> { - self.serialize(F32(v)) + self.serialize(Token::F32(v)) } 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> { - self.serialize(Char(v)) + self.serialize(Token::Char(v)) } 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> { - self.serialize(TupleStart(len)) + self.serialize(Token::TupleStart(len)) } fn serialize_tuple_elt< T: Serialize, Error> >(&mut self, value: &T) -> Result<(), Error> { - try!(self.serialize(TupleSep)); + try!(self.serialize(Token::TupleSep)); value.serialize(self) } 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> { - self.serialize(StructStart(name, len)) + self.serialize(Token::StructStart(name, len)) } fn serialize_struct_elt< T: Serialize, Error> >(&mut self, name: &str, value: &T) -> Result<(), Error> { - try!(self.serialize(StructSep(name))); + try!(self.serialize(Token::StructSep(name))); value.serialize(self) } 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> { - self.serialize(EnumStart(name, variant, len)) + self.serialize(Token::EnumStart(name, variant, len)) } fn serialize_enum_elt< T: Serialize, Error> >(&mut self, value: &T) -> Result<(), Error> { - try!(self.serialize(EnumSep)); + try!(self.serialize(Token::EnumSep)); value.serialize(self) } fn serialize_enum_end(&mut self) -> Result<(), Error> { - self.serialize(EnumEnd) + self.serialize(Token::EnumEnd) } fn serialize_option< @@ -539,11 +539,11 @@ mod tests { >(&mut self, v: &option::Option) -> Result<(), Error> { match *v { Some(ref v) => { - try!(self.serialize(Option(true))); + try!(self.serialize(Token::Option(true))); v.serialize(self) } None => { - self.serialize(Option(false)) + self.serialize(Token::Option(false)) } } } @@ -553,11 +553,11 @@ mod tests { SeqIter: Iterator >(&mut self, mut iter: SeqIter) -> Result<(), Error> { let (len, _) = iter.size_hint(); - try!(self.serialize(SeqStart(len))); + try!(self.serialize(Token::SeqStart(len))); for elt in iter { try!(elt.serialize(self)); } - self.serialize(SeqEnd) + self.serialize(Token::SeqEnd) } fn serialize_map< @@ -566,12 +566,12 @@ mod tests { MapIter: Iterator<(K, V)> >(&mut self, mut iter: MapIter) -> Result<(), Error> { let (len, _) = iter.size_hint(); - try!(self.serialize(MapStart(len))); + try!(self.serialize(Token::MapStart(len))); for (key, value) in iter { try!(key.serialize(self)); try!(value.serialize(self)); } - self.serialize(MapEnd) + self.serialize(Token::MapEnd) } } @@ -580,7 +580,7 @@ mod tests { #[test] fn test_tokens_int() { let tokens = vec!( - Int(5) + Token::Int(5) ); let mut serializer = AssertSerializer::new(tokens.into_iter()); 5i.serialize(&mut serializer).unwrap(); @@ -590,7 +590,7 @@ mod tests { #[test] fn test_tokens_str() { let tokens = vec!( - Str("a"), + Token::Str("a"), ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -601,7 +601,7 @@ mod tests { #[test] fn test_tokens_null() { let tokens = vec!( - Null, + Token::Null, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -612,7 +612,7 @@ mod tests { #[test] fn test_tokens_option_none() { let tokens = vec!( - Option(false), + Token::Option(false), ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -623,8 +623,8 @@ mod tests { #[test] fn test_tokens_option_some() { let tokens = vec!( - Option(true), - Int(5), + Token::Option(true), + Token::Int(5), ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -635,13 +635,13 @@ mod tests { #[test] fn test_tokens_tuple() { let tokens = vec!( - TupleStart(2), - TupleSep, - Int(5), + Token::TupleStart(2), + Token::TupleSep, + Token::Int(5), - TupleSep, - Str("a"), - TupleEnd, + Token::TupleSep, + Token::Str("a"), + Token::TupleEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -652,22 +652,22 @@ mod tests { #[test] fn test_tokens_tuple_compound() { let tokens = vec!( - TupleStart(3), - TupleSep, - Null, + Token::TupleStart(3), + Token::TupleSep, + Token::Null, - TupleSep, - Null, + Token::TupleSep, + Token::Null, - TupleSep, - TupleStart(2), - TupleSep, - Int(5), + Token::TupleSep, + Token::TupleStart(2), + Token::TupleSep, + Token::Int(5), - TupleSep, - Str("a"), - TupleEnd, - TupleEnd, + Token::TupleSep, + Token::Str("a"), + Token::TupleEnd, + Token::TupleEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -678,11 +678,11 @@ mod tests { #[test] fn test_tokens_struct_empty() { let tokens = vec!( - StructStart("Outer", 1), - StructSep("inner"), - SeqStart(0), - SeqEnd, - StructEnd, + Token::StructStart("Outer", 1), + Token::StructSep("inner"), + Token::SeqStart(0), + Token::SeqEnd, + Token::StructEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -693,25 +693,25 @@ mod tests { #[test] fn test_tokens_struct() { let tokens = vec!( - StructStart("Outer", 1), - StructSep("inner"), - SeqStart(1), - StructStart("Inner", 3), - StructSep("a"), - Null, + Token::StructStart("Outer", 1), + Token::StructSep("inner"), + Token::SeqStart(1), + Token::StructStart("Inner", 3), + Token::StructSep("a"), + Token::Null, - StructSep("b"), - Uint(5), + Token::StructSep("b"), + Token::Uint(5), - StructSep("c"), - MapStart(1), - Str("abc"), - Option(true), - Char('c'), - MapEnd, - StructEnd, - SeqEnd, - StructEnd, + Token::StructSep("c"), + Token::MapStart(1), + Token::Str("abc"), + Token::Option(true), + Token::Char('c'), + Token::MapEnd, + Token::StructEnd, + Token::SeqEnd, + Token::StructEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -734,34 +734,34 @@ mod tests { #[test] fn test_tokens_enum() { let tokens = vec!( - EnumStart("Animal", "Dog", 0), - EnumEnd, + Token::EnumStart("Animal", "Dog", 0), + Token::EnumEnd, ); 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); let tokens = vec!( - EnumStart("Animal", "Frog", 2), - EnumSep, - Str("Henry"), + Token::EnumStart("Animal", "Frog", 2), + Token::EnumSep, + Token::Str("Henry"), - EnumSep, - Int(349), - EnumEnd, + Token::EnumSep, + Token::Int(349), + Token::EnumEnd, ); 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); } #[test] fn test_tokens_vec_empty() { let tokens = vec!( - SeqStart(0), - SeqEnd, + Token::SeqStart(0), + Token::SeqEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -773,11 +773,11 @@ mod tests { #[test] fn test_tokens_vec() { let tokens = vec!( - SeqStart(3), - Int(5), - Int(6), - Int(7), - SeqEnd, + Token::SeqStart(3), + Token::Int(5), + Token::Int(6), + Token::Int(7), + Token::SeqEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -788,22 +788,22 @@ mod tests { #[test] fn test_tokens_vec_compound() { let tokens = vec!( - SeqStart(3), - SeqStart(1), - Int(1), - SeqEnd, + Token::SeqStart(3), + Token::SeqStart(1), + Token::Int(1), + Token::SeqEnd, - SeqStart(2), - Int(2), - Int(3), - SeqEnd, + Token::SeqStart(2), + Token::Int(2), + Token::Int(3), + Token::SeqEnd, - SeqStart(3), - Int(4), - Int(5), - Int(6), - SeqEnd, - SeqEnd, + Token::SeqStart(3), + Token::Int(4), + Token::Int(5), + Token::Int(6), + Token::SeqEnd, + Token::SeqEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter()); @@ -814,13 +814,13 @@ mod tests { #[test] fn test_tokens_treemap() { let tokens = vec!( - MapStart(2), - Int(5), - Str("a"), + Token::MapStart(2), + Token::Int(5), + Token::Str("a"), - Int(6), - Str("b"), - MapEnd, + Token::Int(6), + Token::Str("b"), + Token::MapEnd, ); let mut serializer = AssertSerializer::new(tokens.into_iter());