aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorhcpl <hcpl.prog@gmail.com>2018-10-28 12:36:40 +0200
committerhcpl <hcpl.prog@gmail.com>2018-10-28 12:36:40 +0200
commit93c0eaf24e33ab376ce9a5197ac759d37c3fcdf1 (patch)
treefa514155ffcc2b17919215e6a8a378371a952460
parent3aec5a918a6cb39fa32e8a56725a3c2fc0ed6bc2 (diff)
downloadmilf-rs-93c0eaf24e33ab376ce9a5197ac759d37c3fcdf1.tar.gz
milf-rs-93c0eaf24e33ab376ce9a5197ac759d37c3fcdf1.zip
Support tuple Serde types for `Value`
-rw-r--r--src/value.rs63
-rw-r--r--test-suite/tests/serde.rs60
2 files changed, 108 insertions, 15 deletions
diff --git a/src/value.rs b/src/value.rs
index 64f4555..2e42dc3 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -675,9 +675,9 @@ impl ser::Serializer for Serializer {
type Error = ::ser::Error;
type SerializeSeq = SerializeVec;
- type SerializeTuple = ser::Impossible<Value, ::ser::Error>;
- type SerializeTupleStruct = ser::Impossible<Value, ::ser::Error>;
- type SerializeTupleVariant = ser::Impossible<Value, ::ser::Error>;
+ type SerializeTuple = SerializeVec;
+ type SerializeTupleStruct = SerializeVec;
+ type SerializeTupleVariant = SerializeVec;
type SerializeMap = SerializeMap;
type SerializeStruct = SerializeMap;
type SerializeStructVariant = ser::Impossible<Value, ::ser::Error>;
@@ -800,23 +800,23 @@ impl ser::Serializer for Serializer {
})
}
- fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, ::ser::Error> {
- Err(::ser::Error::UnsupportedType)
+ fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, ::ser::Error> {
+ 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, ::ser::Error> {
- Err(::ser::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, ::ser::Error>
{
- Err(::ser::Error::UnsupportedType)
+ self.serialize_seq(Some(len))
}
fn serialize_map(self, _len: Option<usize>)
@@ -869,6 +869,51 @@ impl ser::SerializeSeq for SerializeVec {
}
}
+impl ser::SerializeTuple for SerializeVec {
+ type Ok = Value;
+ type Error = ::ser::Error;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
+ where T: ser::Serialize
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ fn end(self) -> Result<Value, ::ser::Error> {
+ ser::SerializeSeq::end(self)
+ }
+}
+
+impl ser::SerializeTupleStruct for SerializeVec {
+ type Ok = Value;
+ type Error = ::ser::Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
+ where T: ser::Serialize
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ fn end(self) -> Result<Value, ::ser::Error> {
+ ser::SerializeSeq::end(self)
+ }
+}
+
+impl ser::SerializeTupleVariant for SerializeVec {
+ type Ok = Value;
+ type Error = ::ser::Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
+ where T: ser::Serialize
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ fn end(self) -> Result<Value, ::ser::Error> {
+ ser::SerializeSeq::end(self)
+ }
+}
+
impl ser::SerializeMap for SerializeMap {
type Ok = Value;
type Error = ::ser::Error;
diff --git a/test-suite/tests/serde.rs b/test-suite/tests/serde.rs
index b97937f..c1b6d78 100644
--- a/test-suite/tests/serde.rs
+++ b/test-suite/tests/serde.rs
@@ -580,15 +580,63 @@ fn table_structs_empty() {
#[test]
fn fixed_size_array() {
- #[derive(Serialize, PartialEq, Eq, Deserialize, Debug)]
+ #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
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);
+
+ equivalent! {
+ Entity { pos: [1, 2] },
+ Table(map! {
+ pos: Array(vec![
+ Integer(1),
+ Integer(2),
+ ])
+ }),
+ }
+}
+
+#[test]
+fn homogeneous_tuple() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+ struct Collection {
+ elems: (i64, i64, i64),
+ }
+
+ equivalent! {
+ Collection { elems: (0, 1, 2) },
+ Table(map! {
+ elems: Array(vec![
+ Integer(0),
+ Integer(1),
+ Integer(2),
+ ])
+ }),
+ }
+}
+
+#[test]
+fn homogeneous_tuple_struct() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+ struct Object(Vec<String>, Vec<String>, Vec<String>);
+
+ equivalent! {
+ map! {
+ obj: Object(vec!["foo".to_string()], vec![], vec!["bar".to_string(), "baz".to_string()])
+ },
+ Table(map! {
+ obj: Array(vec![
+ Array(vec![
+ Value::String("foo".to_string()),
+ ]),
+ Array(vec![]),
+ Array(vec![
+ Value::String("bar".to_string()),
+ Value::String("baz".to_string()),
+ ]),
+ ])
+ }),
+ }
}
#[test]