Merge pull request #245 from alexcrichton/tuples

Support fixed-length arrays

src/ser.rs

@@ -741,9 +741,9 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
     type Ok = ();
     type Error = Error;
     type SerializeSeq = SerializeSeq<'a, 'b>;
-    type SerializeTuple = ser::Impossible<(), Error>;
-    type SerializeTupleStruct = ser::Impossible<(), Error>;
-    type SerializeTupleVariant = ser::Impossible<(), Error>;
+    type SerializeTuple = SerializeSeq<'a, 'b>;
+    type SerializeTupleStruct = SerializeSeq<'a, 'b>;
+    type SerializeTupleVariant = SerializeSeq<'a, 'b>;
     type SerializeMap = SerializeTable<'a, 'b>;
     type SerializeStruct = SerializeTable<'a, 'b>;
     type SerializeStructVariant = ser::Impossible<(), Error>;
@@ -892,23 +892,23 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         })
     }
 
-    fn serialize_tuple(self, _len: usize)
+    fn serialize_tuple(self, len: usize)
                        -> Result<Self::SerializeTuple, Self::Error> {
-        Err(Error::UnsupportedType)
+        self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize)
+    fn serialize_tuple_struct(self, _name: &'static str, len: usize)
                               -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(Error::UnsupportedType)
+        self.serialize_seq(Some(len))
     }
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
                                _variant_index: u32,
                                _variant: &'static str,
-                               _len: usize)
+                               len: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(Error::UnsupportedType)
+        self.serialize_seq(Some(len))
     }
 
     fn serialize_map(self, _len: Option<usize>)
@@ -998,6 +998,51 @@ impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> {
     }
 }
 
+impl<'a, 'b> ser::SerializeTuple for SerializeSeq<'a, 'b> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+        where T: ser::Serialize,
+    {
+        ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        ser::SerializeSeq::end(self)
+    }
+}
+
+impl<'a, 'b> ser::SerializeTupleVariant for SerializeSeq<'a, 'b> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+        where T: ser::Serialize,
+    {
+        ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        ser::SerializeSeq::end(self)
+    }
+}
+
+impl<'a, 'b> ser::SerializeTupleStruct for SerializeSeq<'a, 'b> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+        where T: ser::Serialize,
+    {
+        ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        ser::SerializeSeq::end(self)
+    }
+}
+
 impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
     type Ok = ();
     type Error = Error;
@@ -1543,9 +1588,9 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
     type Ok = Category;
     type Error = E;
     type SerializeSeq = Self;
-    type SerializeTuple = ser::Impossible<Category, E>;
-    type SerializeTupleStruct = ser::Impossible<Category, E>;
-    type SerializeTupleVariant = ser::Impossible<Category, E>;
+    type SerializeTuple = Self;
+    type SerializeTupleStruct = Self;
+    type SerializeTupleVariant = Self;
     type SerializeMap = Self;
     type SerializeStruct = Self;
     type SerializeStructVariant = ser::Impossible<Category, E>;
@@ -1639,15 +1684,15 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
     }
 
     fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
+        Ok(self)
     }
 
     fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
+        Ok(self)
     }
 
     fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
+        Ok(self)
     }
 
     fn serialize_map(self, _: Option<usize>) -> Result<Self, Self::Error> {
@@ -1677,6 +1722,48 @@ impl<E: ser::Error> ser::SerializeSeq for Categorize<E> {
     }
 }
 
+impl<E: ser::Error> ser::SerializeTuple for Categorize<E> {
+    type Ok = Category;
+    type Error = E;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T)
+                                                     -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(Category::Array)
+    }
+}
+
+impl<E: ser::Error> ser::SerializeTupleVariant for Categorize<E> {
+    type Ok = Category;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T)
+                                                   -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(Category::Array)
+    }
+}
+
+impl<E: ser::Error> ser::SerializeTupleStruct for Categorize<E> {
+    type Ok = Category;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T)
+                                                   -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(Category::Array)
+    }
+}
+
 impl<E: ser::Error> ser::SerializeMap for Categorize<E> {
     type Ok = Category;
     type Error = E;

test-suite/tests/serde.rs

@@ -569,10 +569,23 @@ fn table_structs_empty() {
     expected.insert("bar".to_string(), CanBeEmpty::default());
     expected.insert("baz".to_string(), CanBeEmpty::default());
     expected.insert(
-        "bazv".to_string(), 
+        "bazv".to_string(),
         CanBeEmpty {a: Some("foo".to_string()), b: None},
     );
     expected.insert("foo".to_string(), CanBeEmpty::default());
     assert_eq!(value, expected);
     assert_eq!(toml::to_string(&value).unwrap(), text);
 }
+
+#[test]
+fn fixed_size_array() {
+    #[derive(Serialize, PartialEq, Eq, Deserialize, Debug)]
+    struct Entity {
+        pos: [i32; 2]
+    }
+    let text = "pos = [1, 2]\n";
+    let value: Entity = toml::from_str(text).unwrap();
+    let expected = Entity { pos: [1, 2] };
+    assert_eq!(value, expected);
+    assert_eq!(toml::to_string(&value).unwrap(), text);
+}