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

gstreamer/
value_serde.rs
