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

wip

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-12-08 23:39:43 -08:00
parent 73a9dd86b9
commit ed6d64ad6d
2 changed files with 164 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
serde2/benches/bench_log.rs
View File

@ -21,6 +21,51 @@ use serde2::de;
use serialize::Encodable; use serialize::Encodable;
enum HttpField {
Protocol,
Status,
HostStatus,
UpStatus,
Method,
ContentType,
UserAgent,
Referer,
RequestUri,
}
impl<
S: Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for HttpField {
fn deserialize(state: &mut S) -> Result<HttpField, E> {
struct Visitor;
impl<
'a,
S: de::Deserializer<E>,
E: de::Error,
> de::Visitor<S, HttpField, E> for Visitor {
fn visit_str(&mut self, value: &str) -> Result<HttpField, E> {
let x = match value {
"protocol" => HttpField::Protocol,
"status" => HttpField::Status,
"host_status" => HttpField::HostStatus,
"up_status" => HttpField::UpStatus,
"method" => HttpField::Method,
"content_type" => HttpField::ContentType,
"user_agent" => HttpField::UserAgent,
"referer" => HttpField::Referer,
"request_uri" => HttpField::RequestUri,
_ => panic!(),
};
Ok(x)
}
}
state.visit(&mut Visitor)
}
}
#[deriving(Show, PartialEq, Encodable, Decodable)] #[deriving(Show, PartialEq, Encodable, Decodable)]
#[deriving_serialize] #[deriving_serialize]
//#[deriving_deserialize] //#[deriving_deserialize]
@ -35,7 +80,6 @@ struct Http {
referer: String, referer: String,
request_uri: String, request_uri: String,
} }
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
E: de::Error, E: de::Error,
@ -62,19 +106,17 @@ impl<
loop { loop {
match try!(visitor.visit_key()) { match try!(visitor.visit_key()) {
Some(s) => { Some(field) => {
let s: String = s; match field {
match s.as_slice() { HttpField::Protocol => { protocol = Some(try!(visitor.visit_value())); }
"protocol" => { protocol = Some(try!(visitor.visit_value())); } HttpField::Status => { status = Some(try!(visitor.visit_value())); }
"status" => { status = Some(try!(visitor.visit_value())); } HttpField::HostStatus => { host_status = Some(try!(visitor.visit_value())); }
"host_status" => { host_status = Some(try!(visitor.visit_value())); } HttpField::UpStatus => { up_status = Some(try!(visitor.visit_value())); }
"up_status" => { up_status = Some(try!(visitor.visit_value())); } HttpField::Method => { method = Some(try!(visitor.visit_value())); }
"method" => { method = Some(try!(visitor.visit_value())); } HttpField::ContentType => { content_type = Some(try!(visitor.visit_value())); }
"content_type" => { content_type = Some(try!(visitor.visit_value())); } HttpField::UserAgent => { user_agent = Some(try!(visitor.visit_value())); }
"user_agent" => { user_agent = Some(try!(visitor.visit_value())); } HttpField::Referer => { referer = Some(try!(visitor.visit_value())); }
"referer" => { referer = Some(try!(visitor.visit_value())); } HttpField::RequestUri => { request_uri = Some(try!(visitor.visit_value())); }
"request_uri" => { request_uri = Some(try!(visitor.visit_value())); }
_ => panic!(),
} }
} }
None => { break; } None => { break; }
@ -237,6 +279,41 @@ impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for CacheStatus
} }
} }
enum OriginField {
Ip,
Port,
Hostname,
Protocol,
}
impl<
S: Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for OriginField {
fn deserialize(state: &mut S) -> Result<OriginField, E> {
struct Visitor;
impl<
'a,
S: de::Deserializer<E>,
E: de::Error,
> de::Visitor<S, OriginField, E> for Visitor {
fn visit_str(&mut self, value: &str) -> Result<OriginField, E> {
let x = match value {
"ip" => OriginField::Ip,
"port" => OriginField::Port,
"hostname" => OriginField::Hostname,
"protocol" => OriginField::Protocol,
_ => panic!(),
};
Ok(x)
}
}
state.visit(&mut Visitor)
}
}
#[deriving(Show, PartialEq, Encodable, Decodable)] #[deriving(Show, PartialEq, Encodable, Decodable)]
#[deriving_serialize] #[deriving_serialize]
//#[deriving_deserialize] //#[deriving_deserialize]
@ -268,14 +345,12 @@ impl<
loop { loop {
match try!(visitor.visit_key()) { match try!(visitor.visit_key()) {
Some(s) => { Some(field) => {
let s: String = s; match field {
match s.as_slice() { OriginField::Ip => { ip = Some(try!(visitor.visit_value())); }
"ip" => { ip = Some(try!(visitor.visit_value())); } OriginField::Port => { port = Some(try!(visitor.visit_value())); }
"port" => { port = Some(try!(visitor.visit_value())); } OriginField::Hostname => { hostname = Some(try!(visitor.visit_value())); }
"hostname" => { hostname = Some(try!(visitor.visit_value())); } OriginField::Protocol => { protocol = Some(try!(visitor.visit_value())); }
"protocol" => { protocol = Some(try!(visitor.visit_value())); }
_ => panic!(),
} }
} }
None => { break; } None => { break; }
@ -673,6 +748,57 @@ impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for Country {
} }
} }
enum LogField {
Timestamp,
ZoneId,
ZonePlan,
Http,
Origin,
Country,
CacheStatus,
ServerIp,
ServerName,
RemoteIp,
BytesDlv,
RayId,
}
impl<
S: Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for LogField {
fn deserialize(state: &mut S) -> Result<LogField, E> {
struct Visitor;
impl<
'a,
S: de::Deserializer<E>,
E: de::Error,
> de::Visitor<S, LogField, E> for Visitor {
fn visit_str(&mut self, value: &str) -> Result<LogField, E> {
let x = match value {
"timestamp" => LogField::Timestamp,
"zone_id" => LogField::ZoneId,
"zone_plan" => LogField::ZonePlan,
"http" => LogField::Http,
"origin" => LogField::Origin,
"country" => LogField::Country,
"cache_status" => LogField::CacheStatus,
"server_ip" => LogField::ServerIp,
"server_name" => LogField::ServerName,
"remote_ip" => LogField::RemoteIp,
"bytes_dlv" => LogField::BytesDlv,
"ray_id" => LogField::RayId,
_ => panic!(),
};
Ok(x)
}
}
state.visit(&mut Visitor)
}
}
#[deriving(Show, PartialEq, Encodable, Decodable)] #[deriving(Show, PartialEq, Encodable, Decodable)]
#[deriving_serialize] #[deriving_serialize]
//#[deriving_deserialize] //#[deriving_deserialize]
@ -720,22 +846,20 @@ impl<
loop { loop {
match try!(visitor.visit_key()) { match try!(visitor.visit_key()) {
Some(s) => { Some(field) => {
let s: String = s; match field {
match s.as_slice() { LogField::Timestamp => { timestamp = Some(try!(visitor.visit_value())); }
"timestamp" => { timestamp = Some(try!(visitor.visit_value())); } LogField::ZoneId => { zone_id = Some(try!(visitor.visit_value())); }
"zone_id" => { zone_id = Some(try!(visitor.visit_value())); } LogField::ZonePlan => { zone_plan = Some(try!(visitor.visit_value())); }
"zone_plan" => { zone_plan = Some(try!(visitor.visit_value())); } LogField::Http => { http = Some(try!(visitor.visit_value())); }
"http" => { http = Some(try!(visitor.visit_value())); } LogField::Origin => { origin = Some(try!(visitor.visit_value())); }
"origin" => { origin = Some(try!(visitor.visit_value())); } LogField::Country => { country = Some(try!(visitor.visit_value())); }
"country" => { country = Some(try!(visitor.visit_value())); } LogField::CacheStatus => { cache_status = Some(try!(visitor.visit_value())); }
"cache_status" => { cache_status = Some(try!(visitor.visit_value())); } LogField::ServerIp => { server_ip = Some(try!(visitor.visit_value())); }
"server_ip" => { server_ip = Some(try!(visitor.visit_value())); } LogField::ServerName => { server_name = Some(try!(visitor.visit_value())); }
"server_name" => { server_name = Some(try!(visitor.visit_value())); } LogField::RemoteIp => { remote_ip = Some(try!(visitor.visit_value())); }
"remote_ip" => { remote_ip = Some(try!(visitor.visit_value())); } LogField::BytesDlv => { bytes_dlv = Some(try!(visitor.visit_value())); }
"bytes_dlv" => { bytes_dlv = Some(try!(visitor.visit_value())); } LogField::RayId => { ray_id = Some(try!(visitor.visit_value())); }
"ray_id" => { ray_id = Some(try!(visitor.visit_value())); }
_ => panic!(),
} }
} }
None => { break; } None => { break; }

4
serde2/src/de.rs
View File

@ -84,7 +84,7 @@ pub trait Visitor<S: Deserializer<E>, R, E: Error> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_str(&mut self, _v: &str) -> Result<R, E> { fn visit_str<'a>(&'a mut self, _v: &'a str) -> Result<R, E> {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
@ -294,7 +294,7 @@ 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, v: &str) -> Result<String, E> { fn visit_str<'a>(&'a mut self, v: &'a str) -> Result<String, E> {
Ok(v.to_string()) Ok(v.to_string())
} }