1 // Copyright (C) 2018 François Laignel <fengalin@free.fr> 2 // 3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or 4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your 6 // option. This file may not be copied, modified, or distributed 7 // except according to those terms. 8 9 use glib; 10 use glib::{Date, ToValue}; 11 12 use serde::de; 13 use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor}; 14 use serde::ser; 15 use serde::ser::{Serialize, SerializeSeq, SerializeTuple, Serializer}; 16 17 use std::fmt; 18 19 use Buffer; 20 use DateTime; 21 use Sample; 22 23 use date_time_serde; 24 use value::*; 25 use value_serde::*; 26 27 use Structure; 28 use StructureRef; 29 30 struct FieldSe<'a>(&'a str, &'a glib::SendValue); 31 impl<'a> Serialize for FieldSe<'a> { serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>32 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 33 ser_value!(self.1, |type_, value| { 34 let mut tup = serializer.serialize_tuple(3)?; 35 tup.serialize_element(self.0)?; 36 tup.serialize_element(type_)?; 37 tup.serialize_element(&value)?; 38 tup.end() 39 }) 40 } 41 } 42 43 struct StructureForIter<'a>(&'a StructureRef); 44 impl<'a> Serialize for StructureForIter<'a> { serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>45 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 46 let iter = self.0.iter(); 47 let size = iter.size_hint().0; 48 if size > 0 { 49 let mut seq = serializer.serialize_seq(Some(size))?; 50 for field in iter { 51 seq.serialize_element(&FieldSe(field.0, field.1))?; 52 } 53 seq.end() 54 } else { 55 let seq = serializer.serialize_seq(None)?; 56 seq.end() 57 } 58 } 59 } 60 61 impl Serialize for StructureRef { serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>62 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 63 let mut tup = serializer.serialize_tuple(2)?; 64 tup.serialize_element(self.get_name())?; 65 tup.serialize_element(&StructureForIter(self))?; 66 tup.end() 67 } 68 } 69 70 impl Serialize for Structure { serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>71 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 72 self.as_ref().serialize(serializer) 73 } 74 } 75 76 struct FieldDe(String, SendValue); 77 impl From<FieldDe> for (String, glib::SendValue) { from(field_de: FieldDe) -> Self78 fn from(field_de: FieldDe) -> Self { 79 (field_de.0, field_de.1.into()) 80 } 81 } 82 83 struct FieldVisitor; 84 impl<'de> Visitor<'de> for FieldVisitor { 85 type Value = FieldDe; 86 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result87 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 88 formatter.write_str( 89 "a tuple of 3 elements (name: `String`, type name: `String`, value: `Value`)", 90 ) 91 } 92 visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>93 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> { 94 let name = seq 95 .next_element::<String>()? 96 .ok_or_else(|| de::Error::custom("Expected a value for `Value` name"))?; 97 let type_name = seq 98 .next_element::<String>()? 99 .ok_or_else(|| de::Error::custom("Expected a value for `Value` type"))?; 100 let send_value = de_send_value!(type_name, seq)? 101 .ok_or_else(|| de::Error::custom("Expected a value for `Value`"))?; 102 Ok(FieldDe(name, send_value)) 103 } 104 } 105 106 impl<'de> Deserialize<'de> for FieldDe { deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>107 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 108 deserializer.deserialize_tuple(3, FieldVisitor) 109 } 110 } 111 112 struct FieldsDe<'a>(&'a mut StructureRef); 113 114 struct FieldsVisitor<'a>(&'a mut StructureRef); 115 impl<'de, 'a> Visitor<'de> for FieldsVisitor<'a> { 116 type Value = (); 117 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result118 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 119 formatter.write_str("a sequence of `Structure` `Field`s") 120 } 121 visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<(), A::Error>122 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<(), A::Error> { 123 while let Some(field) = seq.next_element::<FieldDe>()? { 124 let (name, value): (String, glib::SendValue) = field.into(); 125 self.0.set_value(name.as_str(), value); 126 } 127 128 Ok(()) 129 } 130 } 131 132 impl<'de, 'a> DeserializeSeed<'de> for FieldsDe<'a> { 133 type Value = (); 134 deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<(), D::Error>135 fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<(), D::Error> { 136 deserializer.deserialize_seq(FieldsVisitor(self.0)) 137 } 138 } 139 140 struct StructureVisitor; 141 impl<'de> Visitor<'de> for StructureVisitor { 142 type Value = Structure; 143 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result144 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 145 formatter.write_str("a `Structure` (name, sequence of `Field`s)") 146 } 147 visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>148 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> { 149 let name = seq 150 .next_element::<String>()? 151 .ok_or_else(|| de::Error::custom("Expected a name for the `Structure`"))?; 152 let mut structure = Structure::new_empty(&name); 153 seq.next_element_seed(FieldsDe(structure.as_mut()))? 154 .ok_or_else(|| de::Error::custom("Expected a sequence of `Field`s"))?; 155 156 Ok(structure) 157 } 158 } 159 160 impl<'de> Deserialize<'de> for Structure { deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>161 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 162 deserializer.deserialize_tuple(2, StructureVisitor) 163 } 164 } 165 166 #[cfg(test)] 167 mod tests { 168 extern crate ron; 169 170 use glib::{Date, DateMonth}; 171 172 use Array; 173 use DateTime; 174 use Fraction; 175 use Structure; 176 177 #[test] test_serialize()178 fn test_serialize() { 179 ::init().unwrap(); 180 181 let s = Structure::builder("test") 182 .field("f1", &"abc") 183 .field("f2", &String::from("bcd")) 184 .field("f3", &123i32) 185 .field("fraction", &Fraction::new(1, 2)) 186 .field("date", &Date::new_dmy(19, DateMonth::August, 2019)) 187 .field( 188 "date_time", 189 &DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64), 190 ) 191 .field("array", &Array::new(&[&1, &2])) 192 .build(); 193 194 let mut pretty_config = ron::ser::PrettyConfig::default(); 195 pretty_config.new_line = "".to_string(); 196 197 let res = ron::ser::to_string_pretty(&s, pretty_config); 198 assert_eq!( 199 Ok(concat!( 200 r#"("test", ["#, 201 r#" ("f1", "String", Some("abc")),"#, 202 r#" ("f2", "String", Some("bcd")),"#, 203 r#" ("f3", "i32", 123),"#, 204 r#" ("fraction", "Fraction", (1, 2)),"#, 205 r#" ("date", "Date", Some(YMD(2019, 8, 19))),"#, 206 r#" ("date_time", "DateTime", Some(YMDhmsTz(2019, 8, 19, 13, 34, 42, 2))),"#, 207 r#" ("array", "Array", ["#, 208 r#" ("i32", 1),"#, 209 r#" ("i32", 2),"#, 210 r#" ]),"#, 211 r#"])"#, 212 ) 213 .to_owned()), 214 res, 215 ); 216 } 217 218 #[test] test_deserialize()219 fn test_deserialize() { 220 ::init().unwrap(); 221 222 let s_ron = r#" 223 ("test", [ 224 ("f1", "String", Some("abc")), 225 ("f2", "String", Some("bcd")), 226 ("f3", "i32", 123), 227 ("fraction", "Fraction", (1, 2)), 228 ("date", "Date", Some(YMD(2019, 8, 19))), 229 ("date_time", "DateTime", Some(YMDhmsTz(2019, 8, 19, 13, 34, 42, 2))), 230 ("array", "Array", [ 231 ("i32", 1), 232 ("i32", 2), 233 ]), 234 ])"#; 235 let s: Structure = ron::de::from_str(s_ron).unwrap(); 236 assert_eq!( 237 s.as_ref(), 238 Structure::new( 239 "test", 240 &[ 241 ("f1", &"abc"), 242 ("f2", &"bcd"), 243 ("f3", &123), 244 ("date", &Date::new_dmy(19, DateMonth::August, 2019)), 245 ( 246 "date_time", 247 &DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64) 248 ), 249 ("fraction", &Fraction::new(1, 2)), 250 ("array", &Array::new(&[&1, &2])), 251 ], 252 ) 253 .as_ref() 254 ); 255 } 256 257 #[test] test_serde_roundtrip()258 fn test_serde_roundtrip() { 259 ::init().unwrap(); 260 261 let s = Structure::builder("test") 262 .field("f1", &"abc") 263 .field("f2", &"bcd".to_owned()) 264 .field("f3", &123i32) 265 .field("fraction", &Fraction::new(1, 2)) 266 .field("date", &Date::new_dmy(19, DateMonth::August, 2019)) 267 .field( 268 "date_time", 269 &DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64), 270 ) 271 .field("array", &Array::new(&[&1, &2])) 272 .build(); 273 let s_ser = ron::ser::to_string(&s).unwrap(); 274 let s_de: Structure = ron::de::from_str(s_ser.as_str()).unwrap(); 275 assert_eq!(s_de.as_ref(), s.as_ref()); 276 } 277 } 278