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

simplify serializing tuples/structs/enums

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-06-23 21:14:23 -04:00
parent 9058341234
commit 3f66b05798
3 changed files with 94 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
bench_log.rs
View File

@ -31,32 +31,15 @@ impl ser::Serializable for Http {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Http", 9));
try!(s.serialize_struct_sep("protocol"));
try!(self.protocol.serialize(s));
try!(s.serialize_struct_sep("status"));
try!(self.status.serialize(s));
try!(s.serialize_struct_sep("host_status"));
try!(self.host_status.serialize(s));
try!(s.serialize_struct_sep("up_status"));
try!(self.up_status.serialize(s));
try!(s.serialize_struct_sep("method"));
try!(self.method.serialize(s));
try!(s.serialize_struct_sep("content_type"));
try!(self.content_type.serialize(s));
try!(s.serialize_struct_sep("user_agent"));
try!(self.user_agent.serialize(s));
try!(s.serialize_struct_sep("referer"));
try!(self.referer.serialize(s));
try!(s.serialize_struct_sep("request_uri"));
try!(self.request_uri.serialize(s));
try!(s.serialize_struct_sep("protocol", &self.protocol));
try!(s.serialize_struct_sep("status", &self.status));
try!(s.serialize_struct_sep("host_status", &self.host_status));
try!(s.serialize_struct_sep("up_status", &self.up_status));
try!(s.serialize_struct_sep("method", &self.method));
try!(s.serialize_struct_sep("content_type", &self.content_type));
try!(s.serialize_struct_sep("user_agent", &self.user_agent));
try!(s.serialize_struct_sep("referer", &self.referer));
try!(s.serialize_struct_sep("request_uri", &self.request_uri));
s.serialize_struct_end()
}
@ -138,17 +121,10 @@ impl ser::Serializable for Origin {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Http", 4));
try!(s.serialize_struct_sep("ip"));
try!(self.ip.serialize(s));
try!(s.serialize_struct_sep("port"));
try!(self.port.serialize(s));
try!(s.serialize_struct_sep("hostname"));
try!(self.hostname.serialize(s));
try!(s.serialize_struct_sep("protocol"));
try!(self.protocol.serialize(s));
try!(s.serialize_struct_sep("ip", &self.ip));
try!(s.serialize_struct_sep("port", &self.port));
try!(s.serialize_struct_sep("hostname", &self.hostname));
try!(s.serialize_struct_sep("protocol", &self.protocol));
s.serialize_struct_end()
}
@ -484,41 +460,18 @@ impl ser::Serializable for Log {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Log", 12));
try!(s.serialize_struct_sep("timestamp"));
try!(self.timestamp.serialize(s));
try!(s.serialize_struct_sep("zone_id"));
try!(self.zone_id.serialize(s));
try!(s.serialize_struct_sep("zone_plan"));
try!(self.zone_plan.serialize(s));
try!(s.serialize_struct_sep("http"));
try!(self.http.serialize(s));
try!(s.serialize_struct_sep("origin"));
try!(self.origin.serialize(s));
try!(s.serialize_struct_sep("country"));
try!(self.country.serialize(s));
try!(s.serialize_struct_sep("cache_status"));
try!(self.cache_status.serialize(s));
try!(s.serialize_struct_sep("server_ip"));
try!(self.server_ip.serialize(s));
try!(s.serialize_struct_sep("server_name"));
try!(self.server_name.serialize(s));
try!(s.serialize_struct_sep("remote_ip"));
try!(self.remote_ip.serialize(s));
try!(s.serialize_struct_sep("bytes_dlv"));
try!(self.bytes_dlv.serialize(s));
try!(s.serialize_struct_sep("ray_id"));
try!(self.ray_id.serialize(s));
try!(s.serialize_struct_sep("timestamp", &self.timestamp));
try!(s.serialize_struct_sep("zone_id", &self.zone_id));
try!(s.serialize_struct_sep("zone_plan", &self.zone_plan));
try!(s.serialize_struct_sep("http", &self.http));
try!(s.serialize_struct_sep("origin", &self.origin));
try!(s.serialize_struct_sep("country", &self.country));
try!(s.serialize_struct_sep("cache_status", &self.cache_status));
try!(s.serialize_struct_sep("server_ip", &self.server_ip));
try!(s.serialize_struct_sep("server_name", &self.server_name));
try!(s.serialize_struct_sep("remote_ip", &self.remote_ip));
try!(s.serialize_struct_sep("bytes_dlv", &self.bytes_dlv));
try!(s.serialize_struct_sep("ray_id", &self.ray_id));
s.serialize_struct_end()
}

