1use serde::de::value::{MapDeserializer, SeqDeserializer};
2use serde::de::{
3 DeserializeSeed, Deserializer, EnumAccess, Expected, IntoDeserializer, Unexpected,
4 VariantAccess, Visitor,
5};
6use serde::Deserialize;
7
8use crate::de::Error;
9use crate::value::{BigInt, Map, Record, Set, Tuple, Value};
10
11impl Value {
12 fn invalid_type<E>(&self, exp: &dyn Expected) -> E
13 where
14 E: serde::de::Error,
15 {
16 serde::de::Error::invalid_type(self.unexpected(), exp)
17 }
18
19 fn unexpected(&self) -> Unexpected {
20 match self {
21 Value::Bool(b) => Unexpected::Bool(*b),
22 Value::Number(n) => Unexpected::Signed(*n),
23 Value::String(s) => Unexpected::Str(s),
24 Value::List(_) => Unexpected::Seq,
25 Value::Map(_) => Unexpected::Map,
26 Value::Record(_) => Unexpected::Other("record"),
27 Value::BigInt(_) => Unexpected::Other("bigint"),
28 Value::Tuple(_) => Unexpected::Other("tuple"),
29 Value::Set(_) => Unexpected::Other("set"),
30 Value::Unserializable(_) => Unexpected::Other("unserializable"),
31 }
32 }
33}
34
35macro_rules! deserialize_number {
36 ($ty:ty, $to:ident, $visit:ident, $method:ident) => {
37 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
38 where
39 V: Visitor<'de>,
40 {
41 match self {
42 Value::Number(n) => {
43 let num = <$ty>::try_from(n).map_err(|_| {
44 serde::de::Error::invalid_type(Unexpected::Signed(n), &stringify!($ty))
45 })?;
46
47 visitor.$visit(num)
48 }
49 Value::BigInt(v) => {
50 let num = <$ty>::try_from(v.into_inner()).map_err(|_| {
51 serde::de::Error::invalid_type(
52 Unexpected::Other("bigint"),
53 &stringify!($ty),
54 )
55 })?;
56
57 visitor.$visit(num)
58 }
59 _ => Err(self.invalid_type(&visitor)),
60 }
61 }
62 };
63}
64
65impl IntoDeserializer<'_, Error> for Value {
66 type Deserializer = Self;
67
68 fn into_deserializer(self) -> Self::Deserializer {
69 self
70 }
71}
72
73impl<'de> Deserializer<'de> for Value {
74 type Error = Error;
75
76 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
77 where
78 V: Visitor<'de>,
79 {
80 match self {
81 Value::Bool(v) => visitor.visit_bool(v),
82 Value::Number(v) => visitor.visit_i64(v),
83 Value::String(v) => visitor.visit_string(v),
84 Value::BigInt(v) => visit_bigint(v, visitor),
85 Value::List(v) => visit_list(v, visitor),
86 Value::Tuple(v) if v.is_empty() => visitor.visit_unit(),
87 Value::Tuple(v) => visit_tuple(v, visitor),
88 Value::Set(v) => visit_set(v, visitor),
89 Value::Record(v) => visit_record(v, visitor),
90 Value::Map(v) => visit_map(v, visitor),
91 Value::Unserializable(_) => Err(Error::UnsupportedType("unserializable")),
92 }
93 }
94
95 deserialize_number!(i8, to_i8, visit_i8, deserialize_i8);
96 deserialize_number!(i16, to_i16, visit_i16, deserialize_i16);
97 deserialize_number!(i32, to_i32, visit_i32, deserialize_i32);
98 deserialize_number!(i64, to_i64, visit_i64, deserialize_i64);
99 deserialize_number!(i128, to_i128, visit_i128, deserialize_i128);
100 deserialize_number!(u8, to_u8, visit_u8, deserialize_u8);
101 deserialize_number!(u16, to_u16, visit_u16, deserialize_u16);
102 deserialize_number!(u32, to_u32, visit_u32, deserialize_u32);
103 deserialize_number!(u64, to_u64, visit_u64, deserialize_u64);
104 deserialize_number!(u128, to_u128, visit_u128, deserialize_u128);
105
106 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
107 where
108 V: Visitor<'de>,
109 {
110 visitor.visit_some(self)
111 }
112
113 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
114 where
115 V: Visitor<'de>,
116 {
117 match self {
118 Value::Bool(v) => visitor.visit_bool(v),
119 _ => Err(self.invalid_type(&visitor)),
120 }
121 }
122
123 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
124 where
125 V: Visitor<'de>,
126 {
127 self.deserialize_string(visitor)
128 }
129
130 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
131 where
132 V: Visitor<'de>,
133 {
134 self.deserialize_string(visitor)
135 }
136
137 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
138 where
139 V: Visitor<'de>,
140 {
141 match self {
142 Value::String(v) => visitor.visit_string(v),
143 Value::BigInt(v) => visit_bigint(v, visitor),
144 _ => Err(self.invalid_type(&visitor)),
145 }
146 }
147
148 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
149 where
150 V: Visitor<'de>,
151 {
152 self.deserialize_byte_buf(visitor)
153 }
154
155 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
156 where
157 V: Visitor<'de>,
158 {
159 match self {
160 Value::String(v) => visitor.visit_string(v),
161 Value::List(v) => visit_list(v, visitor),
162 _ => Err(self.invalid_type(&visitor)),
163 }
164 }
165
166 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
167 where
168 V: Visitor<'de>,
169 {
170 Err(self.invalid_type(&visitor))
171 }
172
173 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
174 where
175 V: Visitor<'de>,
176 {
177 Err(self.invalid_type(&visitor))
178 }
179
180 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
181 where
182 V: Visitor<'de>,
183 {
184 Err(self.invalid_type(&visitor))
185 }
186
187 fn deserialize_unit_struct<V>(
188 self,
189 _name: &'static str,
190 visitor: V,
191 ) -> Result<V::Value, Self::Error>
192 where
193 V: Visitor<'de>,
194 {
195 self.deserialize_unit(visitor)
196 }
197
198 fn deserialize_newtype_struct<V>(
199 self,
200 _name: &'static str,
201 visitor: V,
202 ) -> Result<V::Value, Self::Error>
203 where
204 V: Visitor<'de>,
205 {
206 visitor.visit_newtype_struct(self)
207 }
208
209 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
210 where
211 V: Visitor<'de>,
212 {
213 match self {
214 Value::List(v) => visit_list(v, visitor),
215 Value::Tuple(v) => visit_tuple(v, visitor),
216 Value::Set(v) => visit_set(v, visitor),
217 _ => Err(self.invalid_type(&visitor)),
218 }
219 }
220
221 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
222 where
223 V: Visitor<'de>,
224 {
225 match self {
226 Value::BigInt(v) => visit_bigint(v, visitor),
227 _ => self.deserialize_seq(visitor),
228 }
229 }
230
231 fn deserialize_tuple_struct<V>(
232 self,
233 _name: &'static str,
234 _len: usize,
235 visitor: V,
236 ) -> Result<V::Value, Self::Error>
237 where
238 V: Visitor<'de>,
239 {
240 self.deserialize_seq(visitor)
241 }
242
243 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
244 where
245 V: Visitor<'de>,
246 {
247 match self {
248 Value::Map(v) => visit_map(v, visitor),
249 _ => Err(self.invalid_type(&visitor)),
250 }
251 }
252
253 fn deserialize_struct<V>(
254 self,
255 _name: &'static str,
256 _fields: &'static [&'static str],
257 visitor: V,
258 ) -> Result<V::Value, Self::Error>
259 where
260 V: Visitor<'de>,
261 {
262 match self {
263 Value::Record(v) => visit_record(v, visitor),
264 _ => Err(self.invalid_type(&visitor)),
265 }
266 }
267
268 fn deserialize_enum<V>(
269 self,
270 _name: &'static str,
271 _variants: &'static [&'static str],
272 visitor: V,
273 ) -> Result<V::Value, Self::Error>
274 where
275 V: Visitor<'de>,
276 {
277 let (variant, value) = match self {
278 Value::Record(value) => {
279 let mut iter = value.into_iter();
280 let (variant, value) = match iter.next() {
281 Some(v) => v,
282 None => {
283 return Err(serde::de::Error::invalid_value(
284 Unexpected::Map,
285 &"map with a single key",
286 ));
287 }
288 };
289 if iter.next().is_some() {
290 return Err(serde::de::Error::invalid_value(
291 Unexpected::Map,
292 &"map with a single key",
293 ));
294 }
295 (variant, Some(value))
296 }
297 Value::String(variant) => (variant, None),
298 other => {
299 return Err(serde::de::Error::invalid_type(
300 other.unexpected(),
301 &"string or map",
302 ));
303 }
304 };
305
306 visitor.visit_enum(EnumDeserializer { variant, value })
307 }
308
309 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
310 where
311 V: Visitor<'de>,
312 {
313 self.deserialize_string(visitor)
314 }
315
316 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
317 where
318 V: Visitor<'de>,
319 {
320 drop(self);
321 visitor.visit_unit()
322 }
323}
324
325fn visit_bigint<'de, V>(v: BigInt, visitor: V) -> Result<V::Value, Error>
326where
327 V: Visitor<'de>,
328{
329 visitor.visit_string(v.to_string())
330}
331
332fn visit_map<'de, V>(v: Map<Value, Value>, visitor: V) -> Result<V::Value, Error>
333where
334 V: Visitor<'de>,
335{
336 let mut deserializer = MapDeserializer::new(v.into_iter());
337 let map = visitor.visit_map(&mut deserializer)?;
338 Ok(map)
339}
340
341fn visit_record<'de, V>(record: Record, visitor: V) -> Result<V::Value, Error>
342where
343 V: Visitor<'de>,
344{
345 if record.is_empty() {
346 return visitor.visit_unit();
347 }
348
349 let mut deserializer = MapDeserializer::new(record.into_iter());
350 let map = visitor.visit_map(&mut deserializer)?;
351 Ok(map)
352}
353
354fn visit_set<'de, V>(v: Set<Value>, visitor: V) -> Result<V::Value, Error>
355where
356 V: Visitor<'de>,
357{
358 let mut deserializer = SeqDeserializer::new(v.into_iter());
359 let seq = visitor.visit_seq(&mut deserializer)?;
360 Ok(seq)
361}
362
363fn visit_tuple<'de, V>(v: Tuple<Value>, visitor: V) -> Result<V::Value, Error>
364where
365 V: Visitor<'de>,
366{
367 let mut deserializer = SeqDeserializer::new(v.into_iter());
368 let seq = visitor.visit_seq(&mut deserializer)?;
369 Ok(seq)
370}
371
372fn visit_list<'de, V>(v: Vec<Value>, visitor: V) -> Result<V::Value, Error>
373where
374 V: Visitor<'de>,
375{
376 let mut deserializer = SeqDeserializer::new(v.into_iter());
377 let seq = visitor.visit_seq(&mut deserializer)?;
378 Ok(seq)
379}
380
381struct EnumDeserializer {
382 variant: String,
383 value: Option<Value>,
384}
385
386impl<'de> EnumAccess<'de> for EnumDeserializer {
387 type Error = Error;
388 type Variant = VariantDeserializer;
389
390 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
391 where
392 V: DeserializeSeed<'de>,
393 {
394 let variant = self.variant.into_deserializer();
395 let visitor = VariantDeserializer { value: self.value };
396 seed.deserialize(variant).map(|v| (v, visitor))
397 }
398}
399
400struct VariantDeserializer {
401 value: Option<Value>,
402}
403
404impl<'de> VariantAccess<'de> for VariantDeserializer {
405 type Error = Error;
406
407 fn unit_variant(self) -> Result<(), Error> {
408 match self.value {
409 Some(value) => Deserialize::deserialize(value),
410 None => Ok(()),
411 }
412 }
413
414 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
415 where
416 T: DeserializeSeed<'de>,
417 {
418 match self.value {
419 Some(value) => seed.deserialize(value),
420 None => Err(serde::de::Error::invalid_type(
421 Unexpected::UnitVariant,
422 &"newtype variant",
423 )),
424 }
425 }
426
427 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
428 where
429 V: Visitor<'de>,
430 {
431 match self.value {
432 Some(Value::Tuple(v)) => {
433 if v.is_empty() {
434 visitor.visit_unit()
435 } else {
436 visit_tuple(v, visitor)
437 }
438 }
439 Some(other) => Err(serde::de::Error::invalid_type(
447 other.unexpected(),
448 &"tuple variant",
449 )),
450 None => Err(serde::de::Error::invalid_type(
451 Unexpected::UnitVariant,
452 &"tuple variant",
453 )),
454 }
455 }
456
457 fn struct_variant<V>(
458 self,
459 _fields: &'static [&'static str],
460 visitor: V,
461 ) -> Result<V::Value, Error>
462 where
463 V: Visitor<'de>,
464 {
465 match self.value {
466 Some(Value::Record(v)) => visit_record(v, visitor),
467 Some(other) => Err(serde::de::Error::invalid_type(
468 other.unexpected(),
469 &"struct variant",
470 )),
471 None => Err(serde::de::Error::invalid_type(
472 Unexpected::UnitVariant,
473 &"struct variant",
474 )),
475 }
476 }
477}