litl_val/to_other/deserializer/
val_e.rs

1use serde::Deserializer;
2use serde::{
3    de::{
4        value::{MapDeserializer, SeqDeserializer},
5        Error, IntoDeserializer, Unexpected, Visitor,
6    },
7    forward_to_deserialize_any,
8};
9
10use super::ValDeserializerError;
11use crate::ValE;
12
13impl<'de> Deserializer<'de> for ValE {
14    type Error = ValDeserializerError;
15
16    #[inline]
17    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
18    where
19        V: serde::de::Visitor<'de>,
20    {
21        match self {
22            ValE::Null => visitor.visit_none(),
23            ValE::Bool(b) => visitor.visit_bool(b),
24            ValE::Number(n) => {
25                // weird hack for deserializing floats when integers are expected
26                // if floats are expected, this should still work!
27                let float = n.into_inner();
28                if float.fract() == 0.0 {
29                    visitor.visit_i64(float as i64)
30                } else {
31                    visitor.visit_f64(float)
32                }
33            }
34            ValE::ShortString(s) => visitor.visit_str(s.as_ref()),
35            ValE::LongString(s) => visitor.visit_str(s.as_ref()),
36            ValE::Array(a) => visitor.visit_seq(SeqDeserializer::new(a.into_vec().into_iter())),
37            ValE::Object(o) => {
38                visitor.visit_map(MapDeserializer::new(o.into_entries().0.into_iter()))
39            }
40        }
41    }
42
43    forward_to_deserialize_any! {
44        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
45        bytes byte_buf unit unit_struct newtype_struct seq tuple
46        tuple_struct map struct identifier ignored_any
47    }
48
49    #[inline]
50    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
51    where
52        V: Visitor<'de>,
53    {
54        match self {
55            ValE::Null => visitor.visit_none(),
56            _ => visitor.visit_some(self),
57        }
58    }
59
60    #[inline]
61    fn deserialize_enum<V>(
62        self,
63        _name: &str,
64        _variants: &'static [&'static str],
65        visitor: V,
66    ) -> Result<V::Value, Self::Error>
67    where
68        V: Visitor<'de>,
69    {
70        deserialize_val_e_enum(self, visitor)
71    }
72}
73
74#[inline]
75pub fn deserialize_val_e_enum<'de, V: Visitor<'de>>(
76    val: ValE,
77    visitor: V,
78) -> Result<V::Value, ValDeserializerError> {
79    let (variant, value) = match val {
80        ValE::Object(value) => {
81            let mut iter = value.into_entries().0.into_iter();
82            let (variant, value) = match iter.next() {
83                Some((k, v)) => (k.into_string(), v),
84                None => {
85                    return Err(ValDeserializerError::invalid_value(
86                        Unexpected::Map,
87                        &"map with a single key",
88                    ));
89                }
90            };
91            // enums are encoded in json as maps with a single key:value pair
92            if iter.next().is_some() {
93                return Err(ValDeserializerError::invalid_value(
94                    Unexpected::Map,
95                    &"map with a single key",
96                ));
97            }
98            (variant, Some(value))
99        }
100        ValE::ShortString(variant) => (variant.as_ref().to_string(), None),
101        ValE::LongString(variant) => (variant.into_string(), None),
102        other => {
103            return Err(ValDeserializerError::invalid_type(
104                Unexpected::Other(&format!("{:?}", other)),
105                &"string or map",
106            ));
107        }
108    };
109
110    visitor.visit_enum(super::enum_de::EnumDeserializer { variant, value })
111}
112
113impl<'de> IntoDeserializer<'de> for ValE {
114    type Deserializer = Self;
115
116    fn into_deserializer(self) -> Self::Deserializer {
117        self
118    }
119}
litl_val/to_other/deserializer/val_e.rs

litl_val/to_other/deserializer/
val_e.rs