76
json.rs
View File

@ -874,13 +874,15 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
}
#[inline]
fn serialize_tuple_sep(&mut self) -> Result<(), io::IoError> {
fn serialize_tuple_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
if self.first {
self.first = false;
Ok(())
} else {
self.wr.write_str(",")
try!(self.wr.write_str(","));
}
value.serialize(self)
}
#[inline]
@ -895,14 +897,17 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
}
#[inline]
fn serialize_struct_sep(&mut self, name: &str) -> Result<(), io::IoError> {
fn serialize_struct_sep<
T: Serializable
>(&mut self, name: &str, value: &T) -> Result<(), io::IoError> {
if self.first {
self.first = false;
} else {
try!(self.wr.write_str(","));
}
try!(name.serialize(self));
self.wr.write_str(":")
try!(self.wr.write_str(":"));
value.serialize(self)
}
#[inline]
@ -919,13 +924,15 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
}
#[inline]
fn serialize_enum_sep(&mut self) -> Result<(), io::IoError> {
fn serialize_enum_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
if self.first {
self.first = false;
Ok(())
} else {
self.wr.write_str(",")
try!(self.wr.write_str(","));
}
value.serialize(self)
}
#[inline]
@ -1126,8 +1133,11 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_tuple_sep(&mut self) -> Result<(), io::IoError> {
self.serialize_sep()
fn serialize_tuple_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
try!(self.serialize_sep());
value.serialize(self)
}
#[inline]
@ -1142,10 +1152,13 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_struct_sep(&mut self, name: &str) -> Result<(), io::IoError> {
fn serialize_struct_sep<
T: Serializable
>(&mut self, name: &str, value: &T) -> Result<(), io::IoError> {
try!(self.serialize_sep());
try!(self.serialize_str(name));
self.wr.write_str(": ")
try!(self.wr.write_str(": "));
value.serialize(self)
}
#[inline]
@ -1154,15 +1167,21 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
}
#[inline]
fn serialize_enum_start(&mut self, _name: &str, variant: &str, len: uint) -> Result<(), io::IoError> {
try!(self.serialize_struct_start("", 1));
try!(self.serialize_struct_sep(variant));
self.serialize_tuple_start(len)
fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> Result<(), io::IoError> {
self.first = true;
try!(self.wr.write_str("{"));
try!(self.serialize_sep());
try!(self.serialize_str(variant));
self.first = true;
self.wr.write_str(": [")
}
#[inline]
fn serialize_enum_sep(&mut self) -> Result<(), io::IoError> {
self.serialize_tuple_sep()
fn serialize_enum_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
try!(self.serialize_sep());
value.serialize(self)
}
#[inline]
@ -2237,11 +2256,8 @@ mod tests {
Frog(ref x0, ref x1) => {
try!(s.serialize_enum_start("Animal", "Frog", 2));
try!(s.serialize_enum_sep());
try!(x0.serialize(s));
try!(s.serialize_enum_sep());
try!(x1.serialize(s));
try!(s.serialize_enum_sep(x0));
try!(s.serialize_enum_sep(x1));
s.serialize_enum_end()
}
@ -2309,14 +2325,9 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Inner", 3));
try!(s.serialize_struct_sep("a"));
try!(self.a.serialize(s));
try!(s.serialize_struct_sep("b"));
try!(self.b.serialize(s));
try!(s.serialize_struct_sep("c"));
try!(self.c.serialize(s));
try!(s.serialize_struct_sep("a", &self.a));
try!(s.serialize_struct_sep("b", &self.b));
try!(s.serialize_struct_sep("c", &self.c));
s.serialize_struct_end()
}
@ -2406,8 +2417,7 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Outer", 1));
try!(s.serialize_struct_sep("inner"));
try!(self.inner.serialize(s));
try!(s.serialize_struct_sep("inner", &self.inner));
s.serialize_struct_end()
}

