pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-14 16:21:03 +00:00
Code Issues 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
Download Patch File Download Diff File Expand all files Collapse all files
bench_log.rs
+25 -72
View File
@@ -31,32 +31,15 @@ impl ser::Serializable for Http {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Http", 9)); try!(s.serialize_struct_start("Http", 9));
try!(s.serialize_struct_sep("protocol")); try!(s.serialize_struct_sep("protocol", &self.protocol));
try!(self.protocol.serialize(s)); try!(s.serialize_struct_sep("status", &self.status));
try!(s.serialize_struct_sep("host_status", &self.host_status));
try!(s.serialize_struct_sep("status")); try!(s.serialize_struct_sep("up_status", &self.up_status));
try!(self.status.serialize(s)); try!(s.serialize_struct_sep("method", &self.method));
try!(s.serialize_struct_sep("content_type", &self.content_type));
try!(s.serialize_struct_sep("host_status")); try!(s.serialize_struct_sep("user_agent", &self.user_agent));
try!(self.host_status.serialize(s)); try!(s.serialize_struct_sep("referer", &self.referer));
try!(s.serialize_struct_sep("request_uri", &self.request_uri));
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));
s.serialize_struct_end() s.serialize_struct_end()
} }
@@ -138,17 +121,10 @@ impl ser::Serializable for Origin {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Http", 4)); try!(s.serialize_struct_start("Http", 4));
try!(s.serialize_struct_sep("ip")); try!(s.serialize_struct_sep("ip", &self.ip));
try!(self.ip.serialize(s)); try!(s.serialize_struct_sep("port", &self.port));
try!(s.serialize_struct_sep("hostname", &self.hostname));
try!(s.serialize_struct_sep("port")); try!(s.serialize_struct_sep("protocol", &self.protocol));
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));
s.serialize_struct_end() s.serialize_struct_end()
} }
@@ -484,41 +460,18 @@ impl ser::Serializable for Log {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Log", 12)); try!(s.serialize_struct_start("Log", 12));
try!(s.serialize_struct_sep("timestamp")); try!(s.serialize_struct_sep("timestamp", &self.timestamp));
try!(self.timestamp.serialize(s)); 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("zone_id")); try!(s.serialize_struct_sep("http", &self.http));
try!(self.zone_id.serialize(s)); try!(s.serialize_struct_sep("origin", &self.origin));
try!(s.serialize_struct_sep("country", &self.country));
try!(s.serialize_struct_sep("zone_plan")); try!(s.serialize_struct_sep("cache_status", &self.cache_status));
try!(self.zone_plan.serialize(s)); 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("http")); try!(s.serialize_struct_sep("remote_ip", &self.remote_ip));
try!(self.http.serialize(s)); try!(s.serialize_struct_sep("bytes_dlv", &self.bytes_dlv));
try!(s.serialize_struct_sep("ray_id", &self.ray_id));
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));
s.serialize_struct_end() s.serialize_struct_end()
} }
json.rs
+43 -33
View File
@@ -874,13 +874,15 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
} }
#[inline] #[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 { if self.first {
self.first = false; self.first = false;
Ok(())
} else { } else {
self.wr.write_str(",") try!(self.wr.write_str(","));
} }
value.serialize(self)
} }
#[inline] #[inline]
@@ -895,14 +897,17 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
} }
#[inline] #[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 { if self.first {
self.first = false; self.first = false;
} else { } else {
try!(self.wr.write_str(",")); try!(self.wr.write_str(","));
} }
try!(name.serialize(self)); try!(name.serialize(self));
self.wr.write_str(":") try!(self.wr.write_str(":"));
value.serialize(self)
} }
#[inline] #[inline]
@@ -919,13 +924,15 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
} }
#[inline] #[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 { if self.first {
self.first = false; self.first = false;
Ok(())
} else { } else {
self.wr.write_str(",") try!(self.wr.write_str(","));
} }
value.serialize(self)
} }
#[inline] #[inline]
@@ -1126,8 +1133,11 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
} }
#[inline] #[inline]
fn serialize_tuple_sep(&mut self) -> Result<(), io::IoError> { fn serialize_tuple_sep<
self.serialize_sep() T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
try!(self.serialize_sep());
value.serialize(self)
} }
#[inline] #[inline]
@@ -1142,10 +1152,13 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
} }
#[inline] #[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_sep());
try!(self.serialize_str(name)); try!(self.serialize_str(name));
self.wr.write_str(": ") try!(self.wr.write_str(": "));
value.serialize(self)
} }
#[inline] #[inline]
@@ -1154,15 +1167,21 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
} }
#[inline] #[inline]
fn serialize_enum_start(&mut self, _name: &str, variant: &str, len: uint) -> Result<(), io::IoError> { fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> Result<(), io::IoError> {
try!(self.serialize_struct_start("", 1)); self.first = true;
try!(self.serialize_struct_sep(variant)); try!(self.wr.write_str("{"));
self.serialize_tuple_start(len) try!(self.serialize_sep());
try!(self.serialize_str(variant));
self.first = true;
self.wr.write_str(": [")
} }
#[inline] #[inline]
fn serialize_enum_sep(&mut self) -> Result<(), io::IoError> { fn serialize_enum_sep<
self.serialize_tuple_sep() T: Serializable
>(&mut self, value: &T) -> Result<(), io::IoError> {
try!(self.serialize_sep());
value.serialize(self)
} }
#[inline] #[inline]
@@ -2237,11 +2256,8 @@ mod tests {
Frog(ref x0, ref x1) => { Frog(ref x0, ref x1) => {
try!(s.serialize_enum_start("Animal", "Frog", 2)); try!(s.serialize_enum_start("Animal", "Frog", 2));
try!(s.serialize_enum_sep()); try!(s.serialize_enum_sep(x0));
try!(x0.serialize(s)); try!(s.serialize_enum_sep(x1));
try!(s.serialize_enum_sep());
try!(x1.serialize(s));
s.serialize_enum_end() s.serialize_enum_end()
} }
@@ -2309,14 +2325,9 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Inner", 3)); try!(s.serialize_struct_start("Inner", 3));
try!(s.serialize_struct_sep("a")); try!(s.serialize_struct_sep("a", &self.a));
try!(self.a.serialize(s)); try!(s.serialize_struct_sep("b", &self.b));
try!(s.serialize_struct_sep("c", &self.c));
try!(s.serialize_struct_sep("b"));
try!(self.b.serialize(s));
try!(s.serialize_struct_sep("c"));
try!(self.c.serialize(s));
s.serialize_struct_end() s.serialize_struct_end()
} }
@@ -2406,8 +2417,7 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Outer", 1)); try!(s.serialize_struct_start("Outer", 1));
try!(s.serialize_struct_sep("inner")); try!(s.serialize_struct_sep("inner", &self.inner));
try!(self.inner.serialize(s));
s.serialize_struct_end() s.serialize_struct_end()
} }
ser.rs
+26 -27
View File
@@ -76,15 +76,15 @@ pub trait Serializer<E> {
fn serialize_str(&mut self, v: &str) -> Result<(), E>; fn serialize_str(&mut self, v: &str) -> Result<(), E>;
fn serialize_tuple_start(&mut self, len: uint) -> 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_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_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_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_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_enum_end(&mut self) -> Result<(), E>;
fn serialize_option<T: Serializable>(&mut self, v: &Option<T>) -> 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_start(len));
$( $(
try!(s.serialize_tuple_sep()); try!(s.serialize_tuple_sep($name));
try!($name.serialize(s));
)* )*
s.serialize_tuple_end() s.serialize_tuple_end()
} }
@@ -287,14 +286,9 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Inner", 3)); try!(s.serialize_struct_start("Inner", 3));
try!(s.serialize_struct_sep("a")); try!(s.serialize_struct_sep("a", &self.a));
try!(self.a.serialize(s)); try!(s.serialize_struct_sep("b", &self.b));
try!(s.serialize_struct_sep("c", &self.c));
try!(s.serialize_struct_sep("b"));
try!(self.b.serialize(s));
try!(s.serialize_struct_sep("c"));
try!(self.c.serialize(s));
s.serialize_struct_end() s.serialize_struct_end()
} }
@@ -315,8 +309,7 @@ mod tests {
>(&self, s: &mut S) -> Result<(), E> { >(&self, s: &mut S) -> Result<(), E> {
try!(s.serialize_struct_start("Outer", 1)); try!(s.serialize_struct_start("Outer", 1));
try!(s.serialize_struct_sep("inner")); try!(s.serialize_struct_sep("inner", &self.inner));
try!(self.inner.serialize(s));
s.serialize_struct_end() s.serialize_struct_end()
} }
@@ -340,14 +333,11 @@ mod tests {
Dog => { Dog => {
try!(s.serialize_enum_start("Animal", "Dog", 0)); 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_start("Animal", "Frog", 2));
try!(s.serialize_enum_sep()); try!(s.serialize_enum_sep(x0));
try!(x.serialize(s)); try!(s.serialize_enum_sep(x1));
try!(s.serialize_enum_sep());
try!(y.serialize(s));
} }
} }
s.serialize_enum_end() s.serialize_enum_end()
@@ -494,8 +484,11 @@ mod tests {
self.serialize(TupleStart(len)) self.serialize(TupleStart(len))
} }
fn serialize_tuple_sep(&mut self) -> Result<(), Error> { fn serialize_tuple_sep<
self.serialize(TupleSep) T: Serializable
>(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(TupleSep));
value.serialize(self)
} }
fn serialize_tuple_end(&mut self) -> Result<(), Error> { fn serialize_tuple_end(&mut self) -> Result<(), Error> {
@@ -506,8 +499,11 @@ mod tests {
self.serialize(StructStart(name, len)) self.serialize(StructStart(name, len))
} }
fn serialize_struct_sep(&mut self, name: &str) -> Result<(), Error> { fn serialize_struct_sep<
self.serialize(StructSep(name)) 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> { fn serialize_struct_end(&mut self) -> Result<(), Error> {
@@ -518,8 +514,11 @@ mod tests {
self.serialize(EnumStart(name, variant, len)) self.serialize(EnumStart(name, variant, len))
} }
fn serialize_enum_sep(&mut self) -> Result<(), Error> { fn serialize_enum_sep<
self.serialize(EnumSep) T: Serializable
>(&mut self, value: &T) -> Result<(), Error> {
try!(self.serialize(EnumSep));
value.serialize(self)
} }
fn serialize_enum_end(&mut self) -> Result<(), Error> { fn serialize_enum_end(&mut self) -> Result<(), Error> {