mason_rs/value/
serde.rs

1use std::{collections::HashMap, fmt};
2
3use serde::{
4    Deserialize, Serialize,
5    de::{MapAccess, SeqAccess, Visitor},
6};
7
8use crate::Value;
9
10impl Serialize for Value {
11    #[inline]
12    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
13    where
14        S: serde::Serializer,
15    {
16        match self {
17            Self::Null => serializer.serialize_unit(),
18            Self::Bool(b) => serializer.serialize_bool(*b),
19            Self::Number(f) => serializer.serialize_f64(*f),
20            Self::String(s) => serializer.serialize_str(s),
21            Self::ByteString(v) => serializer.serialize_bytes(v),
22            Self::Array(v) => v.serialize(serializer),
23            Self::Object(m) => m.serialize(serializer),
24        }
25    }
26}
27
28impl<'de> Deserialize<'de> for Value {
29    #[inline]
30    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
31    where
32        D: serde::Deserializer<'de>,
33    {
34        struct ValueVisitor;
35
36        impl<'de> Visitor<'de> for ValueVisitor {
37            type Value = Value;
38
39            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
40                formatter.write_str("any valid MASON value")
41            }
42
43            #[inline]
44            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
45                Ok(Value::Bool(value))
46            }
47
48            #[inline]
49            fn visit_i64<E>(self, value: i64) -> Result<Value, E>
50            where
51                E: serde::de::Error,
52            {
53                // The largest whole number representable by a f64
54                const MAX: i64 = 2i64.pow(f64::MANTISSA_DIGITS) + 1;
55
56                if value.abs() <= MAX {
57                    Ok(Value::Number(value as f64))
58                } else {
59                    Err(serde::de::Error::invalid_value(
60                        serde::de::Unexpected::Signed(value),
61                        &self,
62                    ))
63                }
64            }
65
66            #[inline]
67            fn visit_i128<E>(self, value: i128) -> Result<Value, E>
68            where
69                E: serde::de::Error,
70            {
71                // The largest whole number representable by a f64
72                const MAX: i128 = 2i128.pow(f64::MANTISSA_DIGITS) + 1;
73
74                if value.abs() <= MAX {
75                    Ok(Value::Number(value as f64))
76                } else {
77                    Err(serde::de::Error::invalid_value(
78                        serde::de::Unexpected::Other(&format!("integer `{value}` as i128")),
79                        &self,
80                    ))
81                }
82            }
83
84            #[inline]
85            fn visit_u64<E>(self, value: u64) -> Result<Value, E>
86            where
87                E: serde::de::Error,
88            {
89                // The largest whole number representable by a f64
90                const MAX: u64 = 2u64.pow(f64::MANTISSA_DIGITS) + 1;
91
92                if value <= MAX {
93                    Ok(Value::Number(value as f64))
94                } else {
95                    Err(serde::de::Error::invalid_value(
96                        serde::de::Unexpected::Unsigned(value),
97                        &self,
98                    ))
99                }
100            }
101
102            #[inline]
103            fn visit_u128<E>(self, value: u128) -> Result<Value, E>
104            where
105                E: serde::de::Error,
106            {
107                // The largest whole number representable by a f64
108                const MAX: u128 = 2u128.pow(f64::MANTISSA_DIGITS) + 1;
109
110                if value <= MAX {
111                    Ok(Value::Number(value as f64))
112                } else {
113                    Err(serde::de::Error::invalid_value(
114                        serde::de::Unexpected::Other(&format!("integer `{value}` as u128")),
115                        &self,
116                    ))
117                }
118            }
119
120            #[inline]
121            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
122                Ok(Value::Number(value))
123            }
124
125            #[inline]
126            fn visit_str<E>(self, value: &str) -> Result<Value, E>
127            where
128                E: serde::de::Error,
129            {
130                self.visit_string(String::from(value))
131            }
132
133            #[inline]
134            fn visit_string<E>(self, value: String) -> Result<Value, E> {
135                Ok(Value::String(value))
136            }
137
138            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> {
139                Ok(Value::ByteString(v.to_vec()))
140            }
141
142            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> {
143                Ok(Value::ByteString(v))
144            }
145
146            #[inline]
147            fn visit_none<E>(self) -> Result<Value, E> {
148                Ok(Value::Null)
149            }
150
151            #[inline]
152            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
153            where
154                D: serde::Deserializer<'de>,
155            {
156                Deserialize::deserialize(deserializer)
157            }
158
159            #[inline]
160            fn visit_unit<E>(self) -> Result<Value, E> {
161                Ok(Value::Null)
162            }
163
164            #[inline]
165            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
166            where
167                V: SeqAccess<'de>,
168            {
169                let mut vec = Vec::new();
170
171                while let Some(elem) = visitor.next_element()? {
172                    vec.push(elem);
173                }
174
175                Ok(Value::Array(vec))
176            }
177
178            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
179            where
180                V: MapAccess<'de>,
181            {
182                let mut values = HashMap::new();
183
184                while let Some((key, value)) = visitor.next_entry()? {
185                    values.insert(key, value);
186                }
187
188                Ok(Value::Object(values))
189            }
190        }
191
192        deserializer.deserialize_any(ValueVisitor)
193    }
194}
mason_rs/value/serde.rs

mason_rs/value/
serde.rs
