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

wip: refactor

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-12-08 23:13:17 -08:00
parent fcd276176b
commit 73a9dd86b9
4 changed files with 223 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/benches/bench_log.rs
+50 -44
View File
@@ -38,18 +38,18 @@ struct Http {
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> Deserialize<S, E> for Http { > de::Deserialize<S, E> for Http {
fn deserialize(state: &mut S) -> Result<Http, E> { fn deserialize(state: &mut S) -> Result<Http, E> {
struct Visitor; struct Visitor;
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> de::Visitor<S, Http, E> for Visitor { > de::Visitor<S, Http, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, Visitor: de::MapVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Http, E> { >(&mut self, mut visitor: Visitor) -> Result<Http, E> {
let mut protocol = None; let mut protocol = None;
let mut status = None; let mut status = None;
let mut host_status = None; let mut host_status = None;
@@ -61,19 +61,19 @@ impl<
let mut request_uri = None; let mut request_uri = None;
loop { loop {
match try!(visitor.visit_key(state)) { match try!(visitor.visit_key()) {
Some(s) => { Some(s) => {
let s: String = s; let s: String = s;
match s.as_slice() { match s.as_slice() {
"protocol" => { protocol = Some(try!(visitor.visit_value(state))); } "protocol" => { protocol = Some(try!(visitor.visit_value())); }
"status" => { status = Some(try!(visitor.visit_value(state))); } "status" => { status = Some(try!(visitor.visit_value())); }
"host_status" => { host_status = Some(try!(visitor.visit_value(state))); } "host_status" => { host_status = Some(try!(visitor.visit_value())); }
"up_status" => { up_status = Some(try!(visitor.visit_value(state))); } "up_status" => { up_status = Some(try!(visitor.visit_value())); }
"method" => { method = Some(try!(visitor.visit_value(state))); } "method" => { method = Some(try!(visitor.visit_value())); }
"content_type" => { content_type = Some(try!(visitor.visit_value(state))); } "content_type" => { content_type = Some(try!(visitor.visit_value())); }
"user_agent" => { user_agent = Some(try!(visitor.visit_value(state))); } "user_agent" => { user_agent = Some(try!(visitor.visit_value())); }
"referer" => { referer = Some(try!(visitor.visit_value(state))); } "referer" => { referer = Some(try!(visitor.visit_value())); }
"request_uri" => { request_uri = Some(try!(visitor.visit_value(state))); } "request_uri" => { request_uri = Some(try!(visitor.visit_value())); }
_ => panic!(), _ => panic!(),
} }
} }
@@ -133,7 +133,10 @@ impl ser::Serialize for HttpProtocol {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for HttpProtocol { impl<
S: de::Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for HttpProtocol {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<HttpProtocol, E> { fn deserialize(state: &mut S) -> Result<HttpProtocol, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -182,7 +185,10 @@ impl ser::Serialize for HttpMethod {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for HttpMethod { impl<
S: de::Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for HttpMethod {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<HttpMethod, E> { fn deserialize(state: &mut S) -> Result<HttpMethod, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -224,7 +230,7 @@ impl ser::Serialize for CacheStatus {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for CacheStatus { impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for CacheStatus {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<CacheStatus, E> { fn deserialize(state: &mut S) -> Result<CacheStatus, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -243,32 +249,32 @@ struct Origin {
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> Deserialize<S, E> for Origin { > Deserialize<S, E> for Origin {
fn deserialize(state: &mut S) -> Result<Origin, E> { fn deserialize(state: &mut S) -> Result<Origin, E> {
struct Visitor; struct Visitor;
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> de::Visitor<S, Origin, E> for Visitor { > de::Visitor<S, Origin, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, Visitor: de::MapVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Origin, E> { >(&mut self, mut visitor: Visitor) -> Result<Origin, E> {
let mut ip = None; let mut ip = None;
let mut port = None; let mut port = None;
let mut hostname = None; let mut hostname = None;
let mut protocol = None; let mut protocol = None;
loop { loop {
match try!(visitor.visit_key(state)) { match try!(visitor.visit_key()) {
Some(s) => { Some(s) => {
let s: String = s; let s: String = s;
match s.as_slice() { match s.as_slice() {
"ip" => { ip = Some(try!(visitor.visit_value(state))); } "ip" => { ip = Some(try!(visitor.visit_value())); }
"port" => { port = Some(try!(visitor.visit_value(state))); } "port" => { port = Some(try!(visitor.visit_value())); }
"hostname" => { hostname = Some(try!(visitor.visit_value(state))); } "hostname" => { hostname = Some(try!(visitor.visit_value())); }
"protocol" => { protocol = Some(try!(visitor.visit_value(state))); } "protocol" => { protocol = Some(try!(visitor.visit_value())); }
_ => panic!(), _ => panic!(),
} }
} }
@@ -323,7 +329,7 @@ impl ser::Serialize for OriginProtocol {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for OriginProtocol { impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for OriginProtocol {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<OriginProtocol, E> { fn deserialize(state: &mut S) -> Result<OriginProtocol, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -366,7 +372,7 @@ impl ser::Serialize for ZonePlan {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for ZonePlan { impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for ZonePlan {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<ZonePlan, E> { fn deserialize(state: &mut S) -> Result<ZonePlan, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -660,7 +666,7 @@ impl ser::Serialize for Country {
} }
} }
impl<S: de::Deserializer<E>, E> de::Deserialize<S, E> for Country { impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for Country {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<Country, E> { fn deserialize(state: &mut S) -> Result<Country, E> {
de::deserialize_from_primitive(state) de::deserialize_from_primitive(state)
@@ -687,18 +693,18 @@ struct Log {
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> Deserialize<S, E> for Log { > Deserialize<S, E> for Log {
fn deserialize(state: &mut S) -> Result<Log, E> { fn deserialize(state: &mut S) -> Result<Log, E> {
struct Visitor; struct Visitor;
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E, E: de::Error,
> de::Visitor<S, Log, E> for Visitor { > de::Visitor<S, Log, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, Visitor: de::MapVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Log, E> { >(&mut self, mut visitor: Visitor) -> Result<Log, E> {
let mut timestamp = None; let mut timestamp = None;
let mut zone_id = None; let mut zone_id = None;
let mut zone_plan = None; let mut zone_plan = None;
@@ -713,22 +719,22 @@ impl<
let mut ray_id = None; let mut ray_id = None;
loop { loop {
match try!(visitor.visit_key(state)) { match try!(visitor.visit_key()) {
Some(s) => { Some(s) => {
let s: String = s; let s: String = s;
match s.as_slice() { match s.as_slice() {
"timestamp" => { timestamp = Some(try!(visitor.visit_value(state))); } "timestamp" => { timestamp = Some(try!(visitor.visit_value())); }
"zone_id" => { zone_id = Some(try!(visitor.visit_value(state))); } "zone_id" => { zone_id = Some(try!(visitor.visit_value())); }
"zone_plan" => { zone_plan = Some(try!(visitor.visit_value(state))); } "zone_plan" => { zone_plan = Some(try!(visitor.visit_value())); }
"http" => { http = Some(try!(visitor.visit_value(state))); } "http" => { http = Some(try!(visitor.visit_value())); }
"origin" => { origin = Some(try!(visitor.visit_value(state))); } "origin" => { origin = Some(try!(visitor.visit_value())); }
"country" => { country = Some(try!(visitor.visit_value(state))); } "country" => { country = Some(try!(visitor.visit_value())); }
"cache_status" => { cache_status = Some(try!(visitor.visit_value(state))); } "cache_status" => { cache_status = Some(try!(visitor.visit_value())); }
"server_ip" => { server_ip = Some(try!(visitor.visit_value(state))); } "server_ip" => { server_ip = Some(try!(visitor.visit_value())); }
"server_name" => { server_name = Some(try!(visitor.visit_value(state))); } "server_name" => { server_name = Some(try!(visitor.visit_value())); }
"remote_ip" => { remote_ip = Some(try!(visitor.visit_value(state))); } "remote_ip" => { remote_ip = Some(try!(visitor.visit_value())); }
"bytes_dlv" => { bytes_dlv = Some(try!(visitor.visit_value(state))); } "bytes_dlv" => { bytes_dlv = Some(try!(visitor.visit_value())); }
"ray_id" => { ray_id = Some(try!(visitor.visit_value(state))); } "ray_id" => { ray_id = Some(try!(visitor.visit_value())); }
_ => panic!(), _ => panic!(),
} }
} }
serde2/src/bin.rs
+51 -44
View File
@@ -77,24 +77,22 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
match self.next() { match self.next() {
Some(Token::Null) => { Some(Token::Null) => {
visitor.visit_null(self) visitor.visit_null()
} }
Some(Token::Int(v)) => { Some(Token::Int(v)) => {
visitor.visit_int(self, v) visitor.visit_int(v)
} }
Some(Token::String(v)) => { Some(Token::String(v)) => {
visitor.visit_string(self, v) visitor.visit_string(v)
} }
Some(Token::Option(is_some)) => { Some(Token::Option(is_some)) => {
visitor.visit_option(self, MyOptionVisitor { visitor.visit_option(MyOptionVisitor { d: self, is_some: is_some })
is_some: is_some,
})
} }
Some(Token::SeqStart(len)) => { Some(Token::SeqStart(len)) => {
visitor.visit_seq(self, MySeqVisitor { len: len }) visitor.visit_seq(MySeqVisitor { d: self, len: len })
} }
Some(Token::MapStart(len)) => { Some(Token::MapStart(len)) => {
visitor.visit_map(self, MyMapVisitor { len: len }) visitor.visit_map(MyMapVisitor { d: self, len: len })
} }
Some(Token::End) => { Some(Token::End) => {
Err(Error::syntax_error()) Err(Error::syntax_error())
@@ -112,18 +110,21 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
match self.peek() { match self.peek() {
Some(&Token::Null) => { Some(&Token::Null) => {
self.next(); self.next();
visitor.visit_option(self, MyOptionVisitor { visitor.visit_option(MyOptionVisitor {
d: self,
is_some: false, is_some: false,
}) })
} }
Some(&Token::Option(is_some)) => { Some(&Token::Option(is_some)) => {
self.next(); self.next();
visitor.visit_option(self, MyOptionVisitor { visitor.visit_option(MyOptionVisitor {
d: self,
is_some: is_some, is_some: is_some,
}) })
} }
_ => { _ => {
visitor.visit_option(self, MyOptionVisitor { visitor.visit_option(MyOptionVisitor {
d: self,
is_some: true, is_some: true,
}) })
} }
@@ -131,19 +132,21 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
} }
} }
struct MyOptionVisitor { struct MyOptionVisitor<'a, Iter: 'a> {
d: &'a mut MyDeserializer<Iter>,
is_some: bool, is_some: bool,
} }
impl< impl<
'a,
Iter: Iterator<Token>, Iter: Iterator<Token>,
> de::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor { > de::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor<'a, Iter> {
fn visit< fn visit<
T: Deserialize<MyDeserializer<Iter>, Error>, T: Deserialize<MyDeserializer<Iter>, Error>,
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> { >(&mut self) -> Result<option::Option<T>, Error> {
if self.is_some { if self.is_some {
self.is_some = false; self.is_some = false;
let value = try!(Deserialize::deserialize(d)); let value = try!(Deserialize::deserialize(self.d));
Ok(Some(value)) Ok(Some(value))
} else { } else {
Ok(None) Ok(None)
@@ -151,26 +154,28 @@ impl<
} }
} }
struct MySeqVisitor { struct MySeqVisitor<'a, Iter: 'a> {
d: &'a mut MyDeserializer<Iter>,
len: uint, len: uint,
} }
impl< impl<
'a,
Iter: Iterator<Token>, Iter: Iterator<Token>,
> de::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor { > de::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor<'a, Iter> {
fn visit< fn visit<
T: Deserialize<MyDeserializer<Iter>, Error> T: Deserialize<MyDeserializer<Iter>, Error>
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> { >(&mut self) -> Result<option::Option<T>, Error> {
use serde2::de::Error; use serde2::de::Error;
match d.peek() { match self.d.peek() {
Some(&Token::End) => { Some(&Token::End) => {
d.next(); self.d.next();
Ok(None) Ok(None)
} }
Some(_) => { Some(_) => {
self.len -= 1; self.len -= 1;
let value = try!(Deserialize::deserialize(d)); let value = try!(Deserialize::deserialize(self.d));
Ok(Some(value)) Ok(Some(value))
} }
None => { None => {
@@ -179,42 +184,44 @@ impl<
} }
} }
fn end(&mut self, d: &mut MyDeserializer<Iter>) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
use serde2::de::Error; use serde2::de::Error;
match d.next() { match self.d.next() {
Some(Token::End) => Ok(()), Some(Token::End) => Ok(()),
Some(_) => Err(Error::syntax_error()), Some(_) => Err(Error::syntax_error()),
None => Err(Error::end_of_stream_error()), None => Err(Error::end_of_stream_error()),
} }
} }
fn size_hint(&self, _d: &mut MyDeserializer<Iter>) -> (uint, option::Option<uint>) { fn size_hint(&self) -> (uint, option::Option<uint>) {
(self.len, Some(self.len)) (self.len, Some(self.len))
} }
} }
struct MyMapVisitor { struct MyMapVisitor<'a, Iter: 'a> {
d: &'a mut MyDeserializer<Iter>,
len: uint, len: uint,
} }
impl< impl<
'a,
Iter: Iterator<Token>, Iter: Iterator<Token>,
> de::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor { > de::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor<'a, Iter> {
fn visit_key< fn visit_key<
K: Deserialize<MyDeserializer<Iter>, Error>, K: Deserialize<MyDeserializer<Iter>, Error>,
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<K>, Error> { >(&mut self) -> Result<option::Option<K>, Error> {
use serde2::de::Error; use serde2::de::Error;
match d.peek() { match self.d.peek() {
Some(&Token::End) => { Some(&Token::End) => {
d.next(); self.d.next();
Ok(None) Ok(None)
} }
Some(_) => { Some(_) => {
self.len -= 1; self.len -= 1;
Ok(Some(try!(Deserialize::deserialize(d)))) Ok(Some(try!(Deserialize::deserialize(self.d))))
} }
None => { None => {
Err(Error::syntax_error()) Err(Error::syntax_error())
@@ -224,21 +231,21 @@ impl<
fn visit_value< fn visit_value<
V: Deserialize<MyDeserializer<Iter>, Error>, V: Deserialize<MyDeserializer<Iter>, Error>,
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<V, Error> { >(&mut self) -> Result<V, Error> {
Ok(try!(Deserialize::deserialize(d))) Ok(try!(Deserialize::deserialize(self.d)))
} }
fn end(&mut self, d: &mut MyDeserializer<Iter>) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
use serde2::de::Error; use serde2::de::Error;
match d.next() { match self.d.next() {
Some(Token::End) => Ok(()), Some(Token::End) => Ok(()),
Some(_) => Err(Error::syntax_error()), Some(_) => Err(Error::syntax_error()),
None => Err(Error::end_of_stream_error()), None => Err(Error::end_of_stream_error()),
} }
} }
fn size_hint(&self, _d: &mut MyDeserializer<Iter>) -> (uint, option::Option<uint>) { fn size_hint(&self) -> (uint, option::Option<uint>) {
(self.len, Some(self.len)) (self.len, Some(self.len))
} }
} }
@@ -270,11 +277,11 @@ mod json {
D: de::Deserializer<E>, D: de::Deserializer<E>,
E: de::Error, E: de::Error,
> de::Visitor<D, Value, E> for Visitor { > de::Visitor<D, Value, E> for Visitor {
fn visit_null(&mut self, _d: &mut D) -> Result<Value, E> { fn visit_null(&mut self) -> Result<Value, E> {
Ok(Value::Null) Ok(Value::Null)
} }
fn visit_int(&mut self, _d: &mut D, v: int) -> Result<Value, E> { fn visit_int(&mut self, v: int) -> Result<Value, E> {
Ok(Value::Int(v)) Ok(Value::Int(v))
} }
@@ -286,8 +293,8 @@ mod json {
fn visit_option< fn visit_option<
Visitor: de::OptionVisitor<D, E>, Visitor: de::OptionVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, mut visitor: Visitor) -> Result<Value, E> {
match try!(visitor.visit(d)) { match try!(visitor.visit()) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Ok(Value::Null), None => Ok(Value::Null),
} }
@@ -295,12 +302,12 @@ mod json {
fn visit_seq< fn visit_seq<
Visitor: de::SeqVisitor<D, E>, Visitor: de::SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, mut visitor: Visitor) -> Result<Value, E> {
let (len, _) = visitor.size_hint(d); let (len, _) = visitor.size_hint();
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()) {
Some(value) => { Some(value) => {
values.push(value); values.push(value);
} }
@@ -315,11 +322,11 @@ mod json {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<D, E>, Visitor: de::MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, mut visitor: Visitor) -> Result<Value, E> {
let mut values = TreeMap::new(); let mut values = TreeMap::new();
loop { loop {
match try!(visitor.visit(d)) { match try!(visitor.visit()) {
Some((key, value)) => { Some((key, value)) => {
values.insert(key, value); values.insert(key, value);
} }
serde2/src/de.rs
+60 -60
View File
@@ -28,85 +28,85 @@ pub trait Deserializer<E> {
} }
pub trait Visitor<S: Deserializer<E>, R, E: Error> { pub trait Visitor<S: Deserializer<E>, R, E: Error> {
fn visit_null(&mut self, state: &mut S) -> Result<R, E> { fn visit_null(&mut self) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_bool(&mut self, state: &mut S, _v: bool) -> Result<R, E> { fn visit_bool(&mut self, _v: bool) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_int(&mut self, state: &mut S, v: int) -> Result<R, E> { fn visit_int(&mut self, v: int) -> Result<R, E> {
self.visit_i64(state, v as i64) self.visit_i64(v as i64)
} }
fn visit_i8(&mut self, state: &mut S, v: i8) -> Result<R, E> { fn visit_i8(&mut self, v: i8) -> Result<R, E> {
self.visit_i64(state, v as i64) self.visit_i64(v as i64)
} }
fn visit_i16(&mut self, state: &mut S, v: i16) -> Result<R, E> { fn visit_i16(&mut self, v: i16) -> Result<R, E> {
self.visit_i64(state, v as i64) self.visit_i64(v as i64)
} }
fn visit_i32(&mut self, state: &mut S, v: i32) -> Result<R, E> { fn visit_i32(&mut self, v: i32) -> Result<R, E> {
self.visit_i64(state, v as i64) self.visit_i64(v as i64)
} }
fn visit_i64(&mut self, state: &mut S, _v: i64) -> Result<R, E> { fn visit_i64(&mut self, _v: i64) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_uint(&mut self, state: &mut S, v: uint) -> Result<R, E> { fn visit_uint(&mut self, v: uint) -> Result<R, E> {
self.visit_u64(state, v as u64) self.visit_u64(v as u64)
} }
fn visit_u8(&mut self, state: &mut S, v: u8) -> Result<R, E> { fn visit_u8(&mut self, v: u8) -> Result<R, E> {
self.visit_u64(state, v as u64) self.visit_u64(v as u64)
} }
fn visit_u16(&mut self, state: &mut S, v: u16) -> Result<R, E> { fn visit_u16(&mut self, v: u16) -> Result<R, E> {
self.visit_u64(state, v as u64) self.visit_u64(v as u64)
} }
fn visit_u32(&mut self, state: &mut S, v: u32) -> Result<R, E> { fn visit_u32(&mut self, v: u32) -> Result<R, E> {
self.visit_u64(state, v as u64) self.visit_u64(v as u64)
} }
fn visit_u64(&mut self, state: &mut S, _v: u64) -> Result<R, E> { fn visit_u64(&mut self, _v: u64) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_f32(&mut self, state: &mut S, v: f32) -> Result<R, E> { fn visit_f32(&mut self, v: f32) -> Result<R, E> {
self.visit_f64(state, v as f64) self.visit_f64(v as f64)
} }
fn visit_f64(&mut self, state: &mut S, _v: f64) -> Result<R, E> { fn visit_f64(&mut self, _v: f64) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_str(&mut self, state: &mut S, _v: &str) -> Result<R, E> { fn visit_str(&mut self, _v: &str) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_string(&mut self, state: &mut S, v: String) -> Result<R, E> { fn visit_string(&mut self, v: String) -> Result<R, E> {
self.visit_str(state, v.as_slice()) self.visit_str(v.as_slice())
} }
fn visit_option< fn visit_option<
V: OptionVisitor<S, E>, V: OptionVisitor<S, E>,
>(&mut self, state: &mut S, _visitor: V) -> Result<R, E> { >(&mut self, _visitor: V) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_seq< fn visit_seq<
V: SeqVisitor<S, E>, V: SeqVisitor<S, E>,
>(&mut self, state: &mut S, _visitor: V) -> Result<R, E> { >(&mut self, _visitor: V) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_map< fn visit_map<
V: MapVisitor<S, E>, V: MapVisitor<S, E>,
>(&mut self, state: &mut S, _visitor: V) -> Result<R, E> { >(&mut self, _visitor: V) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
} }
@@ -114,18 +114,18 @@ pub trait Visitor<S: Deserializer<E>, R, E: Error> {
pub trait OptionVisitor<S, E> { pub trait OptionVisitor<S, E> {
fn visit< fn visit<
T: Deserialize<S, E>, T: Deserialize<S, E>,
>(&mut self, state: &mut S) -> Result<Option<T>, E>; >(&mut self) -> Result<Option<T>, E>;
} }
pub trait SeqVisitor<S, E> { pub trait SeqVisitor<S, E> {
fn visit< fn visit<
T: Deserialize<S, E>, T: Deserialize<S, E>,
>(&mut self, state: &mut S) -> Result<Option<T>, E>; >(&mut self) -> Result<Option<T>, E>;
fn end(&mut self, state: &mut S) -> Result<(), E>; fn end(&mut self) -> Result<(), E>;
#[inline] #[inline]
fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
(0, None) (0, None)
} }
} }
@@ -134,10 +134,10 @@ pub trait MapVisitor<S, E> {
fn visit< fn visit<
K: Deserialize<S, E>, K: Deserialize<S, E>,
V: Deserialize<S, E>, V: Deserialize<S, E>,
>(&mut self, state: &mut S) -> Result<Option<(K, V)>, E> { >(&mut self) -> Result<Option<(K, V)>, E> {
match try!(self.visit_key(state)) { match try!(self.visit_key()) {
Some(key) => { Some(key) => {
let value = try!(self.visit_value(state)); let value = try!(self.visit_value());
Ok(Some((key, value))) Ok(Some((key, value)))
} }
None => Ok(None) None => Ok(None)
@@ -146,16 +146,16 @@ pub trait MapVisitor<S, E> {
fn visit_key< fn visit_key<
K: Deserialize<S, E>, K: Deserialize<S, E>,
>(&mut self, state: &mut S) -> Result<Option<K>, E>; >(&mut self) -> Result<Option<K>, E>;
fn visit_value< fn visit_value<
V: Deserialize<S, E>, V: Deserialize<S, E>,
>(&mut self, state: &mut S) -> Result<V, E>; >(&mut self) -> Result<V, E>;
fn end(&mut self, state: &mut S) -> Result<(), E>; fn end(&mut self) -> Result<(), E>;
#[inline] #[inline]
fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
(0, None) (0, None)
} }
} }
@@ -173,14 +173,14 @@ impl<
S: Deserializer<E>, S: Deserializer<E>,
E: Error, E: Error,
> self::Visitor<S, (), E> for Visitor { > self::Visitor<S, (), E> for Visitor {
fn visit_null(&mut self, _state: &mut S) -> Result<(), E> { fn visit_null(&mut self) -> Result<(), E> {
Ok(()) Ok(())
} }
fn visit_seq< fn visit_seq<
V: SeqVisitor<S, E>, V: SeqVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: V) -> Result<(), E> { >(&mut self, mut visitor: V) -> Result<(), E> {
try!(visitor.end(state)); try!(visitor.end());
Ok(()) Ok(())
} }
} }
@@ -202,7 +202,7 @@ impl<
S: Deserializer<E>, S: Deserializer<E>,
E: Error, E: Error,
> self::Visitor<S, bool, E> for Visitor { > self::Visitor<S, bool, E> for Visitor {
fn visit_bool(&mut self, _state: &mut S, v: bool) -> Result<bool, E> { fn visit_bool(&mut self, v: bool) -> Result<bool, E> {
Ok(v) Ok(v)
} }
} }
@@ -215,7 +215,7 @@ impl<
macro_rules! impl_deserialize_num_method { macro_rules! impl_deserialize_num_method {
($src_ty:ty, $method:ident, $from_method:ident) => { ($src_ty:ty, $method:ident, $from_method:ident) => {
fn $method(&mut self, state: &mut S, v: $src_ty) -> Result<T, E> { fn $method(&mut self, v: $src_ty) -> Result<T, E> {
match FromPrimitive::$from_method(v) { match FromPrimitive::$from_method(v) {
Some(v) => Ok(v), Some(v) => Ok(v),
None => Err(Error::syntax_error()), None => Err(Error::syntax_error()),
@@ -294,11 +294,11 @@ impl<
S: Deserializer<E>, S: Deserializer<E>,
E: Error, E: Error,
> self::Visitor<S, String, E> for Visitor { > self::Visitor<S, String, E> for Visitor {
fn visit_str(&mut self, _state: &mut S, v: &str) -> Result<String, E> { fn visit_str(&mut self, v: &str) -> Result<String, E> {
Ok(v.to_string()) Ok(v.to_string())
} }
fn visit_string(&mut self, _state: &mut S, v: String) -> Result<String, E> { fn visit_string(&mut self, v: String) -> Result<String, E> {
Ok(v) Ok(v)
} }
} }
@@ -324,8 +324,8 @@ impl<
> self::Visitor<S, Option<T>, E> for Visitor { > self::Visitor<S, Option<T>, E> for Visitor {
fn visit_option< fn visit_option<
V: OptionVisitor<S, E>, V: OptionVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: V) -> Result<Option<T>, E> { >(&mut self, mut visitor: V) -> Result<Option<T>, E> {
visitor.visit(state) visitor.visit()
} }
} }
@@ -350,12 +350,12 @@ impl<
> self::Visitor<S, Vec<T>, E> for Visitor { > self::Visitor<S, Vec<T>, E> for Visitor {
fn visit_seq< fn visit_seq<
V: SeqVisitor<S, E>, V: SeqVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: V) -> Result<Vec<T>, E> { >(&mut self, mut visitor: V) -> Result<Vec<T>, E> {
let (len, _) = visitor.size_hint(state); let (len, _) = visitor.size_hint();
let mut values = Vec::with_capacity(len); let mut values = Vec::with_capacity(len);
loop { loop {
match try!(visitor.visit(state)) { match try!(visitor.visit()) {
Some(value) => { Some(value) => {
values.push(value); values.push(value);
} }
@@ -403,15 +403,15 @@ macro_rules! impl_deserialize_tuple {
> self::Visitor<S, ($($name,)+), E> for Visitor { > self::Visitor<S, ($($name,)+), E> for Visitor {
fn visit_seq< fn visit_seq<
V: SeqVisitor<S, E>, V: SeqVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: V) -> Result<($($name,)+), E> { >(&mut self, mut visitor: V) -> Result<($($name,)+), E> {
$( $(
let $name = match try!(visitor.visit(state)) { let $name = match try!(visitor.visit()) {
Some(value) => value, Some(value) => value,
None => { return Err(Error::end_of_stream_error()); } None => { return Err(Error::end_of_stream_error()); }
}; };
)+; )+;
try!(visitor.end(state)); try!(visitor.end());
Ok(($($name,)+)) Ok(($($name,)+))
} }
@@ -444,12 +444,12 @@ impl<
> self::Visitor<S, HashMap<K, V>, E> for Visitor { > self::Visitor<S, HashMap<K, V>, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<S, E>, Visitor: MapVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<HashMap<K, V>, E> { >(&mut self, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
let (len, _) = visitor.size_hint(state); let (len, _) = visitor.size_hint();
let mut values = HashMap::with_capacity(len); let mut values = HashMap::with_capacity(len);
loop { loop {
match try!(visitor.visit(state)) { match try!(visitor.visit()) {
Some((key, value)) => { Some((key, value)) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -484,11 +484,11 @@ impl<
> self::Visitor<S, TreeMap<K, V>, E> for Visitor { > self::Visitor<S, TreeMap<K, V>, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<S, E>, Visitor: MapVisitor<S, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> { >(&mut self, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
let mut values = TreeMap::new(); let mut values = TreeMap::new();
loop { loop {
match try!(visitor.visit(state)) { match try!(visitor.visit()) {
Some((key, value)) => { Some((key, value)) => {
values.insert(key, value); values.insert(key, value);
} }
serde2/src/json/de.rs
+62 -59
View File
@@ -94,29 +94,30 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
match self.ch_or_null() { match self.ch_or_null() {
b'n' => { b'n' => {
try!(self.parse_ident(b"ull")); try!(self.parse_ident(b"ull"));
visitor.visit_null(self) visitor.visit_null()
} }
b't' => { b't' => {
try!(self.parse_ident(b"rue")); try!(self.parse_ident(b"rue"));
visitor.visit_bool(self, true) visitor.visit_bool(true)
} }
b'f' => { b'f' => {
try!(self.parse_ident(b"alse")); try!(self.parse_ident(b"alse"));
visitor.visit_bool(self, false) visitor.visit_bool(false)
} }
b'0' ... b'9' | b'-' => self.parse_number(visitor), b'0' ... b'9' | b'-' => self.parse_number(visitor),
b'"' => { b'"' => {
try!(self.parse_string()); try!(self.parse_string());
let s = String::from_utf8(self.buf.clone()).unwrap(); //let s = String::from_utf8(self.buf.clone()).unwrap();
visitor.visit_string(self, s) let s = str::from_utf8(self.buf.as_slice()).unwrap();
visitor.visit_str(s)
} }
b'[' => { b'[' => {
self.bump(); self.bump();
visitor.visit_seq(self, SeqVisitor { first: true }) visitor.visit_seq(SeqVisitor { parser: self, first: true })
} }
b'{' => { b'{' => {
self.bump(); self.bump();
visitor.visit_map(self, MapVisitor { first: true }) visitor.visit_map(MapVisitor { parser: self, first: true })
} }
_ => { _ => {
Err(self.error(ErrorCode::ExpectedSomeValue)) Err(self.error(ErrorCode::ExpectedSomeValue))
@@ -160,9 +161,9 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
res = try!(self.parse_exponent(res)); res = try!(self.parse_exponent(res));
} }
visitor.visit_f64(self, neg * res) visitor.visit_f64(neg * res)
} else { } else {
visitor.visit_i64(self, neg * res) visitor.visit_i64(neg * res)
} }
} }
@@ -389,114 +390,116 @@ impl<Iter: Iterator<u8>> Deserializer<Error> for Parser<Iter> {
} }
} }
struct SeqVisitor { struct SeqVisitor<'a, Iter: 'a> {
parser: &'a mut Parser<Iter>,
first: bool, first: bool,
} }
impl<Iter: Iterator<u8>> de::SeqVisitor<Parser<Iter>, Error> for SeqVisitor { impl<'a, Iter: Iterator<u8>> de::SeqVisitor<Parser<Iter>, Error> for SeqVisitor<'a, Iter> {
fn visit< fn visit<
T: de::Deserialize<Parser<Iter>, Error>, T: de::Deserialize<Parser<Iter>, Error>,
>(&mut self, d: &mut Parser<Iter>) -> Result<Option<T>, Error> { >(&mut self) -> Result<Option<T>, Error> {
d.parse_whitespace(); self.parser.parse_whitespace();
if d.ch_is(b']') { if self.parser.ch_is(b']') {
d.bump(); self.parser.bump();
return Ok(None); return Ok(None);
} }
if self.first { if self.first {
self.first = false; self.first = false;
} else { } else {
if d.ch_is(b',') { if self.parser.ch_is(b',') {
d.bump(); self.parser.bump();
} else if d.eof() { } else if self.parser.eof() {
return Err(d.error(ErrorCode::EOFWhileParsingList)); return Err(self.parser.error(ErrorCode::EOFWhileParsingList));
} else { } else {
return Err(d.error(ErrorCode::ExpectedListCommaOrEnd)); return Err(self.parser.error(ErrorCode::ExpectedListCommaOrEnd));
} }
} }
let value = try!(de::Deserialize::deserialize(d)); let value = try!(de::Deserialize::deserialize(self.parser));
Ok(Some(value)) Ok(Some(value))
} }
fn end(&mut self, d: &mut Parser<Iter>) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
if d.ch_is(b']') { if self.parser.ch_is(b']') {
d.bump(); self.parser.bump();
Ok(()) Ok(())
} else if d.eof() { } else if self.parser.eof() {
Err(d.error(ErrorCode::EOFWhileParsingList)) Err(self.parser.error(ErrorCode::EOFWhileParsingList))
} else { } else {
Err(d.error(ErrorCode::TrailingCharacters)) Err(self.parser.error(ErrorCode::TrailingCharacters))
} }
} }
} }
struct MapVisitor { struct MapVisitor<'a, Iter: 'a> {
parser: &'a mut Parser<Iter>,
first: bool, first: bool,
} }
impl<Iter: Iterator<u8>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor { impl<'a, Iter: Iterator<u8>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor<'a, Iter> {
fn visit_key< fn visit_key<
K: de::Deserialize<Parser<Iter>, Error>, K: de::Deserialize<Parser<Iter>, Error>,
>(&mut self, d: &mut Parser<Iter>) -> Result<Option<K>, Error> { >(&mut self) -> Result<Option<K>, Error> {
d.parse_whitespace(); self.parser.parse_whitespace();
if d.ch_is(b'}') { if self.parser.ch_is(b'}') {
d.bump(); self.parser.bump();
return Ok(None); return Ok(None);
} }
if self.first { if self.first {
self.first = false; self.first = false;
} else { } else {
if d.ch_is(b',') { if self.parser.ch_is(b',') {
d.bump(); self.parser.bump();
d.parse_whitespace(); self.parser.parse_whitespace();
} else if d.eof() { } else if self.parser.eof() {
return Err(d.error(ErrorCode::EOFWhileParsingObject)); return Err(self.parser.error(ErrorCode::EOFWhileParsingObject));
} else { } else {
return Err(d.error(ErrorCode::ExpectedObjectCommaOrEnd)); return Err(self.parser.error(ErrorCode::ExpectedObjectCommaOrEnd));
} }
} }
if d.eof() { if self.parser.eof() {
return Err(d.error(ErrorCode::EOFWhileParsingValue)); return Err(self.parser.error(ErrorCode::EOFWhileParsingValue));
} }
if !d.ch_is(b'"') { if !self.parser.ch_is(b'"') {
return Err(d.error(ErrorCode::KeyMustBeAString)); return Err(self.parser.error(ErrorCode::KeyMustBeAString));
} }
Ok(Some(try!(de::Deserialize::deserialize(d)))) Ok(Some(try!(de::Deserialize::deserialize(self.parser))))
} }
fn visit_value< fn visit_value<
V: de::Deserialize<Parser<Iter>, Error>, V: de::Deserialize<Parser<Iter>, Error>,
>(&mut self, d: &mut Parser<Iter>) -> Result<V, Error> { >(&mut self) -> Result<V, Error> {
d.parse_whitespace(); self.parser.parse_whitespace();
if d.ch_is(b':') { if self.parser.ch_is(b':') {
d.bump(); self.parser.bump();
} else if d.eof() { } else if self.parser.eof() {
return Err(d.error(ErrorCode::EOFWhileParsingObject)); return Err(self.parser.error(ErrorCode::EOFWhileParsingObject));
} else { } else {
return Err(d.error(ErrorCode::ExpectedColon)); return Err(self.parser.error(ErrorCode::ExpectedColon));
} }
d.parse_whitespace(); self.parser.parse_whitespace();
Ok(try!(de::Deserialize::deserialize(d))) Ok(try!(de::Deserialize::deserialize(self.parser)))
} }
fn end(&mut self, d: &mut Parser<Iter>) -> Result<(), Error> { fn end(&mut self) -> Result<(), Error> {
if d.ch_is(b']') { if self.parser.ch_is(b']') {
d.bump(); self.parser.bump();
Ok(()) Ok(())
} else if d.eof() { } else if self.parser.eof() {
Err(d.error(ErrorCode::EOFWhileParsingList)) Err(self.parser.error(ErrorCode::EOFWhileParsingList))
} else { } else {
Err(d.error(ErrorCode::TrailingCharacters)) Err(self.parser.error(ErrorCode::TrailingCharacters))
} }
} }
} }