pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-23 09:28:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix serde to compile on master again

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-11-22 16:27:01 -08:00
parent ff8c8c77cc
commit 857723dff6
15 changed files with 1115 additions and 1094 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/json/builder.rs
+14 -14
View File
@@ -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<Value>,
@@ -23,7 +23,7 @@ impl ListBuilder {
}
pub fn unwrap(self) -> Value {
List(self.list)
Value::List(self.list)
}
pub fn push<T: ToJson>(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<K: StrAllocating, V: ToJson>(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));
}
}
src/json/de.rs
+38 -29
View File
@@ -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<Iter: Iterator<u8>> Iterator<Result<de::Token, Error>> for Parser<Iter> {
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<Iter: Iterator<u8>> Parser<Iter> {
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<Iter: Iterator<u8>> Parser<Iter> {
_ => 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<Iter: Iterator<u8>> Parser<Iter> {
}
};
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<Iter: Iterator<u8>> Parser<Iter> {
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<Iter: Iterator<u8>> Parser<Iter> {
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<Iter: Iterator<u8>> Parser<Iter> {
}
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<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
>(&mut self, _field: &'static str) -> Result<T, Error> {
// 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<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
U: de::Deserialize<Parser<Iter>, Error>
>(&mut self, token: de::Token) -> Result<Option<U>, 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<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
_name: &str,
variants: &[&str]) -> Result<uint, Error> {
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<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
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<Iter: Iterator<u8>> de::Deserializer<Error> for Parser<Iter> {
#[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))
}
src/json/error.rs
+125
View File
@@ -0,0 +1,125 @@
use std::error;
use std::fmt;
use std::io;
use de::{Token, TokenKind};
/// The errors that can arise while parsing a JSON stream.
#[deriving(Clone, PartialEq)]
pub enum ErrorCode {
ConversionError(Token),
EOFWhileParsingList,
EOFWhileParsingObject,
EOFWhileParsingString,
EOFWhileParsingValue,
ExpectedColon,
ExpectedConversion,
ExpectedEnumEnd,
ExpectedEnumEndToken,
ExpectedEnumMapStart,
ExpectedEnumToken,
ExpectedEnumVariantString,
ExpectedListCommaOrEnd,
ExpectedName,
ExpectedObjectCommaOrEnd,
ExpectedSomeIdent,
ExpectedSomeValue,
ExpectedTokens(Token, &'static [TokenKind]),
InvalidEscape,
InvalidNumber,
InvalidUnicodeCodePoint,
KeyMustBeAString,
LoneLeadingSurrogateInHexEscape,
MissingField(&'static str),
NotFourDigit,
NotUtf8,
TrailingCharacters,
UnexpectedEndOfHexEscape,
UnexpectedName(Token),
UnknownVariant,
UnrecognizedHex,
}
impl fmt::Show for ErrorCode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ErrorCode::ConversionError(ref token) => write!(f, "failed to convert {}", token),
ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
ErrorCode::ExpectedColon => "expected `:`".fmt(f),
ErrorCode::ExpectedConversion => "expected conversion".fmt(f),
ErrorCode::ExpectedEnumEnd => "expected enum end".fmt(f),
ErrorCode::ExpectedEnumEndToken => "expected enum map end".fmt(f),
ErrorCode::ExpectedEnumMapStart => "expected enum map start".fmt(f),
ErrorCode::ExpectedEnumToken => "expected enum token".fmt(f),
ErrorCode::ExpectedEnumVariantString => "expected variant".fmt(f),
ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
ErrorCode::ExpectedName => "expected name".fmt(f),
ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),
ErrorCode::ExpectedSomeIdent => "expected ident".fmt(f),
ErrorCode::ExpectedSomeValue => "expected value".fmt(f),
ErrorCode::ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token),
ErrorCode::InvalidEscape => "invalid escape".fmt(f),
ErrorCode::InvalidNumber => "invalid number".fmt(f),
ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
ErrorCode::UnexpectedName(ref name) => write!(f, "unexpected name {}", name),
ErrorCode::UnknownVariant => "unknown variant".fmt(f),
ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
}
}
}
#[deriving(Clone, PartialEq, Show)]
pub enum Error {
/// msg, line, col
SyntaxError(ErrorCode, uint, uint),
IoError(io::IoError),
ExpectedError(String, String),
MissingFieldError(String),
UnknownVariantError(String),
}
impl error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::SyntaxError(..) => "syntax error",
Error::IoError(ref error) => error.description(),
Error::ExpectedError(ref expected, _) => expected.as_slice(),
Error::MissingFieldError(_) => "missing field",
Error::UnknownVariantError(_) => "unknown variant",
}
}
fn detail(&self) -> Option<String> {
match *self {
Error::SyntaxError(ref code, line, col) => {
Some(format!("{} at line {} column {}", code, line, col))
}
Error::IoError(ref error) => error.detail(),
Error::ExpectedError(ref expected, ref found) => {
Some(format!("expected {}, found {}", expected, found))
}
Error::MissingFieldError(ref field) => {
Some(format!("missing field {}", field))
}
Error::UnknownVariantError(ref variant) => {
Some(format!("unknown variant {}", variant))
}
}
}
}
impl error::FromError<io::IoError> for Error {
fn from_error(error: io::IoError) -> Error {
Error::IoError(error)
}
}
src/json/mod.rs
+209 -347
View File
File diff suppressed because it is too large Load Diff
src/json/ser.rs
+22 -22
View File
@@ -44,7 +44,7 @@ pub fn escape_str<W: Writer>(wr: &mut W, v: &str) -> IoResult<()> {
}
fn escape_char<W: Writer>(wr: &mut W, v: char) -> IoResult<()> {
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<W: Writer>(wr: &mut W, v: f64) -> IoResult<()> {
fn spaces<W: Writer>(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<W: Writer> ser::Serializer<IoError> for Serializer<W> {
#[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<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
#[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]
src/json/value.rs
+155 -148
View File
@@ -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<string::String, Value>> {
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<Value>> {
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<i64> {
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<f64> {
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<bool> {
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<S: ser::Serializer<E>, E> ser::Serialize<S, E> 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<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Value {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Value, E> {
fn deserialize_token(d: &mut D, token: Token) -> Result<Value, E> {
match token {
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<Value> = 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<Value>),
DeserializerObjectState(tree_map::MoveEntries<string::String, Value>),
DeserializerEndState,
enum State {
Value(Value),
List(vec::MoveItems<Value>),
Object(tree_map::MoveEntries<string::String, Value>),
End,
}
pub struct Deserializer {
stack: Vec<DeserializerState>,
stack: Vec<State>,
}
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<Result<de::Token, Error>> for Deserializer {
impl Iterator<Result<Token, Error>> for Deserializer {
#[inline]
fn next(&mut self) -> Option<Result<de::Token, Error>> {
fn next(&mut self) -> Option<Result<Token, Error>> {
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<Result<de::Token, Error>> for Deserializer {
impl de::Deserializer<Error> 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<Error> for Deserializer {
>(&mut self, _field: &'static str) -> Result<T, Error> {
// 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<Deserializer, Error>
>(&mut self, token: de::Token) -> Result<Option<U>, Error> {
>(&mut self, token: Token) -> Result<Option<U>, 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<Error> 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<uint, Error> {
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("<variant-name>".to_string()));
}
None => { return Err(MissingFieldError("<variant-name>".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<A:ToJson> ToJson for Vec<A> {
fn to_json(&self) -> Value { List(self.iter().map(|elt| elt.to_json()).collect()) }
fn to_json(&self) -> Value {
Value::List(self.iter().map(|elt| elt.to_json()).collect())
}
}
impl<A:ToJson> ToJson for TreeMap<string::String, A> {
@@ -627,7 +634,7 @@ impl<A:ToJson> ToJson for TreeMap<string::String, A> {
for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Object(d)
Value::Object(d)
}
}
@@ -637,14 +644,14 @@ impl<A:ToJson> ToJson for HashMap<string::String, A> {
for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Object(d)
Value::Object(d)
}
}
impl<A:ToJson> ToJson for Option<A> {
fn to_json(&self) -> Value {
match *self {
None => Null,
None => Value::Null,
Some(ref value) => value.to_json()
}
}