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

serde List -> Array

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-12-05 22:23:03 -08:00
parent f6434fcf77
commit 0bd94c7653
3 changed files with 47 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/json/builder.rs
View File

@ -13,31 +13,31 @@ use std::str::StrAllocating;
use json::value::{ToJson, Value};
pub struct ListBuilder {
list: Vec<Value>,
pub struct ArrayBuilder {
array: Vec<Value>,
}
impl ListBuilder {
pub fn new() -> ListBuilder {
ListBuilder { list: Vec::new() }
impl ArrayBuilder {
pub fn new() -> ArrayBuilder {
ArrayBuilder { array: Vec::new() }
}
pub fn unwrap(self) -> Value {
Value::List(self.list)
Value::Array(self.array)
}
pub fn push<T: ToJson>(self, value: T) -> ListBuilder {
pub fn push<T: ToJson>(self, value: T) -> ArrayBuilder {
let mut builder = self;
builder.list.push(value.to_json());
builder.array.push(value.to_json());
builder
}
pub fn push_list(self, f: |ListBuilder| -> ListBuilder) -> ListBuilder {
let builder = ListBuilder::new();
pub fn push_array(self, f: |ArrayBuilder| -> ArrayBuilder) -> ArrayBuilder {
let builder = ArrayBuilder::new();
self.push(f(builder).unwrap())
}
pub fn push_object(self, f: |ObjectBuilder| -> ObjectBuilder) -> ListBuilder {
pub fn push_object(self, f: |ObjectBuilder| -> ObjectBuilder) -> ArrayBuilder {
let builder = ObjectBuilder::new();
self.push(f(builder).unwrap())
}
@ -62,8 +62,8 @@ impl ObjectBuilder {
builder
}
pub fn insert_list<S: StrAllocating>(self, key: S, f: |ListBuilder| -> ListBuilder) -> ObjectBuilder {
let builder = ListBuilder::new();
pub fn insert_array<S: StrAllocating>(self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
let builder = ArrayBuilder::new();
self.insert(key.into_string(), f(builder).unwrap())
}
@ -78,26 +78,26 @@ mod tests {
use std::collections::TreeMap;
use json::value::Value;
use super::{ListBuilder, ObjectBuilder};
use super::{ArrayBuilder, ObjectBuilder};
#[test]
fn test_list_builder() {
let value = ListBuilder::new().unwrap();
assert_eq!(value, Value::List(Vec::new()));
fn test_array_builder() {
let value = ArrayBuilder::new().unwrap();
assert_eq!(value, Value::Array(Vec::new()));
let value = ListBuilder::new()
let value = ArrayBuilder::new()
.push(1i)
.push(2i)
.push(3i)
.unwrap();
assert_eq!(value, Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
assert_eq!(value, Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
let value = ListBuilder::new()
.push_list(|bld| bld.push(1i).push(2i).push(3i))
let value = ArrayBuilder::new()
.push_array(|bld| bld.push(1i).push(2i).push(3i))
.unwrap();
assert_eq!(value, Value::List(vec!(Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
let value = ListBuilder::new()
let value = ArrayBuilder::new()
.push_object(|bld|
bld
.insert("a".to_string(), 1i)
@ -107,7 +107,7 @@ mod tests {
let mut map = TreeMap::new();
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))));
assert_eq!(value, Value::Array(vec!(Value::Object(map))));
}
#[test]

2
src/json/mod.rs
View File

@ -292,7 +292,7 @@ fn main() {
*/
pub use self::builder::{ListBuilder, ObjectBuilder};
pub use self::builder::{ArrayBuilder, ObjectBuilder};
pub use self::de::{
Parser,
from_str,

44
src/json/value.rs
View File

@ -21,7 +21,7 @@ pub enum Value {
Integer(i64),
Floating(f64),
String(string::String),
List(Vec<Value>),
Array(Vec<Value>),
Object(TreeMap<string::String, Value>),
}
@ -107,16 +107,16 @@ impl Value {
}
}
/// Returns true if the Json value is a List. Returns false otherwise.
pub fn is_list<'a>(&'a self) -> bool {
self.as_list().is_some()
/// Returns true if the Json value is a Array. Returns false otherwise.
pub fn is_array<'a>(&'a self) -> bool {
self.as_array().is_some()
}
/// If the Json value is a List, returns the associated vector.
/// If the Json value is a Array, returns the associated vector.
/// Returns None otherwise.
pub fn as_list<'a>(&'a self) -> Option<&'a Vec<Value>> {
pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
match *self {
Value::List(ref list) => Some(list),
Value::Array(ref array) => Some(array),
_ => None
}
}
@ -243,7 +243,7 @@ impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Value {
Value::String(ref v) => {
v.serialize(s)
}
Value::List(ref v) => {
Value::Array(ref v) => {
v.serialize(s)
}
Value::Object(ref v) => {
@ -277,8 +277,8 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
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(Value::List(list))
let array = try!(de::Deserialize::deserialize_token(d, token));
Ok(Value::Array(array))
}
Token::StructStart(_, _) | Token::MapStart(_) => {
let object = try!(de::Deserialize::deserialize_token(d, token));
@ -288,7 +288,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
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(), Value::List(fields));
object.insert(name.to_string(), Value::Array(fields));
Ok(Value::Object(object))
}
Token::End => {
@ -303,7 +303,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
enum State {
Value(Value),
List(vec::MoveItems<Value>),
Array(vec::MoveItems<Value>),
Object(tree_map::MoveEntries<string::String, Value>),
End,
}
@ -333,9 +333,9 @@ impl Iterator<Result<Token, Error>> for Deserializer {
Value::Integer(x) => Token::I64(x),
Value::Floating(x) => Token::F64(x),
Value::String(x) => Token::String(x),
Value::List(x) => {
Value::Array(x) => {
let len = x.len();
self.stack.push(State::List(x.into_iter()));
self.stack.push(State::Array(x.into_iter()));
Token::SeqStart(len)
}
Value::Object(x) => {
@ -347,10 +347,10 @@ impl Iterator<Result<Token, Error>> for Deserializer {
return Some(Ok(token));
}
Some(State::List(mut iter)) => {
Some(State::Array(mut iter)) => {
match iter.next() {
Some(value) => {
self.stack.push(State::List(iter));
self.stack.push(State::Array(iter));
self.stack.push(State::Value(value));
// loop around.
}
@ -441,11 +441,11 @@ impl de::Deserializer<Error> for Deserializer {
};
let (variant, fields) = match iter.next() {
Some((variant, Value::List(fields))) => (variant, fields),
Some((variant, Value::Array(fields))) => (variant, fields),
Some((key, value)) => {
return Err(
Error::ExpectedError(
"List".to_string(),
"Array".to_string(),
format!("{} => {}", key, value)
)
);
@ -608,12 +608,12 @@ macro_rules! impl_to_json_tuple {
let ($(ref $name,)*) = *self;
let mut list = Vec::with_capacity(len);
let mut array = Vec::with_capacity(len);
$(
list.push($name.to_json());
array.push($name.to_json());
)*
Value::List(list)
Value::Array(array)
}
}
peel_to_json_tuple!($($name,)*)
@ -624,7 +624,7 @@ 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 {
Value::List(self.iter().map(|elt| elt.to_json()).collect())
Value::Array(self.iter().map(|elt| elt.to_json()).collect())
}
}