pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-17 00:01:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix serde2 macro generation

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-10-14 18:08:34 -07:00
parent f614fb6667
commit 0b8324ae09
4 changed files with 299 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/benches/bench_log.rs
+63 -34
View File
@@ -14,12 +14,11 @@ use test::Bencher;
//use serde2::de; //use serde2::de;
use serde2::json; use serde2::json;
use serde2::Serialize;
use serde2::ser; use serde2::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,15 +38,20 @@ enum HttpProtocol {
HTTP11, HTTP11,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for HttpProtocol { impl ser::Serialize for HttpProtocol {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -70,15 +74,20 @@ enum HttpMethod {
PATCH, PATCH,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for HttpMethod { impl ser::Serialize for HttpMethod {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -94,15 +103,20 @@ enum CacheStatus {
Hit, Hit,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for CacheStatus { impl ser::Serialize for CacheStatus {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -111,8 +125,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,
@@ -127,15 +141,20 @@ enum OriginProtocol {
HTTPS, HTTPS,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for OriginProtocol { impl ser::Serialize for OriginProtocol {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -152,15 +171,20 @@ enum ZonePlan {
ENT, ENT,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for ZonePlan { impl ser::Serialize for ZonePlan {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -428,15 +452,20 @@ enum Country {
ZW, ZW,
} }
impl<S: ser::VisitorState<R>, R> ser::Serialize<S, R> for Country { impl ser::Serialize for Country {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> R { fn visit<
s.visit_uint(*self as uint) S,
R,
E,
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *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)
@@ -445,8 +474,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,
@@ -632,11 +661,11 @@ fn bench_serializer(b: &mut Bencher) {
fn bench_copy(b: &mut Bencher) { fn bench_copy(b: &mut Bencher) {
let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
let json = Vec::from_slice(s.as_bytes()); let json = s.as_bytes().to_vec();
b.bytes = json.len() as u64; b.bytes = json.len() as u64;
b.iter(|| { b.iter(|| {
let _json = Vec::from_slice(s.as_bytes()); let _json = s.as_bytes().to_vec();
}); });
} }
@@ -930,7 +959,7 @@ fn bench_manual_my_mem_writer1_escape(b: &mut Bencher) {
fn direct<W: Writer>(wr: W, log: &Log) { fn direct<W: Writer>(wr: W, log: &Log) {
use serde2::ser::VisitorState; use serde2::ser::VisitorState;
let mut serializer = json::Serializer::new(wr); let mut serializer = json::Writer::new(wr);
serializer.serialize_struct_start("Log", 12).unwrap(); serializer.serialize_struct_start("Log", 12).unwrap();
serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap(); serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap();
serde2/serde2_macros/src/lib.rs
+98 -60
View File
@@ -12,7 +12,7 @@ use syntax::ast::{
Item, Item,
Expr, Expr,
MutMutable, MutMutable,
LitNil, //LitNil,
}; };
use syntax::ast; use syntax::ast;
use syntax::codemap::Span; use syntax::codemap::Span;
@@ -22,14 +22,14 @@ use syntax::ext::deriving::generic::{
EnumMatching, EnumMatching,
FieldInfo, FieldInfo,
MethodDef, MethodDef,
Named, //Named,
StaticFields, //StaticFields,
StaticStruct, //StaticStruct,
StaticEnum, //StaticEnum,
Struct, Struct,
Substructure, Substructure,
TraitDef, TraitDef,
Unnamed, //Unnamed,
combine_substructure, combine_substructure,
}; };
use syntax::ext::deriving::generic::ty::{ use syntax::ext::deriving::generic::ty::{
@@ -38,8 +38,8 @@ use syntax::ext::deriving::generic::ty::{
Literal, Literal,
Path, Path,
Ptr, Ptr,
Self, //Self,
Tuple, //Tuple,
borrowed_explicit_self, borrowed_explicit_self,
}; };
use syntax::parse::token; use syntax::parse::token;
@@ -51,21 +51,21 @@ 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"),
ItemDecorator(box expand_deriving_deserializable)); ItemDecorator(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,
mut 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));
@@ -73,54 +73,86 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
let trait_def = TraitDef { let trait_def = TraitDef {
span: sp, span: sp,
attributes: vec!(), attributes: vec!(),
path: Path::new_(vec!("serde2", "ser", "Serialize"), None, path: Path::new(vec!["serde2", "ser", "Serialize"]),
vec!(box Literal(Path::new_local("__S")),
box Literal(Path::new_local("__R"))), true),
additional_bounds: Vec::new(), additional_bounds: Vec::new(),
generics: LifetimeBounds { generics: LifetimeBounds::empty(),
lifetimes: Vec::new(), methods: vec![
bounds: vec!(("__S", None, vec!(Path::new_(
vec!("serde2", "ser", "VisitorState"), None,
vec!(box Literal(Path::new_local("__R"))), true))),
("__R", None, vec!()))
},
methods: vec!(
MethodDef { MethodDef {
name: "serialize", name: "visit",
generics: LifetimeBounds::empty(), generics: LifetimeBounds {
lifetimes: Vec::new(),
bounds: vec![
("__S", None, vec![]),
("__R", None, vec![]),
("__E", None, vec![]),
(
"__V",
None,
vec![
Path::new_(
vec!["serde2", "ser", "Visitor"],
None,
vec![
box Literal(Path::new_local("__S")),
box Literal(Path::new_local("__R")),
box Literal(Path::new_local("__E")),
],
true
),
],
),
]
},
explicit_self: borrowed_explicit_self(), explicit_self: borrowed_explicit_self(),
args: vec!(Ptr(box Literal(Path::new_local("__S")), args: vec![
Borrowed(None, MutMutable))), Ptr(
box Literal(Path::new_local("__S")),
Borrowed(None, MutMutable)
),
Literal(
Path::new_local("__V"),
),
],
ret_ty: Literal( ret_ty: Literal(
Path::new_local("__R") Path::new_(
vec!("std", "result", "Result"),
None,
vec![
box Literal(Path::new_local("__R")),
box Literal(Path::new_local("__E")),
],
true
)
), ),
attributes: attrs, attributes: attrs,
combine_substructure: combine_substructure(|a, b, c| { combine_substructure: combine_substructure(|a, b, c| {
serializable_substructure(a, b, c) serialize_substructure(a, b, c)
}), }),
}) }
]
}; };
trait_def.expand(cx, mitem, item, push) trait_def.expand(cx, mitem, item, push)
} }
fn serializable_substructure(cx: &ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> { fn serialize_substructure(cx: &ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> {
let serializer = substr.nonself_args[0].clone(); let state = substr.nonself_args[0].clone();
let visitor = substr.nonself_args[1].clone();
match *substr.fields { match *substr.fields {
Struct(ref fields) => { Struct(ref fields) => {
if fields.is_empty() { if fields.is_empty() {
serialize_tuple_struct(cx) serialize_tuple_struct(cx)
} else { } else {
serialize_struct(cx, span, serializer, substr.type_ident, fields) serialize_struct(cx, span, state, visitor, substr.type_ident, fields)
} }
} }
EnumMatching(_idx, variant, ref fields) => { EnumMatching(_idx, variant, ref fields) => {
serialize_enum(cx, span, serializer, substr.type_ident, variant, fields) serialize_enum(cx, span, state, visitor, substr.type_ident, variant, fields)
} }
_ => cx.bug("expected Struct or EnumMatching in deriving_serializable") _ => cx.bug("expected Struct or EnumMatching in deriving_serialize")
} }
} }
@@ -131,7 +163,8 @@ fn serialize_tuple_struct(cx: &ExtCtxt) -> P<Expr> {
fn serialize_struct(cx: &ExtCtxt, fn serialize_struct(cx: &ExtCtxt,
span: Span, span: Span,
serializer: P<Expr>, state: P<Expr>,
visitor: P<Expr>,
type_ident: Ident, type_ident: Ident,
fields: &Vec<FieldInfo>) -> P<Expr> { fields: &Vec<FieldInfo>) -> P<Expr> {
@@ -150,12 +183,13 @@ fn serialize_struct(cx: &ExtCtxt,
}; };
let name = name.unwrap(); let name = name.unwrap();
let name_expr = cx.expr_str(span, token::get_ident(name)); let expr = cx.expr_str(span, token::get_ident(name));
quote_arm!(cx, quote_arm!(cx,
$i => { $i => {
self.state += 1; self.state += 1;
Some(s.visit_map_elt($first, $name_expr, &self.value.$name)) let v = try!(visitor.visit_map_elt(state, $first, $expr, &self.value.$name));
Ok(Some(v))
} }
) )
}) })
@@ -169,14 +203,17 @@ fn serialize_struct(cx: &ExtCtxt,
impl< impl<
'a, 'a,
S: ::serde2::VisitorState<R>, S,
R R,
> ::serde2::Visitor<S, R> for Visitor<'a> { E,
> ::serde2::ser::MapVisitor<S, R, E> for Visitor<'a> {
#[inline] #[inline]
fn visit(&mut self, s: &mut S) -> Option<R> { fn visit<
V: ::serde2::ser::Visitor<S, R, E>,
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
match self.state { match self.state {
$arms $arms
_ => None, _ => Ok(None),
} }
} }
@@ -187,7 +224,7 @@ fn serialize_struct(cx: &ExtCtxt,
} }
} }
$serializer.visit_named_map($type_name, Visitor { $visitor.visit_named_map($state, $type_name, Visitor {
value: self, value: self,
state: 0, state: 0,
}) })
@@ -196,7 +233,8 @@ fn serialize_struct(cx: &ExtCtxt,
fn serialize_enum(cx: &ExtCtxt, fn serialize_enum(cx: &ExtCtxt,
span: Span, span: Span,
serializer: P<Expr>, state: P<Expr>,
visitor: P<Expr>,
type_ident: Ident, type_ident: Ident,
variant: &ast::Variant, variant: &ast::Variant,
fields: &Vec<FieldInfo>) -> P<Expr> { fields: &Vec<FieldInfo>) -> P<Expr> {
@@ -211,23 +249,23 @@ fn serialize_enum(cx: &ExtCtxt,
let len = fields.len(); let len = fields.len();
let stmts: Vec<P<ast::Stmt>> = fields.iter() let stmts: Vec<P<ast::Stmt>> = fields.iter()
.map(|&FieldInfo { ref self_, span, .. }| { .map(|&FieldInfo { ref self_, .. }| {
quote_stmt!( quote_stmt!(
cx, cx,
try!($serializer.serialize_enum_elt(&$self_)) try!($visitor.serialize_enum_elt($state, &$self_))
) )
}) })
.collect(); .collect();
quote_expr!(cx, { quote_expr!(cx, {
try!($serializer.serialize_enum_start($type_name, $variant_name, $len)); try!($visitor.serialize_enum_start($state, $type_name, $variant_name, $len));
$stmts $stmts
$serializer.serialize_enum_end() $visitor.serialize_enum_end($state)
}) })
} }
/* /*
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,
@@ -235,7 +273,7 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
let trait_def = TraitDef { let trait_def = TraitDef {
span: span, span: span,
attributes: Vec::new(), attributes: Vec::new(),
path: Path::new_(vec!("serde2", "de", "Deserializable"), None, path: Path::new_(vec!("serde2", "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(),
@@ -271,7 +309,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)
}), }),
}) })
}; };
@@ -279,7 +317,7 @@ 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, span: Span,
substr: &Substructure) -> P<Expr> { substr: &Substructure) -> P<Expr> {
let deserializer = substr.nonself_args[0]; let deserializer = substr.nonself_args[0];
let token = substr.nonself_args[1]; let token = substr.nonself_args[1];
@@ -303,7 +341,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)")
} }
} }
@@ -356,7 +394,7 @@ fn deserialize_struct_from_struct(
) -> P<ast::Expr> { ) -> P<ast::Expr> {
let expect_struct_field = cx.ident_of("expect_struct_field"); let expect_struct_field = cx.ident_of("expect_struct_field");
let call = deserializable_static_fields( let call = deserialize_static_fields(
cx, cx,
span, span,
type_ident, type_ident,
@@ -403,7 +441,7 @@ fn deserialize_struct_from_map(
quote_arm!(cx, quote_arm!(cx,
$s => { $s => {
$name = Some( $name = Some(
try!(::serde2::de::Deserializable::deserialize($deserializer)) try!(::serde2::de::Deserialize::deserialize($deserializer))
); );
continue; continue;
}) })
@@ -489,7 +527,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,
@@ -520,7 +558,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,
serde2/src/de.rs
+137 -137
View File
@@ -4,8 +4,8 @@ use std::num;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
pub trait Deserialize<D, E> { pub trait Deserialize<S, E> {
fn deserialize(d: &mut D) -> Result<Self, E>; fn deserialize(state: &mut S) -> Result<Self, E>;
} }
pub trait Deserializer<E> { pub trait Deserializer<E> {
@@ -26,95 +26,95 @@ pub trait Deserializer<E> {
fn end_of_stream_error(&mut self) -> E; fn end_of_stream_error(&mut self) -> E;
} }
pub trait Visitor<D: Deserializer<E>, R, E> { pub trait Visitor<S: Deserializer<E>, R, E> {
fn visit_null(&mut self, d: &mut D) -> Result<R, E> { fn visit_null(&mut self, state: &mut S) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_bool(&mut self, d: &mut D, _v: bool) -> Result<R, E> { fn visit_bool(&mut self, state: &mut S, _v: bool) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_int(&mut self, d: &mut D, v: int) -> Result<R, E> { fn visit_int(&mut self, state: &mut S, v: int) -> Result<R, E> {
self.visit_i64(d, v as i64) self.visit_i64(state, v as i64)
} }
fn visit_i64(&mut self, d: &mut D, _v: i64) -> Result<R, E> { fn visit_i64(&mut self, state: &mut S, _v: i64) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_uint(&mut self, d: &mut D, v: uint) -> Result<R, E> { fn visit_uint(&mut self, state: &mut S, v: uint) -> Result<R, E> {
self.visit_u64(d, v as u64) self.visit_u64(state, v as u64)
} }
fn visit_u64(&mut self, d: &mut D, _v: u64) -> Result<R, E> { fn visit_u64(&mut self, state: &mut S, _v: u64) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_f32(&mut self, d: &mut D, v: f32) -> Result<R, E> { fn visit_f32(&mut self, state: &mut S, v: f32) -> Result<R, E> {
self.visit_f64(d, v as f64) self.visit_f64(state, v as f64)
} }
fn visit_f64(&mut self, d: &mut D, _v: f64) -> Result<R, E> { fn visit_f64(&mut self, state: &mut S, _v: f64) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_str(&mut self, d: &mut D, _v: &str) -> Result<R, E> { fn visit_str(&mut self, state: &mut S, _v: &str) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_string(&mut self, d: &mut D, v: String) -> Result<R, E> { fn visit_string(&mut self, state: &mut S, v: String) -> Result<R, E> {
self.visit_str(d, v.as_slice()) self.visit_str(state, v.as_slice())
} }
fn visit_option< fn visit_option<
V: OptionVisitor<D, E>, V: OptionVisitor<S, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> { >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_seq< fn visit_seq<
V: SeqVisitor<D, E>, V: SeqVisitor<S, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> { >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
fn visit_map< fn visit_map<
V: MapVisitor<D, E>, V: MapVisitor<S, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> { >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
Err(d.syntax_error()) Err(state.syntax_error())
} }
} }
pub trait OptionVisitor<D, E> { pub trait OptionVisitor<S, E> {
fn visit< fn visit<
T: Deserialize<D, E>, T: Deserialize<S, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>; >(&mut self, state: &mut S) -> Result<Option<T>, E>;
} }
pub trait SeqVisitor<D, E> { pub trait SeqVisitor<S, E> {
fn visit< fn visit<
T: Deserialize<D, E>, T: Deserialize<S, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>; >(&mut self, state: &mut S) -> Result<Option<T>, E>;
fn end(&mut self, d: &mut D) -> Result<(), E>; fn end(&mut self, state: &mut S) -> Result<(), E>;
#[inline] #[inline]
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) { fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) {
(0, None) (0, None)
} }
} }
pub trait MapVisitor<D, E> { pub trait MapVisitor<S, E> {
fn visit< fn visit<
K: Deserialize<D, E>, K: Deserialize<S, E>,
V: Deserialize<D, E>, V: Deserialize<S, E>,
>(&mut self, d: &mut D) -> Result<Option<(K, V)>, E>; >(&mut self, state: &mut S) -> Result<Option<(K, V)>, E>;
fn end(&mut self, d: &mut D) -> Result<(), E>; fn end(&mut self, state: &mut S) -> Result<(), E>;
#[inline] #[inline]
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) { fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) {
(0, None) (0, None)
} }
} }
@@ -122,45 +122,45 @@ pub trait MapVisitor<D, E> {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for () { > Deserialize<S, E> for () {
fn deserialize(d: &mut D) -> Result<(), E> { fn deserialize(state: &mut S) -> Result<(), E> {
struct Visitor; struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, (), E> for Visitor { impl<S: Deserializer<E>, E> self::Visitor<S, (), E> for Visitor {
fn visit_null(&mut self, _d: &mut D) -> Result<(), E> { fn visit_null(&mut self, _state: &mut S) -> Result<(), E> {
Ok(()) Ok(())
} }
fn visit_seq< fn visit_seq<
V: SeqVisitor<D, E>, V: SeqVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<(), E> { >(&mut self, state: &mut S, mut visitor: V) -> Result<(), E> {
try!(visitor.end(d)); try!(visitor.end(state));
Ok(()) Ok(())
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for bool { > Deserialize<S, E> for bool {
fn deserialize(d: &mut D) -> Result<bool, E> { fn deserialize(state: &mut S) -> Result<bool, E> {
struct Visitor; struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, bool, E> for Visitor { impl<S: Deserializer<E>, E> self::Visitor<S, bool, E> for Visitor {
fn visit_bool(&mut self, _d: &mut D, v: bool) -> Result<bool, E> { fn visit_bool(&mut self, _state: &mut S, v: bool) -> Result<bool, E> {
Ok(v) Ok(v)
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
@@ -168,10 +168,10 @@ impl<
macro_rules! impl_deserialize_num_method { macro_rules! impl_deserialize_num_method {
($dst_ty:ty, $src_ty:ty, $method:ident) => { ($dst_ty:ty, $src_ty:ty, $method:ident) => {
fn $method(&mut self, d: &mut D, v: $src_ty) -> Result<$dst_ty, E> { fn $method(&mut self, state: &mut S, v: $src_ty) -> Result<$dst_ty, E> {
match num::cast(v) { match num::cast(v) {
Some(v) => Ok(v), Some(v) => Ok(v),
None => Err(d.syntax_error()), None => Err(state.syntax_error()),
} }
} }
} }
@@ -179,12 +179,12 @@ macro_rules! impl_deserialize_num_method {
macro_rules! impl_deserialize_num { macro_rules! impl_deserialize_num {
($ty:ty) => { ($ty:ty) => {
impl<D: Deserializer<E>, E> Deserialize<D, E> for $ty { impl<S: Deserializer<E>, E> Deserialize<S, E> for $ty {
#[inline] #[inline]
fn deserialize(d: &mut D) -> Result<$ty, E> { fn deserialize(state: &mut S) -> Result<$ty, E> {
struct Visitor; struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, $ty, E> for Visitor { impl<S: Deserializer<E>, E> self::Visitor<S, $ty, E> for Visitor {
impl_deserialize_num_method!($ty, int, visit_int) impl_deserialize_num_method!($ty, int, visit_int)
impl_deserialize_num_method!($ty, i64, visit_i64) impl_deserialize_num_method!($ty, i64, visit_i64)
impl_deserialize_num_method!($ty, uint, visit_uint) impl_deserialize_num_method!($ty, uint, visit_uint)
@@ -193,7 +193,7 @@ macro_rules! impl_deserialize_num {
impl_deserialize_num_method!($ty, f64, visit_f64) impl_deserialize_num_method!($ty, f64, visit_f64)
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
} }
@@ -209,75 +209,75 @@ impl_deserialize_num!(f64)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for String { > Deserialize<S, E> for String {
fn deserialize(d: &mut D) -> Result<String, E> { fn deserialize(state: &mut S) -> Result<String, E> {
struct Visitor; struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, String, E> for Visitor { impl<S: Deserializer<E>, E> self::Visitor<S, String, E> for Visitor {
fn visit_str(&mut self, _d: &mut D, v: &str) -> Result<String, E> { fn visit_str(&mut self, _state: &mut S, v: &str) -> Result<String, E> {
Ok(v.to_string()) Ok(v.to_string())
} }
fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> { fn visit_string(&mut self, _state: &mut S, v: String) -> Result<String, E> {
Ok(v) Ok(v)
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
T: Deserialize<D, E>, T: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for Option<T> { > Deserialize<S, E> for Option<T> {
fn deserialize(d: &mut D) -> Result<Option<T>, E> { fn deserialize(state: &mut S) -> Result<Option<T>, E> {
struct Visitor; struct Visitor;
impl< impl<
T: Deserialize<D, E>, T: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> self::Visitor<D, Option<T>, E> for Visitor { > self::Visitor<S, Option<T>, E> for Visitor {
fn visit_option< fn visit_option<
V: OptionVisitor<D, E>, V: OptionVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Option<T>, E> { >(&mut self, state: &mut S, mut visitor: V) -> Result<Option<T>, E> {
visitor.visit(d) visitor.visit(state)
} }
} }
d.visit_option(&mut Visitor) state.visit_option(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
T: Deserialize<D, E>, T: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for Vec<T> { > Deserialize<S, E> for Vec<T> {
fn deserialize(d: &mut D) -> Result<Vec<T>, E> { fn deserialize(state: &mut S) -> Result<Vec<T>, E> {
struct Visitor; struct Visitor;
impl< impl<
T: Deserialize<D, E>, T: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> self::Visitor<D, Vec<T>, E> for Visitor { > self::Visitor<S, Vec<T>, E> for Visitor {
fn visit_seq< fn visit_seq<
V: SeqVisitor<D, E>, V: SeqVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Vec<T>, E> { >(&mut self, state: &mut S, mut visitor: V) -> Result<Vec<T>, E> {
let (len, _) = visitor.size_hint(d); let (len, _) = visitor.size_hint(state);
let mut values = Vec::with_capacity(len); let mut values = Vec::with_capacity(len);
loop { loop {
match try!(visitor.visit(d)) { match try!(visitor.visit(state)) {
Some(value) => { Some(value) => {
values.push(value); values.push(value);
} }
@@ -291,7 +291,7 @@ impl<
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
@@ -309,37 +309,37 @@ macro_rules! impl_deserialize_tuple {
peel!($($name,)*) peel!($($name,)*)
impl< impl<
D: Deserializer<E>, S: Deserializer<E>,
E, E,
$($name: Deserialize<D, E>),+ $($name: Deserialize<S, E>),+
> Deserialize<D, E> for ($($name,)+) { > Deserialize<S, E> for ($($name,)+) {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn deserialize(d: &mut D) -> Result<($($name,)+), E> { fn deserialize(state: &mut S) -> Result<($($name,)+), E> {
struct Visitor; struct Visitor;
impl< impl<
D: Deserializer<E>, S: Deserializer<E>,
E, E,
$($name: Deserialize<D, E>,)+ $($name: Deserialize<S, E>,)+
> self::Visitor<D, ($($name,)+), E> for Visitor { > self::Visitor<S, ($($name,)+), E> for Visitor {
fn visit_seq< fn visit_seq<
V: SeqVisitor<D, E>, V: SeqVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<($($name,)+), E> { >(&mut self, state: &mut S, mut visitor: V) -> Result<($($name,)+), E> {
$( $(
let $name = match try!(visitor.visit(d)) { let $name = match try!(visitor.visit(state)) {
Some(value) => value, Some(value) => value,
None => { return Err(d.end_of_stream_error()); } None => { return Err(state.end_of_stream_error()); }
}; };
)+; )+;
try!(visitor.end(d)); try!(visitor.end(state));
Ok(($($name,)+)) Ok(($($name,)+))
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
} }
@@ -350,28 +350,28 @@ impl_deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
K: Deserialize<D, E> + Eq + Hash, K: Deserialize<S, E> + Eq + Hash,
V: Deserialize<D, E>, V: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for HashMap<K, V> { > Deserialize<S, E> for HashMap<K, V> {
fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> { fn deserialize(state: &mut S) -> Result<HashMap<K, V>, E> {
struct Visitor; struct Visitor;
impl< impl<
K: Deserialize<D, E> + Eq + Hash, K: Deserialize<S, E> + Eq + Hash,
V: Deserialize<D, E>, V: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> self::Visitor<D, HashMap<K, V>, E> for Visitor { > self::Visitor<S, HashMap<K, V>, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<D, E>, Visitor: MapVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> { >(&mut self, state: &mut S, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
let (len, _) = visitor.size_hint(d); let (len, _) = visitor.size_hint(state);
let mut values = HashMap::with_capacity(len); let mut values = HashMap::with_capacity(len);
loop { loop {
match try!(visitor.visit(d)) { match try!(visitor.visit(state)) {
Some((key, value)) => { Some((key, value)) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -385,32 +385,32 @@ impl<
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
impl< impl<
K: Deserialize<D, E> + Eq + Ord, K: Deserialize<S, E> + Eq + Ord,
V: Deserialize<D, E>, V: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> Deserialize<D, E> for TreeMap<K, V> { > Deserialize<S, E> for TreeMap<K, V> {
fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> { fn deserialize(state: &mut S) -> Result<TreeMap<K, V>, E> {
struct Visitor; struct Visitor;
impl< impl<
K: Deserialize<D, E> + Eq + Ord, K: Deserialize<S, E> + Eq + Ord,
V: Deserialize<D, E>, V: Deserialize<S, E>,
D: Deserializer<E>, S: Deserializer<E>,
E, E,
> self::Visitor<D, TreeMap<K, V>, E> for Visitor { > self::Visitor<S, TreeMap<K, V>, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<D, E>, Visitor: MapVisitor<S, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> { >(&mut self, state: &mut S, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
let mut values = TreeMap::new(); let mut values = TreeMap::new();
loop { loop {
match try!(visitor.visit(d)) { match try!(visitor.visit(state)) {
Some((key, value)) => { Some((key, value)) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -424,6 +424,6 @@ impl<
} }
} }
d.visit(&mut Visitor) state.visit(&mut Visitor)
} }
} }
serde2/src/lib.rs
+1 -1
View File
@@ -1,6 +1,6 @@
#![feature(macro_rules)] #![feature(macro_rules)]
//pub use ser::{Serialize, Serializer}; pub use ser::{Serialize, Serializer};
//pub use ser::{Visitor, VisitorState}; //pub use ser::{Visitor, VisitorState};
//pub use ser::GatherTokens; //pub use ser::GatherTokens;