trs_data_value/
deserializer.rs

1use std::{collections::HashMap, fmt};
2
3use serde::{
4    de::{Deserialize, Deserializer, MapAccess, Visitor},
5    ser::{Serialize, SerializeMap},
6};
7
8use super::DataValue;
9
10// A Visitor is a type that holds methods that a Deserializer can drive
11// depending on what is contained in the input data.
12//
13struct DataValueVisitor;
14
15// This is the trait that Deserializers are going to be driving. There
16// is one method for each type of data that our type knows how to
17// deserialize from.
18impl<'de> Visitor<'de> for DataValueVisitor {
19    // The type that our Visitor is going to produce.
20    type Value = DataValue;
21
22    // Format a message stating what data this Visitor expects to receive.
23    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
24        formatter.write_str("a very special map")
25    }
26
27    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
28    where
29        E: serde::de::Error,
30    {
31        Ok(DataValue::Bool(v))
32    }
33
34    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
35    where
36        E: serde::de::Error,
37    {
38        Ok(DataValue::I64(v))
39    }
40
41    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
42    where
43        E: serde::de::Error,
44    {
45        Ok(DataValue::U64(v))
46    }
47
48    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
49    where
50        E: serde::de::Error,
51    {
52        Ok(DataValue::F64(v))
53    }
54
55    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
56    where
57        E: serde::de::Error,
58    {
59        Ok(DataValue::String(v.into()))
60    }
61
62    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
63    where
64        E: serde::de::Error,
65    {
66        Ok(DataValue::String(v.into()))
67    }
68
69    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
70    where
71        E: serde::de::Error,
72    {
73        Ok(DataValue::F32(v))
74    }
75
76    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
77    where
78        E: serde::de::Error,
79    {
80        Ok(DataValue::U8(v))
81    }
82
83    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
84    where
85        E: serde::de::Error,
86    {
87        Ok(DataValue::I128(v))
88    }
89
90    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
91    where
92        E: serde::de::Error,
93    {
94        Ok(DataValue::U128(v))
95    }
96
97    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
98    where
99        E: serde::de::Error,
100    {
101        Ok(DataValue::Bytes(v.into()))
102    }
103
104    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
105    where
106        E: serde::de::Error,
107    {
108        Ok(DataValue::Bytes(v))
109    }
110
111    fn visit_none<E>(self) -> Result<Self::Value, E>
112    where
113        E: serde::de::Error,
114    {
115        Ok(DataValue::Null)
116    }
117
118    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
119    where
120        D: Deserializer<'de>,
121    {
122        Deserialize::deserialize(deserializer)
123    }
124
125    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
126    where
127        A: serde::de::SeqAccess<'de>,
128    {
129        let mut vec = Vec::new();
130        while let Ok(Some(value)) = seq.next_element() {
131            vec.push(value);
132        }
133        Ok(DataValue::Vec(vec))
134    }
135
136    // Deserialize MyMap from an abstract "map" provided by the
137    // Deserializer. The MapAccess input is a callback provided by
138    // the Deserializer to let us see each entry in the map.
139    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
140    where
141        M: MapAccess<'de>,
142    {
143        let mut map = HashMap::with_capacity(access.size_hint().unwrap_or(0));
144
145        // While there are entries remaining in the input, add them
146        // into our map.
147        while let Some((key, value)) = access.next_entry()? {
148            map.insert(key, value);
149        }
150
151        Ok(DataValue::Map(map))
152    }
153}
154
155// This is the trait that informs Serde how to deserialize MyMap.
156impl<'de> Deserialize<'de> for DataValue {
157    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
158    where
159        D: Deserializer<'de>,
160    {
161        deserializer.deserialize_any(DataValueVisitor)
162    }
163}
164
165impl Serialize for DataValue {
166    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
167    where
168        S: serde::Serializer,
169    {
170        match self {
171            DataValue::Bool(v) => serializer.serialize_bool(*v),
172            DataValue::I64(v) => serializer.serialize_i64(*v),
173            DataValue::U64(v) => serializer.serialize_u64(*v),
174            DataValue::F64(v) => serializer.serialize_f64(*v),
175            DataValue::String(v) => serializer.serialize_str(v),
176            DataValue::F32(v) => serializer.serialize_f32(*v),
177            DataValue::U8(v) => serializer.serialize_u8(*v),
178            DataValue::I128(v) => serializer.serialize_i128(*v),
179            DataValue::U128(v) => serializer.serialize_u128(*v),
180            DataValue::Bytes(v) => serializer.serialize_bytes(v),
181            DataValue::Vec(v) => v.serialize(serializer),
182            DataValue::Map(v) => {
183                // v.serialize(serializer)
184                let mut map = serializer.serialize_map(Some(v.len()))?;
185                for (k, v) in v {
186                    map.serialize_entry(k, v)?;
187                }
188                map.end()
189            }
190            DataValue::Null => serializer.serialize_none(),
191            DataValue::I32(v) => serializer.serialize_i32(*v),
192            DataValue::U32(v) => serializer.serialize_u32(*v),
193            DataValue::EnumNumber(v) => serializer.serialize_i32(*v),
194        }
195    }
196}
197
198#[cfg(test)]
199mod test {
200
201    use super::*;
202    use rstest::*;
203
204    #[rstest]
205    #[case::bool(true, DataValue::Bool(true))]
206    #[case::i64(-42i64, DataValue::I64(-42))]
207    #[case::f64(42.0f64, DataValue::F64(42.0))]
208    #[case::str("test", DataValue::String("test".into()))]
209    #[case::string("test".to_string(), DataValue::String("test".into()))]
210    #[case::seq(vec![DataValue::I64(-1), DataValue::I64(-2)], DataValue::Vec(vec![DataValue::I64(-1), DataValue::I64(-2)]))]
211    #[case::map({
212        let mut map = HashMap::new();
213        map.insert("key".to_string(), DataValue::U64(42));
214        map
215    }, DataValue::Map(crate::stdhashmap!("key" => DataValue::U64(42))))]
216    fn test_deserialize(#[case] input: impl Into<DataValue>, #[case] expected: DataValue) {
217        let input = input.into();
218        let serialized = serde_json::to_value(&input);
219        assert!(serialized.is_ok(), "{:?}", serialized);
220        println!("{:?}", serialized);
221        let deserialized: Result<DataValue, _> = serde_json::from_value(serialized.unwrap());
222        assert!(deserialized.is_ok(), "{:?}", deserialized);
223        assert_eq!(deserialized.unwrap(), expected);
224    }
225
226    #[derive(Debug, thiserror::Error)]
227    enum DummyError {
228        #[error("Custom error: {0}")]
229        Custom(String),
230    }
231    impl serde::de::Error for DummyError {
232        #[cold]
233        fn custom<T: fmt::Display>(msg: T) -> Self {
234            Self::Custom(msg.to_string())
235        }
236    }
237
238    #[rstest]
239    fn test_visitor() {
240        let v = DataValueVisitor.visit_bool::<DummyError>(true);
241        assert!(v.is_ok());
242        assert_eq!(v.unwrap(), DataValue::Bool(true));
243        let v = DataValueVisitor.visit_i64::<DummyError>(-42);
244        assert!(v.is_ok());
245        assert_eq!(v.unwrap(), DataValue::I64(-42));
246        let v = DataValueVisitor.visit_u64::<DummyError>(42);
247        assert!(v.is_ok());
248        assert_eq!(v.unwrap(), DataValue::U64(42));
249        let v = DataValueVisitor.visit_f64::<DummyError>(42.0);
250        assert!(v.is_ok());
251        assert_eq!(v.unwrap(), DataValue::F64(42.0));
252        let v = DataValueVisitor.visit_str::<DummyError>("test");
253        assert!(v.is_ok());
254        assert_eq!(v.unwrap(), DataValue::String("test".into()));
255        let v = DataValueVisitor.visit_string::<DummyError>("test".to_string());
256        assert!(v.is_ok());
257        assert_eq!(v.unwrap(), DataValue::String("test".into()));
258        let v = DataValueVisitor.visit_f32::<DummyError>(42.0);
259        assert!(v.is_ok());
260        assert_eq!(v.unwrap(), DataValue::F32(42.0));
261        let v = DataValueVisitor.visit_u8::<DummyError>(42);
262        assert!(v.is_ok());
263        assert_eq!(v.unwrap(), DataValue::U8(42));
264        let v = DataValueVisitor.visit_i128::<DummyError>(i128::MAX);
265        assert!(v.is_ok());
266        assert_eq!(v.unwrap(), DataValue::I128(i128::MAX));
267        let v = DataValueVisitor.visit_u128::<DummyError>(u128::MAX);
268        assert!(v.is_ok());
269        assert_eq!(v.unwrap(), DataValue::U128(u128::MAX));
270        let v = DataValueVisitor.visit_bytes::<DummyError>(b"test");
271        assert!(v.is_ok());
272        assert_eq!(v.unwrap(), DataValue::Bytes(b"test".to_vec()));
273        let v = DataValueVisitor.visit_byte_buf::<DummyError>(b"test".to_vec());
274        assert!(v.is_ok());
275        assert_eq!(v.unwrap(), DataValue::Bytes(b"test".to_vec()));
276        let v = DataValueVisitor.visit_none::<DummyError>();
277        assert!(v.is_ok());
278        assert_eq!(v.unwrap(), DataValue::Null);
279    }
280}
trs_data_value/deserializer.rs

trs_data_value/
deserializer.rs
