Rename Serializable to Serialize, Deserializable to Deserialize
This commit is contained in:
Erick Tryzelaar
parent
45247c7ef6
commit
21a58e86e4
@ -11,12 +11,12 @@ use test::Bencher;
|
||||
|
||||
use serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserializable};
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_deserialize]
|
||||
enum Animal {
|
||||
Dog,
|
||||
Frog(String, int)
|
||||
@ -260,7 +260,7 @@ mod deserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<AnimalDeserializer, Error>
|
||||
T: de::Deserialize<AnimalDeserializer, Error>
|
||||
>(&mut self, _field: &'static str) -> Result<T, Error> {
|
||||
Err(SyntaxError)
|
||||
}
|
||||
@ -299,7 +299,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
|
||||
let animal = Dog;
|
||||
|
||||
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
|
||||
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
|
||||
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
@ -311,7 +311,7 @@ fn bench_deserializer_frog(b: &mut Bencher) {
|
||||
let animal = Frog("Henry".to_string(), 349);
|
||||
|
||||
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
|
||||
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
|
||||
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, animal);
|
||||
})
|
||||
|
||||
@ -14,12 +14,12 @@ use test::Bencher;
|
||||
|
||||
use serde::de;
|
||||
use serde::json;
|
||||
use serde::ser::Serializable;
|
||||
use serde::ser::Serialize;
|
||||
use serde::ser;
|
||||
|
||||
#[deriving(Encodable, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Http {
|
||||
protocol: HttpProtocol,
|
||||
status: u32,
|
||||
@ -39,14 +39,14 @@ enum HttpProtocol {
|
||||
HTTP11,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpProtocol {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpProtocol {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpProtocol {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpProtocol {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -68,14 +68,14 @@ enum HttpMethod {
|
||||
PATCH,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpMethod {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpMethod {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpMethod {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpMethod {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -90,14 +90,14 @@ enum CacheStatus {
|
||||
Hit,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for CacheStatus {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for CacheStatus {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for CacheStatus {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -105,8 +105,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
|
||||
}
|
||||
|
||||
#[deriving(Encodable, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Origin {
|
||||
ip: String,
|
||||
port: u32,
|
||||
@ -121,14 +121,14 @@ enum OriginProtocol {
|
||||
HTTPS,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for OriginProtocol {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for OriginProtocol {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for OriginProtocol {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for OriginProtocol {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -144,14 +144,14 @@ enum ZonePlan {
|
||||
ENT,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for ZonePlan {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for ZonePlan {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for ZonePlan {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for ZonePlan {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -418,14 +418,14 @@ enum Country {
|
||||
ZW,
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Country {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Country {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_uint(*self as uint)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Country {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> {
|
||||
d.expect_from_primitive(token)
|
||||
@ -433,8 +433,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
|
||||
}
|
||||
|
||||
#[deriving(Encodable, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Log {
|
||||
timestamp: i64,
|
||||
zone_id: u32,
|
||||
|
||||
@ -13,7 +13,7 @@ use test::Bencher;
|
||||
|
||||
use serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserializable};
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -258,7 +258,7 @@ mod deserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<IntDeserializer, Error>
|
||||
T: de::Deserialize<IntDeserializer, Error>
|
||||
>(&mut self, _field: &'static str) -> Result<T, Error> {
|
||||
Err(SyntaxError)
|
||||
}
|
||||
@ -310,9 +310,9 @@ fn bench_decoder_100(b: &mut Bencher) {
|
||||
fn run_deserializer<
|
||||
D: Deserializer<E>,
|
||||
E: Show,
|
||||
T: Clone + PartialEq + Show + Deserializable<D, E>
|
||||
T: Clone + PartialEq + Show + Deserialize<D, E>
|
||||
>(mut d: D, value: T) {
|
||||
let v: T = Deserializable::deserialize(&mut d).unwrap();
|
||||
let v: T = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, v);
|
||||
}
|
||||
|
||||
@ -12,12 +12,12 @@ use test::Bencher;
|
||||
|
||||
use serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserializable};
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_deserialize]
|
||||
struct Inner {
|
||||
a: (),
|
||||
b: uint,
|
||||
@ -27,7 +27,7 @@ struct Inner {
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_deserialize]
|
||||
struct Outer {
|
||||
inner: Vec<Inner>,
|
||||
}
|
||||
@ -387,7 +387,7 @@ mod deserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<OuterDeserializer, Error>
|
||||
T: de::Deserialize<OuterDeserializer, Error>
|
||||
>(&mut self, field: &'static str) -> Result<T, Error> {
|
||||
Err(MissingField(field))
|
||||
}
|
||||
@ -468,7 +468,7 @@ fn bench_deserializer_0_0(b: &mut Bencher) {
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
|
||||
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, outer);
|
||||
})
|
||||
@ -490,7 +490,7 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
|
||||
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, outer);
|
||||
})
|
||||
@ -517,7 +517,7 @@ fn bench_deserializer_1_5(b: &mut Bencher) {
|
||||
};
|
||||
|
||||
let mut d = deserializer::OuterDeserializer::new(outer.clone());
|
||||
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
|
||||
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, outer);
|
||||
})
|
||||
|
||||
@ -12,7 +12,7 @@ use test::Bencher;
|
||||
|
||||
use serialize::{Decoder, Decodable};
|
||||
|
||||
use serde::de::{Deserializer, Deserializable};
|
||||
use serde::de::{Deserializer, Deserialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -327,7 +327,7 @@ mod deserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<IntDeserializer, Error>
|
||||
T: de::Deserialize<IntDeserializer, Error>
|
||||
>(&mut self, _field: &'static str) -> Result<T, Error> {
|
||||
Err(SyntaxError)
|
||||
}
|
||||
@ -399,7 +399,7 @@ mod deserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<U8Deserializer, Error>
|
||||
T: de::Deserialize<U8Deserializer, Error>
|
||||
>(&mut self, _field: &'static str) -> Result<T, Error> {
|
||||
Err(SyntaxError)
|
||||
}
|
||||
@ -421,9 +421,9 @@ fn run_decoder<
|
||||
fn run_deserializer<
|
||||
D: Deserializer<E>,
|
||||
E: Show,
|
||||
T: Clone + PartialEq + Show + Deserializable<D, E>
|
||||
T: Clone + PartialEq + Show + Deserialize<D, E>
|
||||
>(mut d: D, value: T) {
|
||||
let v: T = Deserializable::deserialize(&mut d).unwrap();
|
||||
let v: T = Deserialize::deserialize(&mut d).unwrap();
|
||||
|
||||
assert_eq!(value, v);
|
||||
}
|
||||
|
||||
@ -59,26 +59,26 @@ use rustc::plugin::Registry;
|
||||
#[doc(hidden)]
|
||||
pub fn plugin_registrar(reg: &mut Registry) {
|
||||
reg.register_syntax_extension(
|
||||
token::intern("deriving_serializable"),
|
||||
Decorator(box expand_deriving_serializable));
|
||||
token::intern("deriving_serialize"),
|
||||
Decorator(box expand_deriving_serialize));
|
||||
|
||||
reg.register_syntax_extension(
|
||||
token::intern("deriving_deserializable"),
|
||||
Decorator(box expand_deriving_deserializable));
|
||||
token::intern("deriving_deserialize"),
|
||||
Decorator(box expand_deriving_deserialize));
|
||||
}
|
||||
|
||||
fn expand_deriving_serializable(cx: &mut ExtCtxt,
|
||||
sp: Span,
|
||||
mitem: &MetaItem,
|
||||
item: &Item,
|
||||
push: |P<ast::Item>|) {
|
||||
fn expand_deriving_serialize(cx: &mut ExtCtxt,
|
||||
sp: Span,
|
||||
mitem: &MetaItem,
|
||||
item: &Item,
|
||||
push: |P<ast::Item>|) {
|
||||
let inline = cx.meta_word(sp, token::InternedString::new("inline"));
|
||||
let attrs = vec!(cx.attribute(sp, inline));
|
||||
|
||||
let trait_def = TraitDef {
|
||||
span: sp,
|
||||
attributes: vec!(),
|
||||
path: Path::new_(vec!("serde", "ser", "Serializable"), None,
|
||||
path: Path::new_(vec!("serde", "ser", "Serialize"), None,
|
||||
vec!(box Literal(Path::new_local("__S")),
|
||||
box Literal(Path::new_local("__E"))), true),
|
||||
additional_bounds: Vec::new(),
|
||||
@ -109,7 +109,7 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
|
||||
),
|
||||
attributes: attrs,
|
||||
combine_substructure: combine_substructure(|a, b, c| {
|
||||
serializable_substructure(a, b, c, item)
|
||||
serialize_substructure(a, b, c, item)
|
||||
}),
|
||||
})
|
||||
};
|
||||
@ -117,11 +117,10 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
|
||||
trait_def.expand(cx, mitem, item, push)
|
||||
}
|
||||
|
||||
fn serializable_substructure(cx: &ExtCtxt,
|
||||
span: Span,
|
||||
substr: &Substructure,
|
||||
item: &Item
|
||||
) -> P<Expr> {
|
||||
fn serialize_substructure(cx: &ExtCtxt,
|
||||
span: Span,
|
||||
substr: &Substructure,
|
||||
item: &Item) -> P<Expr> {
|
||||
let serializer = substr.nonself_args[0].clone();
|
||||
|
||||
match (&item.node, substr.fields) {
|
||||
@ -193,19 +192,19 @@ fn serializable_substructure(cx: &ExtCtxt,
|
||||
})
|
||||
}
|
||||
|
||||
_ => cx.bug("expected Struct or EnumMatching in deriving_serializable")
|
||||
_ => cx.bug("expected Struct or EnumMatching in deriving_serialize")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
|
||||
span: Span,
|
||||
mitem: &MetaItem,
|
||||
item: &Item,
|
||||
push: |P<Item>|) {
|
||||
pub fn expand_deriving_deserialize(cx: &mut ExtCtxt,
|
||||
span: Span,
|
||||
mitem: &MetaItem,
|
||||
item: &Item,
|
||||
push: |P<Item>|) {
|
||||
let trait_def = TraitDef {
|
||||
span: span,
|
||||
attributes: Vec::new(),
|
||||
path: Path::new_(vec!("serde", "de", "Deserializable"), None,
|
||||
path: Path::new_(vec!("serde", "de", "Deserialize"), None,
|
||||
vec!(box Literal(Path::new_local("__D")),
|
||||
box Literal(Path::new_local("__E"))), true),
|
||||
additional_bounds: Vec::new(),
|
||||
@ -241,7 +240,7 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
|
||||
),
|
||||
attributes: Vec::new(),
|
||||
combine_substructure: combine_substructure(|a, b, c| {
|
||||
deserializable_substructure(a, b, c)
|
||||
deserialize_substructure(a, b, c)
|
||||
}),
|
||||
})
|
||||
};
|
||||
@ -249,8 +248,9 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
|
||||
trait_def.expand(cx, mitem, item, push)
|
||||
}
|
||||
|
||||
fn deserializable_substructure(cx: &mut ExtCtxt, span: Span,
|
||||
substr: &Substructure) -> P<Expr> {
|
||||
fn deserialize_substructure(cx: &mut ExtCtxt,
|
||||
span: Span,
|
||||
substr: &Substructure) -> P<Expr> {
|
||||
let deserializer = substr.nonself_args[0].clone();
|
||||
let token = substr.nonself_args[1].clone();
|
||||
|
||||
@ -275,7 +275,7 @@ fn deserializable_substructure(cx: &mut ExtCtxt, span: Span,
|
||||
deserializer,
|
||||
token)
|
||||
}
|
||||
_ => cx.bug("expected StaticEnum or StaticStruct in deriving(Deserializable)")
|
||||
_ => cx.bug("expected StaticEnum or StaticStruct in deriving(Deserialize)")
|
||||
}
|
||||
}
|
||||
|
||||
@ -372,7 +372,7 @@ fn deserialize_struct(
|
||||
Some(_) => unreachable!(),
|
||||
None => {
|
||||
let _: ::serde::de::IgnoreTokens =
|
||||
try!(::serde::de::Deserializable::deserialize($deserializer));
|
||||
try!(::serde::de::Deserialize::deserialize($deserializer));
|
||||
}
|
||||
}
|
||||
//try!($deserializer.ignore_field(token))
|
||||
@ -409,7 +409,7 @@ fn deserialize_enum(
|
||||
let arms: Vec<ast::Arm> = fields.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &(name, span, ref parts))| {
|
||||
let call = deserializable_static_fields(
|
||||
let call = deserialize_static_fields(
|
||||
cx,
|
||||
span,
|
||||
name,
|
||||
@ -441,7 +441,7 @@ fn deserialize_enum(
|
||||
/// Create a deserializer for a single enum variant/struct:
|
||||
/// - `outer_pat_ident` is the name of this enum variant/struct
|
||||
/// - `getarg` should retrieve the `uint`-th field with name `&str`.
|
||||
fn deserializable_static_fields(
|
||||
fn deserialize_static_fields(
|
||||
cx: &ExtCtxt,
|
||||
span: Span,
|
||||
outer_pat_ident: Ident,
|
||||
|
||||
180
src/de.rs
180
src/de.rs
@ -177,7 +177,7 @@ macro_rules! to_result {
|
||||
}
|
||||
|
||||
pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
/// Called when a `Deserializable` expected more tokens, but the
|
||||
/// Called when a `Deserialize` expected more tokens, but the
|
||||
/// `Deserializer` was empty.
|
||||
fn end_of_stream_error(&mut self) -> E;
|
||||
|
||||
@ -190,15 +190,15 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
/// Called when a value was unable to be coerced into another value.
|
||||
fn conversion_error(&mut self, token: Token) -> E;
|
||||
|
||||
/// Called when a `Deserializable` structure did not deserialize a field
|
||||
/// Called when a `Deserialize` structure did not deserialize a field
|
||||
/// named `field`.
|
||||
fn missing_field<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self, field: &'static str) -> Result<T, E>;
|
||||
|
||||
/// Called when a deserializable has decided to not consume this token.
|
||||
/// Called when a `Deserialize` has decided to not consume this token.
|
||||
fn ignore_field(&mut self, _token: Token) -> Result<(), E> {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize(self));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize(self));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@ -305,12 +305,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_option<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self, token: Token) -> Result<option::Option<T>, E> {
|
||||
match token {
|
||||
Option(false) => Ok(None),
|
||||
Option(true) => {
|
||||
let value: T = try!(Deserializable::deserialize(self));
|
||||
let value: T = try!(Deserialize::deserialize(self));
|
||||
Ok(Some(value))
|
||||
}
|
||||
token => Err(self.syntax_error(token, [OptionKind])),
|
||||
@ -328,9 +328,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_tuple_elt<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<T, E> {
|
||||
Deserializable::deserialize(self)
|
||||
Deserialize::deserialize(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -377,9 +377,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_struct_value<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<T, E> {
|
||||
Deserializable::deserialize(self)
|
||||
Deserialize::deserialize(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -409,9 +409,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_enum_elt<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<T, E> {
|
||||
Deserializable::deserialize(self)
|
||||
Deserialize::deserialize(self)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -433,12 +433,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_seq_elt_or_end<
|
||||
T: Deserializable<Self, E>
|
||||
T: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<option::Option<T>, E> {
|
||||
match try!(self.expect_token()) {
|
||||
End => Ok(None),
|
||||
token => {
|
||||
let value = try!(Deserializable::deserialize_token(self, token));
|
||||
let value = try!(Deserialize::deserialize_token(self, token));
|
||||
Ok(Some(value))
|
||||
}
|
||||
}
|
||||
@ -447,7 +447,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
#[inline]
|
||||
fn expect_seq<
|
||||
'a,
|
||||
T: Deserializable<Self, E>,
|
||||
T: Deserialize<Self, E>,
|
||||
C: FromIterator<T>
|
||||
>(&'a mut self, token: Token) -> Result<C, E> {
|
||||
let len = try!(self.expect_seq_start(token));
|
||||
@ -476,14 +476,14 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
|
||||
#[inline]
|
||||
fn expect_map_elt_or_end<
|
||||
K: Deserializable<Self, E>,
|
||||
V: Deserializable<Self, E>
|
||||
K: Deserialize<Self, E>,
|
||||
V: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<option::Option<(K, V)>, E> {
|
||||
match try!(self.expect_token()) {
|
||||
End => Ok(None),
|
||||
token => {
|
||||
let key = try!(Deserializable::deserialize_token(self, token));
|
||||
let value = try!(Deserializable::deserialize(self));
|
||||
let key = try!(Deserialize::deserialize_token(self, token));
|
||||
let value = try!(Deserialize::deserialize(self));
|
||||
Ok(Some((key, value)))
|
||||
}
|
||||
}
|
||||
@ -492,8 +492,8 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
|
||||
#[inline]
|
||||
fn expect_map<
|
||||
'a,
|
||||
K: Deserializable<Self, E>,
|
||||
V: Deserializable<Self, E>,
|
||||
K: Deserialize<Self, E>,
|
||||
V: Deserialize<Self, E>,
|
||||
C: FromIterator<(K, V)>
|
||||
>(&'a mut self, token: Token) -> Result<C, E> {
|
||||
let len = try!(self.expect_map_start(token));
|
||||
@ -525,7 +525,7 @@ impl<
|
||||
'a,
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E>
|
||||
T: Deserialize<D, E>
|
||||
> Iterator<T> for SeqDeserializer<'a, D, E> {
|
||||
#[inline]
|
||||
fn next(&mut self) -> option::Option<T> {
|
||||
@ -556,8 +556,8 @@ impl<
|
||||
'a,
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
K: Deserializable<D, E>,
|
||||
V: Deserializable<D, E>
|
||||
K: Deserialize<D, E>,
|
||||
V: Deserialize<D, E>
|
||||
> Iterator<(K, V)> for MapDeserializer<'a, D, E> {
|
||||
#[inline]
|
||||
fn next(&mut self) -> option::Option<(K, V)> {
|
||||
@ -578,11 +578,11 @@ impl<
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
pub trait Deserializable<D: Deserializer<E>, E> {
|
||||
pub trait Deserialize<D: Deserializer<E>, E> {
|
||||
#[inline]
|
||||
fn deserialize(d: &mut D) -> Result<Self, E> {
|
||||
let token = try!(d.expect_token());
|
||||
Deserializable::deserialize_token(d, token)
|
||||
Deserialize::deserialize_token(d, token)
|
||||
}
|
||||
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Self, E>;
|
||||
@ -590,9 +590,9 @@ pub trait Deserializable<D: Deserializer<E>, E> {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! impl_deserializable {
|
||||
macro_rules! impl_deserialize {
|
||||
($ty:ty, $method:ident) => {
|
||||
impl<D: Deserializer<E>, E> Deserializable<D, E> for $ty {
|
||||
impl<D: Deserializer<E>, E> Deserialize<D, E> for $ty {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<$ty, E> {
|
||||
d.$method(token)
|
||||
@ -601,55 +601,55 @@ macro_rules! impl_deserializable {
|
||||
}
|
||||
}
|
||||
|
||||
impl_deserializable!(bool, expect_bool)
|
||||
impl_deserializable!(int, expect_num)
|
||||
impl_deserializable!(i8, expect_num)
|
||||
impl_deserializable!(i16, expect_num)
|
||||
impl_deserializable!(i32, expect_num)
|
||||
impl_deserializable!(i64, expect_num)
|
||||
impl_deserializable!(uint, expect_num)
|
||||
impl_deserializable!(u8, expect_num)
|
||||
impl_deserializable!(u16, expect_num)
|
||||
impl_deserializable!(u32, expect_num)
|
||||
impl_deserializable!(u64, expect_num)
|
||||
impl_deserializable!(f32, expect_num)
|
||||
impl_deserializable!(f64, expect_num)
|
||||
impl_deserializable!(char, expect_char)
|
||||
impl_deserializable!(&'static str, expect_str)
|
||||
impl_deserializable!(string::String, expect_string)
|
||||
impl_deserialize!(bool, expect_bool)
|
||||
impl_deserialize!(int, expect_num)
|
||||
impl_deserialize!(i8, expect_num)
|
||||
impl_deserialize!(i16, expect_num)
|
||||
impl_deserialize!(i32, expect_num)
|
||||
impl_deserialize!(i64, expect_num)
|
||||
impl_deserialize!(uint, expect_num)
|
||||
impl_deserialize!(u8, expect_num)
|
||||
impl_deserialize!(u16, expect_num)
|
||||
impl_deserialize!(u32, expect_num)
|
||||
impl_deserialize!(u64, expect_num)
|
||||
impl_deserialize!(f32, expect_num)
|
||||
impl_deserialize!(f64, expect_num)
|
||||
impl_deserialize!(char, expect_char)
|
||||
impl_deserialize!(&'static str, expect_str)
|
||||
impl_deserialize!(string::String, expect_string)
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E>
|
||||
> Deserializable<D, E> for Box<T> {
|
||||
T: Deserialize<D, E>
|
||||
> Deserialize<D, E> for Box<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Box<T>, E> {
|
||||
Ok(box try!(Deserializable::deserialize_token(d, token)))
|
||||
Ok(box try!(Deserialize::deserialize_token(d, token)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E>
|
||||
> Deserializable<D, E> for Rc<T> {
|
||||
T: Deserialize<D, E>
|
||||
> Deserialize<D, E> for Rc<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Rc<T>, E> {
|
||||
Ok(Rc::new(try!(Deserializable::deserialize_token(d, token))))
|
||||
Ok(Rc::new(try!(Deserialize::deserialize_token(d, token))))
|
||||
}
|
||||
}
|
||||
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E> + Send + Sync
|
||||
> Deserializable<D, E> for Arc<T> {
|
||||
T: Deserialize<D, E> + Send + Sync
|
||||
> Deserialize<D, E> for Arc<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Arc<T>, E> {
|
||||
Ok(Arc::new(try!(Deserializable::deserialize_token(d, token))))
|
||||
Ok(Arc::new(try!(Deserialize::deserialize_token(d, token))))
|
||||
}
|
||||
}
|
||||
|
||||
@ -658,8 +658,8 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D ,E>
|
||||
> Deserializable<D, E> for option::Option<T> {
|
||||
T: Deserialize<D ,E>
|
||||
> Deserialize<D, E> for option::Option<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<option::Option<T>, E> {
|
||||
d.expect_option(token)
|
||||
@ -671,8 +671,8 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D ,E>
|
||||
> Deserializable<D, E> for Vec<T> {
|
||||
T: Deserialize<D ,E>
|
||||
> Deserialize<D, E> for Vec<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Vec<T>, E> {
|
||||
d.expect_seq(token)
|
||||
@ -684,9 +684,9 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
K: Deserializable<D, E> + Eq + Hash,
|
||||
V: Deserializable<D, E>
|
||||
> Deserializable<D, E> for HashMap<K, V> {
|
||||
K: Deserialize<D, E> + Eq + Hash,
|
||||
V: Deserialize<D, E>
|
||||
> Deserialize<D, E> for HashMap<K, V> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<HashMap<K, V>, E> {
|
||||
d.expect_map(token)
|
||||
@ -696,9 +696,9 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
K: Deserializable<D, E> + Ord,
|
||||
V: Deserializable<D, E>
|
||||
> Deserializable<D, E> for TreeMap<K, V> {
|
||||
K: Deserialize<D, E> + Ord,
|
||||
V: Deserialize<D, E>
|
||||
> Deserialize<D, E> for TreeMap<K, V> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> {
|
||||
d.expect_map(token)
|
||||
@ -710,8 +710,8 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E> + Eq + Hash
|
||||
> Deserializable<D, E> for HashSet<T> {
|
||||
T: Deserialize<D, E> + Eq + Hash
|
||||
> Deserialize<D, E> for HashSet<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<HashSet<T>, E> {
|
||||
d.expect_seq(token)
|
||||
@ -721,8 +721,8 @@ impl<
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
T: Deserializable<D, E> + Ord
|
||||
> Deserializable<D, E> for TreeSet<T> {
|
||||
T: Deserialize<D, E> + Ord
|
||||
> Deserialize<D, E> for TreeSet<T> {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> {
|
||||
d.expect_seq(token)
|
||||
@ -740,7 +740,7 @@ macro_rules! impl_deserialize_tuple {
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E
|
||||
> Deserializable<D, E> for () {
|
||||
> Deserialize<D, E> for () {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<(), E> {
|
||||
d.expect_null(token)
|
||||
@ -751,8 +751,8 @@ macro_rules! impl_deserialize_tuple {
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E,
|
||||
$($name: Deserializable<D, E>),*
|
||||
> Deserializable<D, E> for ($($name,)*) {
|
||||
$($name: Deserialize<D, E>),*
|
||||
> Deserialize<D, E> for ($($name,)*) {
|
||||
#[inline]
|
||||
#[allow(non_snake_case)]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<($($name,)*), E> {
|
||||
@ -780,12 +780,12 @@ impl_deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
|
||||
/// recursive structures.
|
||||
pub struct IgnoreTokens;
|
||||
|
||||
impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
impl<D: Deserializer<E>, E> Deserialize<D, E> for IgnoreTokens {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<IgnoreTokens, E> {
|
||||
match token {
|
||||
Option(true) => {
|
||||
Deserializable::deserialize(d)
|
||||
Deserialize::deserialize(d)
|
||||
}
|
||||
|
||||
EnumStart(_, _, _) => {
|
||||
@ -793,7 +793,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
match try!(d.expect_token()) {
|
||||
End => { return Ok(IgnoreTokens); }
|
||||
token => {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -804,7 +804,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
match try!(d.expect_token()) {
|
||||
End => { return Ok(IgnoreTokens); }
|
||||
Str(_) | String(_) => {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize(d));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize(d));
|
||||
}
|
||||
_token => { return Err(d.syntax_error(token, [EndKind, StrKind, StringKind])); }
|
||||
}
|
||||
@ -816,7 +816,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
match try!(d.expect_token()) {
|
||||
End => { return Ok(IgnoreTokens); }
|
||||
token => {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -827,7 +827,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
match try!(d.expect_token()) {
|
||||
End => { return Ok(IgnoreTokens); }
|
||||
token => {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -838,8 +838,8 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
|
||||
match try!(d.expect_token()) {
|
||||
End => { return Ok(IgnoreTokens); }
|
||||
token => {
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
|
||||
let _: IgnoreTokens = try!(Deserializable::deserialize(d));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
|
||||
let _: IgnoreTokens = try!(Deserialize::deserialize(d));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -967,7 +967,7 @@ impl GatherTokens {
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: Deserializer<E>, E> Deserializable<D, E> for GatherTokens {
|
||||
impl<D: Deserializer<E>, E> Deserialize<D, E> for GatherTokens {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<GatherTokens, E> {
|
||||
let mut tokens = GatherTokens {
|
||||
@ -986,7 +986,7 @@ mod tests {
|
||||
use std::{option, string};
|
||||
use serialize::Decoder;
|
||||
|
||||
use super::{Deserializer, Deserializable, Token, TokenKind, IgnoreTokens};
|
||||
use super::{Deserializer, Deserialize, Token, TokenKind, IgnoreTokens};
|
||||
use super::{
|
||||
Null,
|
||||
Bool,
|
||||
@ -1034,7 +1034,7 @@ mod tests {
|
||||
impl<
|
||||
D: Deserializer<E>,
|
||||
E
|
||||
> Deserializable<D, E> for Inner {
|
||||
> Deserialize<D, E> for Inner {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Inner, E> {
|
||||
try!(d.expect_struct_start(token, "Inner"));
|
||||
@ -1056,7 +1056,7 @@ mod tests {
|
||||
Some(1) => { b = Some(try!(d.expect_struct_value())); }
|
||||
Some(2) => { c = Some(try!(d.expect_struct_value())); }
|
||||
Some(_) => unreachable!(),
|
||||
None => { let _: IgnoreTokens = try!(Deserializable::deserialize(d)); }
|
||||
None => { let _: IgnoreTokens = try!(Deserialize::deserialize(d)); }
|
||||
}
|
||||
}
|
||||
|
||||
@ -1071,7 +1071,7 @@ mod tests {
|
||||
inner: Vec<Inner>,
|
||||
}
|
||||
|
||||
impl<D: Deserializer<E>, E> Deserializable<D, E> for Outer {
|
||||
impl<D: Deserializer<E>, E> Deserialize<D, E> for Outer {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Outer, E> {
|
||||
try!(d.expect_struct_start(token, "Outer"));
|
||||
@ -1089,7 +1089,7 @@ mod tests {
|
||||
match idx {
|
||||
Some(0) => { inner = Some(try!(d.expect_struct_value())); }
|
||||
Some(_) => unreachable!(),
|
||||
None => { let _: IgnoreTokens = try!(Deserializable::deserialize(d)); }
|
||||
None => { let _: IgnoreTokens = try!(Deserialize::deserialize(d)); }
|
||||
}
|
||||
}
|
||||
|
||||
@ -1105,7 +1105,7 @@ mod tests {
|
||||
Frog(string::String, int)
|
||||
}
|
||||
|
||||
impl<D: Deserializer<E>, E> Deserializable<D, E> for Animal {
|
||||
impl<D: Deserializer<E>, E> Deserialize<D, E> for Animal {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: Token) -> Result<Animal, E> {
|
||||
match try!(d.expect_enum_start(token, "Animal", ["Dog", "Frog"])) {
|
||||
@ -1114,8 +1114,8 @@ mod tests {
|
||||
Ok(Dog)
|
||||
}
|
||||
1 => {
|
||||
let x0 = try!(Deserializable::deserialize(d));
|
||||
let x1 = try!(Deserializable::deserialize(d));
|
||||
let x0 = try!(Deserialize::deserialize(d));
|
||||
let x1 = try!(Deserialize::deserialize(d));
|
||||
try!(d.expect_enum_end());
|
||||
Ok(Frog(x0, x1))
|
||||
}
|
||||
@ -1179,7 +1179,7 @@ mod tests {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: Deserializable<TokenDeserializer<Iter>, Error>
|
||||
T: Deserialize<TokenDeserializer<Iter>, Error>
|
||||
>(&mut self, field: &'static str) -> Result<T, Error> {
|
||||
Err(MissingField(field))
|
||||
}
|
||||
@ -1193,7 +1193,7 @@ mod tests {
|
||||
fn $name() {
|
||||
$(
|
||||
let mut deserializer = TokenDeserializer::new($tokens.into_iter());
|
||||
let value: $ty = Deserializable::deserialize(&mut deserializer).unwrap();
|
||||
let value: $ty = Deserialize::deserialize(&mut deserializer).unwrap();
|
||||
|
||||
assert_eq!(value, $value);
|
||||
)+
|
||||
|
||||
142
src/json/mod.rs
142
src/json/mod.rs
@ -52,12 +52,12 @@ A simple JSON document serializing a person, his/her age, address and phone numb
|
||||
|
||||
Rust provides a mechanism for low boilerplate serializing and deserializing
|
||||
of values to and from JSON via the serialization API.
|
||||
To be able to serialize a piece of data, it must implement the `serde::Serializable` trait.
|
||||
To be able to deserialize a piece of data, it must implement the `serde::Deserializable` trait.
|
||||
To be able to serialize a piece of data, it must implement the `serde::Serialize` trait.
|
||||
To be able to deserialize a piece of data, it must implement the `serde::Deserialize` trait.
|
||||
The Rust compiler provides an annotation to automatically generate
|
||||
the code for these traits: `#[deriving_serializable]` and `#[deriving_deserializable]`.
|
||||
the code for these traits: `#[deriving_serialize]` and `#[deriving_deserialize]`.
|
||||
|
||||
To serialize using `Serializable`:
|
||||
To serialize using `Serialize`:
|
||||
|
||||
```rust
|
||||
#![feature(phase)]
|
||||
@ -67,9 +67,9 @@ extern crate serde;
|
||||
|
||||
use std::io::{MemWriter, AsRefWriter};
|
||||
use serde::json;
|
||||
use serde::Serializable;
|
||||
use serde::Serialize;
|
||||
|
||||
#[deriving_serializable]
|
||||
#[deriving_serialize]
|
||||
pub struct TestStruct {
|
||||
data_str: String,
|
||||
}
|
||||
@ -90,7 +90,7 @@ fn main() {
|
||||
}
|
||||
```
|
||||
|
||||
Two wrapper functions are provided to serialize a Serializable object
|
||||
Two wrapper functions are provided to serialize a `Serialize` object
|
||||
into a string (String) or buffer (~[u8]): `json::to_string(value)` and
|
||||
`json::to_vec(value)`.
|
||||
|
||||
@ -104,7 +104,7 @@ JSON API provide an enum `json::Json` and a trait `ToJson` to serialize object.
|
||||
The trait `ToJson` serialize object into a container `json::Json` and the API provide writer
|
||||
to serialize them into a stream or a string ...
|
||||
|
||||
When using `ToJson` the `Serializable` trait implementation is not mandatory.
|
||||
When using `ToJson` the `Serialize` trait implementation is not mandatory.
|
||||
|
||||
A basic `ToJson` example using a TreeMap of attribute name / attribute value:
|
||||
|
||||
@ -140,7 +140,7 @@ fn main() {
|
||||
}
|
||||
```
|
||||
|
||||
To deserialize a JSON string using `Deserializable` trait :
|
||||
To deserialize a JSON string using `Deserialize` trait :
|
||||
|
||||
```rust
|
||||
#![feature(phase)]
|
||||
@ -149,9 +149,9 @@ extern crate serde_macros;
|
||||
extern crate serde;
|
||||
|
||||
use serde::json;
|
||||
use serde::Deserializable;
|
||||
use serde::Deserialize;
|
||||
|
||||
#[deriving_deserializable]
|
||||
#[deriving_deserialize]
|
||||
pub struct MyStruct {
|
||||
attr1: u8,
|
||||
attr2: String,
|
||||
@ -160,7 +160,7 @@ pub struct MyStruct {
|
||||
fn main() {
|
||||
let json_str_to_deserialize = "{ \"attr1\": 1, \"attr2\": \"toto\" }";
|
||||
let mut parser = json::Parser::new(json_str_to_deserialize.bytes());
|
||||
let deserialized_object: MyStruct = match Deserializable::deserialize(&mut parser) {
|
||||
let deserialized_object: MyStruct = match Deserialize::deserialize(&mut parser) {
|
||||
Ok(v) => v,
|
||||
Err(e) => panic!("Decoding error: {}", e)
|
||||
};
|
||||
@ -182,8 +182,8 @@ extern crate serde;
|
||||
|
||||
use serde::json;
|
||||
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
pub struct TestStruct1 {
|
||||
data_int: u8,
|
||||
data_str: String,
|
||||
@ -191,7 +191,7 @@ pub struct TestStruct1 {
|
||||
}
|
||||
|
||||
// To serialize use the `json::to_string` to serialize an object in a string.
|
||||
// It calls the generated `Serializable` impl.
|
||||
// It calls the generated `Serialize` impl.
|
||||
fn main() {
|
||||
let to_serialize_object = TestStruct1 {
|
||||
data_int: 1,
|
||||
@ -223,10 +223,10 @@ extern crate serde;
|
||||
use std::collections::TreeMap;
|
||||
use serde::json::ToJson;
|
||||
use serde::json;
|
||||
use serde::Deserializable;
|
||||
use serde::Deserialize;
|
||||
|
||||
#[deriving_serializable] // generate Serializable impl
|
||||
#[deriving_deserializable] // generate Deserializable impl
|
||||
#[deriving_serialize] // generate Serialize impl
|
||||
#[deriving_deserialize] // generate Deserialize impl
|
||||
pub struct TestStruct1 {
|
||||
data_int: u8,
|
||||
data_str: String,
|
||||
@ -257,7 +257,7 @@ fn main() {
|
||||
// Deserialize like before.
|
||||
|
||||
let mut parser = json::Parser::new(json_str.as_slice().bytes());
|
||||
let deserialized: TestStruct1 = Deserializable::deserialize(&mut parser).unwrap();
|
||||
let deserialized: TestStruct1 = Deserialize::deserialize(&mut parser).unwrap();
|
||||
}
|
||||
```
|
||||
|
||||
@ -279,7 +279,7 @@ use std::vec::Vec;
|
||||
use std::vec;
|
||||
|
||||
use de;
|
||||
use ser::Serializable;
|
||||
use ser::Serialize;
|
||||
use ser;
|
||||
|
||||
pub mod builder;
|
||||
@ -498,7 +498,7 @@ impl fmt::Show for Json {
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Json {
|
||||
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Json {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
match *self {
|
||||
@ -527,7 +527,7 @@ impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Json {
|
||||
}
|
||||
}
|
||||
|
||||
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Json {
|
||||
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Json {
|
||||
#[inline]
|
||||
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Json, E> {
|
||||
match token {
|
||||
@ -549,18 +549,18 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Json {
|
||||
de::Str(x) => Ok(String(x.to_string())),
|
||||
de::String(x) => Ok(String(x)),
|
||||
de::Option(false) => Ok(Null),
|
||||
de::Option(true) => de::Deserializable::deserialize(d),
|
||||
de::Option(true) => de::Deserialize::deserialize(d),
|
||||
de::TupleStart(_) | de::SeqStart(_) => {
|
||||
let list = try!(de::Deserializable::deserialize_token(d, token));
|
||||
let list = try!(de::Deserialize::deserialize_token(d, token));
|
||||
Ok(List(list))
|
||||
}
|
||||
de::StructStart(_, _) | de::MapStart(_) => {
|
||||
let object = try!(de::Deserializable::deserialize_token(d, token));
|
||||
let object = try!(de::Deserialize::deserialize_token(d, token));
|
||||
Ok(Object(object))
|
||||
}
|
||||
de::EnumStart(_, name, len) => {
|
||||
let token = de::SeqStart(len);
|
||||
let fields: Vec<Json> = try!(de::Deserializable::deserialize_token(d, token));
|
||||
let fields: Vec<Json> = try!(de::Deserialize::deserialize_token(d, token));
|
||||
let mut object = TreeMap::new();
|
||||
object.insert(name.to_string(), List(fields));
|
||||
Ok(Object(object))
|
||||
@ -668,22 +668,22 @@ impl de::Deserializer<ParserError> for JsonDeserializer {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<JsonDeserializer, ParserError>
|
||||
T: de::Deserialize<JsonDeserializer, ParserError>
|
||||
>(&mut self, _field: &'static str) -> Result<T, ParserError> {
|
||||
// JSON can represent `null` values as a missing value, so this isn't
|
||||
// necessarily an error.
|
||||
de::Deserializable::deserialize_token(self, de::Null)
|
||||
de::Deserialize::deserialize_token(self, de::Null)
|
||||
}
|
||||
|
||||
// Special case treating options as a nullable value.
|
||||
#[inline]
|
||||
fn expect_option<
|
||||
U: de::Deserializable<JsonDeserializer, ParserError>
|
||||
U: de::Deserialize<JsonDeserializer, ParserError>
|
||||
>(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
|
||||
match token {
|
||||
de::Null => Ok(None),
|
||||
token => {
|
||||
let value: U = try!(de::Deserializable::deserialize_token(self, token));
|
||||
let value: U = try!(de::Deserialize::deserialize_token(self, token));
|
||||
Ok(Some(value))
|
||||
}
|
||||
}
|
||||
@ -1054,7 +1054,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_tuple_elt<
|
||||
T: Serializable<Serializer<W>, io::IoError>
|
||||
T: Serialize<Serializer<W>, io::IoError>
|
||||
>(&mut self, value: &T) -> IoResult<()> {
|
||||
if self.first {
|
||||
self.first = false;
|
||||
@ -1077,7 +1077,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_struct_elt<
|
||||
T: Serializable<Serializer<W>, io::IoError>
|
||||
T: Serialize<Serializer<W>, io::IoError>
|
||||
>(&mut self, name: &str, value: &T) -> IoResult<()> {
|
||||
if self.first {
|
||||
self.first = false;
|
||||
@ -1104,7 +1104,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_enum_elt<
|
||||
T: Serializable<Serializer<W>, io::IoError>
|
||||
T: Serialize<Serializer<W>, io::IoError>
|
||||
>(&mut self, value: &T) -> IoResult<()> {
|
||||
if self.first {
|
||||
self.first = false;
|
||||
@ -1121,7 +1121,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_option<
|
||||
T: Serializable<Serializer<W>, io::IoError>
|
||||
T: Serialize<Serializer<W>, io::IoError>
|
||||
>(&mut self, v: &Option<T>) -> IoResult<()> {
|
||||
match *v {
|
||||
Some(ref v) => {
|
||||
@ -1135,7 +1135,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_seq<
|
||||
T: Serializable<Serializer<W>, io::IoError>,
|
||||
T: Serialize<Serializer<W>, io::IoError>,
|
||||
Iter: Iterator<T>
|
||||
>(&mut self, mut iter: Iter) -> IoResult<()> {
|
||||
try!(self.wr.write_str("["));
|
||||
@ -1154,8 +1154,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_map<
|
||||
K: Serializable<Serializer<W>, io::IoError>,
|
||||
V: Serializable<Serializer<W>, io::IoError>,
|
||||
K: Serialize<Serializer<W>, io::IoError>,
|
||||
V: Serialize<Serializer<W>, io::IoError>,
|
||||
Iter: Iterator<(K, V)>
|
||||
>(&mut self, mut iter: Iter) -> IoResult<()> {
|
||||
//Warning: WriterFormatter was added to work around
|
||||
@ -1319,7 +1319,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_tuple_elt<
|
||||
T: Serializable<PrettySerializer<W>, io::IoError>
|
||||
T: Serialize<PrettySerializer<W>, io::IoError>
|
||||
>(&mut self, value: &T) -> IoResult<()> {
|
||||
try!(self.serialize_sep());
|
||||
value.serialize(self)
|
||||
@ -1338,7 +1338,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_struct_elt<
|
||||
T: Serializable<PrettySerializer<W>, io::IoError>
|
||||
T: Serialize<PrettySerializer<W>, io::IoError>
|
||||
>(&mut self, name: &str, value: &T) -> IoResult<()> {
|
||||
try!(self.serialize_sep());
|
||||
try!(self.serialize_str(name));
|
||||
@ -1363,7 +1363,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_enum_elt<
|
||||
T: Serializable<PrettySerializer<W>, io::IoError>
|
||||
T: Serialize<PrettySerializer<W>, io::IoError>
|
||||
>(&mut self, value: &T) -> IoResult<()> {
|
||||
try!(self.serialize_sep());
|
||||
value.serialize(self)
|
||||
@ -1377,7 +1377,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_option<
|
||||
T: Serializable<PrettySerializer<W>, io::IoError>
|
||||
T: Serialize<PrettySerializer<W>, io::IoError>
|
||||
>(&mut self, v: &Option<T>) -> IoResult<()> {
|
||||
match *v {
|
||||
Some(ref v) => {
|
||||
@ -1391,7 +1391,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_seq<
|
||||
T: Serializable<PrettySerializer<W>, io::IoError>,
|
||||
T: Serialize<PrettySerializer<W>, io::IoError>,
|
||||
Iter: Iterator<T>
|
||||
>(&mut self, mut iter: Iter) -> IoResult<()> {
|
||||
try!(self.wr.write_str("["));
|
||||
@ -1407,8 +1407,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
|
||||
#[inline]
|
||||
fn serialize_map<
|
||||
K: Serializable<PrettySerializer<W>, io::IoError>,
|
||||
V: Serializable<PrettySerializer<W>, io::IoError>,
|
||||
K: Serialize<PrettySerializer<W>, io::IoError>,
|
||||
V: Serialize<PrettySerializer<W>, io::IoError>,
|
||||
Iter: Iterator<(K, V)>
|
||||
>(&mut self, mut iter: Iter) -> IoResult<()> {
|
||||
try!(self.wr.write_str("{"));
|
||||
@ -1428,7 +1428,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
|
||||
/// Encode the specified struct into a json `[u8]` buffer.
|
||||
#[inline]
|
||||
pub fn to_vec<
|
||||
T: ser::Serializable<Serializer<MemWriter>, io::IoError>
|
||||
T: ser::Serialize<Serializer<MemWriter>, io::IoError>
|
||||
>(value: &T) -> Vec<u8> {
|
||||
let wr = MemWriter::with_capacity(1024);
|
||||
let mut serializer = Serializer::new(wr);
|
||||
@ -1441,7 +1441,7 @@ pub fn to_vec<
|
||||
/// Encode the specified struct into a json `String` buffer.
|
||||
#[inline]
|
||||
pub fn to_string<
|
||||
T: ser::Serializable<Serializer<MemWriter>, io::IoError>
|
||||
T: ser::Serialize<Serializer<MemWriter>, io::IoError>
|
||||
>(value: &T) -> Result<string::String, Vec<u8>> {
|
||||
let buf = to_vec(value);
|
||||
string::String::from_utf8(buf)
|
||||
@ -1449,7 +1449,7 @@ pub fn to_string<
|
||||
|
||||
/// Encode the specified struct into a json `[u8]` buffer.
|
||||
pub fn to_pretty_vec<
|
||||
T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError>
|
||||
T: ser::Serialize<PrettySerializer<MemWriter>, io::IoError>
|
||||
>(value: &T) -> Vec<u8> {
|
||||
let wr = MemWriter::new();
|
||||
let mut serializer = PrettySerializer::new(wr);
|
||||
@ -1459,7 +1459,7 @@ pub fn to_pretty_vec<
|
||||
|
||||
/// Encode the specified struct into a json `String` buffer.
|
||||
pub fn to_pretty_string<
|
||||
T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError>
|
||||
T: ser::Serialize<PrettySerializer<MemWriter>, io::IoError>
|
||||
>(value: &T) -> Result<string::String, Vec<u8>> {
|
||||
let buf = to_pretty_vec(value);
|
||||
string::String::from_utf8(buf)
|
||||
@ -2147,22 +2147,22 @@ impl<Iter: Iterator<u8>> de::Deserializer<ParserError> for Parser<Iter> {
|
||||
|
||||
#[inline]
|
||||
fn missing_field<
|
||||
T: de::Deserializable<Parser<Iter>, ParserError>
|
||||
T: de::Deserialize<Parser<Iter>, ParserError>
|
||||
>(&mut self, _field: &'static str) -> Result<T, ParserError> {
|
||||
// JSON can represent `null` values as a missing value, so this isn't
|
||||
// necessarily an error.
|
||||
de::Deserializable::deserialize_token(self, de::Null)
|
||||
de::Deserialize::deserialize_token(self, de::Null)
|
||||
}
|
||||
|
||||
// Special case treating options as a nullable value.
|
||||
#[inline]
|
||||
fn expect_option<
|
||||
U: de::Deserializable<Parser<Iter>, ParserError>
|
||||
U: de::Deserialize<Parser<Iter>, ParserError>
|
||||
>(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
|
||||
match token {
|
||||
de::Null => Ok(None),
|
||||
token => {
|
||||
let value: U = try!(de::Deserializable::deserialize_token(self, token));
|
||||
let value: U = try!(de::Deserialize::deserialize_token(self, token));
|
||||
Ok(Some(value))
|
||||
}
|
||||
}
|
||||
@ -2244,10 +2244,10 @@ impl<Iter: Iterator<u8>> de::Deserializer<ParserError> for Parser<Iter> {
|
||||
/// Decodes a json value from an `Iterator<u8>`.
|
||||
pub fn from_iter<
|
||||
Iter: Iterator<u8>,
|
||||
T: de::Deserializable<Parser<Iter>, ParserError>
|
||||
T: de::Deserialize<Parser<Iter>, ParserError>
|
||||
>(iter: Iter) -> Result<T, ParserError> {
|
||||
let mut parser = Parser::new(iter);
|
||||
let value = try!(de::Deserializable::deserialize(&mut parser));
|
||||
let value = try!(de::Deserialize::deserialize(&mut parser));
|
||||
|
||||
// Make sure the whole stream has been consumed.
|
||||
match parser.next() {
|
||||
@ -2260,17 +2260,17 @@ pub fn from_iter<
|
||||
/// Decodes a json value from a string
|
||||
pub fn from_str<
|
||||
'a,
|
||||
T: de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
|
||||
T: de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
|
||||
>(s: &'a str) -> Result<T, BuilderError> {
|
||||
from_iter(s.bytes())
|
||||
}
|
||||
|
||||
/// Decodes a json value from a `Json`.
|
||||
pub fn from_json<
|
||||
T: de::Deserializable<JsonDeserializer, ParserError>
|
||||
T: de::Deserialize<JsonDeserializer, ParserError>
|
||||
>(json: Json) -> Result<T, ParserError> {
|
||||
let mut d = JsonDeserializer::new(json);
|
||||
de::Deserializable::deserialize(&mut d)
|
||||
de::Deserialize::deserialize(&mut d)
|
||||
}
|
||||
|
||||
macro_rules! expect(
|
||||
@ -2461,7 +2461,7 @@ mod tests {
|
||||
ListCommaOrEnd,
|
||||
};
|
||||
use de;
|
||||
use ser::{Serializable, Serializer};
|
||||
use ser::{Serialize, Serializer};
|
||||
use ser;
|
||||
|
||||
macro_rules! treemap {
|
||||
@ -2473,8 +2473,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
enum Animal {
|
||||
Dog,
|
||||
Frog(string::String, Vec<int>)
|
||||
@ -2502,8 +2502,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Inner {
|
||||
a: (),
|
||||
b: uint,
|
||||
@ -2523,8 +2523,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Outer {
|
||||
inner: Vec<Inner>,
|
||||
}
|
||||
@ -2540,7 +2540,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn test_encode_ok<
|
||||
T: PartialEq + Show + ToJson + ser::Serializable<super::Serializer<io::MemWriter>, io::IoError>
|
||||
T: PartialEq + Show + ToJson + ser::Serialize<super::Serializer<io::MemWriter>, io::IoError>
|
||||
>(errors: &[(T, &str)]) {
|
||||
for &(ref value, out) in errors.iter() {
|
||||
let out = out.to_string();
|
||||
@ -2554,7 +2554,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn test_pretty_encode_ok<
|
||||
T: PartialEq + Show + ToJson + ser::Serializable<super::PrettySerializer<io::MemWriter>, io::IoError>
|
||||
T: PartialEq + Show + ToJson + ser::Serialize<super::PrettySerializer<io::MemWriter>, io::IoError>
|
||||
>(errors: &[(T, &str)]) {
|
||||
for &(ref value, out) in errors.iter() {
|
||||
let out = out.to_string();
|
||||
@ -2891,7 +2891,7 @@ mod tests {
|
||||
// FIXME (#5527): these could be merged once UFCS is finished.
|
||||
fn test_parse_err<
|
||||
'a,
|
||||
T: Show + de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
|
||||
T: Show + de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
|
||||
>(errors: &[(&'a str, ParserError)]) {
|
||||
for &(s, ref err) in errors.iter() {
|
||||
let v: Result<T, ParserError> = from_str(s);
|
||||
@ -2901,7 +2901,7 @@ mod tests {
|
||||
|
||||
fn test_parse_ok<
|
||||
'a,
|
||||
T: PartialEq + Show + ToJson + de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
|
||||
T: PartialEq + Show + ToJson + de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
|
||||
>(errors: &[(&'a str, T)]) {
|
||||
for &(s, ref value) in errors.iter() {
|
||||
let v: T = from_str(s).unwrap();
|
||||
@ -2913,7 +2913,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn test_json_deserialize_ok<
|
||||
T: PartialEq + Show + ToJson + de::Deserializable<JsonDeserializer, ParserError>
|
||||
T: PartialEq + Show + ToJson + de::Deserialize<JsonDeserializer, ParserError>
|
||||
>(errors: &[T]) {
|
||||
for value in errors.iter() {
|
||||
let v: T = from_json(value.to_json()).unwrap();
|
||||
@ -3219,8 +3219,8 @@ mod tests {
|
||||
]);
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Foo {
|
||||
x: Option<int>,
|
||||
}
|
||||
|
||||
@ -12,8 +12,8 @@ extern crate serde_macros;
|
||||
#[cfg(test)]
|
||||
extern crate serialize;
|
||||
|
||||
pub use ser::{Serializer, Serializable};
|
||||
pub use de::{Deserializer, Deserializable};
|
||||
pub use ser::{Serializer, Serialize};
|
||||
pub use de::{Deserializer, Deserialize};
|
||||
|
||||
pub mod de;
|
||||
pub mod ser;
|
||||
|
||||
124
src/ser.rs
124
src/ser.rs
@ -79,49 +79,49 @@ pub trait Serializer<E> {
|
||||
|
||||
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
|
||||
fn serialize_tuple_elt<
|
||||
T: Serializable<Self, E>
|
||||
T: Serialize<Self, E>
|
||||
>(&mut self, v: &T) -> Result<(), E>;
|
||||
fn serialize_tuple_end(&mut self) -> Result<(), E>;
|
||||
|
||||
fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
|
||||
fn serialize_struct_elt<
|
||||
T: Serializable<Self, E>
|
||||
T: Serialize<Self, E>
|
||||
>(&mut self, name: &str, v: &T) -> Result<(), E>;
|
||||
fn serialize_struct_end(&mut self) -> Result<(), E>;
|
||||
|
||||
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
|
||||
fn serialize_enum_elt<
|
||||
T: Serializable<Self, E>
|
||||
T: Serialize<Self, E>
|
||||
>(&mut self, v: &T) -> Result<(), E>;
|
||||
fn serialize_enum_end(&mut self) -> Result<(), E>;
|
||||
|
||||
fn serialize_option<
|
||||
T: Serializable<Self, E>
|
||||
T: Serialize<Self, E>
|
||||
>(&mut self, v: &Option<T>) -> Result<(), E>;
|
||||
|
||||
fn serialize_seq<
|
||||
T: Serializable<Self, E>,
|
||||
T: Serialize<Self, E>,
|
||||
Iter: Iterator<T>
|
||||
>(&mut self, iter: Iter) -> Result<(), E>;
|
||||
|
||||
fn serialize_map<
|
||||
K: Serializable<Self, E>,
|
||||
V: Serializable<Self, E>,
|
||||
K: Serialize<Self, E>,
|
||||
V: Serialize<Self, E>,
|
||||
Iter: Iterator<(K, V)>
|
||||
>(&mut self, iter: Iter) -> Result<(), E>;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
pub trait Serializable<S: Serializer<E>, E> {
|
||||
pub trait Serialize<S: Serializer<E>, E> {
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E>;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! impl_serializable {
|
||||
macro_rules! impl_serialize {
|
||||
($ty:ty, $method:ident) => {
|
||||
impl<S: Serializer<E>, E> Serializable<S, E> for $ty {
|
||||
impl<S: Serializer<E>, E> Serialize<S, E> for $ty {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.$method(*self)
|
||||
@ -130,31 +130,31 @@ macro_rules! impl_serializable {
|
||||
}
|
||||
}
|
||||
|
||||
impl_serializable!(bool, serialize_bool)
|
||||
impl_serializable!(int, serialize_int)
|
||||
impl_serializable!(i8, serialize_i8)
|
||||
impl_serializable!(i16, serialize_i16)
|
||||
impl_serializable!(i32, serialize_i32)
|
||||
impl_serializable!(i64, serialize_i64)
|
||||
impl_serializable!(uint, serialize_uint)
|
||||
impl_serializable!(u8, serialize_u8)
|
||||
impl_serializable!(u16, serialize_u16)
|
||||
impl_serializable!(u32, serialize_u32)
|
||||
impl_serializable!(u64, serialize_u64)
|
||||
impl_serializable!(f32, serialize_f32)
|
||||
impl_serializable!(f64, serialize_f64)
|
||||
impl_serializable!(char, serialize_char)
|
||||
impl_serialize!(bool, serialize_bool)
|
||||
impl_serialize!(int, serialize_int)
|
||||
impl_serialize!(i8, serialize_i8)
|
||||
impl_serialize!(i16, serialize_i16)
|
||||
impl_serialize!(i32, serialize_i32)
|
||||
impl_serialize!(i64, serialize_i64)
|
||||
impl_serialize!(uint, serialize_uint)
|
||||
impl_serialize!(u8, serialize_u8)
|
||||
impl_serialize!(u16, serialize_u16)
|
||||
impl_serialize!(u32, serialize_u32)
|
||||
impl_serialize!(u64, serialize_u64)
|
||||
impl_serialize!(f32, serialize_f32)
|
||||
impl_serialize!(f64, serialize_f64)
|
||||
impl_serialize!(char, serialize_char)
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<'a, S: Serializer<E>, E> Serializable<S, E> for &'a str {
|
||||
impl<'a, S: Serializer<E>, E> Serialize<S, E> for &'a str {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_str(*self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: Serializer<E>, E> Serializable<S, E> for String {
|
||||
impl<S: Serializer<E>, E> Serialize<S, E> for String {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
self.as_slice().serialize(s)
|
||||
@ -163,14 +163,14 @@ impl<S: Serializer<E>, E> Serializable<S, E> for String {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! impl_serializable_box {
|
||||
macro_rules! impl_serialize_box {
|
||||
($ty:ty) => {
|
||||
impl<
|
||||
'a,
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E>
|
||||
> Serializable<S, E> for $ty {
|
||||
T: Serialize<S, E>
|
||||
> Serialize<S, E> for $ty {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
(**self).serialize(s)
|
||||
@ -179,15 +179,15 @@ macro_rules! impl_serializable_box {
|
||||
}
|
||||
}
|
||||
|
||||
impl_serializable_box!(&'a T)
|
||||
impl_serializable_box!(Box<T>)
|
||||
impl_serializable_box!(Rc<T>)
|
||||
impl_serialize_box!(&'a T)
|
||||
impl_serialize_box!(Box<T>)
|
||||
impl_serialize_box!(Rc<T>)
|
||||
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E> + Send + Sync
|
||||
> Serializable<S, E> for Arc<T> {
|
||||
T: Serialize<S, E> + Send + Sync
|
||||
> Serialize<S, E> for Arc<T> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
(**self).serialize(s)
|
||||
@ -199,8 +199,8 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E>
|
||||
> Serializable<S, E> for Option<T> {
|
||||
T: Serialize<S, E>
|
||||
> Serialize<S, E> for Option<T> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_option(self)
|
||||
@ -212,8 +212,8 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E>
|
||||
> Serializable<S, E> for Vec<T> {
|
||||
T: Serialize<S, E>
|
||||
> Serialize<S, E> for Vec<T> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_seq(self.iter())
|
||||
@ -225,9 +225,9 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
K: Serializable<S, E> + Eq + Hash,
|
||||
V: Serializable<S, E>
|
||||
> Serializable<S, E> for HashMap<K, V> {
|
||||
K: Serialize<S, E> + Eq + Hash,
|
||||
V: Serialize<S, E>
|
||||
> Serialize<S, E> for HashMap<K, V> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_map(self.iter())
|
||||
@ -237,9 +237,9 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
K: Serializable<S, E> + Ord,
|
||||
V: Serializable<S, E>
|
||||
> Serializable<S, E> for TreeMap<K, V> {
|
||||
K: Serialize<S, E> + Ord,
|
||||
V: Serialize<S, E>
|
||||
> Serialize<S, E> for TreeMap<K, V> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_map(self.iter())
|
||||
@ -251,8 +251,8 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E> + Eq + Hash
|
||||
> Serializable<S, E> for HashSet<T> {
|
||||
T: Serialize<S, E> + Eq + Hash
|
||||
> Serialize<S, E> for HashSet<T> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_seq(self.iter())
|
||||
@ -262,8 +262,8 @@ impl<
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
T: Serializable<S, E> + Ord
|
||||
> Serializable<S, E> for TreeSet<T> {
|
||||
T: Serialize<S, E> + Ord
|
||||
> Serialize<S, E> for TreeSet<T> {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_seq(self.iter())
|
||||
@ -278,7 +278,7 @@ macro_rules! peel {
|
||||
|
||||
macro_rules! impl_serialize_tuple {
|
||||
() => {
|
||||
impl<S: Serializer<E>, E> Serializable<S, E> for () {
|
||||
impl<S: Serializer<E>, E> Serialize<S, E> for () {
|
||||
#[inline]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
s.serialize_null()
|
||||
@ -289,8 +289,8 @@ macro_rules! impl_serialize_tuple {
|
||||
impl<
|
||||
S: Serializer<E>,
|
||||
E,
|
||||
$($name:Serializable<S, E>),+
|
||||
> Serializable<S, E> for ($($name,)+) {
|
||||
$($name:Serialize<S, E>),+
|
||||
> Serialize<S, E> for ($($name,)+) {
|
||||
#[inline]
|
||||
#[allow(non_snake_case)]
|
||||
fn serialize(&self, s: &mut S) -> Result<(), E> {
|
||||
@ -323,12 +323,12 @@ mod tests {
|
||||
|
||||
use serialize::Decoder;
|
||||
|
||||
use super::{Serializer, Serializable};
|
||||
use super::{Serializer, Serialize};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_serialize]
|
||||
struct Inner {
|
||||
a: (),
|
||||
b: uint,
|
||||
@ -338,7 +338,7 @@ mod tests {
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_serialize]
|
||||
struct Outer {
|
||||
inner: Vec<Inner>,
|
||||
}
|
||||
@ -346,7 +346,7 @@ mod tests {
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[deriving(Clone, PartialEq, Show, Decodable)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_serialize]
|
||||
enum Animal {
|
||||
Dog,
|
||||
Frog(String, int)
|
||||
@ -494,7 +494,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_tuple_elt<
|
||||
T: Serializable<AssertSerializer<Iter>, Error>
|
||||
T: Serialize<AssertSerializer<Iter>, Error>
|
||||
>(&mut self, value: &T) -> Result<(), Error> {
|
||||
try!(self.serialize(TupleSep));
|
||||
value.serialize(self)
|
||||
@ -509,7 +509,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_struct_elt<
|
||||
T: Serializable<AssertSerializer<Iter>, Error>
|
||||
T: Serialize<AssertSerializer<Iter>, Error>
|
||||
>(&mut self, name: &str, value: &T) -> Result<(), Error> {
|
||||
try!(self.serialize(StructSep(name)));
|
||||
value.serialize(self)
|
||||
@ -524,7 +524,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_enum_elt<
|
||||
T: Serializable<AssertSerializer<Iter>, Error>
|
||||
T: Serialize<AssertSerializer<Iter>, Error>
|
||||
>(&mut self, value: &T) -> Result<(), Error> {
|
||||
try!(self.serialize(EnumSep));
|
||||
value.serialize(self)
|
||||
@ -535,7 +535,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_option<
|
||||
T: Serializable<AssertSerializer<Iter>, Error>
|
||||
T: Serialize<AssertSerializer<Iter>, Error>
|
||||
>(&mut self, v: &option::Option<T>) -> Result<(), Error> {
|
||||
match *v {
|
||||
Some(ref v) => {
|
||||
@ -549,7 +549,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_seq<
|
||||
T: Serializable<AssertSerializer<Iter>, Error>,
|
||||
T: Serialize<AssertSerializer<Iter>, Error>,
|
||||
SeqIter: Iterator<T>
|
||||
>(&mut self, mut iter: SeqIter) -> Result<(), Error> {
|
||||
let (len, _) = iter.size_hint();
|
||||
@ -561,8 +561,8 @@ mod tests {
|
||||
}
|
||||
|
||||
fn serialize_map<
|
||||
K: Serializable<AssertSerializer<Iter>, Error>,
|
||||
V: Serializable<AssertSerializer<Iter>, Error>,
|
||||
K: Serialize<AssertSerializer<Iter>, Error>,
|
||||
V: Serialize<AssertSerializer<Iter>, Error>,
|
||||
MapIter: Iterator<(K, V)>
|
||||
>(&mut self, mut iter: MapIter) -> Result<(), Error> {
|
||||
let (len, _) = iter.size_hint();
|
||||
|
||||
@ -5,8 +5,8 @@ extern crate serde;
|
||||
extern crate serde_macros;
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
#[deriving_serializable]
|
||||
#[deriving_deserializable]
|
||||
#[deriving_serialize]
|
||||
#[deriving_deserialize]
|
||||
struct Test {
|
||||
#[serial_name = "$schema"]
|
||||
schema: String,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user