simplify serializing tuples/structs/enums

ser.rs

@@ -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> {