53
ser.rs
View File

@ -76,15 +76,15 @@ pub trait Serializer<E> {
fn serialize_str(&mut self, v: &str) -> Result<(), E>;
fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
fn serialize_tuple_sep(&mut self) -> Result<(), E>;
fn serialize_tuple_sep<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
fn serialize_tuple_end(&mut self) -> Result<(), E>;
fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
fn serialize_struct_sep(&mut self, name: &str) -> Result<(), E>;
fn serialize_struct_sep<T: Serializable>(&mut self, name: &str, v: &T) -> Result<(), E>;
fn serialize_struct_end(&mut self) -> Result<(), E>;
fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
fn serialize_enum_sep(&mut self) -> Result<(), E>;
fn serialize_enum_sep<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
fn serialize_enum_end(&mut self) -> Result<(), E>;
fn serialize_option<T: Serializable>(&mut self, v: &Option<T>) -> Result<(), E>;
@ -248,8 +248,7 @@ macro_rules! impl_serialize_tuple {
try!(s.serialize_tuple_start(len));
$(
try!(s.serialize_tuple_sep());
try!($name.serialize(s));
try!(s.serialize_tuple_sep($name));
)*
s.serialize_tuple_end()
}
@ -287,14 +286,9 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Inner", 3));
try!(s.serialize_struct_sep("a"));
try!(self.a.serialize(s));
try!(s.serialize_struct_sep("b"));
try!(self.b.serialize(s));
try!(s.serialize_struct_sep("c"));
try!(self.c.serialize(s));
try!(s.serialize_struct_sep("a", &self.a));
try!(s.serialize_struct_sep("b", &self.b));
try!(s.serialize_struct_sep("c", &self.c));
s.serialize_struct_end()
}
@ -315,8 +309,7 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Outer", 1));
try!(s.serialize_struct_sep("inner"));
try!(self.inner.serialize(s));
try!(s.serialize_struct_sep("inner", &self.inner));
s.serialize_struct_end()
}
@ -340,14 +333,11 @@ mod tests {
Dog => {
try!(s.serialize_enum_start("Animal", "Dog", 0));
}
Frog(ref x, y) => {
Frog(ref x0, ref x1) => {
try!(s.serialize_enum_start("Animal", "Frog", 2));
try!(s.serialize_enum_sep());
try!(x.serialize(s));
try!(s.serialize_enum_sep());
try!(y.serialize(s));
try!(s.serialize_enum_sep(x0));
try!(s.serialize_enum_sep(x1));
}
}
s.serialize_enum_end()
@ -494,8 +484,11 @@ mod tests {
self.serialize(TupleStart(len))
}
fn serialize_tuple_sep(&mut self) -> Result<(), Error> {
self.serialize(TupleSep)
fn serialize_tuple_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(TupleSep));
value.serialize(self)
}
fn serialize_tuple_end(&mut self) -> Result<(), Error> {
@ -506,8 +499,11 @@ mod tests {
self.serialize(StructStart(name, len))
}
fn serialize_struct_sep(&mut self, name: &str) -> Result<(), Error> {
self.serialize(StructSep(name))
fn serialize_struct_sep<
T: Serializable
>(&mut self, name: &str, value: &T) -> Result<(), Error> {
try!(self.serialize(StructSep(name)));
value.serialize(self)
}
fn serialize_struct_end(&mut self) -> Result<(), Error> {
@ -518,8 +514,11 @@ mod tests {
self.serialize(EnumStart(name, variant, len))
}
fn serialize_enum_sep(&mut self) -> Result<(), Error> {
self.serialize(EnumSep)
fn serialize_enum_sep<
T: Serializable
>(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(EnumSep));
value.serialize(self)
}
fn serialize_enum_end(&mut self) -> Result<(), Error> {