pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-23 16:28:02 +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/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()
}
}