compris/de/deserializer/
deserializer.rs

1use super::{
2    super::{super::normal::*, errors::*},
3    enum_deserializer::*,
4    map_as_list_deserializer::*,
5    map_deserializer::*,
6    seq_deserializer::*,
7};
8
9use {num_traits::*, serde::de};
10
11//
12// Deserializer
13//
14
15/// Serde deserializer for Compris normal types.
16///
17/// Will convert number types only if information is not lost. Otherwise, will return an error.
18///
19/// See [NumCast::from](cast::NumCast::from).
20pub struct Deserializer<'own, AnnotatedT> {
21    variant: &'own Variant<AnnotatedT>,
22}
23
24impl<'own, AnnotatedT> Deserializer<'own, AnnotatedT> {
25    /// Constructor
26    pub fn new(variant: &'own Variant<AnnotatedT>) -> Self {
27        Self { variant }
28    }
29
30    fn incompatible_type_error(&self) -> DeserializeError {
31        DeserializeError::incompatible_type(&self.variant)
32    }
33
34    fn incompatible_value_error(&self) -> DeserializeError {
35        DeserializeError::incompatible_variant(&self.variant)
36    }
37}
38
39// See: https://serde.rs/impl-deserializer.html
40
41impl<'de, 'own, AnnotatedT> de::Deserializer<'de> for &'own mut Deserializer<'de, AnnotatedT> {
42    type Error = DeserializeError;
43
44    fn deserialize_any<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
45    where
46        VisitorT: de::Visitor<'de>,
47    {
48        match self.variant {
49            Variant::Undefined => Err(self.incompatible_type_error()),
50            Variant::Null(_) => self.deserialize_unit(visitor),
51            Variant::Integer(_) => self.deserialize_i64(visitor),
52            Variant::UnsignedInteger(_) => self.deserialize_u64(visitor),
53            Variant::Float(_) => self.deserialize_f64(visitor),
54            Variant::Boolean(_) => self.deserialize_bool(visitor),
55            Variant::Text(_) => self.deserialize_str(visitor),
56            Variant::Blob(_) => self.deserialize_bytes(visitor),
57            Variant::List(_) => self.deserialize_seq(visitor),
58            Variant::Map(_) => self.deserialize_map(visitor),
59        }
60    }
61
62    fn deserialize_bool<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
63    where
64        VisitorT: de::Visitor<'de>,
65    {
66        match self.variant {
67            Variant::Boolean(boolean) => visitor.visit_bool(boolean.inner),
68            _ => Err(self.incompatible_type_error()),
69        }
70    }
71
72    fn deserialize_i8<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
73    where
74        VisitorT: de::Visitor<'de>,
75    {
76        match self.variant {
77            Variant::Integer(integer) => match cast(integer.inner) {
78                Some(integer) => visitor.visit_i8(integer),
79                None => Err(self.incompatible_value_error()),
80            },
81
82            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
83                Some(integer) => visitor.visit_i8(integer),
84                None => Err(self.incompatible_value_error()),
85            },
86
87            Variant::Float(float) => {
88                let float: f64 = float.inner.into();
89                if float.fract() == 0. {
90                    match cast(float) {
91                        Some(integer) => visitor.visit_i8(integer),
92                        None => Err(self.incompatible_value_error()),
93                    }
94                } else {
95                    Err(self.incompatible_value_error())
96                }
97            }
98
99            _ => Err(self.incompatible_type_error()),
100        }
101    }
102
103    fn deserialize_i16<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
104    where
105        VisitorT: de::Visitor<'de>,
106    {
107        match self.variant {
108            Variant::Integer(integer) => match cast(integer.inner) {
109                Some(integer) => visitor.visit_i16(integer),
110                None => Err(self.incompatible_value_error()),
111            },
112
113            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
114                Some(integer) => visitor.visit_i16(integer),
115                None => Err(self.incompatible_value_error()),
116            },
117
118            Variant::Float(float) => {
119                let float: f64 = float.into();
120                if float.fract() == 0. {
121                    match cast(float) {
122                        Some(integer) => visitor.visit_i16(integer),
123                        None => Err(self.incompatible_value_error()),
124                    }
125                } else {
126                    Err(self.incompatible_value_error())
127                }
128            }
129
130            _ => Err(self.incompatible_type_error()),
131        }
132    }
133
134    fn deserialize_i32<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
135    where
136        VisitorT: de::Visitor<'de>,
137    {
138        match self.variant {
139            Variant::Integer(integer) => match cast(integer.inner) {
140                Some(integer) => visitor.visit_i32(integer),
141                None => Err(self.incompatible_value_error()),
142            },
143
144            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
145                Some(integer) => visitor.visit_i32(integer),
146                None => Err(self.incompatible_value_error()),
147            },
148
149            Variant::Float(float) => {
150                let float: f64 = float.into();
151                if float.fract() == 0. {
152                    match cast(float) {
153                        Some(integer) => visitor.visit_i32(integer),
154                        None => Err(self.incompatible_value_error()),
155                    }
156                } else {
157                    Err(self.incompatible_value_error())
158                }
159            }
160
161            _ => Err(self.incompatible_type_error()),
162        }
163    }
164
165    fn deserialize_i64<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
166    where
167        VisitorT: de::Visitor<'de>,
168    {
169        match self.variant {
170            Variant::Integer(integer) => visitor.visit_i64(integer.inner),
171
172            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
173                Some(integer) => visitor.visit_i64(integer),
174                None => Err(self.incompatible_value_error()),
175            },
176
177            Variant::Float(float) => {
178                let float: f64 = float.inner.into();
179                if float.fract() == 0. {
180                    match cast(float) {
181                        Some(integer) => visitor.visit_i64(integer),
182                        None => Err(self.incompatible_value_error()),
183                    }
184                } else {
185                    Err(self.incompatible_value_error())
186                }
187            }
188
189            _ => Err(self.incompatible_type_error()),
190        }
191    }
192
193    fn deserialize_u8<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
194    where
195        VisitorT: de::Visitor<'de>,
196    {
197        match self.variant {
198            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
199                Some(unsigned_integer) => visitor.visit_u8(unsigned_integer),
200                None => Err(self.incompatible_value_error()),
201            },
202
203            Variant::Integer(integer) => {
204                if integer.inner >= 0 {
205                    match cast(integer.inner) {
206                        Some(insigned_integer) => visitor.visit_u8(insigned_integer),
207                        None => Err(self.incompatible_value_error()),
208                    }
209                } else {
210                    Err(self.incompatible_value_error())
211                }
212            }
213
214            Variant::Float(float) => {
215                let float: f64 = float.into();
216                if (float >= 0.) && (float.fract() == 0.) {
217                    match cast(float) {
218                        Some(unsigned_integer) => visitor.visit_u8(unsigned_integer),
219                        None => Err(self.incompatible_value_error()),
220                    }
221                } else {
222                    Err(self.incompatible_value_error())
223                }
224            }
225
226            _ => Err(self.incompatible_type_error()),
227        }
228    }
229
230    fn deserialize_u16<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
231    where
232        VisitorT: de::Visitor<'de>,
233    {
234        match self.variant {
235            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
236                Some(unsigned_integer) => visitor.visit_u16(unsigned_integer),
237                None => Err(self.incompatible_value_error()),
238            },
239
240            Variant::Integer(integer) => {
241                if integer.inner >= 0 {
242                    match cast(integer.inner) {
243                        Some(insigned_integer) => visitor.visit_u16(insigned_integer),
244                        None => Err(self.incompatible_value_error()),
245                    }
246                } else {
247                    Err(self.incompatible_value_error())
248                }
249            }
250
251            Variant::Float(float) => {
252                let float: f64 = float.into();
253                if (float >= 0.) && (float.fract() == 0.) {
254                    match cast(float) {
255                        Some(unsigned_integer) => visitor.visit_u16(unsigned_integer),
256                        None => Err(self.incompatible_value_error()),
257                    }
258                } else {
259                    Err(self.incompatible_value_error())
260                }
261            }
262
263            _ => Err(self.incompatible_type_error()),
264        }
265    }
266
267    fn deserialize_u32<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
268    where
269        VisitorT: de::Visitor<'de>,
270    {
271        match self.variant {
272            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
273                Some(unsigned_integer) => visitor.visit_u32(unsigned_integer),
274                None => Err(self.incompatible_value_error()),
275            },
276
277            Variant::Integer(integer) => {
278                if integer.inner >= 0 {
279                    match cast(integer.inner) {
280                        Some(insigned_integer) => visitor.visit_u32(insigned_integer),
281                        None => Err(self.incompatible_value_error()),
282                    }
283                } else {
284                    Err(self.incompatible_value_error())
285                }
286            }
287
288            Variant::Float(float) => {
289                let float: f64 = float.inner.into();
290                if (float >= 0.) && (float.fract() == 0.) {
291                    match cast(float) {
292                        Some(unsigned_integer) => visitor.visit_u32(unsigned_integer),
293                        None => Err(self.incompatible_value_error()),
294                    }
295                } else {
296                    Err(self.incompatible_value_error())
297                }
298            }
299
300            _ => Err(self.incompatible_type_error()),
301        }
302    }
303
304    fn deserialize_u64<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
305    where
306        VisitorT: de::Visitor<'de>,
307    {
308        match self.variant {
309            Variant::UnsignedInteger(unsigned_integer) => visitor.visit_u64(unsigned_integer.inner),
310
311            Variant::Integer(integer) => {
312                if integer.inner >= 0 {
313                    match cast(integer.inner) {
314                        Some(insigned_integer) => visitor.visit_u64(insigned_integer),
315                        None => Err(self.incompatible_value_error()),
316                    }
317                } else {
318                    Err(self.incompatible_value_error())
319                }
320            }
321
322            Variant::Float(float) => {
323                let float: f64 = float.into();
324                if (float >= 0.) && (float.fract() == 0.) {
325                    match cast(float) {
326                        Some(unsigned_integer) => visitor.visit_u64(unsigned_integer),
327                        None => Err(self.incompatible_value_error()),
328                    }
329                } else {
330                    Err(self.incompatible_value_error())
331                }
332            }
333
334            _ => Err(self.incompatible_type_error()),
335        }
336    }
337
338    fn deserialize_f32<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
339    where
340        VisitorT: de::Visitor<'de>,
341    {
342        match self.variant {
343            Variant::Float(float) => {
344                let float: f64 = float.into();
345                match cast(float) {
346                    Some(float) => visitor.visit_f32(float),
347                    None => Err(self.incompatible_value_error()),
348                }
349            }
350
351            Variant::Integer(integer) => match cast(integer.inner) {
352                Some(float) => visitor.visit_f32(float),
353                None => Err(self.incompatible_value_error()),
354            },
355
356            Variant::UnsignedInteger(unsigned_integer) => match cast(unsigned_integer.inner) {
357                Some(float) => visitor.visit_f32(float),
358                None => Err(self.incompatible_value_error()),
359            },
360
361            _ => Err(self.incompatible_type_error()),
362        }
363    }
364
365    fn deserialize_f64<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
366    where
367        VisitorT: de::Visitor<'de>,
368    {
369        match self.variant {
370            Variant::Float(float) => visitor.visit_f64(float.into()),
371
372            Variant::Integer(integer) => match cast(integer.inner) {
373                Some(float) => visitor.visit_f64(float),
374                None => Err(self.incompatible_value_error()),
375            },
376
377            Variant::UnsignedInteger(unsigned_integer) => match cast::<_, f64>(unsigned_integer.inner) {
378                Some(float) => visitor.visit_f64(float),
379                None => Err(self.incompatible_value_error()),
380            },
381
382            _ => Err(self.incompatible_type_error()),
383        }
384    }
385
386    fn deserialize_char<VisitorT>(self, _visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
387    where
388        VisitorT: de::Visitor<'de>,
389    {
390        Err(DeserializeError::NotSupported("deserialize_char"))
391    }
392
393    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
394    where
395        V: de::Visitor<'de>,
396    {
397        match self.variant {
398            Variant::Text(text) => visitor.visit_str(text.into()),
399            _ => Err(self.incompatible_type_error()),
400        }
401    }
402
403    fn deserialize_string<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
404    where
405        VisitorT: de::Visitor<'de>,
406    {
407        match self.variant {
408            Variant::Text(text) => visitor.visit_str(text.into()),
409            _ => Err(self.incompatible_type_error()),
410        }
411    }
412
413    fn deserialize_bytes<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
414    where
415        VisitorT: de::Visitor<'de>,
416    {
417        match self.variant {
418            Variant::Blob(blob) => visitor.visit_bytes(blob.into()),
419            _ => Err(self.incompatible_type_error()),
420        }
421    }
422
423    fn deserialize_byte_buf<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
424    where
425        VisitorT: de::Visitor<'de>,
426    {
427        match self.variant {
428            Variant::Blob(blob) => visitor.visit_bytes(blob.into()),
429            _ => Err(self.incompatible_type_error()),
430        }
431    }
432
433    fn deserialize_option<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
434    where
435        VisitorT: de::Visitor<'de>,
436    {
437        match self.variant {
438            Variant::Null(_) => visitor.visit_none(),
439            _ => visitor.visit_some(self),
440        }
441    }
442
443    fn deserialize_unit<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
444    where
445        VisitorT: de::Visitor<'de>,
446    {
447        match self.variant {
448            Variant::Null(_) => visitor.visit_unit(),
449            _ => Err(self.incompatible_type_error()),
450        }
451    }
452
453    fn deserialize_unit_struct<VisitorT>(
454        self,
455        _name: &'static str,
456        visitor: VisitorT,
457    ) -> Result<VisitorT::Value, Self::Error>
458    where
459        VisitorT: de::Visitor<'de>,
460    {
461        self.deserialize_unit(visitor)
462    }
463
464    fn deserialize_newtype_struct<VisitorT>(
465        self,
466        _name: &'static str,
467        visitor: VisitorT,
468    ) -> Result<VisitorT::Value, Self::Error>
469    where
470        VisitorT: de::Visitor<'de>,
471    {
472        visitor.visit_newtype_struct(self)
473    }
474
475    fn deserialize_seq<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
476    where
477        VisitorT: de::Visitor<'de>,
478    {
479        match self.variant {
480            Variant::List(list) => Ok(visitor.visit_seq(SeqDeserializer::new(list))?),
481            _ => Err(self.incompatible_type_error()),
482        }
483    }
484
485    fn deserialize_tuple<VisitorT>(self, _len: usize, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
486    where
487        VisitorT: de::Visitor<'de>,
488    {
489        self.deserialize_seq(visitor)
490    }
491
492    fn deserialize_tuple_struct<VisitorT>(
493        self,
494        _name: &'static str,
495        _len: usize,
496        visitor: VisitorT,
497    ) -> Result<VisitorT::Value, Self::Error>
498    where
499        VisitorT: de::Visitor<'de>,
500    {
501        self.deserialize_seq(visitor)
502    }
503
504    fn deserialize_map<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
505    where
506        VisitorT: de::Visitor<'de>,
507    {
508        match self.variant {
509            Variant::Map(map) => Ok(visitor.visit_map(MapDeserializer::new(map))?),
510            Variant::List(list) => Ok(visitor.visit_map(MapAsListDeserializer::new(list))?),
511            _ => Err(self.incompatible_type_error()),
512        }
513    }
514
515    fn deserialize_struct<VisitorT>(
516        self,
517        _name: &'static str,
518        _fields: &'static [&'static str],
519        visitor: VisitorT,
520    ) -> Result<VisitorT::Value, Self::Error>
521    where
522        VisitorT: de::Visitor<'de>,
523    {
524        self.deserialize_map(visitor)
525    }
526
527    fn deserialize_enum<VisitorT>(
528        self,
529        _name: &'static str,
530        _variants: &'static [&'static str],
531        visitor: VisitorT,
532    ) -> Result<VisitorT::Value, Self::Error>
533    where
534        VisitorT: de::Visitor<'de>,
535    {
536        match self.variant {
537            Variant::Map(map) => Ok(visitor.visit_enum(EnumDeserializer::new(map)?)?),
538            _ => Err(self.incompatible_type_error()),
539        }
540    }
541
542    fn deserialize_identifier<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
543    where
544        VisitorT: de::Visitor<'de>,
545    {
546        self.deserialize_any(visitor)
547    }
548
549    fn deserialize_ignored_any<VisitorT>(self, visitor: VisitorT) -> Result<VisitorT::Value, Self::Error>
550    where
551        VisitorT: de::Visitor<'de>,
552    {
553        self.deserialize_any(visitor)
554    }
555}
compris/de/deserializer/deserializer.rs

compris/de/deserializer/
deserializer.rs
