gstreamer/format/
format_serde.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use serde::{
4    de::{Deserialize, Deserializer},
5    ser::{Serialize, Serializer},
6};
7
8use crate::format::{Buffers, Bytes, Default, Other, Percent, Undefined};
9
10// FIXME: the ser/de impl assumed `GenericFormattedValue` was always used.
11// When serializing a `SpecificFormattedValue`, we loose the type and only
12// serialize the inner value in parenthesis.
13// Manual implementation for some types that would otherwise yield representations such as:
14// "Default(Some((42)))"
15macro_rules! impl_serde(
16    ($t:ident, $inner:ty) => {
17        impl Serialize for $t {
18            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
19                use std::ops::Deref;
20                self.deref().serialize(serializer)
21            }
22        }
23
24        impl<'de> Deserialize<'de> for $t {
25            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
26                skip_assert_initialized!();
27                <$inner>::deserialize(deserializer)
28                    .and_then(|value| {
29                        $t::try_from(value).map_err(|_| {
30                            use serde::de::{Error, Unexpected};
31                            D::Error::invalid_value(
32                                Unexpected::Unsigned(value.into()),
33                                &concat!("valid ", stringify!($t)),
34                            )
35                        })
36                    })
37            }
38        }
39    }
40);
41
42impl_serde!(Buffers, u64);
43impl_serde!(Bytes, u64);
44impl_serde!(Default, u64);
45impl_serde!(Other, u64);
46impl_serde!(Percent, u32);
47
48impl Serialize for Undefined {
49    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
50        use std::ops::Deref;
51        self.deref().serialize(serializer)
52    }
53}
54
55impl<'de> Deserialize<'de> for Undefined {
56    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
57        skip_assert_initialized!();
58        i64::deserialize(deserializer).map(Into::into)
59    }
60}
61
62#[cfg(test)]
63mod tests {
64    use crate::{
65        format::{prelude::*, Default, Other, Undefined},
66        ClockTime, Format, GenericFormattedValue,
67    };
68
69    #[test]
70    fn test_serialize() {
71        let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
72
73        let value = GenericFormattedValue::from(Undefined::from(42));
74        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
75        assert_eq!(Ok("Undefined(42)".to_owned()), res);
76        let res = serde_json::to_string(&value).unwrap();
77        assert_eq!("{\"Undefined\":42}".to_owned(), res);
78
79        let value = GenericFormattedValue::from(42.default_format());
80        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
81        assert_eq!(Ok("Default(Some(42))".to_owned()), res);
82        let res = serde_json::to_string(&value).unwrap();
83        assert_eq!("{\"Default\":42}".to_owned(), res);
84
85        let value = GenericFormattedValue::from(Default::NONE);
86        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
87        assert_eq!(Ok("Default(None)".to_owned()), res);
88        let res = serde_json::to_string(&value).unwrap();
89        assert_eq!("{\"Default\":null}".to_owned(), res);
90
91        let value = GenericFormattedValue::from(42.bytes());
92        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
93        assert_eq!(Ok("Bytes(Some(42))".to_owned()), res);
94        let res = serde_json::to_string(&value).unwrap();
95        assert_eq!("{\"Bytes\":42}".to_owned(), res);
96
97        let value = GenericFormattedValue::from(ClockTime::from_nseconds(42_123_456_789));
98        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
99        assert_eq!(Ok("Time(Some(42123456789))".to_owned()), res);
100        let res = serde_json::to_string(&value).unwrap();
101        assert_eq!("{\"Time\":42123456789}".to_owned(), res);
102
103        let value = GenericFormattedValue::from(42.buffers());
104        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
105        assert_eq!(Ok("Buffers(Some(42))".to_owned()), res);
106        let res = serde_json::to_string(&value).unwrap();
107        assert_eq!("{\"Buffers\":42}".to_owned(), res);
108
109        let percent = 0.42.percent_ratio();
110        let value = GenericFormattedValue::from(percent);
111        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
112        assert_eq!(Ok("Percent(Some(420000))".to_owned()), res);
113        let res = serde_json::to_string(&value).unwrap();
114        assert_eq!("{\"Percent\":420000}".to_owned(), res);
115
116        let other = Other::try_from(42).ok();
117        let value = GenericFormattedValue::Other(Format::Default, other);
118        let res = ron::ser::to_string_pretty(&value, pretty_config.clone());
119        assert_eq!(Ok("Other(Default, Some(42))".to_owned()), res);
120        let res = serde_json::to_string(&value).unwrap();
121        assert_eq!("{\"Other\":[\"Default\",42]}".to_owned(), res);
122
123        let value = GenericFormattedValue::new(Format::__Unknown(7), 42);
124        let res = ron::ser::to_string_pretty(&value, pretty_config);
125        assert_eq!(Ok("Other(__Unknown(7), Some(42))".to_owned()), res);
126        let res = serde_json::to_string(&value).unwrap();
127        assert_eq!("{\"Other\":[{\"__Unknown\":7},42]}".to_owned(), res);
128    }
129
130    #[test]
131    fn test_deserialize() {
132        let value_ron = "Default(Some(42))";
133        let value_de: GenericFormattedValue = ron::de::from_str(value_ron).unwrap();
134        assert_eq!(value_de, GenericFormattedValue::from(42.default_format()));
135
136        let value_json = "{\"Default\":42}";
137        let value_de: GenericFormattedValue = serde_json::from_str(value_json).unwrap();
138        assert_eq!(value_de, GenericFormattedValue::from(Default::from_u64(42)));
139
140        let value_ron = "Other(Buffers, Some(42))";
141        let gfv_value = GenericFormattedValue::Other(Format::Buffers, Some(42 * Other::ONE));
142
143        let value_de: GenericFormattedValue = ron::de::from_str(value_ron).unwrap();
144        assert_eq!(value_de, gfv_value);
145
146        let value_json = "{\"Other\":[\"Buffers\",42]}";
147        let value_de: GenericFormattedValue = serde_json::from_str(value_json).unwrap();
148        assert_eq!(value_de, gfv_value);
149    }
150
151    #[test]
152    fn test_serde_roundtrip() {
153        macro_rules! test_roundrip(
154            ($value:expr) => {
155                let value_ser = ron::ser::to_string(&$value).unwrap();
156                let value_de: GenericFormattedValue = ron::de::from_str(value_ser.as_str()).unwrap();
157                assert_eq!(value_de, $value);
158            }
159        );
160
161        test_roundrip!(GenericFormattedValue::Undefined(Undefined::from(42)));
162        test_roundrip!(GenericFormattedValue::from(Default::from_u64(42)));
163        test_roundrip!(GenericFormattedValue::from(42.bytes()));
164        test_roundrip!(GenericFormattedValue::from(ClockTime::from_nseconds(
165            42_123_456_789
166        )));
167        test_roundrip!(GenericFormattedValue::from(42.buffers()));
168        test_roundrip!(GenericFormattedValue::from(42.percent()));
169        let gfv_value = GenericFormattedValue::Other(Format::Default, Other::try_from(42).ok());
170        test_roundrip!(gfv_value);
171        test_roundrip!(GenericFormattedValue::new(Format::__Unknown(7), 42));
172    }
173}
gstreamer/format/format_serde.rs

gstreamer/format/
format_serde.rs
