diff --git a/bench_log.rs b/bench_log.rs index 1575b57f..f29540d9 100644 --- a/bench_log.rs +++ b/bench_log.rs @@ -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() } diff --git a/json.rs b/json.rs index aa1a7572..5b593fa4 100644 --- a/json.rs +++ b/json.rs @@ -874,13 +874,15 @@ impl ser::Serializer for Serializer { } #[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 ser::Serializer for Serializer { } #[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 ser::Serializer for Serializer { } #[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 ser::Serializer for PrettySerializer { } #[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 ser::Serializer for PrettySerializer { } #[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 ser::Serializer for PrettySerializer { } #[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() } diff --git a/ser.rs b/ser.rs index 6ae9f944..03da1f98 100644 --- a/ser.rs +++ b/ser.rs @@ -76,15 +76,15 @@ pub trait Serializer { 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(&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(&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(&mut self, v: &T) -> Result<(), E>; fn serialize_enum_end(&mut self) -> Result<(), E>; fn serialize_option(&mut self, v: &Option) -> 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> {