zen_types/rcvalue/
de.rs

1use crate::constant::NUMBER_TOKEN;
2use crate::rcvalue::RcValue;
3use ahash::{HashMap, HashMapExt};
4use rust_decimal::Decimal;
5use rust_decimal::prelude::FromPrimitive;
6use serde::de::{DeserializeSeed, Error, MapAccess, SeqAccess, Unexpected, Visitor};
7use serde::{Deserialize, Deserializer};
8use std::fmt::Formatter;
9use std::marker::PhantomData;
10use std::ops::Deref;
11use std::rc::Rc;
12
13struct RcValueVisitor;
14
15impl<'de> Visitor<'de> for RcValueVisitor {
16    type Value = RcValue;
17
18    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
19        formatter.write_str("A valid type")
20    }
21
22    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
23    where
24        E: Error,
25    {
26        Ok(RcValue::Bool(v))
27    }
28
29    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
30    where
31        E: Error,
32    {
33        Ok(RcValue::Number(Decimal::from_i64(v).ok_or_else(|| {
34            Error::invalid_value(Unexpected::Signed(v), &self)
35        })?))
36    }
37
38    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
39    where
40        E: Error,
41    {
42        Ok(RcValue::Number(Decimal::from_u64(v).ok_or_else(|| {
43            Error::invalid_value(Unexpected::Unsigned(v), &self)
44        })?))
45    }
46
47    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
48    where
49        E: Error,
50    {
51        Ok(RcValue::Number(Decimal::from_f64(v).ok_or_else(|| {
52            Error::invalid_value(Unexpected::Float(v), &self)
53        })?))
54    }
55
56    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
57    where
58        E: Error,
59    {
60        Ok(RcValue::String(Rc::from(v)))
61    }
62
63    fn visit_unit<E>(self) -> Result<Self::Value, E>
64    where
65        E: Error,
66    {
67        Ok(RcValue::Null)
68    }
69
70    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
71    where
72        A: SeqAccess<'de>,
73    {
74        let mut vec = Vec::with_capacity(seq.size_hint().unwrap_or_default());
75        while let Some(value) = seq.next_element_seed(RcValueDeserializer)? {
76            vec.push(value);
77        }
78
79        Ok(RcValue::Array(vec))
80    }
81
82    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
83    where
84        A: MapAccess<'de>,
85    {
86        let mut m = HashMap::with_capacity(map.size_hint().unwrap_or_default());
87        let mut first = true;
88
89        while let Some((key, value)) =
90            map.next_entry_seed(PhantomData::<Rc<str>>, RcValueDeserializer)?
91        {
92            if first && key.deref() == NUMBER_TOKEN {
93                let str = match &value {
94                    RcValue::String(s) => s.as_ref(),
95                    _ => return Err(Error::custom("failed to deserialize number")),
96                };
97
98                return Ok(RcValue::Number(
99                    Decimal::from_str_exact(str)
100                        .or_else(|_| Decimal::from_scientific(str))
101                        .map_err(|_| Error::custom("invalid number"))?,
102                ));
103            }
104
105            m.insert(key, value);
106            first = false;
107        }
108
109        Ok(RcValue::Object(m))
110    }
111}
112
113pub struct RcValueDeserializer;
114
115impl<'de> DeserializeSeed<'de> for RcValueDeserializer {
116    type Value = RcValue;
117
118    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
119    where
120        D: Deserializer<'de>,
121    {
122        deserializer.deserialize_any(RcValueVisitor)
123    }
124}
125
126impl<'de> Deserialize<'de> for RcValue {
127    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
128    where
129        D: Deserializer<'de>,
130    {
131        deserializer.deserialize_any(RcValueVisitor)
132    }
133}
zen_types/rcvalue/de.rs

zen_types/rcvalue/
de.rs
