itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename Serializable to Serialize, Deserializable to Deserialize

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-11-13 07:54:44 -08:00
parent 45247c7ef6
commit 21a58e86e4
11 changed files with 297 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
benches/bench_enum.rs
View File

@ -11,12 +11,12 @@ use test::Bencher;
use serialize::{Decoder, Decodable}; use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable}; use serde::de::{Deserializer, Deserialize};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable] #[deriving_deserialize]
enum Animal { enum Animal {
Dog, Dog,
Frog(String, int) Frog(String, int)
@ -260,7 +260,7 @@ mod deserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<AnimalDeserializer, Error> T: de::Deserialize<AnimalDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError) Err(SyntaxError)
} }
@ -299,7 +299,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
let animal = Dog; let animal = Dog;
let mut d = deserializer::AnimalDeserializer::new(animal.clone()); 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); assert_eq!(value, animal);
}) })
@ -311,7 +311,7 @@ fn bench_deserializer_frog(b: &mut Bencher) {
let animal = Frog("Henry".to_string(), 349); let animal = Frog("Henry".to_string(), 349);
let mut d = deserializer::AnimalDeserializer::new(animal.clone()); 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); assert_eq!(value, animal);
}) })

38
benches/bench_log.rs
View File

@ -14,12 +14,12 @@ use test::Bencher;
use serde::de; use serde::de;
use serde::json; use serde::json;
use serde::ser::Serializable; use serde::ser::Serialize;
use serde::ser; use serde::ser;
#[deriving(Encodable, Decodable)] #[deriving(Encodable, Decodable)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Http { struct Http {
protocol: HttpProtocol, protocol: HttpProtocol,
status: u32, status: u32,
@ -39,14 +39,14 @@ enum HttpProtocol {
HTTP11, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> {
d.expect_from_primitive(token) d.expect_from_primitive(token)
@ -68,14 +68,14 @@ enum HttpMethod {
PATCH, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> {
d.expect_from_primitive(token) d.expect_from_primitive(token)
@ -90,14 +90,14 @@ enum CacheStatus {
Hit, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> {
d.expect_from_primitive(token) 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(Encodable, Decodable)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Origin { struct Origin {
ip: String, ip: String,
port: u32, port: u32,
@ -121,14 +121,14 @@ enum OriginProtocol {
HTTPS, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> {
d.expect_from_primitive(token) d.expect_from_primitive(token)
@ -144,14 +144,14 @@ enum ZonePlan {
ENT, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> {
d.expect_from_primitive(token) d.expect_from_primitive(token)
@ -418,14 +418,14 @@ enum Country {
ZW, 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint) 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> {
d.expect_from_primitive(token) 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(Encodable, Decodable)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Log { struct Log {
timestamp: i64, timestamp: i64,
zone_id: u32, zone_id: u32,

8
benches/bench_map.rs
View File

@ -13,7 +13,7 @@ use test::Bencher;
use serialize::{Decoder, Decodable}; use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable}; use serde::de::{Deserializer, Deserialize};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -258,7 +258,7 @@ mod deserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<IntDeserializer, Error> T: de::Deserialize<IntDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError) Err(SyntaxError)
} }
@ -310,9 +310,9 @@ fn bench_decoder_100(b: &mut Bencher) {
fn run_deserializer< fn run_deserializer<
D: Deserializer<E>, D: Deserializer<E>,
E: Show, E: Show,
T: Clone + PartialEq + Show + Deserializable<D, E> T: Clone + PartialEq + Show + Deserialize<D, E>
>(mut d: D, value: T) { >(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); assert_eq!(value, v);
} }

14
benches/bench_struct.rs
View File

@ -12,12 +12,12 @@ use test::Bencher;
use serialize::{Decoder, Decodable}; use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable}; use serde::de::{Deserializer, Deserialize};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable] #[deriving_deserialize]
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
@ -27,7 +27,7 @@ struct Inner {
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable] #[deriving_deserialize]
struct Outer { struct Outer {
inner: Vec<Inner>, inner: Vec<Inner>,
} }
@ -387,7 +387,7 @@ mod deserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<OuterDeserializer, Error> T: de::Deserialize<OuterDeserializer, Error>
>(&mut self, field: &'static str) -> Result<T, Error> { >(&mut self, field: &'static str) -> Result<T, Error> {
Err(MissingField(field)) Err(MissingField(field))
} }
@ -468,7 +468,7 @@ fn bench_deserializer_0_0(b: &mut Bencher) {
}; };
let mut d = deserializer::OuterDeserializer::new(outer.clone()); 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); 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 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); 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 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); assert_eq!(value, outer);
}) })

10
benches/bench_vec.rs
View File

@ -12,7 +12,7 @@ use test::Bencher;
use serialize::{Decoder, Decodable}; use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable}; use serde::de::{Deserializer, Deserialize};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -327,7 +327,7 @@ mod deserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<IntDeserializer, Error> T: de::Deserialize<IntDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError) Err(SyntaxError)
} }
@ -399,7 +399,7 @@ mod deserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<U8Deserializer, Error> T: de::Deserialize<U8Deserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> { >(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError) Err(SyntaxError)
} }
@ -421,9 +421,9 @@ fn run_decoder<
fn run_deserializer< fn run_deserializer<
D: Deserializer<E>, D: Deserializer<E>,
E: Show, E: Show,
T: Clone + PartialEq + Show + Deserializable<D, E> T: Clone + PartialEq + Show + Deserialize<D, E>
>(mut d: D, value: T) { >(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); assert_eq!(value, v);
} }

60
serde_macros/src/lib.rs
View File

