gstreamer/
value_serde.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3#![allow(clippy::upper_case_acronyms)]
4
5use std::{fmt, mem};
6
7use glib::{prelude::*, Date};
8use num_rational::Rational32;
9use once_cell::sync::Lazy;
10use serde::{
11    de,
12    de::{Deserialize, Deserializer, SeqAccess, Visitor},
13    ser,
14    ser::{Serialize, SerializeTuple, Serializer},
15};
16
17use crate::{date_time_serde, value::*, Buffer, DateTime, List, Sample, Structure};
18
19pub(crate) static ARRAY_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Array::static_type);
20pub(crate) static BITMASK_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Bitmask::static_type);
21pub(crate) static DATE_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Date::static_type);
22pub(crate) static DATE_TIME_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(DateTime::static_type);
23pub(crate) static FRACTION_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Fraction::static_type);
24pub(crate) static FRACTION_RANGE_OTHER_TYPE_ID: Lazy<glib::Type> =
25    Lazy::new(FractionRange::static_type);
26pub(crate) static INT_RANGE_I32_OTHER_TYPE_ID: Lazy<glib::Type> =
27    Lazy::new(IntRange::<i32>::static_type);
28pub(crate) static INT_RANGE_I64_OTHER_TYPE_ID: Lazy<glib::Type> =
29    Lazy::new(IntRange::<i64>::static_type);
30pub(crate) static LIST_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(List::static_type);
31pub(crate) static SAMPLE_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Sample::static_type);
32pub(crate) static BUFFER_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Buffer::static_type);
33pub(crate) static STRUCTURE_OTHER_TYPE_ID: Lazy<glib::Type> = Lazy::new(Structure::static_type);
34
35impl Serialize for Fraction {
36    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
37        self.0.serialize(serializer)
38    }
39}
40
41impl<'de> Deserialize<'de> for Fraction {
42    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
43        skip_assert_initialized!();
44        Rational32::deserialize(deserializer)
45            .map(|rational| Fraction::new(*rational.numer(), *rational.denom()))
46    }
47}
48
49macro_rules! ser_some_value (
50    ($value:expr, $t:ty, $ser_closure:expr) => {
51        {
52            let value = $value.get::<$t>().expect("ser_some_value macro");
53            $ser_closure(stringify!($t), value)
54        }
55    }
56);
57macro_rules! ser_opt_value (
58    ($value:expr, $t:ty, $ser_closure:expr) => {
59        {
60            let value = $value.get::<Option<$t>>().expect("ser_opt_value macro");
61            $ser_closure(stringify!($t), value)
62        }
63    }
64);
65macro_rules! ser_value (
66    ($value:expr, $ser_closure:expr) => {
67        #[allow(clippy::redundant_closure_call)]
68        match $value.type_() {
69            glib::Type::I8 => ser_some_value!($value, i8, $ser_closure),
70            glib::Type::U8 => ser_some_value!($value, u8, $ser_closure),
71            glib::Type::BOOL => ser_some_value!($value, bool, $ser_closure),
72            glib::Type::I32 => ser_some_value!($value, i32, $ser_closure),
73            glib::Type::U32 => ser_some_value!($value, u32, $ser_closure),
74            glib::Type::I64 => ser_some_value!($value, i64, $ser_closure),
75            glib::Type::U64 => ser_some_value!($value, u64, $ser_closure),
76            glib::Type::F32 => ser_some_value!($value, f32, $ser_closure),
77            glib::Type::F64 => ser_some_value!($value, f64, $ser_closure),
78            glib::Type::STRING => ser_opt_value!($value, String, $ser_closure),
79            type_id => {
80                if *ARRAY_OTHER_TYPE_ID == type_id {
81                    ser_some_value!($value, Array, $ser_closure)
82                } else if *BITMASK_OTHER_TYPE_ID == type_id {
83                    ser_some_value!($value, Bitmask, $ser_closure)
84                } else if *STRUCTURE_OTHER_TYPE_ID == type_id {
85                    ser_some_value!($value, Structure, $ser_closure)
86                } else if *DATE_OTHER_TYPE_ID == type_id {
87                    ser_opt_value!($value, Date, |type_, value: Option<Date>| {
88                        // Need to wrap the `glib::Date` in new type `date_time_serde::Date` first
89                        // See comment in `date_time_serde.rs`
90                        $ser_closure(type_, value.map(date_time_serde::Date::from))
91                    })
92                } else if *DATE_TIME_OTHER_TYPE_ID == type_id {
93                    ser_opt_value!($value, DateTime, $ser_closure)
94                } else if *FRACTION_OTHER_TYPE_ID == type_id {
95                    ser_some_value!($value, Fraction, $ser_closure)
96                } else if *FRACTION_RANGE_OTHER_TYPE_ID == type_id {
97                    ser_some_value!($value, FractionRange, $ser_closure)
98                } else if *INT_RANGE_I32_OTHER_TYPE_ID == type_id {
99                    ser_some_value!($value, IntRange<i32>, $ser_closure)
100                } else if *INT_RANGE_I64_OTHER_TYPE_ID == type_id {
101                    ser_some_value!($value, IntRange<i64>, $ser_closure)
102                } else if *LIST_OTHER_TYPE_ID == type_id {
103                    ser_some_value!($value, crate::List, $ser_closure)
104                } else if *SAMPLE_OTHER_TYPE_ID == type_id {
105                    ser_opt_value!($value, Sample, $ser_closure)
106                } else if *BUFFER_OTHER_TYPE_ID == type_id {
107                    ser_opt_value!($value, Buffer, $ser_closure)
108                } else {
109                    Err(
110                        ser::Error::custom(
111                            format!("unimplemented `Value` serialization for type {}",
112                                type_id,
113                            )
114                        )
115                    )
116                }
117            }
118        }
119    }
120);
121
122#[repr(transparent)]
123pub(crate) struct SendValue(glib::SendValue);
124impl SendValue {
125    pub(crate) fn from(send_value: glib::SendValue) -> Self {
126        skip_assert_initialized!();
127        SendValue(send_value)
128    }
129}
130
131impl From<SendValue> for glib::SendValue {
132    fn from(send_value: SendValue) -> Self {
133        skip_assert_initialized!();
134        send_value.0
135    }
136}
137
138impl Serialize for SendValue {
139    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
140        ser_value!(self.0, |type_, value| {
141            let mut tup = serializer.serialize_tuple(2)?;
142            tup.serialize_element(type_)?;
143            tup.serialize_element(&value)?;
144            tup.end()
145        })
146    }
147}
148
149macro_rules! impl_ser_send_value_collection (
150    ($t:ident) => (
151        impl Serialize for $t {
152            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
153                let send_value_vec = unsafe {
154                    &*(self.as_slice() as *const [glib::SendValue] as *const [SendValue])
155                };
156                send_value_vec.serialize(serializer)
157            }
158        }
159    );
160);
161
162impl_ser_send_value_collection!(Array);
163impl_ser_send_value_collection!(List);
164
165macro_rules! de_some_send_value(
166    ($type_name:expr, $seq:expr, $t:ty) => (
167        de_some_send_value!("Value", $type_name, $seq, $t)
168    );
169    ($outer_type:expr, $type_name:expr, $seq:expr, $t:ty) => (
170        de_send_value!($outer_type, $type_name, $seq, $t, $t)
171    );
172);
173macro_rules! de_opt_send_value(
174    ($type_name:expr, $seq:expr, $t:ty) => (
175        de_opt_send_value!("Value", $type_name, $seq, $t)
176    );
177    ($outer_type:expr, $type_name:expr, $seq:expr, $t:ty) => (
178        de_send_value!($outer_type, $type_name, $seq, Option<$t>, $t)
179    );
180);
181macro_rules! de_send_value(
182    ($outer_type:expr, $type_name:expr, $seq:expr, $elem_t:ty, $t:ty) => (
183        Ok(match $seq.next_element::<$elem_t>()? {
184            Some(base_value) => {
185                Some(SendValue::from(base_value
186                    .to_value()
187                    .try_into_send_value::<$t>()
188                    .map_err(|_|
189                        de::Error::custom(format!(
190                            "Failed to convert `{}` with type {:?} to `SendValue`",
191                            $outer_type,
192                            $type_name,
193                        ))
194                    )?
195                ))
196            }
197            None => None
198        })
199    );
200    ($type_name:expr, $seq:expr) => (
201        match $type_name.as_str() {
202            "i8" => de_some_send_value!($type_name, $seq, i8),
203            "u8" => de_some_send_value!($type_name, $seq, u8),
204            "bool" => de_some_send_value!($type_name, $seq, bool),
205            "i32" => de_some_send_value!($type_name, $seq, i32),
206            "u32" => de_some_send_value!($type_name, $seq, u32),
207            "i64" => de_some_send_value!($type_name, $seq, i64),
208            "u64" => de_some_send_value!($type_name, $seq, u64),
209            "f32" => de_some_send_value!($type_name, $seq, f32),
210            "f64" => de_some_send_value!($type_name, $seq, f64),
211            "String" => de_opt_send_value!($type_name, $seq, String),
212            "Array" => de_some_send_value!($type_name, $seq, Array),
213            "Bitmask" => de_some_send_value!($type_name, $seq, Bitmask),
214            "Structure" => de_some_send_value!($type_name, $seq, Structure),
215            "Date" => {
216                // Need to deserialize as `date_time_serde::Date` new type
217                // See comment in `date_time_serde.rs`
218                de_send_value!(
219                    "Value",
220                    $type_name,
221                    $seq,
222                    Option<date_time_serde::Date>,
223                    Date
224                )
225            }
226            "DateTime" => de_opt_send_value!($type_name, $seq, DateTime),
227            "Fraction" => de_some_send_value!($type_name, $seq, Fraction),
228            "FractionRange" => de_some_send_value!($type_name, $seq, FractionRange),
229            "IntRange<i32>" => de_some_send_value!($type_name, $seq, IntRange<i32>),
230            "IntRange<i64>" => de_some_send_value!($type_name, $seq, IntRange<i64>),
231            "Sample" => de_opt_send_value!($type_name, $seq, Sample),
232            "Buffer" => de_opt_send_value!($type_name, $seq, Buffer),
233            _ => return Err(
234                de::Error::custom(
235                    format!(
236                        "unimplemented deserialization for `Value` with type `{}`",
237                        $type_name,
238                    ),
239                )
240            ),
241        }
242    );
243);
244
245struct SendValueVisitor;
246impl<'de> Visitor<'de> for SendValueVisitor {
247    type Value = SendValue;
248
249    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
250        formatter.write_str("a tuple: (name, value)")
251    }
252
253    fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
254        let type_name = seq
255            .next_element::<String>()?
256            .ok_or_else(|| de::Error::custom("Expected a value for `Value` type"))?;
257        let send_value = de_send_value!(type_name, seq)?
258            .ok_or_else(|| de::Error::custom("Expected a value for `Value`"))?;
259        Ok(send_value)
260    }
261}
262
263impl<'de> Deserialize<'de> for SendValue {
264    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
265        skip_assert_initialized!();
266        deserializer.deserialize_tuple(2, SendValueVisitor {})
267    }
268}
269
270macro_rules! impl_de_send_value_collection (
271    ($t:ident) => {
272        impl<'de> Deserialize<'de> for $t {
273            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
274                skip_assert_initialized!();
275                let send_value_vec = Vec::<SendValue>::deserialize(deserializer)?;
276                Ok($t::from_values(unsafe{
277                    mem::transmute::<Vec<SendValue>, Vec<glib::SendValue>>(send_value_vec)
278                }))
279            }
280        }
281    }
282);
283
284impl_de_send_value_collection!(Array);
285impl_de_send_value_collection!(List);
286
287#[cfg(test)]
288mod tests {
289    use glib::{Date, DateMonth};
290
291    use crate::{Array, Bitmask, DateTime, Fraction, FractionRange, IntRange, List, Structure};
292
293    #[test]
294    fn test_serialize_simple() {
295        crate::init().unwrap();
296
297        let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
298
299        // Fraction
300        let fraction = Fraction::new(1, 3);
301
302        let res = ron::ser::to_string_pretty(&fraction, pretty_config.clone());
303        assert_eq!(Ok("(1, 3)".to_owned()), res);
304
305        let res = serde_json::to_string(&fraction).unwrap();
306        assert_eq!("[1,3]".to_owned(), res);
307
308        // FractionRange
309        let fraction_range = FractionRange::new(Fraction::new(1, 3), Fraction::new(1, 2));
310
311        let res = ron::ser::to_string_pretty(&fraction_range, pretty_config.clone());
312        assert_eq!(Ok("(    min: (1, 3),    max: (1, 2),)".to_owned()), res);
313
314        let res = serde_json::to_string(&fraction_range).unwrap();
315        assert_eq!(r#"{"min":[1,3],"max":[1,2]}"#.to_owned(), res);
316
317        // IntRange
318        let int_range = IntRange::with_step(0, 42, 21);
319        let res = ron::ser::to_string_pretty(&int_range, pretty_config.clone());
320        assert_eq!(Ok("(    min: 0,    max: 42,    step: 21,)".to_owned()), res,);
321
322        let res = serde_json::to_string(&int_range).unwrap();
323        assert_eq!(r#"{"min":0,"max":42,"step":21}"#.to_owned(), res);
324
325        // Bitmask
326        let bitmask = Bitmask::new(1024 + 128 + 32);
327
328        let res = ron::ser::to_string_pretty(&bitmask, pretty_config.clone());
329        assert_eq!(Ok("(1184)".to_owned()), res);
330
331        let res = serde_json::to_string(&bitmask).unwrap();
332        assert_eq!("1184".to_owned(), res);
333
334        // Nested structure
335        let s = Structure::builder("foobar")
336            .field("foo", 42)
337            .field("baz", Structure::builder("baz").field("foo", 43).build())
338            .build();
339
340        let res = ron::ser::to_string_pretty(&s, pretty_config);
341        assert_eq!(
342            Ok(r#"("foobar", [    ("foo", "i32", 42),    ("baz", "Structure", ("baz", [        ("foo", "i32", 43),    ])),])"#.to_owned()),
343            res
344        );
345
346        let res = serde_json::to_string(&s).unwrap();
347        assert_eq!(
348            r#"["foobar",[["foo","i32",42],["baz","Structure",["baz",[["foo","i32",43]]]]]]"#
349                .to_owned(),
350            res
351        );
352    }
353
354    #[test]
355    fn test_serialize_collections() {
356        crate::init().unwrap();
357
358        let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
359
360        // Array
361        let value_13 = Fraction::new(1, 3);
362        let value_12 = Fraction::new(1, 2);
363
364        let array = Array::new([value_13, value_12]);
365
366        let res = ron::ser::to_string_pretty(&array, pretty_config.clone());
367        assert_eq!(
368            Ok(concat!(
369                r#"["#,
370                r#"    ("Fraction", (1, 3)),"#,
371                r#"    ("Fraction", (1, 2)),"#,
372                r#"]"#
373            )
374            .to_owned()),
375            res,
376        );
377
378        let res = serde_json::to_string(&array).unwrap();
379        assert_eq!(r#"[["Fraction",[1,3]],["Fraction",[1,2]]]"#.to_owned(), res);
380
381        // List
382        let value_12 = Fraction::new(1, 2);
383
384        let list = List::new([value_12]);
385
386        let res = ron::ser::to_string_pretty(&list, pretty_config);
387        assert_eq!(
388            Ok(concat!(r#"["#, r#"    ("Fraction", (1, 2)),"#, r#"]"#).to_owned()),
389            res,
390        );
391    }
392
393    #[test]
394    fn test_deserialize_simple() {
395        crate::init().unwrap();
396
397        // Fraction
398        let fraction_ron = "(1, 3)";
399        let fraction: Fraction = ron::de::from_str(fraction_ron).unwrap();
400        assert_eq!(fraction.0.numer(), &1);
401        assert_eq!(fraction.0.denom(), &3);
402
403        let fraction_json = "[1,3]";
404        let fraction: Fraction = serde_json::from_str(fraction_json).unwrap();
405        assert_eq!(fraction.0.numer(), &1);
406        assert_eq!(fraction.0.denom(), &3);
407
408        // FractionRange
409        let fraction_range_ron = "(min: (1, 3), max: (1, 2))";
410        let fraction_range: FractionRange = ron::de::from_str(fraction_range_ron).unwrap();
411        assert_eq!(fraction_range.min().0.denom(), &3);
412        assert_eq!(fraction_range.max().0.denom(), &2);
413
414        let fraction_range_json = r#"{"min":[1,3],"max":[1,2]}"#;
415        let fraction_range: FractionRange = serde_json::from_str(fraction_range_json).unwrap();
416        assert_eq!(fraction_range.min().0.denom(), &3);
417        assert_eq!(fraction_range.max().0.denom(), &2);
418
419        // IntRange
420        let int_range_ron = "(min: 0, max: 42, step: 21)";
421        let int_range: IntRange<i32> = ron::de::from_str(int_range_ron).unwrap();
422        assert_eq!(int_range.min(), 0);
423        assert_eq!(int_range.max(), 42);
424        assert_eq!(int_range.step(), 21);
425
426        let int_range_json = r#"{"min":0,"max":42,"step":21}"#;
427        let int_range: IntRange<i32> = serde_json::from_str(int_range_json).unwrap();
428        assert_eq!(int_range.min(), 0);
429        assert_eq!(int_range.max(), 42);
430        assert_eq!(int_range.step(), 21);
431
432        // Bitmask
433        let bitmask_ref = Bitmask::new(1024 + 128 + 32);
434
435        let bitmask_ron = "(1184)";
436        let bitmask: Bitmask = ron::de::from_str(bitmask_ron).unwrap();
437        assert_eq!(bitmask_ref, bitmask);
438
439        let bitmask_json = "1184";
440        let bitmask: Bitmask = serde_json::from_str(bitmask_json).unwrap();
441        assert_eq!(bitmask_ref, bitmask);
442
443        // Nested structure
444        let s_ref = Structure::builder("foobar")
445            .field("foo", 42)
446            .field("baz", Structure::builder("baz").field("foo", 43).build())
447            .build();
448
449        let s_ron = r#"("foobar", [    ("foo", "i32", 42),    ("baz", "Structure", ("baz", [        ("foo", "i32", 43),    ])),])"#;
450        let s: Structure = ron::de::from_str(s_ron).unwrap();
451        assert_eq!(s_ref, s);
452
453        let s_json =
454            r#"["foobar",[["foo","i32",42],["baz","Structure",["baz",[["foo","i32",43]]]]]]"#;
455        let s: Structure = serde_json::from_str(s_json).unwrap();
456        assert_eq!(s_ref, s);
457    }
458
459    #[test]
460    fn test_serde_roundtrip_simple() {
461        crate::init().unwrap();
462
463        // Fraction
464        let fraction = Fraction::new(1, 3);
465        let fraction_ser = ron::ser::to_string(&fraction).unwrap();
466        let fraction_de: Fraction = ron::de::from_str(fraction_ser.as_str()).unwrap();
467        assert_eq!(fraction_de.0.numer(), fraction.0.numer());
468        assert_eq!(fraction_de.0.denom(), fraction.0.denom());
469
470        // FractionRange
471        let fraction_range = FractionRange::new(Fraction::new(1, 3), Fraction::new(1, 2));
472        let fraction_range_ser = ron::ser::to_string(&fraction_range).unwrap();
473        let fraction_range_de: FractionRange =
474            ron::de::from_str(fraction_range_ser.as_str()).unwrap();
475        assert_eq!(
476            fraction_range_de.min().0.denom(),
477            fraction_range.min().0.denom()
478        );
479        assert_eq!(
480            fraction_range_de.max().0.denom(),
481            fraction_range.max().0.denom()
482        );
483
484        // IntRange
485        let int_range = IntRange::with_step(0, 42, 21);
486        let int_range_ser = ron::ser::to_string(&int_range).unwrap();
487        let int_range_de: IntRange<i32> = ron::de::from_str(int_range_ser.as_str()).unwrap();
488        assert_eq!(int_range_de.min(), int_range.min());
489        assert_eq!(int_range_de.max(), int_range.max());
490        assert_eq!(int_range_de.step(), int_range.step());
491
492        // Bitmask
493        let bitmask = Bitmask::new(1024 + 128 + 32);
494        let bitmask_ser = ron::ser::to_string(&bitmask).unwrap();
495        let bitmask_de: Bitmask = ron::de::from_str(bitmask_ser.as_str()).unwrap();
496        assert_eq!(bitmask_de, bitmask);
497
498        // Nested structure
499        let s = Structure::builder("foobar")
500            .field("foo", 42)
501            .field("baz", Structure::builder("baz").field("foo", 43).build())
502            .build();
503        let s_ser = ron::ser::to_string(&s).unwrap();
504        let s_de: Structure = ron::de::from_str(s_ser.as_str()).unwrap();
505        assert_eq!(s_de, s);
506    }
507
508    #[allow(clippy::cognitive_complexity)]
509    #[test]
510    fn test_deserialize_collections() {
511        crate::init().unwrap();
512
513        // Array of fractions
514        let array_ron = r#"[
515                ("Fraction", (1, 3)),
516                ("Fraction", (1, 2)),
517            ]"#;
518        let array: Array = ron::de::from_str(array_ron).unwrap();
519        let slice = array.as_slice();
520        assert_eq!(2, slice.len());
521
522        let fraction = slice[0].get::<Fraction>().expect("slice[0]");
523        assert_eq!(fraction.0.numer(), &1);
524        assert_eq!(fraction.0.denom(), &3);
525
526        let fraction = slice[1].get::<Fraction>().expect("slice[1]");
527        assert_eq!(fraction.0.numer(), &1);
528        assert_eq!(fraction.0.denom(), &2);
529
530        // Array of strings
531        let array_ron = r#"[
532                ("String", Some("test str")),
533                ("String", None),
534            ]"#;
535        let array: Array = ron::de::from_str(array_ron).unwrap();
536        let slice = array.as_slice();
537        assert_eq!(2, slice.len());
538        assert_eq!(
539            "test str".to_owned(),
540            slice[0].get::<String>().expect("slice[0]")
541        );
542
543        assert!(slice[1]
544            .get::<Option<String>>()
545            .expect("slice[1]")
546            .is_none());
547
548        // Array of dates
549        let array_ron = r#"[
550                ("Date", Some(YMD(2019, 8, 19))),
551                ("Date", None),
552            ]"#;
553        let array: Array = ron::de::from_str(array_ron).unwrap();
554        let slice = array.as_slice();
555        assert_eq!(2, slice.len());
556        assert_eq!(
557            Date::from_dmy(19, DateMonth::August, 2019).unwrap(),
558            slice[0].get::<Date>().expect("slice[0]")
559        );
560
561        assert!(slice[1].get::<Option<Date>>().expect("slice[1]").is_none());
562
563        // Array of fractions
564        let array_json = r#"[["Fraction",[1,3]],["Fraction",[1,2]]]"#;
565        let array: Array = serde_json::from_str(array_json).unwrap();
566        let slice = array.as_slice();
567        assert_eq!(2, slice.len());
568
569        let fraction = slice[0].get::<Fraction>().expect("slice[0]");
570        assert_eq!(fraction.0.numer(), &1);
571        assert_eq!(fraction.0.denom(), &3);
572
573        let fraction = slice[1].get::<Fraction>().expect("slice[1]");
574        assert_eq!(fraction.0.numer(), &1);
575        assert_eq!(fraction.0.denom(), &2);
576
577        // Array of strings
578        let array_json = r#"[["String","test str"],["String",null]]"#;
579        let array: Array = serde_json::from_str(array_json).unwrap();
580        let slice = array.as_slice();
581        assert_eq!(2, slice.len());
582        assert_eq!(
583            "test str".to_owned(),
584            slice[0].get::<String>().expect("slice[0]")
585        );
586
587        assert!(slice[1]
588            .get::<Option<String>>()
589            .expect("slice[1]")
590            .is_none());
591
592        // Array of dates
593        let array_json = r#"[["Date",{"YMD":[2019,8,19]}],["Date",null]]"#;
594        let array: Array = serde_json::from_str(array_json).unwrap();
595        let slice = array.as_slice();
596        assert_eq!(2, slice.len());
597        assert_eq!(
598            Date::from_dmy(19, DateMonth::August, 2019).unwrap(),
599            slice[0].get::<Date>().expect("slice[0]")
600        );
601
602        assert!(slice[1].get::<Option<Date>>().expect("slice[1]").is_none());
603
604        // List of fractions
605        let list_ron = r#"[
606                ("Fraction", (1, 2)),
607            ]"#;
608        let list: List = ron::de::from_str(list_ron).unwrap();
609        let slice = list.as_slice();
610        assert_eq!(1, slice.len());
611
612        let fraction = slice[0].get::<Fraction>().expect("slice[0]");
613        assert_eq!(fraction.0.numer(), &1);
614        assert_eq!(fraction.0.denom(), &2);
615
616        // List of strings
617        let list_ron = r#"[
618                ("String", Some("test str")),
619                ("String", None),
620            ]"#;
621        let list: List = ron::de::from_str(list_ron).unwrap();
622        let slice = list.as_slice();
623        assert_eq!(2, slice.len());
624        assert_eq!(
625            "test str".to_owned(),
626            slice[0].get::<String>().expect("slice[0]")
627        );
628
629        assert!(slice[1]
630            .get::<Option<String>>()
631            .expect("slice[1]")
632            .is_none());
633
634        // List of date times
635        let list_ron = r#"[
636                ("DateTime", Some(YMDhmsTz(2019, 8, 19, 13, 34, 42, 2))),
637                ("DateTime", None),
638            ]"#;
639        let list: List = ron::de::from_str(list_ron).unwrap();
640        let slice = list.as_slice();
641        assert_eq!(2, slice.len());
642        assert_eq!(
643            DateTime::new(2f32, 2019, 8, 19, 13, 34, 42f64).unwrap(),
644            slice[0].get::<DateTime>().expect("slice[0]")
645        );
646
647        assert!(slice[1]
648            .get::<Option<DateTime>>()
649            .expect("slice[1]")
650            .is_none());
651    }
652
653    #[test]
654    fn test_serde_roundtrip_collection() {
655        crate::init().unwrap();
656
657        // Array
658        let value_13 = Fraction::new(1, 3);
659        let value_12 = Fraction::new(1, 2);
660
661        let array = Array::new([value_13, value_12]);
662        let array_ser = ron::ser::to_string(&array).unwrap();
663
664        let array_de: Array = ron::de::from_str(array_ser.as_str()).unwrap();
665        let slice_de = array_de.as_slice();
666        let slice = array.as_slice();
667        assert_eq!(slice_de.len(), slice.len());
668
669        let fraction_de = slice_de[0].get::<Fraction>().expect("slice_de[0]");
670        let fraction = slice[0].get::<Fraction>().expect("slice[0]");
671        assert_eq!(fraction_de.0.numer(), fraction.0.numer());
672        assert_eq!(fraction_de.0.denom(), fraction.0.denom());
673
674        let fraction_de = slice_de[1].get::<Fraction>().expect("slice_de[1]");
675        let fraction = slice[1].get::<Fraction>().expect("slice[1]");
676        assert_eq!(fraction_de.0.numer(), fraction.0.numer());
677        assert_eq!(fraction.0.denom(), fraction.0.denom());
678
679        // List
680        let value_12 = Fraction::new(1, 2);
681
682        let list = List::new([value_12]);
683        let list_ser = ron::ser::to_string(&list).unwrap();
684
685        let list_de: List = ron::de::from_str(list_ser.as_str()).unwrap();
686        let slice_de = list_de.as_slice();
687        let slice = list.as_slice();
688        assert_eq!(slice_de.len(), slice.len());
689
690        let fraction_de = slice_de[0].get::<Fraction>().expect("slice_de[0]");
691        let fraction = slice[0].get::<Fraction>().expect("slice[0]");
692        assert_eq!(fraction_de.0.numer(), fraction.0.numer());
693        assert_eq!(fraction_de.0.denom(), fraction.0.denom());
694    }
695}
gstreamer/value_serde.rs

gstreamer/
value_serde.rs
