1use std::fmt::{self, Formatter};
2
3use indexmap::IndexMap;
4use serde::{
5 de::{Error as DeError, MapAccess, SeqAccess, Visitor},
6 ser::SerializeMap,
7 Deserialize, Deserializer, Serialize, Serializer,
8};
9
10use crate::{ConstValue, Name, Number, Value};
11
12impl Serialize for ConstValue {
13 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
14 match self {
15 ConstValue::Null => serializer.serialize_none(),
16 ConstValue::Number(v) => v.serialize(serializer),
17 ConstValue::String(v) => serializer.serialize_str(v),
18 ConstValue::Boolean(v) => serializer.serialize_bool(*v),
19 ConstValue::Binary(v) => serializer.serialize_bytes(v),
20 ConstValue::Enum(v) => serializer.serialize_str(v),
21 ConstValue::List(v) => v.serialize(serializer),
22 ConstValue::Object(v) => v.serialize(serializer),
23 }
24 }
25}
26
27impl<'de> Deserialize<'de> for ConstValue {
28 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
29 struct ValueVisitor;
30
31 impl<'de> Visitor<'de> for ValueVisitor {
32 type Value = ConstValue;
33
34 #[inline]
35 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
36 formatter.write_str("any valid value")
37 }
38
39 #[inline]
40 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
41 where
42 E: DeError,
43 {
44 Ok(ConstValue::Boolean(v))
45 }
46
47 #[inline]
48 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
49 where
50 E: DeError,
51 {
52 Ok(ConstValue::Number(v.into()))
53 }
54
55 #[inline]
56 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
57 where
58 E: DeError,
59 {
60 Ok(ConstValue::Number(v.into()))
61 }
62
63 #[inline]
64 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
65 where
66 E: DeError,
67 {
68 Ok(Number::from_f64(v).map_or(ConstValue::Null, ConstValue::Number))
69 }
70
71 #[inline]
72 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
73 where
74 E: DeError,
75 {
76 Ok(ConstValue::String(v.to_string()))
77 }
78
79 #[inline]
80 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
81 where
82 E: DeError,
83 {
84 Ok(ConstValue::String(v))
85 }
86
87 #[inline]
88 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
89 where
90 E: DeError,
91 {
92 Ok(ConstValue::Binary(v.to_vec().into()))
93 }
94
95 #[inline]
96 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
97 where
98 E: DeError,
99 {
100 Ok(ConstValue::Binary(v.into()))
101 }
102
103 #[inline]
104 fn visit_none<E>(self) -> Result<Self::Value, E>
105 where
106 E: DeError,
107 {
108 Ok(ConstValue::Null)
109 }
110
111 #[inline]
112 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
113 where
114 D: Deserializer<'de>,
115 {
116 Deserialize::deserialize(deserializer)
117 }
118
119 #[inline]
120 fn visit_unit<E>(self) -> Result<Self::Value, E>
121 where
122 E: DeError,
123 {
124 Ok(ConstValue::Null)
125 }
126
127 fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
128 where
129 A: SeqAccess<'de>,
130 {
131 let mut vec = Vec::new();
132 while let Some(elem) = visitor.next_element()? {
133 vec.push(elem);
134 }
135 Ok(ConstValue::List(vec))
136 }
137
138 fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
139 where
140 A: MapAccess<'de>,
141 {
142 let mut map = IndexMap::new();
143 while let Some((name, value)) = visitor.next_entry()? {
144 map.insert(name, value);
145 }
146 Ok(ConstValue::Object(map))
147 }
148 }
149
150 deserializer.deserialize_any(ValueVisitor)
151 }
152}
153
154#[derive(Debug)]
155struct SerdeVariable(Name);
156
157impl Serialize for SerdeVariable {
158 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
159 let mut s = serializer.serialize_map(Some(1))?;
160 s.serialize_entry("$var", &self.0)?;
161 s.end()
162 }
163}
164
165impl Serialize for Value {
166 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
167 match self {
168 Value::Variable(name) => SerdeVariable(name.clone()).serialize(serializer),
169 Value::Null => serializer.serialize_none(),
170 Value::Number(v) => v.serialize(serializer),
171 Value::String(v) => serializer.serialize_str(v),
172 Value::Boolean(v) => serializer.serialize_bool(*v),
173 Value::Binary(v) => serializer.serialize_bytes(v),
174 Value::Enum(v) => serializer.serialize_str(v),
175 Value::List(v) => v.serialize(serializer),
176 Value::Object(v) => v.serialize(serializer),
177 }
178 }
179}
180
181impl<'de> Deserialize<'de> for Value {
182 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
183 struct ValueVisitor;
184
185 impl<'de> Visitor<'de> for ValueVisitor {
186 type Value = Value;
187
188 #[inline]
189 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
190 formatter.write_str("any valid value")
191 }
192
193 #[inline]
194 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
195 where
196 E: DeError,
197 {
198 Ok(Value::Boolean(v))
199 }
200
201 #[inline]
202 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
203 where
204 E: DeError,
205 {
206 Ok(Value::Number(v.into()))
207 }
208
209 #[inline]
210 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
211 where
212 E: DeError,
213 {
214 Ok(Value::Number(v.into()))
215 }
216
217 #[inline]
218 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
219 where
220 E: DeError,
221 {
222 Ok(Number::from_f64(v).map_or(Value::Null, Value::Number))
223 }
224
225 #[inline]
226 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
227 where
228 E: DeError,
229 {
230 Ok(Value::String(v.to_string()))
231 }
232
233 #[inline]
234 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
235 where
236 E: DeError,
237 {
238 Ok(Value::String(v))
239 }
240
241 #[inline]
242 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
243 where
244 E: DeError,
245 {
246 Ok(Value::Binary(v.to_vec().into()))
247 }
248
249 #[inline]
250 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
251 where
252 E: DeError,
253 {
254 Ok(Value::Binary(v.into()))
255 }
256
257 #[inline]
258 fn visit_none<E>(self) -> Result<Self::Value, E>
259 where
260 E: DeError,
261 {
262 Ok(Value::Null)
263 }
264
265 #[inline]
266 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
267 where
268 D: Deserializer<'de>,
269 {
270 Deserialize::deserialize(deserializer)
271 }
272
273 #[inline]
274 fn visit_unit<E>(self) -> Result<Self::Value, E>
275 where
276 E: DeError,
277 {
278 Ok(Value::Null)
279 }
280
281 fn visit_seq<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
282 where
283 A: SeqAccess<'de>,
284 {
285 let mut vec = Vec::new();
286 while let Some(elem) = visitor.next_element()? {
287 vec.push(elem);
288 }
289 Ok(Value::List(vec))
290 }
291
292 fn visit_map<A>(self, mut visitor: A) -> Result<Self::Value, A::Error>
293 where
294 A: MapAccess<'de>,
295 {
296 let mut map = IndexMap::new();
297 while let Some((name, value)) = visitor.next_entry()? {
298 match &value {
299 Value::String(value) if name == "$var" => {
300 return Ok(Value::Variable(Name::new(value)));
301 }
302 _ => {
303 map.insert(name, value);
304 }
305 }
306 }
307 Ok(Value::Object(map))
308 }
309 }
310
311 deserializer.deserialize_any(ValueVisitor)
312 }
313}
314
315#[cfg(test)]
316mod tests {
317 use super::*;
318
319 #[test]
320 fn var_serde() {
321 let var = Value::Variable(Name::new("abc"));
322 let s = serde_json::to_string(&var).unwrap();
323 assert_eq!(s, r#"{"$var":"abc"}"#);
324 assert_eq!(var, serde_json::from_str(&s).unwrap());
325 }
326}