1use super::error::{Error, Result};
2use super::Value;
3use serde::de::{
4 DeserializeSeed, EnumAccess, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor,
5};
6use serde::{self, Deserializer};
7use std;
8use std::collections::HashMap;
9use std::vec;
10
11impl<'de> serde::Deserializer<'de> for Value {
12 type Error = Error;
13
14 #[inline]
15 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
16 where
17 V: Visitor<'de>,
18 {
19 match self {
20 Value::Int(v) => visitor.visit_i32(v),
21 Value::Bool(v) => visitor.visit_bool(v),
22 Value::DateTime(v) | Value::String(v) => visitor.visit_string(v),
23 Value::Double(v) => visitor.visit_f64(v),
24 Value::Base64(v) => visitor.visit_bytes(v.as_slice()),
25 Value::Array(v) => {
26 let len = v.len();
27 let mut deserializer = SeqDeserializer::new(v);
28 let seq = visitor.visit_seq(&mut deserializer)?;
29 let remaining = deserializer.iter.len();
30 if remaining == 0 {
31 Ok(seq)
32 } else {
33 Err(serde::de::Error::invalid_length(
34 len,
35 &"fewer elements in array",
36 ))
37 }
38 }
39 Value::Struct(v) => {
40 let len = v.len();
41 let mut deserializer = MapDeserializer::new(v);
42 let map = visitor.visit_map(&mut deserializer)?;
43 let remaining = deserializer.iter.len();
44 if remaining == 0 {
45 Ok(map)
46 } else {
47 Err(serde::de::Error::invalid_length(
48 len,
49 &"fewer elements in map",
50 ))
51 }
52 }
53 }
54 }
55
56 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
57 where
58 V: Visitor<'de>,
59 {
60 match self {
61 Value::Bool(v) => visitor.visit_bool(v),
62 Value::String(v) => match v.as_str() {
63 "true" => visitor.visit_bool(true),
64 "false" => visitor.visit_bool(false),
65 _ => Err(serde::de::Error::invalid_value(
66 Unexpected::Str(&v),
67 &visitor,
68 )),
69 },
70 _ => Err(serde::de::Error::invalid_value(self.unexpected(), &visitor)),
71 }
72 }
73
74 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
75 where
76 V: Visitor<'de>,
77 {
78 let v = handle_integer(self, &visitor)?;
79 visitor.visit_i8(v)
80 }
81
82 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
83 where
84 V: Visitor<'de>,
85 {
86 let v = handle_integer(self, &visitor)?;
87 visitor.visit_i16(v)
88 }
89
90 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
91 where
92 V: Visitor<'de>,
93 {
94 let v = handle_integer(self, &visitor)?;
95 visitor.visit_i32(v)
96 }
97
98 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
99 where
100 V: Visitor<'de>,
101 {
102 let v = handle_integer(self, &visitor)?;
103 visitor.visit_i64(v)
104 }
105
106 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
107 where
108 V: Visitor<'de>,
109 {
110 let v = handle_integer(self, &visitor)?;
111 visitor.visit_u8(v)
112 }
113
114 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
115 where
116 V: Visitor<'de>,
117 {
118 let v = handle_integer(self, &visitor)?;
119 visitor.visit_u16(v)
120 }
121
122 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
123 where
124 V: Visitor<'de>,
125 {
126 let v = handle_integer(self, &visitor)?;
127 visitor.visit_u32(v)
128 }
129
130 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
131 where
132 V: Visitor<'de>,
133 {
134 let v = handle_integer(self, &visitor)?;
135 visitor.visit_u64(v)
136 }
137
138 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
139 where
140 V: Visitor<'de>,
141 {
142 match self {
143 Value::Double(v) => visitor.visit_f32(v as f32),
144 Value::String(v) => {
145 let x: Result<f32> = v
146 .parse()
147 .map_err(|_| serde::de::Error::invalid_value(Unexpected::Str(&v), &visitor));
148 visitor.visit_f32(x?)
149 }
150 _ => Err(serde::de::Error::invalid_value(self.unexpected(), &visitor)),
151 }
152 }
153
154 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
155 where
156 V: Visitor<'de>,
157 {
158 match self {
159 Value::Double(v) => visitor.visit_f64(v),
160 Value::String(v) => {
161 let x: Result<f64> = v
162 .parse()
163 .map_err(|_| serde::de::Error::invalid_value(Unexpected::Str(&v), &visitor));
164 visitor.visit_f64(x?)
165 }
166 Value::Int(v) => visitor.visit_f64(v as f64),
167 _ => Err(serde::de::Error::invalid_value(self.unexpected(), &visitor)),
168 }
169 }
170
171 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
172 where
173 V: Visitor<'de>,
174 {
175 if let Value::String(v) = self {
176 if v.len() != 1 {
177 return Err(serde::de::Error::invalid_value(
178 Unexpected::Str(&v),
179 &"string with a single character",
180 ));
181 }
182 visitor.visit_char(v.chars().next().unwrap())
183 } else {
184 Err(serde::de::Error::invalid_value(self.unexpected(), &visitor))
185 }
186 }
187
188 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
189 where
190 V: Visitor<'de>,
191 {
192 if let Value::String(v) = self {
193 visitor.visit_str(&v)
194 } else {
195 Err(serde::de::Error::invalid_value(self.unexpected(), &visitor))
196 }
197 }
198
199 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
200 where
201 V: Visitor<'de>,
202 {
203 if let Value::String(v) = self {
204 visitor.visit_string(v)
205 } else {
206 Err(serde::de::Error::invalid_value(self.unexpected(), &visitor))
207 }
208 }
209
210 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
211 where
212 V: Visitor<'de>,
213 {
214 if let Value::Base64(v) = self {
215 visitor.visit_bytes(v.as_slice())
216 } else {
217 Err(serde::de::Error::invalid_value(self.unexpected(), &visitor))
218 }
219 }
220
221 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
222 where
223 V: Visitor<'de>,
224 {
225 if let Value::Base64(v) = self {
226 visitor.visit_byte_buf(v)
227 } else {
228 Err(serde::de::Error::invalid_value(self.unexpected(), &visitor))
229 }
230 }
231
232 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
233 where
234 V: Visitor<'de>,
235 {
236 match self {
237 Value::Array(mut v) => {
238 let v1 = v.pop();
239 if !v.is_empty() {
240 return Err(serde::de::Error::invalid_value(
241 Unexpected::Seq,
242 &"array with a single element",
243 ));
244 }
245 match v1 {
246 Some(x) => visitor.visit_some(x),
247 None => visitor.visit_none(),
248 }
249 }
250
251 v => visitor.visit_some(v),
252 }
253 }
254
255 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
256 where
257 V: Visitor<'de>,
258 {
259 if let Value::Struct(v) = self {
260 if !v.is_empty() {
261 return Err(serde::de::Error::invalid_value(
262 Unexpected::Map,
263 &"empty map",
264 ));
265 }
266 visitor.visit_unit()
267 } else {
268 Err(serde::de::Error::invalid_value(
269 self.unexpected(),
270 &"empty map",
271 ))
272 }
273 }
274
275 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
276 where
277 V: Visitor<'de>,
278 {
279 self.deserialize_unit(visitor)
280 }
281
282 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
283 where
284 V: Visitor<'de>,
285 {
286 visitor.visit_newtype_struct(self)
287 }
288
289 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
290 where
291 V: Visitor<'de>,
292 {
293 self.deserialize_any(visitor)
294 }
295
296 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
297 where
298 V: Visitor<'de>,
299 {
300 self.deserialize_any(visitor)
301 }
302
303 fn deserialize_tuple_struct<V>(
304 self,
305 _name: &'static str,
306 _len: usize,
307 visitor: V,
308 ) -> Result<V::Value>
309 where
310 V: Visitor<'de>,
311 {
312 self.deserialize_any(visitor)
313 }
314
315 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
316 where
317 V: Visitor<'de>,
318 {
319 self.deserialize_any(visitor)
320 }
321
322 fn deserialize_struct<V>(
323 self,
324 _name: &'static str,
325 _fields: &'static [&'static str],
326 visitor: V,
327 ) -> Result<V::Value>
328 where
329 V: Visitor<'de>,
330 {
331 self.deserialize_any(visitor)
332 }
333
334 fn deserialize_enum<V>(
335 self,
336 _name: &'static str,
337 _variants: &'static [&'static str],
338 visitor: V,
339 ) -> Result<V::Value>
340 where
341 V: Visitor<'de>,
342 {
343 match self {
344 Value::Struct(members) => {
345 let mut member_iter = members.into_iter();
346 if let Some((key, value)) = member_iter.next() {
347 if member_iter.next().is_none() {
348 return visitor.visit_enum(EnumDeserializer {
349 variant: key,
350 value,
351 });
352 }
353 }
354 Err(serde::de::Error::invalid_value(
355 Unexpected::Map,
356 &"map with a single key",
357 ))
358 }
359 other => Err(serde::de::Error::invalid_value(
360 other.unexpected(),
361 &"map with a single key",
362 )),
363 }
364 }
365
366 forward_to_deserialize_any! {
367 identifier ignored_any
368 }
369}
370
371struct SeqDeserializer {
372 iter: vec::IntoIter<Value>,
373}
374
375impl SeqDeserializer {
376 fn new(vec: Vec<Value>) -> Self {
377 SeqDeserializer {
378 iter: vec.into_iter(),
379 }
380 }
381}
382
383impl<'de> serde::Deserializer<'de> for SeqDeserializer {
384 type Error = Error;
385
386 #[inline]
387 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value>
388 where
389 V: Visitor<'de>,
390 {
391 let len = self.iter.len();
392 let ret = visitor.visit_seq(&mut self)?;
393 let remaining = self.iter.len();
394 if remaining == 0 {
395 Ok(ret)
396 } else {
397 Err(serde::de::Error::invalid_length(
398 len,
399 &"fewer elements in array",
400 ))
401 }
402 }
403
404 forward_to_deserialize_any! {
405 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
406 byte_buf option unit unit_struct newtype_struct seq tuple
407 tuple_struct map struct enum identifier ignored_any
408 }
409}
410
411impl<'de> SeqAccess<'de> for SeqDeserializer {
412 type Error = Error;
413
414 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
415 where
416 T: DeserializeSeed<'de>,
417 {
418 match self.iter.next() {
419 Some(value) => seed.deserialize(value).map(Some),
420 None => Ok(None),
421 }
422 }
423
424 fn size_hint(&self) -> Option<usize> {
425 match self.iter.size_hint() {
426 (lower, Some(upper)) if lower == upper => Some(upper),
427 _ => None,
428 }
429 }
430}
431
432struct MapDeserializer {
433 iter: <HashMap<String, Value> as IntoIterator>::IntoIter,
434 value: Option<Value>,
435}
436
437impl MapDeserializer {
438 fn new(map: HashMap<String, Value>) -> Self {
439 MapDeserializer {
440 iter: map.into_iter(),
441 value: None,
442 }
443 }
444}
445
446impl<'de> MapAccess<'de> for MapDeserializer {
447 type Error = Error;
448
449 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
450 where
451 T: DeserializeSeed<'de>,
452 {
453 match self.iter.next() {
454 Some((key, value)) => {
455 self.value = Some(value);
456 seed.deserialize(Value::String(key)).map(Some)
457 }
458 None => Ok(None),
459 }
460 }
461
462 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
463 where
464 T: DeserializeSeed<'de>,
465 {
466 match self.value.take() {
467 Some(value) => seed.deserialize(value),
468 None => Err(serde::de::Error::custom("value is missing")),
469 }
470 }
471
472 fn size_hint(&self) -> Option<usize> {
473 match self.iter.size_hint() {
474 (lower, Some(upper)) if lower == upper => Some(upper),
475 _ => None,
476 }
477 }
478}
479
480impl<'de> serde::Deserializer<'de> for MapDeserializer {
481 type Error = Error;
482
483 #[inline]
484 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
485 where
486 V: Visitor<'de>,
487 {
488 visitor.visit_map(self)
489 }
490
491 forward_to_deserialize_any! {
492 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
493 byte_buf option unit unit_struct newtype_struct seq tuple
494 tuple_struct map struct enum identifier ignored_any
495 }
496}
497
498struct EnumDeserializer {
499 variant: String,
500 value: Value,
501}
502
503impl<'de> EnumAccess<'de> for EnumDeserializer {
504 type Error = Error;
505 type Variant = Value;
506
507 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Value)>
508 where
509 V: DeserializeSeed<'de>,
510 {
511 let value = self.value;
512 let variant = Value::String(self.variant);
513 seed.deserialize(variant).map(|v| (v, value))
514 }
515}
516
517impl<'de> VariantAccess<'de> for Value {
518 type Error = Error;
519
520 fn unit_variant(self) -> Result<()> {
521 if let Value::Struct(v) = self {
522 if !v.is_empty() {
523 return Err(serde::de::Error::invalid_value(
524 Unexpected::Map,
525 &"empty map",
526 ));
527 }
528 Ok(())
529 } else {
530 Err(serde::de::Error::invalid_value(
531 self.unexpected(),
532 &"empty map",
533 ))
534 }
535 }
536
537 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
538 where
539 T: DeserializeSeed<'de>,
540 {
541 seed.deserialize(self)
542 }
543
544 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
545 where
546 V: Visitor<'de>,
547 {
548 self.deserialize_seq(visitor)
549 }
550
551 fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
552 where
553 V: Visitor<'de>,
554 {
555 self.deserialize_struct("", fields, visitor)
556 }
557}
558
559trait FromI32 {
560 fn from_i32(v: i32) -> Self;
561}
562
563macro_rules! impl_from_i32 {
564 ($($ty:ty)*) => {
565 $(
566 impl FromI32 for $ty {
567 #[inline]
568 fn from_i32(v: i32) -> $ty {
569 v as $ty
570 }
571 }
572 )*
573 }
574}
575
576impl_from_i32!(u8 u16 u32 u64 i8 i16 i32);
577
578impl FromI32 for i64 {
579 #[inline]
580 fn from_i32(v: i32) -> i64 {
581 v.into()
582 }
583}
584
585fn handle_integer<'de, T, V>(value: Value, visitor: &V) -> Result<T>
586where
587 T: FromI32 + std::str::FromStr,
588 V: Visitor<'de>,
589{
590 match value {
591 Value::Int(v) => Ok(T::from_i32(v)),
592 Value::String(v) => v
593 .parse()
594 .map_err(|_| serde::de::Error::invalid_value(Unexpected::Str(&v), visitor)),
595 _ => Err(serde::de::Error::invalid_value(value.unexpected(), visitor)),
596 }
597}