@ -59,26 +59,26 @@ use rustc::plugin::Registry;
#[doc(hidden)] #[doc(hidden)]
pub fn plugin_registrar(reg: &mut Registry) { pub fn plugin_registrar(reg: &mut Registry) {
reg.register_syntax_extension( reg.register_syntax_extension(
token::intern("deriving_serializable"), token::intern("deriving_serialize"),
Decorator(box expand_deriving_serializable)); Decorator(box expand_deriving_serialize));
reg.register_syntax_extension( reg.register_syntax_extension(
token::intern("deriving_deserializable"), token::intern("deriving_deserialize"),
Decorator(box expand_deriving_deserializable)); Decorator(box expand_deriving_deserialize));
} }
fn expand_deriving_serializable(cx: &mut ExtCtxt, fn expand_deriving_serialize(cx: &mut ExtCtxt,
sp: Span, sp: Span,
mitem: &MetaItem, mitem: &MetaItem,
item: &Item, item: &Item,
push: |P<ast::Item>|) { push: |P<ast::Item>|) {
let inline = cx.meta_word(sp, token::InternedString::new("inline")); let inline = cx.meta_word(sp, token::InternedString::new("inline"));
let attrs = vec!(cx.attribute(sp, inline)); let attrs = vec!(cx.attribute(sp, inline));
let trait_def = TraitDef { let trait_def = TraitDef {
span: sp, span: sp,
attributes: vec!(), 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")), vec!(box Literal(Path::new_local("__S")),
box Literal(Path::new_local("__E"))), true), box Literal(Path::new_local("__E"))), true),
additional_bounds: Vec::new(), additional_bounds: Vec::new(),
@ -109,7 +109,7 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
), ),
attributes: attrs, attributes: attrs,
combine_substructure: combine_substructure(|a, b, c| { 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) trait_def.expand(cx, mitem, item, push)
} }
fn serializable_substructure(cx: &ExtCtxt, fn serialize_substructure(cx: &ExtCtxt,
span: Span, span: Span,
substr: &Substructure, substr: &Substructure,
item: &Item item: &Item) -> P<Expr> {
) -> P<Expr> {
let serializer = substr.nonself_args[0].clone(); let serializer = substr.nonself_args[0].clone();
match (&item.node, substr.fields) { 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, pub fn expand_deriving_deserialize(cx: &mut ExtCtxt,
span: Span, span: Span,
mitem: &MetaItem, mitem: &MetaItem,
item: &Item, item: &Item,
push: |P<Item>|) { push: |P<Item>|) {
let trait_def = TraitDef { let trait_def = TraitDef {
span: span, span: span,
attributes: Vec::new(), 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")), vec!(box Literal(Path::new_local("__D")),
box Literal(Path::new_local("__E"))), true), box Literal(Path::new_local("__E"))), true),
additional_bounds: Vec::new(), additional_bounds: Vec::new(),
@ -241,7 +240,7 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
), ),
attributes: Vec::new(), attributes: Vec::new(),
combine_substructure: combine_substructure(|a, b, c| { 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) trait_def.expand(cx, mitem, item, push)
} }
fn deserializable_substructure(cx: &mut ExtCtxt, span: Span, fn deserialize_substructure(cx: &mut ExtCtxt,
substr: &Substructure) -> P<Expr> { span: Span,
substr: &Substructure) -> P<Expr> {
let deserializer = substr.nonself_args[0].clone(); let deserializer = substr.nonself_args[0].clone();
let token = substr.nonself_args[1].clone(); let token = substr.nonself_args[1].clone();
@ -275,7 +275,7 @@ fn deserializable_substructure(cx: &mut ExtCtxt, span: Span,
deserializer, deserializer,
token) 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!(), Some(_) => unreachable!(),
None => { None => {
let _: ::serde::de::IgnoreTokens = let _: ::serde::de::IgnoreTokens =
try!(::serde::de::Deserializable::deserialize($deserializer)); try!(::serde::de::Deserialize::deserialize($deserializer));
} }
} }
//try!($deserializer.ignore_field(token)) //try!($deserializer.ignore_field(token))
@ -409,7 +409,7 @@ fn deserialize_enum(
let arms: Vec<ast::Arm> = fields.iter() let arms: Vec<ast::Arm> = fields.iter()
.enumerate() .enumerate()
.map(|(i, &(name, span, ref parts))| { .map(|(i, &(name, span, ref parts))| {
let call = deserializable_static_fields( let call = deserialize_static_fields(
cx, cx,
span, span,
name, name,
@ -441,7 +441,7 @@ fn deserialize_enum(
/// Create a deserializer for a single enum variant/struct: /// Create a deserializer for a single enum variant/struct:
/// - `outer_pat_ident` is the name of this enum variant/struct /// - `outer_pat_ident` is the name of this enum variant/struct
/// - `getarg` should retrieve the `uint`-th field with name `&str`. /// - `getarg` should retrieve the `uint`-th field with name `&str`.
fn deserializable_static_fields( fn deserialize_static_fields(
cx: &ExtCtxt, cx: &ExtCtxt,
span: Span, span: Span,
outer_pat_ident: Ident, outer_pat_ident: Ident,

180
src/de.rs
View File

@ -177,7 +177,7 @@ macro_rules! to_result {
} }
pub trait Deserializer<E>: Iterator<Result<Token, E>> { 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. /// `Deserializer` was empty.
fn end_of_stream_error(&mut self) -> E; 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. /// Called when a value was unable to be coerced into another value.
fn conversion_error(&mut self, token: Token) -> E; 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`. /// named `field`.
fn missing_field< fn missing_field<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self, field: &'static str) -> Result<T, 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> { fn ignore_field(&mut self, _token: Token) -> Result<(), E> {
let _: IgnoreTokens = try!(Deserializable::deserialize(self)); let _: IgnoreTokens = try!(Deserialize::deserialize(self));
Ok(()) Ok(())
} }
@ -305,12 +305,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_option< fn expect_option<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self, token: Token) -> Result<option::Option<T>, E> { >(&mut self, token: Token) -> Result<option::Option<T>, E> {
match token { match token {
Option(false) => Ok(None), Option(false) => Ok(None),
Option(true) => { Option(true) => {
let value: T = try!(Deserializable::deserialize(self)); let value: T = try!(Deserialize::deserialize(self));
Ok(Some(value)) Ok(Some(value))
} }
token => Err(self.syntax_error(token, [OptionKind])), token => Err(self.syntax_error(token, [OptionKind])),
@ -328,9 +328,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_tuple_elt< fn expect_tuple_elt<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self) -> Result<T, E> { >(&mut self) -> Result<T, E> {
Deserializable::deserialize(self) Deserialize::deserialize(self)
} }
#[inline] #[inline]
@ -377,9 +377,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_struct_value< fn expect_struct_value<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self) -> Result<T, E> { >(&mut self) -> Result<T, E> {
Deserializable::deserialize(self) Deserialize::deserialize(self)
} }
#[inline] #[inline]
@ -409,9 +409,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_enum_elt< fn expect_enum_elt<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self) -> Result<T, E> { >(&mut self) -> Result<T, E> {
Deserializable::deserialize(self) Deserialize::deserialize(self)
} }
#[inline] #[inline]
@ -433,12 +433,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_seq_elt_or_end< fn expect_seq_elt_or_end<
T: Deserializable<Self, E> T: Deserialize<Self, E>
>(&mut self) -> Result<option::Option<T>, E> { >(&mut self) -> Result<option::Option<T>, E> {
match try!(self.expect_token()) { match try!(self.expect_token()) {
End => Ok(None), End => Ok(None),
token => { token => {
let value = try!(Deserializable::deserialize_token(self, token)); let value = try!(Deserialize::deserialize_token(self, token));
Ok(Some(value)) Ok(Some(value))
} }
} }
@ -447,7 +447,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_seq< fn expect_seq<
'a, 'a,
T: Deserializable<Self, E>, T: Deserialize<Self, E>,
C: FromIterator<T> C: FromIterator<T>
>(&'a mut self, token: Token) -> Result<C, E> { >(&'a mut self, token: Token) -> Result<C, E> {
let len = try!(self.expect_seq_start(token)); let len = try!(self.expect_seq_start(token));
@ -476,14 +476,14 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_map_elt_or_end< fn expect_map_elt_or_end<
K: Deserializable<Self, E>, K: Deserialize<Self, E>,
V: Deserializable<Self, E> V: Deserialize<Self, E>
>(&mut self) -> Result<option::Option<(K, V)>, E> { >(&mut self) -> Result<option::Option<(K, V)>, E> {
match try!(self.expect_token()) { match try!(self.expect_token()) {
End => Ok(None), End => Ok(None),
token => { token => {
let key = try!(Deserializable::deserialize_token(self, token)); let key = try!(Deserialize::deserialize_token(self, token));
let value = try!(Deserializable::deserialize(self)); let value = try!(Deserialize::deserialize(self));
Ok(Some((key, value))) Ok(Some((key, value)))
} }
} }
@ -492,8 +492,8 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
#[inline] #[inline]
fn expect_map< fn expect_map<
'a, 'a,
K: Deserializable<Self, E>, K: Deserialize<Self, E>,
V: Deserializable<Self, E>, V: Deserialize<Self, E>,
C: FromIterator<(K, V)> C: FromIterator<(K, V)>
>(&'a mut self, token: Token) -> Result<C, E> { >(&'a mut self, token: Token) -> Result<C, E> {
let len = try!(self.expect_map_start(token)); let len = try!(self.expect_map_start(token));
@ -525,7 +525,7 @@ impl<
'a, 'a,
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> T: Deserialize<D, E>
> Iterator<T> for SeqDeserializer<'a, D, E> { > Iterator<T> for SeqDeserializer<'a, D, E> {
#[inline] #[inline]
fn next(&mut self) -> option::Option<T> { fn next(&mut self) -> option::Option<T> {
@ -556,8 +556,8 @@ impl<
'a, 'a,
D: Deserializer<E>, D: Deserializer<E>,
E, E,
K: Deserializable<D, E>, K: Deserialize<D, E>,
V: Deserializable<D, E> V: Deserialize<D, E>
> Iterator<(K, V)> for MapDeserializer<'a, D, E> { > Iterator<(K, V)> for MapDeserializer<'a, D, E> {
#[inline] #[inline]
fn next(&mut self) -> option::Option<(K, V)> { 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] #[inline]
fn deserialize(d: &mut D) -> Result<Self, E> { fn deserialize(d: &mut D) -> Result<Self, E> {
let token = try!(d.expect_token()); 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>; 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) => { ($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] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<$ty, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<$ty, E> {
d.$method(token) d.$method(token)
@ -601,55 +601,55 @@ macro_rules! impl_deserializable {
} }
} }
impl_deserializable!(bool, expect_bool) impl_deserialize!(bool, expect_bool)
impl_deserializable!(int, expect_num) impl_deserialize!(int, expect_num)
impl_deserializable!(i8, expect_num) impl_deserialize!(i8, expect_num)
impl_deserializable!(i16, expect_num) impl_deserialize!(i16, expect_num)
impl_deserializable!(i32, expect_num) impl_deserialize!(i32, expect_num)
impl_deserializable!(i64, expect_num) impl_deserialize!(i64, expect_num)
impl_deserializable!(uint, expect_num) impl_deserialize!(uint, expect_num)
impl_deserializable!(u8, expect_num) impl_deserialize!(u8, expect_num)
impl_deserializable!(u16, expect_num) impl_deserialize!(u16, expect_num)
impl_deserializable!(u32, expect_num) impl_deserialize!(u32, expect_num)
impl_deserializable!(u64, expect_num) impl_deserialize!(u64, expect_num)
impl_deserializable!(f32, expect_num) impl_deserialize!(f32, expect_num)
impl_deserializable!(f64, expect_num) impl_deserialize!(f64, expect_num)
impl_deserializable!(char, expect_char) impl_deserialize!(char, expect_char)
impl_deserializable!(&'static str, expect_str) impl_deserialize!(&'static str, expect_str)
impl_deserializable!(string::String, expect_string) impl_deserialize!(string::String, expect_string)
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> T: Deserialize<D, E>
> Deserializable<D, E> for Box<T> { > Deserialize<D, E> for Box<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Box<T>, E> { 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< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> T: Deserialize<D, E>
> Deserializable<D, E> for Rc<T> { > Deserialize<D, E> for Rc<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Rc<T>, E> { 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< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> + Send + Sync T: Deserialize<D, E> + Send + Sync
> Deserializable<D, E> for Arc<T> { > Deserialize<D, E> for Arc<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Arc<T>, E> { 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< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D ,E> T: Deserialize<D ,E>
> Deserializable<D, E> for option::Option<T> { > Deserialize<D, E> for option::Option<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<option::Option<T>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<option::Option<T>, E> {
d.expect_option(token) d.expect_option(token)
@ -671,8 +671,8 @@ impl<
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D ,E> T: Deserialize<D ,E>
> Deserializable<D, E> for Vec<T> { > Deserialize<D, E> for Vec<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Vec<T>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<Vec<T>, E> {
d.expect_seq(token) d.expect_seq(token)
@ -684,9 +684,9 @@ impl<
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
K: Deserializable<D, E> + Eq + Hash, K: Deserialize<D, E> + Eq + Hash,
V: Deserializable<D, E> V: Deserialize<D, E>
> Deserializable<D, E> for HashMap<K, V> { > Deserialize<D, E> for HashMap<K, V> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<HashMap<K, V>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<HashMap<K, V>, E> {
d.expect_map(token) d.expect_map(token)
@ -696,9 +696,9 @@ impl<
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
K: Deserializable<D, E> + Ord, K: Deserialize<D, E> + Ord,
V: Deserializable<D, E> V: Deserialize<D, E>
> Deserializable<D, E> for TreeMap<K, V> { > Deserialize<D, E> for TreeMap<K, V> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> {
d.expect_map(token) d.expect_map(token)
@ -710,8 +710,8 @@ impl<
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> + Eq + Hash T: Deserialize<D, E> + Eq + Hash
> Deserializable<D, E> for HashSet<T> { > Deserialize<D, E> for HashSet<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<HashSet<T>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<HashSet<T>, E> {
d.expect_seq(token) d.expect_seq(token)
@ -721,8 +721,8 @@ impl<
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserializable<D, E> + Ord T: Deserialize<D, E> + Ord
> Deserializable<D, E> for TreeSet<T> { > Deserialize<D, E> for TreeSet<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> {
d.expect_seq(token) d.expect_seq(token)
@ -740,7 +740,7 @@ macro_rules! impl_deserialize_tuple {
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E E
> Deserializable<D, E> for () { > Deserialize<D, E> for () {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<(), E> { fn deserialize_token(d: &mut D, token: Token) -> Result<(), E> {
d.expect_null(token) d.expect_null(token)
@ -751,8 +751,8 @@ macro_rules! impl_deserialize_tuple {
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
$($name: Deserializable<D, E>),* $($name: Deserialize<D, E>),*
> Deserializable<D, E> for ($($name,)*) { > Deserialize<D, E> for ($($name,)*) {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn deserialize_token(d: &mut D, token: Token) -> Result<($($name,)*), E> { 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. /// recursive structures.
pub struct IgnoreTokens; pub struct IgnoreTokens;
impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens { impl<D: Deserializer<E>, E> Deserialize<D, E> for IgnoreTokens {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<IgnoreTokens, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<IgnoreTokens, E> {
match token { match token {
Option(true) => { Option(true) => {
Deserializable::deserialize(d) Deserialize::deserialize(d)
} }
EnumStart(_, _, _) => { EnumStart(_, _, _) => {
@ -793,7 +793,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
match try!(d.expect_token()) { match try!(d.expect_token()) {
End => { return Ok(IgnoreTokens); } End => { return Ok(IgnoreTokens); }
token => { 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()) { match try!(d.expect_token()) {
End => { return Ok(IgnoreTokens); } End => { return Ok(IgnoreTokens); }
Str(_) | String(_) => { Str(_) | String(_) => {
let _: IgnoreTokens = try!(Deserializable::deserialize(d)); let _: IgnoreTokens = try!(Deserialize::deserialize(d));
} }
_token => { return Err(d.syntax_error(token, [EndKind, StrKind, StringKind])); } _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()) { match try!(d.expect_token()) {
End => { return Ok(IgnoreTokens); } End => { return Ok(IgnoreTokens); }
token => { 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()) { match try!(d.expect_token()) {
End => { return Ok(IgnoreTokens); } End => { return Ok(IgnoreTokens); }
token => { 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()) { match try!(d.expect_token()) {
End => { return Ok(IgnoreTokens); } End => { return Ok(IgnoreTokens); }
token => { token => {
let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token)); let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
let _: IgnoreTokens = try!(Deserializable::deserialize(d)); 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] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<GatherTokens, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<GatherTokens, E> {
let mut tokens = GatherTokens { let mut tokens = GatherTokens {
@ -986,7 +986,7 @@ mod tests {
use std::{option, string}; use std::{option, string};
use serialize::Decoder; use serialize::Decoder;
use super::{Deserializer, Deserializable, Token, TokenKind, IgnoreTokens}; use super::{Deserializer, Deserialize, Token, TokenKind, IgnoreTokens};
use super::{ use super::{
Null, Null,
Bool, Bool,
@ -1034,7 +1034,7 @@ mod tests {
impl< impl<
D: Deserializer<E>, D: Deserializer<E>,
E E
> Deserializable<D, E> for Inner { > Deserialize<D, E> for Inner {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Inner, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<Inner, E> {
try!(d.expect_struct_start(token, "Inner")); try!(d.expect_struct_start(token, "Inner"));
@ -1056,7 +1056,7 @@ mod tests {
Some(1) => { b = Some(try!(d.expect_struct_value())); } Some(1) => { b = Some(try!(d.expect_struct_value())); }
Some(2) => { c = Some(try!(d.expect_struct_value())); } Some(2) => { c = Some(try!(d.expect_struct_value())); }
Some(_) => unreachable!(), 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>, inner: Vec<Inner>,
} }
impl<D: Deserializer<E>, E> Deserializable<D, E> for Outer { impl<D: Deserializer<E>, E> Deserialize<D, E> for Outer {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Outer, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<Outer, E> {
try!(d.expect_struct_start(token, "Outer")); try!(d.expect_struct_start(token, "Outer"));
@ -1089,7 +1089,7 @@ mod tests {
match idx { match idx {
Some(0) => { inner = Some(try!(d.expect_struct_value())); } Some(0) => { inner = Some(try!(d.expect_struct_value())); }
Some(_) => unreachable!(), 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) 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] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<Animal, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<Animal, E> {
match try!(d.expect_enum_start(token, "Animal", ["Dog", "Frog"])) { match try!(d.expect_enum_start(token, "Animal", ["Dog", "Frog"])) {
@ -1114,8 +1114,8 @@ mod tests {
Ok(Dog) Ok(Dog)
} }
1 => { 1 => {
let x0 = try!(Deserializable::deserialize(d)); let x0 = try!(Deserialize::deserialize(d));
let x1 = try!(Deserializable::deserialize(d)); let x1 = try!(Deserialize::deserialize(d));
try!(d.expect_enum_end()); try!(d.expect_enum_end());
Ok(Frog(x0, x1)) Ok(Frog(x0, x1))
} }
@ -1179,7 +1179,7 @@ mod tests {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: Deserializable<TokenDeserializer<Iter>, Error> T: Deserialize<TokenDeserializer<Iter>, Error>
>(&mut self, field: &'static str) -> Result<T, Error> { >(&mut self, field: &'static str) -> Result<T, Error> {
Err(MissingField(field)) Err(MissingField(field))
} }
@ -1193,7 +1193,7 @@ mod tests {
fn $name() { fn $name() {
$( $(
let mut deserializer = TokenDeserializer::new($tokens.into_iter()); 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); assert_eq!(value, $value);
)+ )+

142
src/json/mod.rs
View File

@ -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 Rust provides a mechanism for low boilerplate serializing and deserializing
of values to and from JSON via the serialization API. 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 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::Deserializable` 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 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 ```rust
#![feature(phase)] #![feature(phase)]
@ -67,9 +67,9 @@ extern crate serde;
use std::io::{MemWriter, AsRefWriter}; use std::io::{MemWriter, AsRefWriter};
use serde::json; use serde::json;
use serde::Serializable; use serde::Serialize;
#[deriving_serializable] #[deriving_serialize]
pub struct TestStruct { pub struct TestStruct {
data_str: String, 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 into a string (String) or buffer (~[u8]): `json::to_string(value)` and
`json::to_vec(value)`. `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 The trait `ToJson` serialize object into a container `json::Json` and the API provide writer
to serialize them into a stream or a string ... 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: 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 ```rust
#![feature(phase)] #![feature(phase)]
@ -149,9 +149,9 @@ extern crate serde_macros;
extern crate serde; extern crate serde;
use serde::json; use serde::json;
use serde::Deserializable; use serde::Deserialize;
#[deriving_deserializable] #[deriving_deserialize]
pub struct MyStruct { pub struct MyStruct {
attr1: u8, attr1: u8,
attr2: String, attr2: String,
@ -160,7 +160,7 @@ pub struct MyStruct {
fn main() { fn main() {
let json_str_to_deserialize = "{ \"attr1\": 1, \"attr2\": \"toto\" }"; let json_str_to_deserialize = "{ \"attr1\": 1, \"attr2\": \"toto\" }";
let mut parser = json::Parser::new(json_str_to_deserialize.bytes()); 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, Ok(v) => v,
Err(e) => panic!("Decoding error: {}", e) Err(e) => panic!("Decoding error: {}", e)
}; };
@ -182,8 +182,8 @@ extern crate serde;
use serde::json; use serde::json;
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
pub struct TestStruct1 { pub struct TestStruct1 {
data_int: u8, data_int: u8,
data_str: String, data_str: String,
@ -191,7 +191,7 @@ pub struct TestStruct1 {
} }
// To serialize use the `json::to_string` to serialize an object in a string. // 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() { fn main() {
let to_serialize_object = TestStruct1 { let to_serialize_object = TestStruct1 {
data_int: 1, data_int: 1,
@ -223,10 +223,10 @@ extern crate serde;
use std::collections::TreeMap; use std::collections::TreeMap;
use serde::json::ToJson; use serde::json::ToJson;
use serde::json; use serde::json;
use serde::Deserializable; use serde::Deserialize;
#[deriving_serializable] // generate Serializable impl #[deriving_serialize] // generate Serialize impl
#[deriving_deserializable] // generate Deserializable impl #[deriving_deserialize] // generate Deserialize impl
pub struct TestStruct1 { pub struct TestStruct1 {
data_int: u8, data_int: u8,
data_str: String, data_str: String,
@ -257,7 +257,7 @@ fn main() {
// Deserialize like before. // Deserialize like before.
let mut parser = json::Parser::new(json_str.as_slice().bytes()); 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 std::vec;
use de; use de;
use ser::Serializable; use ser::Serialize;
use ser; use ser;
pub mod builder; 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
match *self { 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] #[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Json, E> { fn deserialize_token(d: &mut D, token: de::Token) -> Result<Json, E> {
match token { 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::Str(x) => Ok(String(x.to_string())),
de::String(x) => Ok(String(x)), de::String(x) => Ok(String(x)),
de::Option(false) => Ok(Null), de::Option(false) => Ok(Null),
de::Option(true) => de::Deserializable::deserialize(d), de::Option(true) => de::Deserialize::deserialize(d),
de::TupleStart(_) | de::SeqStart(_) => { 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)) Ok(List(list))
} }
de::StructStart(_, _) | de::MapStart(_) => { 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)) Ok(Object(object))
} }
de::EnumStart(_, name, len) => { de::EnumStart(_, name, len) => {
let token = de::SeqStart(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(); let mut object = TreeMap::new();
object.insert(name.to_string(), List(fields)); object.insert(name.to_string(), List(fields));
Ok(Object(object)) Ok(Object(object))
@ -668,22 +668,22 @@ impl de::Deserializer<ParserError> for JsonDeserializer {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<JsonDeserializer, ParserError> T: de::Deserialize<JsonDeserializer, ParserError>
>(&mut self, _field: &'static str) -> Result<T, ParserError> { >(&mut self, _field: &'static str) -> Result<T, ParserError> {
// JSON can represent `null` values as a missing value, so this isn't // JSON can represent `null` values as a missing value, so this isn't
// necessarily an error. // 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. // Special case treating options as a nullable value.
#[inline] #[inline]
fn expect_option< fn expect_option<
U: de::Deserializable<JsonDeserializer, ParserError> U: de::Deserialize<JsonDeserializer, ParserError>
>(&mut self, token: de::Token) -> Result<Option<U>, ParserError> { >(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
match token { match token {
de::Null => Ok(None), de::Null => Ok(None),
token => { token => {
let value: U = try!(de::Deserializable::deserialize_token(self, token)); let value: U = try!(de::Deserialize::deserialize_token(self, token));
Ok(Some(value)) Ok(Some(value))
} }
} }
@ -1054,7 +1054,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_tuple_elt< fn serialize_tuple_elt<
T: Serializable<Serializer<W>, io::IoError> T: Serialize<Serializer<W>, io::IoError>
>(&mut self, value: &T) -> IoResult<()> { >(&mut self, value: &T) -> IoResult<()> {
if self.first { if self.first {
self.first = false; self.first = false;
@ -1077,7 +1077,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_struct_elt< fn serialize_struct_elt<
T: Serializable<Serializer<W>, io::IoError> T: Serialize<Serializer<W>, io::IoError>
>(&mut self, name: &str, value: &T) -> IoResult<()> { >(&mut self, name: &str, value: &T) -> IoResult<()> {
if self.first { if self.first {
self.first = false; self.first = false;
@ -1104,7 +1104,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_enum_elt< fn serialize_enum_elt<
T: Serializable<Serializer<W>, io::IoError> T: Serialize<Serializer<W>, io::IoError>
>(&mut self, value: &T) -> IoResult<()> { >(&mut self, value: &T) -> IoResult<()> {
if self.first { if self.first {
self.first = false; self.first = false;
@ -1121,7 +1121,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_option< fn serialize_option<
T: Serializable<Serializer<W>, io::IoError> T: Serialize<Serializer<W>, io::IoError>
>(&mut self, v: &Option<T>) -> IoResult<()> { >(&mut self, v: &Option<T>) -> IoResult<()> {
match *v { match *v {
Some(ref v) => { Some(ref v) => {
@ -1135,7 +1135,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_seq< fn serialize_seq<
T: Serializable<Serializer<W>, io::IoError>, T: Serialize<Serializer<W>, io::IoError>,
Iter: Iterator<T> Iter: Iterator<T>
>(&mut self, mut iter: Iter) -> IoResult<()> { >(&mut self, mut iter: Iter) -> IoResult<()> {
try!(self.wr.write_str("[")); try!(self.wr.write_str("["));
@ -1154,8 +1154,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[inline] #[inline]
fn serialize_map< fn serialize_map<
K: Serializable<Serializer<W>, io::IoError>, K: Serialize<Serializer<W>, io::IoError>,
V: Serializable<Serializer<W>, io::IoError>, V: Serialize<Serializer<W>, io::IoError>,
Iter: Iterator<(K, V)> Iter: Iterator<(K, V)>
>(&mut self, mut iter: Iter) -> IoResult<()> { >(&mut self, mut iter: Iter) -> IoResult<()> {
//Warning: WriterFormatter was added to work around //Warning: WriterFormatter was added to work around
@ -1319,7 +1319,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_tuple_elt< fn serialize_tuple_elt<
T: Serializable<PrettySerializer<W>, io::IoError> T: Serialize<PrettySerializer<W>, io::IoError>
>(&mut self, value: &T) -> IoResult<()> { >(&mut self, value: &T) -> IoResult<()> {
try!(self.serialize_sep()); try!(self.serialize_sep());
value.serialize(self) value.serialize(self)
@ -1338,7 +1338,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_struct_elt< fn serialize_struct_elt<
T: Serializable<PrettySerializer<W>, io::IoError> T: Serialize<PrettySerializer<W>, io::IoError>
>(&mut self, name: &str, value: &T) -> IoResult<()> { >(&mut self, name: &str, value: &T) -> IoResult<()> {
try!(self.serialize_sep()); try!(self.serialize_sep());
try!(self.serialize_str(name)); try!(self.serialize_str(name));
@ -1363,7 +1363,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_enum_elt< fn serialize_enum_elt<
T: Serializable<PrettySerializer<W>, io::IoError> T: Serialize<PrettySerializer<W>, io::IoError>
>(&mut self, value: &T) -> IoResult<()> { >(&mut self, value: &T) -> IoResult<()> {
try!(self.serialize_sep()); try!(self.serialize_sep());
value.serialize(self) value.serialize(self)
@ -1377,7 +1377,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_option< fn serialize_option<
T: Serializable<PrettySerializer<W>, io::IoError> T: Serialize<PrettySerializer<W>, io::IoError>
>(&mut self, v: &Option<T>) -> IoResult<()> { >(&mut self, v: &Option<T>) -> IoResult<()> {
match *v { match *v {
Some(ref v) => { Some(ref v) => {
@ -1391,7 +1391,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_seq< fn serialize_seq<
T: Serializable<PrettySerializer<W>, io::IoError>, T: Serialize<PrettySerializer<W>, io::IoError>,
Iter: Iterator<T> Iter: Iterator<T>
>(&mut self, mut iter: Iter) -> IoResult<()> { >(&mut self, mut iter: Iter) -> IoResult<()> {
try!(self.wr.write_str("[")); try!(self.wr.write_str("["));
@ -1407,8 +1407,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
#[inline] #[inline]
fn serialize_map< fn serialize_map<
K: Serializable<PrettySerializer<W>, io::IoError>, K: Serialize<PrettySerializer<W>, io::IoError>,
V: Serializable<PrettySerializer<W>, io::IoError>, V: Serialize<PrettySerializer<W>, io::IoError>,
Iter: Iterator<(K, V)> Iter: Iterator<(K, V)>
>(&mut self, mut iter: Iter) -> IoResult<()> { >(&mut self, mut iter: Iter) -> IoResult<()> {
try!(self.wr.write_str("{")); 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. /// Encode the specified struct into a json `[u8]` buffer.
#[inline] #[inline]
pub fn to_vec< pub fn to_vec<
T: ser::Serializable<Serializer<MemWriter>, io::IoError> T: ser::Serialize<Serializer<MemWriter>, io::IoError>
>(value: &T) -> Vec<u8> { >(value: &T) -> Vec<u8> {
let wr = MemWriter::with_capacity(1024); let wr = MemWriter::with_capacity(1024);
let mut serializer = Serializer::new(wr); let mut serializer = Serializer::new(wr);
@ -1441,7 +1441,7 @@ pub fn to_vec<
/// Encode the specified struct into a json `String` buffer. /// Encode the specified struct into a json `String` buffer.
#[inline] #[inline]
pub fn to_string< 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>> { >(value: &T) -> Result<string::String, Vec<u8>> {
let buf = to_vec(value); let buf = to_vec(value);
string::String::from_utf8(buf) string::String::from_utf8(buf)
@ -1449,7 +1449,7 @@ pub fn to_string<
/// Encode the specified struct into a json `[u8]` buffer. /// Encode the specified struct into a json `[u8]` buffer.
pub fn to_pretty_vec< pub fn to_pretty_vec<
T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError> T: ser::Serialize<PrettySerializer<MemWriter>, io::IoError>
>(value: &T) -> Vec<u8> { >(value: &T) -> Vec<u8> {
let wr = MemWriter::new(); let wr = MemWriter::new();
let mut serializer = PrettySerializer::new(wr); let mut serializer = PrettySerializer::new(wr);
@ -1459,7 +1459,7 @@ pub fn to_pretty_vec<
/// Encode the specified struct into a json `String` buffer. /// Encode the specified struct into a json `String` buffer.
pub fn to_pretty_string< 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>> { >(value: &T) -> Result<string::String, Vec<u8>> {
let buf = to_pretty_vec(value); let buf = to_pretty_vec(value);
string::String::from_utf8(buf) string::String::from_utf8(buf)
@ -2147,22 +2147,22 @@ impl<Iter: Iterator<u8>> de::Deserializer<ParserError> for Parser<Iter> {
#[inline] #[inline]
fn missing_field< fn missing_field<
T: de::Deserializable<Parser<Iter>, ParserError> T: de::Deserialize<Parser<Iter>, ParserError>
>(&mut self, _field: &'static str) -> Result<T, ParserError> { >(&mut self, _field: &'static str) -> Result<T, ParserError> {
// JSON can represent `null` values as a missing value, so this isn't // JSON can represent `null` values as a missing value, so this isn't
// necessarily an error. // 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. // Special case treating options as a nullable value.
#[inline] #[inline]
fn expect_option< fn expect_option<
U: de::Deserializable<Parser<Iter>, ParserError> U: de::Deserialize<Parser<Iter>, ParserError>
>(&mut self, token: de::Token) -> Result<Option<U>, ParserError> { >(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
match token { match token {
de::Null => Ok(None), de::Null => Ok(None),
token => { token => {
let value: U = try!(de::Deserializable::deserialize_token(self, token)); let value: U = try!(de::Deserialize::deserialize_token(self, token));
Ok(Some(value)) 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>`. /// Decodes a json value from an `Iterator<u8>`.
pub fn from_iter< pub fn from_iter<
Iter: Iterator<u8>, Iter: Iterator<u8>,
T: de::Deserializable<Parser<Iter>, ParserError> T: de::Deserialize<Parser<Iter>, ParserError>
>(iter: Iter) -> Result<T, ParserError> { >(iter: Iter) -> Result<T, ParserError> {
let mut parser = Parser::new(iter); 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. // Make sure the whole stream has been consumed.
match parser.next() { match parser.next() {
@ -2260,17 +2260,17 @@ pub fn from_iter<
/// Decodes a json value from a string /// Decodes a json value from a string
pub fn from_str< pub fn from_str<
'a, 'a,
T: de::Deserializable<Parser<str::Bytes<'a>>, ParserError> T: de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
>(s: &'a str) -> Result<T, BuilderError> { >(s: &'a str) -> Result<T, BuilderError> {
from_iter(s.bytes()) from_iter(s.bytes())
} }
/// Decodes a json value from a `Json`. /// Decodes a json value from a `Json`.
pub fn from_json< pub fn from_json<
T: de::Deserializable<JsonDeserializer, ParserError> T: de::Deserialize<JsonDeserializer, ParserError>
>(json: Json) -> Result<T, ParserError> { >(json: Json) -> Result<T, ParserError> {
let mut d = JsonDeserializer::new(json); let mut d = JsonDeserializer::new(json);
de::Deserializable::deserialize(&mut d) de::Deserialize::deserialize(&mut d)
} }
macro_rules! expect( macro_rules! expect(
@ -2461,7 +2461,7 @@ mod tests {
ListCommaOrEnd, ListCommaOrEnd,
}; };
use de; use de;
use ser::{Serializable, Serializer}; use ser::{Serialize, Serializer};
use ser; use ser;
macro_rules! treemap { macro_rules! treemap {
@ -2473,8 +2473,8 @@ mod tests {
} }
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
enum Animal { enum Animal {
Dog, Dog,
Frog(string::String, Vec<int>) Frog(string::String, Vec<int>)
@ -2502,8 +2502,8 @@ mod tests {
} }
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
@ -2523,8 +2523,8 @@ mod tests {
} }
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Outer { struct Outer {
inner: Vec<Inner>, inner: Vec<Inner>,
} }
@ -2540,7 +2540,7 @@ mod tests {
} }
fn test_encode_ok< 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)]) { >(errors: &[(T, &str)]) {
for &(ref value, out) in errors.iter() { for &(ref value, out) in errors.iter() {
let out = out.to_string(); let out = out.to_string();
@ -2554,7 +2554,7 @@ mod tests {
} }
fn test_pretty_encode_ok< 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)]) { >(errors: &[(T, &str)]) {
for &(ref value, out) in errors.iter() { for &(ref value, out) in errors.iter() {
let out = out.to_string(); let out = out.to_string();
@ -2891,7 +2891,7 @@ mod tests {
// FIXME (#5527): these could be merged once UFCS is finished. // FIXME (#5527): these could be merged once UFCS is finished.
fn test_parse_err< fn test_parse_err<
'a, 'a,
T: Show + de::Deserializable<Parser<str::Bytes<'a>>, ParserError> T: Show + de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
>(errors: &[(&'a str, ParserError)]) { >(errors: &[(&'a str, ParserError)]) {
for &(s, ref err) in errors.iter() { for &(s, ref err) in errors.iter() {
let v: Result<T, ParserError> = from_str(s); let v: Result<T, ParserError> = from_str(s);
@ -2901,7 +2901,7 @@ mod tests {
fn test_parse_ok< fn test_parse_ok<
'a, '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)]) { >(errors: &[(&'a str, T)]) {
for &(s, ref value) in errors.iter() { for &(s, ref value) in errors.iter() {
let v: T = from_str(s).unwrap(); let v: T = from_str(s).unwrap();
@ -2913,7 +2913,7 @@ mod tests {
} }
fn test_json_deserialize_ok< fn test_json_deserialize_ok<
T: PartialEq + Show + ToJson + de::Deserializable<JsonDeserializer, ParserError> T: PartialEq + Show + ToJson + de::Deserialize<JsonDeserializer, ParserError>
>(errors: &[T]) { >(errors: &[T]) {
for value in errors.iter() { for value in errors.iter() {
let v: T = from_json(value.to_json()).unwrap(); let v: T = from_json(value.to_json()).unwrap();
@ -3219,8 +3219,8 @@ mod tests {
]); ]);
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Foo { struct Foo {
x: Option<int>, x: Option<int>,
} }

4
src/lib.rs
View File

@ -12,8 +12,8 @@ extern crate serde_macros;
#[cfg(test)] #[cfg(test)]
extern crate serialize; extern crate serialize;
pub use ser::{Serializer, Serializable}; pub use ser::{Serializer, Serialize};
pub use de::{Deserializer, Deserializable}; pub use de::{Deserializer, Deserialize};
pub mod de; pub mod de;
pub mod ser; pub mod ser;

124
src/ser.rs
View File

@ -79,49 +79,49 @@ pub trait Serializer<E> {
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>; fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
fn serialize_tuple_elt< fn serialize_tuple_elt<
T: Serializable<Self, E> T: Serialize<Self, E>
>(&mut self, v: &T) -> Result<(), E>; >(&mut self, v: &T) -> Result<(), E>;
fn serialize_tuple_end(&mut self) -> 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_start(&mut self, name: &str, len: uint) -> Result<(), E>;
fn serialize_struct_elt< fn serialize_struct_elt<
T: Serializable<Self, E> T: Serialize<Self, E>
>(&mut self, name: &str, v: &T) -> Result<(), E>; >(&mut self, name: &str, v: &T) -> Result<(), E>;
fn serialize_struct_end(&mut self) -> 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_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
fn serialize_enum_elt< fn serialize_enum_elt<
T: Serializable<Self, E> T: Serialize<Self, E>
>(&mut self, v: &T) -> Result<(), E>; >(&mut self, v: &T) -> Result<(), E>;
fn serialize_enum_end(&mut self) -> Result<(), E>; fn serialize_enum_end(&mut self) -> Result<(), E>;
fn serialize_option< fn serialize_option<
T: Serializable<Self, E> T: Serialize<Self, E>
>(&mut self, v: &Option<T>) -> Result<(), E>; >(&mut self, v: &Option<T>) -> Result<(), E>;
fn serialize_seq< fn serialize_seq<
T: Serializable<Self, E>, T: Serialize<Self, E>,
Iter: Iterator<T> Iter: Iterator<T>
>(&mut self, iter: Iter) -> Result<(), E>; >(&mut self, iter: Iter) -> Result<(), E>;
fn serialize_map< fn serialize_map<
K: Serializable<Self, E>, K: Serialize<Self, E>,
V: Serializable<Self, E>, V: Serialize<Self, E>,
Iter: Iterator<(K, V)> Iter: Iterator<(K, V)>
>(&mut self, iter: Iter) -> Result<(), E>; >(&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>; fn serialize(&self, s: &mut S) -> Result<(), E>;
} }
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
macro_rules! impl_serializable { macro_rules! impl_serialize {
($ty:ty, $method:ident) => { ($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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.$method(*self) s.$method(*self)
@ -130,31 +130,31 @@ macro_rules! impl_serializable {
} }
} }
impl_serializable!(bool, serialize_bool) impl_serialize!(bool, serialize_bool)
impl_serializable!(int, serialize_int) impl_serialize!(int, serialize_int)
impl_serializable!(i8, serialize_i8) impl_serialize!(i8, serialize_i8)
impl_serializable!(i16, serialize_i16) impl_serialize!(i16, serialize_i16)
impl_serializable!(i32, serialize_i32) impl_serialize!(i32, serialize_i32)
impl_serializable!(i64, serialize_i64) impl_serialize!(i64, serialize_i64)
impl_serializable!(uint, serialize_uint) impl_serialize!(uint, serialize_uint)
impl_serializable!(u8, serialize_u8) impl_serialize!(u8, serialize_u8)
impl_serializable!(u16, serialize_u16) impl_serialize!(u16, serialize_u16)
impl_serializable!(u32, serialize_u32) impl_serialize!(u32, serialize_u32)
impl_serializable!(u64, serialize_u64) impl_serialize!(u64, serialize_u64)
impl_serializable!(f32, serialize_f32) impl_serialize!(f32, serialize_f32)
impl_serializable!(f64, serialize_f64) impl_serialize!(f64, serialize_f64)
impl_serializable!(char, serialize_char) 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_str(*self) 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] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
self.as_slice().serialize(s) 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) => { ($ty:ty) => {
impl< impl<
'a, 'a,
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> T: Serialize<S, E>
> Serializable<S, E> for $ty { > Serialize<S, E> for $ty {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
(**self).serialize(s) (**self).serialize(s)
@ -179,15 +179,15 @@ macro_rules! impl_serializable_box {
} }
} }
impl_serializable_box!(&'a T) impl_serialize_box!(&'a T)
impl_serializable_box!(Box<T>) impl_serialize_box!(Box<T>)
impl_serializable_box!(Rc<T>) impl_serialize_box!(Rc<T>)
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> + Send + Sync T: Serialize<S, E> + Send + Sync
> Serializable<S, E> for Arc<T> { > Serialize<S, E> for Arc<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
(**self).serialize(s) (**self).serialize(s)
@ -199,8 +199,8 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> T: Serialize<S, E>
> Serializable<S, E> for Option<T> { > Serialize<S, E> for Option<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_option(self) s.serialize_option(self)
@ -212,8 +212,8 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> T: Serialize<S, E>
> Serializable<S, E> for Vec<T> { > Serialize<S, E> for Vec<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_seq(self.iter()) s.serialize_seq(self.iter())
@ -225,9 +225,9 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
K: Serializable<S, E> + Eq + Hash, K: Serialize<S, E> + Eq + Hash,
V: Serializable<S, E> V: Serialize<S, E>
> Serializable<S, E> for HashMap<K, V> { > Serialize<S, E> for HashMap<K, V> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_map(self.iter()) s.serialize_map(self.iter())
@ -237,9 +237,9 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
K: Serializable<S, E> + Ord, K: Serialize<S, E> + Ord,
V: Serializable<S, E> V: Serialize<S, E>
> Serializable<S, E> for TreeMap<K, V> { > Serialize<S, E> for TreeMap<K, V> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_map(self.iter()) s.serialize_map(self.iter())
@ -251,8 +251,8 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> + Eq + Hash T: Serialize<S, E> + Eq + Hash
> Serializable<S, E> for HashSet<T> { > Serialize<S, E> for HashSet<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_seq(self.iter()) s.serialize_seq(self.iter())
@ -262,8 +262,8 @@ impl<
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serializable<S, E> + Ord T: Serialize<S, E> + Ord
> Serializable<S, E> for TreeSet<T> { > Serialize<S, E> for TreeSet<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_seq(self.iter()) s.serialize_seq(self.iter())
@ -278,7 +278,7 @@ macro_rules! peel {
macro_rules! impl_serialize_tuple { macro_rules! impl_serialize_tuple {
() => { () => {
impl<S: Serializer<E>, E> Serializable<S, E> for () { impl<S: Serializer<E>, E> Serialize<S, E> for () {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_null() s.serialize_null()
@ -289,8 +289,8 @@ macro_rules! impl_serialize_tuple {
impl< impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
$($name:Serializable<S, E>),+ $($name:Serialize<S, E>),+
> Serializable<S, E> for ($($name,)+) { > Serialize<S, E> for ($($name,)+) {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
@ -323,12 +323,12 @@ mod tests {
use serialize::Decoder; use serialize::Decoder;
use super::{Serializer, Serializable}; use super::{Serializer, Serialize};
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_serializable] #[deriving_serialize]
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
@ -338,7 +338,7 @@ mod tests {
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_serializable] #[deriving_serialize]
struct Outer { struct Outer {
inner: Vec<Inner>, inner: Vec<Inner>,
} }
@ -346,7 +346,7 @@ mod tests {
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)] #[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_serializable] #[deriving_serialize]
enum Animal { enum Animal {
Dog, Dog,
Frog(String, int) Frog(String, int)
@ -494,7 +494,7 @@ mod tests {
} }
fn serialize_tuple_elt< fn serialize_tuple_elt<
T: Serializable<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, value: &T) -> Result<(), Error> { >(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(TupleSep)); try!(self.serialize(TupleSep));
value.serialize(self) value.serialize(self)
@ -509,7 +509,7 @@ mod tests {
} }
fn serialize_struct_elt< fn serialize_struct_elt<
T: Serializable<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, name: &str, value: &T) -> Result<(), Error> { >(&mut self, name: &str, value: &T) -> Result<(), Error> {
try!(self.serialize(StructSep(name))); try!(self.serialize(StructSep(name)));
value.serialize(self) value.serialize(self)
@ -524,7 +524,7 @@ mod tests {
} }
fn serialize_enum_elt< fn serialize_enum_elt<
T: Serializable<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, value: &T) -> Result<(), Error> { >(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(EnumSep)); try!(self.serialize(EnumSep));
value.serialize(self) value.serialize(self)
@ -535,7 +535,7 @@ mod tests {
} }
fn serialize_option< fn serialize_option<
T: Serializable<AssertSerializer<Iter>, Error> T: Serialize<AssertSerializer<Iter>, Error>
>(&mut self, v: &option::Option<T>) -> Result<(), Error> { >(&mut self, v: &option::Option<T>) -> Result<(), Error> {
match *v { match *v {
Some(ref v) => { Some(ref v) => {
@ -549,7 +549,7 @@ mod tests {
} }
fn serialize_seq< fn serialize_seq<
T: Serializable<AssertSerializer<Iter>, Error>, T: Serialize<AssertSerializer<Iter>, Error>,
SeqIter: Iterator<T> SeqIter: Iterator<T>
>(&mut self, mut iter: SeqIter) -> Result<(), Error> { >(&mut self, mut iter: SeqIter) -> Result<(), Error> {
let (len, _) = iter.size_hint(); let (len, _) = iter.size_hint();
@ -561,8 +561,8 @@ mod tests {
} }
fn serialize_map< fn serialize_map<
K: Serializable<AssertSerializer<Iter>, Error>, K: Serialize<AssertSerializer<Iter>, Error>,
V: Serializable<AssertSerializer<Iter>, Error>, V: Serialize<AssertSerializer<Iter>, Error>,
MapIter: Iterator<(K, V)> MapIter: Iterator<(K, V)>
>(&mut self, mut iter: MapIter) -> Result<(), Error> { >(&mut self, mut iter: MapIter) -> Result<(), Error> {
let (len, _) = iter.size_hint(); let (len, _) = iter.size_hint();

4
tests/json_struct.rs
View File

@ -5,8 +5,8 @@ extern crate serde;
extern crate serde_macros; extern crate serde_macros;
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
#[deriving_serializable] #[deriving_serialize]
#[deriving_deserializable] #[deriving_deserialize]
struct Test { struct Test {
#[serial_name = "$schema"] #[serial_name = "$schema"]
schema: String, schema: String,