1use crate::error::{Error, ErrorCode};
2use crate::map::Map;
3use crate::number::Number;
4use crate::value::Value;
5use alloc::borrow::{Cow, ToOwned};
6use alloc::string::String;
7#[cfg(feature = "raw_value")]
8use alloc::string::ToString;
9use alloc::vec::{self, Vec};
10use core::fmt;
11use core::slice;
12use core::str::FromStr;
13use serde::de::{
14 self, Deserialize, DeserializeSeed, Deserializer as _, EnumAccess, Expected, IntoDeserializer,
15 MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor,
16};
17use serde::forward_to_deserialize_any;
18
19#[cfg(feature = "arbitrary_precision")]
20use crate::number::NumberFromString;
21
22impl<'de> Deserialize<'de> for Value {
23 #[inline]
24 fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
25 where
26 D: serde::Deserializer<'de>,
27 {
28 struct ValueVisitor;
29
30 impl<'de> Visitor<'de> for ValueVisitor {
31 type Value = Value;
32
33 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
34 formatter.write_str("any valid JSON value")
35 }
36
37 #[inline]
38 fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
39 Ok(Value::Bool(value))
40 }
41
42 #[inline]
43 fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
44 Ok(Value::Number(value.into()))
45 }
46
47 fn visit_i128<E>(self, value: i128) -> Result<Value, E>
48 where
49 E: serde::de::Error,
50 {
51 let de = serde::de::value::I128Deserializer::new(value);
52 Number::deserialize(de).map(Value::Number)
53 }
54
55 #[inline]
56 fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
57 Ok(Value::Number(value.into()))
58 }
59
60 fn visit_u128<E>(self, value: u128) -> Result<Value, E>
61 where
62 E: serde::de::Error,
63 {
64 let de = serde::de::value::U128Deserializer::new(value);
65 Number::deserialize(de).map(Value::Number)
66 }
67
68 #[inline]
69 fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
70 Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
71 }
72
73 #[cfg(any(feature = "std", feature = "alloc"))]
74 #[inline]
75 fn visit_str<E>(self, value: &str) -> Result<Value, E>
76 where
77 E: serde::de::Error,
78 {
79 self.visit_string(String::from(value))
80 }
81
82 #[cfg(any(feature = "std", feature = "alloc"))]
83 #[inline]
84 fn visit_string<E>(self, value: String) -> Result<Value, E> {
85 Ok(Value::String(value))
86 }
87
88 #[inline]
89 fn visit_none<E>(self) -> Result<Value, E> {
90 Ok(Value::Null)
91 }
92
93 #[inline]
94 fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
95 where
96 D: serde::Deserializer<'de>,
97 {
98 Deserialize::deserialize(deserializer)
99 }
100
101 #[inline]
102 fn visit_unit<E>(self) -> Result<Value, E> {
103 Ok(Value::Null)
104 }
105
106 #[inline]
107 fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
108 where
109 V: SeqAccess<'de>,
110 {
111 let mut vec = Vec::new();
112
113 while let Some(elem) = tri!(visitor.next_element()) {
114 vec.push(elem);
115 }
116
117 Ok(Value::Array(vec))
118 }
119
120 #[cfg(any(feature = "std", feature = "alloc"))]
121 fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
122 where
123 V: MapAccess<'de>,
124 {
125 match tri!(visitor.next_key_seed(KeyClassifier)) {
126 #[cfg(feature = "arbitrary_precision")]
127 Some(KeyClass::Number) => {
128 let number: NumberFromString = tri!(visitor.next_value());
129 Ok(Value::Number(number.value))
130 }
131 #[cfg(feature = "raw_value")]
132 Some(KeyClass::RawValue) => {
133 let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString));
134 crate::from_str(value.get()).map_err(de::Error::custom)
135 }
136 Some(KeyClass::Map(first_key)) => {
137 let mut values = Map::new();
138
139 values.insert(first_key, tri!(visitor.next_value()));
140 while let Some((key, value)) = tri!(visitor.next_entry()) {
141 values.insert(key, value);
142 }
143
144 Ok(Value::Object(values))
145 }
146 None => Ok(Value::Object(Map::new())),
147 }
148 }
149 }
150
151 deserializer.deserialize_any(ValueVisitor)
152 }
153}
154
155impl FromStr for Value {
156 type Err = Error;
157 fn from_str(s: &str) -> Result<Value, Error> {
158 super::super::de::from_str(s)
159 }
160}
161
162macro_rules! deserialize_number {
163 ($method:ident) => {
164 #[cfg(not(feature = "arbitrary_precision"))]
165 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
166 where
167 V: Visitor<'de>,
168 {
169 match self {
170 Value::Number(n) => n.deserialize_any(visitor),
171 _ => Err(self.invalid_type(&visitor)),
172 }
173 }
174
175 #[cfg(feature = "arbitrary_precision")]
176 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
177 where
178 V: Visitor<'de>,
179 {
180 match self {
181 Value::Number(n) => n.$method(visitor),
182 _ => self.deserialize_any(visitor),
183 }
184 }
185 };
186}
187
188fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
189where
190 V: Visitor<'de>,
191{
192 let len: usize = array.len();
193 let mut deserializer: SeqDeserializer = SeqDeserializer::new(vec:array);
194 let seq: >::Value = tri!(visitor.visit_seq(&mut deserializer));
195 let remaining: usize = deserializer.iter.len();
196 if remaining == 0 {
197 Ok(seq)
198 } else {
199 Err(serde::de::Error::invalid_length(
200 len,
201 &"fewer elements in array",
202 ))
203 }
204}
205
206impl<'de> serde::Deserializer<'de> for Map<String, Value> {
207 type Error = Error;
208
209 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
210 where
211 V: Visitor<'de>,
212 {
213 let len = self.len();
214 let mut deserializer = MapDeserializer::new(self);
215 let map = tri!(visitor.visit_map(&mut deserializer));
216 let remaining = deserializer.iter.len();
217 if remaining == 0 {
218 Ok(map)
219 } else {
220 Err(serde::de::Error::invalid_length(
221 len,
222 &"fewer elements in map",
223 ))
224 }
225 }
226
227 fn deserialize_enum<V>(
228 self,
229 _name: &'static str,
230 _variants: &'static [&'static str],
231 visitor: V,
232 ) -> Result<V::Value, Self::Error>
233 where
234 V: Visitor<'de>,
235 {
236 let mut iter = self.into_iter();
237 let (variant, value) = match iter.next() {
238 Some(v) => v,
239 None => {
240 return Err(serde::de::Error::invalid_value(
241 Unexpected::Map,
242 &"map with a single key",
243 ));
244 }
245 };
246 // enums are encoded in json as maps with a single key:value pair
247 if iter.next().is_some() {
248 return Err(serde::de::Error::invalid_value(
249 Unexpected::Map,
250 &"map with a single key",
251 ));
252 }
253
254 visitor.visit_enum(EnumDeserializer {
255 variant,
256 value: Some(value),
257 })
258 }
259
260 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
261 where
262 V: Visitor<'de>,
263 {
264 drop(self);
265 visitor.visit_unit()
266 }
267
268 forward_to_deserialize_any! {
269 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
270 bytes byte_buf option unit unit_struct newtype_struct seq tuple
271 tuple_struct map struct identifier
272 }
273}
274
275impl<'de> serde::Deserializer<'de> for Value {
276 type Error = Error;
277
278 #[inline]
279 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
280 where
281 V: Visitor<'de>,
282 {
283 match self {
284 Value::Null => visitor.visit_unit(),
285 Value::Bool(v) => visitor.visit_bool(v),
286 Value::Number(n) => n.deserialize_any(visitor),
287 #[cfg(any(feature = "std", feature = "alloc"))]
288 Value::String(v) => visitor.visit_string(v),
289 #[cfg(not(any(feature = "std", feature = "alloc")))]
290 Value::String(_) => unreachable!(),
291 Value::Array(v) => visit_array(v, visitor),
292 Value::Object(v) => v.deserialize_any(visitor),
293 }
294 }
295
296 deserialize_number!(deserialize_i8);
297 deserialize_number!(deserialize_i16);
298 deserialize_number!(deserialize_i32);
299 deserialize_number!(deserialize_i64);
300 deserialize_number!(deserialize_i128);
301 deserialize_number!(deserialize_u8);
302 deserialize_number!(deserialize_u16);
303 deserialize_number!(deserialize_u32);
304 deserialize_number!(deserialize_u64);
305 deserialize_number!(deserialize_u128);
306 deserialize_number!(deserialize_f32);
307 deserialize_number!(deserialize_f64);
308
309 #[inline]
310 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
311 where
312 V: Visitor<'de>,
313 {
314 match self {
315 Value::Null => visitor.visit_none(),
316 _ => visitor.visit_some(self),
317 }
318 }
319
320 #[inline]
321 fn deserialize_enum<V>(
322 self,
323 name: &'static str,
324 variants: &'static [&'static str],
325 visitor: V,
326 ) -> Result<V::Value, Error>
327 where
328 V: Visitor<'de>,
329 {
330 match self {
331 Value::Object(value) => value.deserialize_enum(name, variants, visitor),
332 Value::String(variant) => visitor.visit_enum(EnumDeserializer {
333 variant,
334 value: None,
335 }),
336 other => Err(serde::de::Error::invalid_type(
337 other.unexpected(),
338 &"string or map",
339 )),
340 }
341 }
342
343 #[inline]
344 fn deserialize_newtype_struct<V>(
345 self,
346 name: &'static str,
347 visitor: V,
348 ) -> Result<V::Value, Error>
349 where
350 V: Visitor<'de>,
351 {
352 #[cfg(feature = "raw_value")]
353 {
354 if name == crate::raw::TOKEN {
355 return visitor.visit_map(crate::raw::OwnedRawDeserializer {
356 raw_value: Some(self.to_string()),
357 });
358 }
359 }
360
361 let _ = name;
362 visitor.visit_newtype_struct(self)
363 }
364
365 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
366 where
367 V: Visitor<'de>,
368 {
369 match self {
370 Value::Bool(v) => visitor.visit_bool(v),
371 _ => Err(self.invalid_type(&visitor)),
372 }
373 }
374
375 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
376 where
377 V: Visitor<'de>,
378 {
379 self.deserialize_string(visitor)
380 }
381
382 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
383 where
384 V: Visitor<'de>,
385 {
386 self.deserialize_string(visitor)
387 }
388
389 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
390 where
391 V: Visitor<'de>,
392 {
393 match self {
394 #[cfg(any(feature = "std", feature = "alloc"))]
395 Value::String(v) => visitor.visit_string(v),
396 _ => Err(self.invalid_type(&visitor)),
397 }
398 }
399
400 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
401 where
402 V: Visitor<'de>,
403 {
404 self.deserialize_byte_buf(visitor)
405 }
406
407 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
408 where
409 V: Visitor<'de>,
410 {
411 match self {
412 #[cfg(any(feature = "std", feature = "alloc"))]
413 Value::String(v) => visitor.visit_string(v),
414 Value::Array(v) => visit_array(v, visitor),
415 _ => Err(self.invalid_type(&visitor)),
416 }
417 }
418
419 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
420 where
421 V: Visitor<'de>,
422 {
423 match self {
424 Value::Null => visitor.visit_unit(),
425 _ => Err(self.invalid_type(&visitor)),
426 }
427 }
428
429 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
430 where
431 V: Visitor<'de>,
432 {
433 self.deserialize_unit(visitor)
434 }
435
436 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
437 where
438 V: Visitor<'de>,
439 {
440 match self {
441 Value::Array(v) => visit_array(v, visitor),
442 _ => Err(self.invalid_type(&visitor)),
443 }
444 }
445
446 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
447 where
448 V: Visitor<'de>,
449 {
450 self.deserialize_seq(visitor)
451 }
452
453 fn deserialize_tuple_struct<V>(
454 self,
455 _name: &'static str,
456 _len: usize,
457 visitor: V,
458 ) -> Result<V::Value, Error>
459 where
460 V: Visitor<'de>,
461 {
462 self.deserialize_seq(visitor)
463 }
464
465 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
466 where
467 V: Visitor<'de>,
468 {
469 match self {
470 Value::Object(v) => v.deserialize_any(visitor),
471 _ => Err(self.invalid_type(&visitor)),
472 }
473 }
474
475 fn deserialize_struct<V>(
476 self,
477 _name: &'static str,
478 _fields: &'static [&'static str],
479 visitor: V,
480 ) -> Result<V::Value, Error>
481 where
482 V: Visitor<'de>,
483 {
484 match self {
485 Value::Array(v) => visit_array(v, visitor),
486 Value::Object(v) => v.deserialize_any(visitor),
487 _ => Err(self.invalid_type(&visitor)),
488 }
489 }
490
491 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
492 where
493 V: Visitor<'de>,
494 {
495 self.deserialize_string(visitor)
496 }
497
498 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
499 where
500 V: Visitor<'de>,
501 {
502 drop(self);
503 visitor.visit_unit()
504 }
505}
506
507struct EnumDeserializer {
508 variant: String,
509 value: Option<Value>,
510}
511
512impl<'de> EnumAccess<'de> for EnumDeserializer {
513 type Error = Error;
514 type Variant = VariantDeserializer;
515
516 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
517 where
518 V: DeserializeSeed<'de>,
519 {
520 let variant: StringDeserializer = self.variant.into_deserializer();
521 let visitor: VariantDeserializer = VariantDeserializer { value: self.value };
522 seed.deserialize(variant).map(|v: >::Value| (v, visitor))
523 }
524}
525
526impl<'de> IntoDeserializer<'de, Error> for Value {
527 type Deserializer = Self;
528
529 fn into_deserializer(self) -> Self::Deserializer {
530 self
531 }
532}
533
534impl<'de> IntoDeserializer<'de, Error> for &'de Value {
535 type Deserializer = Self;
536
537 fn into_deserializer(self) -> Self::Deserializer {
538 self
539 }
540}
541
542struct VariantDeserializer {
543 value: Option<Value>,
544}
545
546impl<'de> VariantAccess<'de> for VariantDeserializer {
547 type Error = Error;
548
549 fn unit_variant(self) -> Result<(), Error> {
550 match self.value {
551 Some(value) => Deserialize::deserialize(value),
552 None => Ok(()),
553 }
554 }
555
556 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
557 where
558 T: DeserializeSeed<'de>,
559 {
560 match self.value {
561 Some(value) => seed.deserialize(value),
562 None => Err(serde::de::Error::invalid_type(
563 Unexpected::UnitVariant,
564 &"newtype variant",
565 )),
566 }
567 }
568
569 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
570 where
571 V: Visitor<'de>,
572 {
573 match self.value {
574 Some(Value::Array(v)) => {
575 if v.is_empty() {
576 visitor.visit_unit()
577 } else {
578 visit_array(v, visitor)
579 }
580 }
581 Some(other) => Err(serde::de::Error::invalid_type(
582 other.unexpected(),
583 &"tuple variant",
584 )),
585 None => Err(serde::de::Error::invalid_type(
586 Unexpected::UnitVariant,
587 &"tuple variant",
588 )),
589 }
590 }
591
592 fn struct_variant<V>(
593 self,
594 _fields: &'static [&'static str],
595 visitor: V,
596 ) -> Result<V::Value, Error>
597 where
598 V: Visitor<'de>,
599 {
600 match self.value {
601 Some(Value::Object(v)) => v.deserialize_any(visitor),
602 Some(other) => Err(serde::de::Error::invalid_type(
603 other.unexpected(),
604 &"struct variant",
605 )),
606 None => Err(serde::de::Error::invalid_type(
607 Unexpected::UnitVariant,
608 &"struct variant",
609 )),
610 }
611 }
612}
613
614struct SeqDeserializer {
615 iter: vec::IntoIter<Value>,
616}
617
618impl SeqDeserializer {
619 fn new(vec: Vec<Value>) -> Self {
620 SeqDeserializer {
621 iter: vec.into_iter(),
622 }
623 }
624}
625
626impl<'de> SeqAccess<'de> for SeqDeserializer {
627 type Error = Error;
628
629 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
630 where
631 T: DeserializeSeed<'de>,
632 {
633 match self.iter.next() {
634 Some(value: Value) => seed.deserialize(value).map(op:Some),
635 None => Ok(None),
636 }
637 }
638
639 fn size_hint(&self) -> Option<usize> {
640 match self.iter.size_hint() {
641 (lower: usize, Some(upper: usize)) if lower == upper => Some(upper),
642 _ => None,
643 }
644 }
645}
646
647struct MapDeserializer {
648 iter: <Map<String, Value> as IntoIterator>::IntoIter,
649 value: Option<Value>,
650}
651
652impl MapDeserializer {
653 fn new(map: Map<String, Value>) -> Self {
654 MapDeserializer {
655 iter: map.into_iter(),
656 value: None,
657 }
658 }
659}
660
661impl<'de> MapAccess<'de> for MapDeserializer {
662 type Error = Error;
663
664 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
665 where
666 T: DeserializeSeed<'de>,
667 {
668 match self.iter.next() {
669 Some((key, value)) => {
670 self.value = Some(value);
671 let key_de = MapKeyDeserializer {
672 key: Cow::Owned(key),
673 };
674 seed.deserialize(key_de).map(Some)
675 }
676 None => Ok(None),
677 }
678 }
679
680 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
681 where
682 T: DeserializeSeed<'de>,
683 {
684 match self.value.take() {
685 Some(value) => seed.deserialize(value),
686 None => Err(serde::de::Error::custom("value is missing")),
687 }
688 }
689
690 fn size_hint(&self) -> Option<usize> {
691 match self.iter.size_hint() {
692 (lower, Some(upper)) if lower == upper => Some(upper),
693 _ => None,
694 }
695 }
696}
697
698macro_rules! deserialize_value_ref_number {
699 ($method:ident) => {
700 #[cfg(not(feature = "arbitrary_precision"))]
701 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
702 where
703 V: Visitor<'de>,
704 {
705 match self {
706 Value::Number(n) => n.deserialize_any(visitor),
707 _ => Err(self.invalid_type(&visitor)),
708 }
709 }
710
711 #[cfg(feature = "arbitrary_precision")]
712 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
713 where
714 V: Visitor<'de>,
715 {
716 match self {
717 Value::Number(n) => n.$method(visitor),
718 _ => self.deserialize_any(visitor),
719 }
720 }
721 };
722}
723
724fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
725where
726 V: Visitor<'de>,
727{
728 let len: usize = array.len();
729 let mut deserializer: SeqRefDeserializer<'_> = SeqRefDeserializer::new(slice:array);
730 let seq: >::Value = tri!(visitor.visit_seq(&mut deserializer));
731 let remaining: usize = deserializer.iter.len();
732 if remaining == 0 {
733 Ok(seq)
734 } else {
735 Err(serde::de::Error::invalid_length(
736 len,
737 &"fewer elements in array",
738 ))
739 }
740}
741
742impl<'de> serde::Deserializer<'de> for &'de Map<String, Value> {
743 type Error = Error;
744
745 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
746 where
747 V: Visitor<'de>,
748 {
749 let len = self.len();
750 let mut deserializer = MapRefDeserializer::new(self);
751 let map = tri!(visitor.visit_map(&mut deserializer));
752 let remaining = deserializer.iter.len();
753 if remaining == 0 {
754 Ok(map)
755 } else {
756 Err(serde::de::Error::invalid_length(
757 len,
758 &"fewer elements in map",
759 ))
760 }
761 }
762
763 fn deserialize_enum<V>(
764 self,
765 _name: &'static str,
766 _variants: &'static [&'static str],
767 visitor: V,
768 ) -> Result<V::Value, Self::Error>
769 where
770 V: Visitor<'de>,
771 {
772 let mut iter = self.into_iter();
773 let (variant, value) = match iter.next() {
774 Some(v) => v,
775 None => {
776 return Err(serde::de::Error::invalid_value(
777 Unexpected::Map,
778 &"map with a single key",
779 ));
780 }
781 };
782 // enums are encoded in json as maps with a single key:value pair
783 if iter.next().is_some() {
784 return Err(serde::de::Error::invalid_value(
785 Unexpected::Map,
786 &"map with a single key",
787 ));
788 }
789
790 visitor.visit_enum(EnumRefDeserializer {
791 variant,
792 value: Some(value),
793 })
794 }
795
796 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
797 where
798 V: Visitor<'de>,
799 {
800 visitor.visit_unit()
801 }
802
803 forward_to_deserialize_any! {
804 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
805 bytes byte_buf option unit unit_struct newtype_struct seq tuple
806 tuple_struct map struct identifier
807 }
808}
809
810impl<'de> serde::Deserializer<'de> for &'de Value {
811 type Error = Error;
812
813 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
814 where
815 V: Visitor<'de>,
816 {
817 match self {
818 Value::Null => visitor.visit_unit(),
819 Value::Bool(v) => visitor.visit_bool(*v),
820 Value::Number(n) => n.deserialize_any(visitor),
821 Value::String(v) => visitor.visit_borrowed_str(v),
822 Value::Array(v) => visit_array_ref(v, visitor),
823 Value::Object(v) => v.deserialize_any(visitor),
824 }
825 }
826
827 deserialize_value_ref_number!(deserialize_i8);
828 deserialize_value_ref_number!(deserialize_i16);
829 deserialize_value_ref_number!(deserialize_i32);
830 deserialize_value_ref_number!(deserialize_i64);
831 deserialize_number!(deserialize_i128);
832 deserialize_value_ref_number!(deserialize_u8);
833 deserialize_value_ref_number!(deserialize_u16);
834 deserialize_value_ref_number!(deserialize_u32);
835 deserialize_value_ref_number!(deserialize_u64);
836 deserialize_number!(deserialize_u128);
837 deserialize_value_ref_number!(deserialize_f32);
838 deserialize_value_ref_number!(deserialize_f64);
839
840 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
841 where
842 V: Visitor<'de>,
843 {
844 match *self {
845 Value::Null => visitor.visit_none(),
846 _ => visitor.visit_some(self),
847 }
848 }
849
850 fn deserialize_enum<V>(
851 self,
852 name: &'static str,
853 variants: &'static [&'static str],
854 visitor: V,
855 ) -> Result<V::Value, Error>
856 where
857 V: Visitor<'de>,
858 {
859 match self {
860 Value::Object(value) => value.deserialize_enum(name, variants, visitor),
861 Value::String(variant) => visitor.visit_enum(EnumRefDeserializer {
862 variant,
863 value: None,
864 }),
865 other => Err(serde::de::Error::invalid_type(
866 other.unexpected(),
867 &"string or map",
868 )),
869 }
870 }
871
872 #[inline]
873 fn deserialize_newtype_struct<V>(
874 self,
875 name: &'static str,
876 visitor: V,
877 ) -> Result<V::Value, Error>
878 where
879 V: Visitor<'de>,
880 {
881 #[cfg(feature = "raw_value")]
882 {
883 if name == crate::raw::TOKEN {
884 return visitor.visit_map(crate::raw::OwnedRawDeserializer {
885 raw_value: Some(self.to_string()),
886 });
887 }
888 }
889
890 let _ = name;
891 visitor.visit_newtype_struct(self)
892 }
893
894 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
895 where
896 V: Visitor<'de>,
897 {
898 match *self {
899 Value::Bool(v) => visitor.visit_bool(v),
900 _ => Err(self.invalid_type(&visitor)),
901 }
902 }
903
904 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
905 where
906 V: Visitor<'de>,
907 {
908 self.deserialize_str(visitor)
909 }
910
911 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
912 where
913 V: Visitor<'de>,
914 {
915 match self {
916 Value::String(v) => visitor.visit_borrowed_str(v),
917 _ => Err(self.invalid_type(&visitor)),
918 }
919 }
920
921 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
922 where
923 V: Visitor<'de>,
924 {
925 self.deserialize_str(visitor)
926 }
927
928 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
929 where
930 V: Visitor<'de>,
931 {
932 match self {
933 Value::String(v) => visitor.visit_borrowed_str(v),
934 Value::Array(v) => visit_array_ref(v, visitor),
935 _ => Err(self.invalid_type(&visitor)),
936 }
937 }
938
939 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
940 where
941 V: Visitor<'de>,
942 {
943 self.deserialize_bytes(visitor)
944 }
945
946 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
947 where
948 V: Visitor<'de>,
949 {
950 match *self {
951 Value::Null => visitor.visit_unit(),
952 _ => Err(self.invalid_type(&visitor)),
953 }
954 }
955
956 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
957 where
958 V: Visitor<'de>,
959 {
960 self.deserialize_unit(visitor)
961 }
962
963 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
964 where
965 V: Visitor<'de>,
966 {
967 match self {
968 Value::Array(v) => visit_array_ref(v, visitor),
969 _ => Err(self.invalid_type(&visitor)),
970 }
971 }
972
973 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
974 where
975 V: Visitor<'de>,
976 {
977 self.deserialize_seq(visitor)
978 }
979
980 fn deserialize_tuple_struct<V>(
981 self,
982 _name: &'static str,
983 _len: usize,
984 visitor: V,
985 ) -> Result<V::Value, Error>
986 where
987 V: Visitor<'de>,
988 {
989 self.deserialize_seq(visitor)
990 }
991
992 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
993 where
994 V: Visitor<'de>,
995 {
996 match self {
997 Value::Object(v) => v.deserialize_any(visitor),
998 _ => Err(self.invalid_type(&visitor)),
999 }
1000 }
1001
1002 fn deserialize_struct<V>(
1003 self,
1004 _name: &'static str,
1005 _fields: &'static [&'static str],
1006 visitor: V,
1007 ) -> Result<V::Value, Error>
1008 where
1009 V: Visitor<'de>,
1010 {
1011 match self {
1012 Value::Array(v) => visit_array_ref(v, visitor),
1013 Value::Object(v) => v.deserialize_any(visitor),
1014 _ => Err(self.invalid_type(&visitor)),
1015 }
1016 }
1017
1018 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
1019 where
1020 V: Visitor<'de>,
1021 {
1022 self.deserialize_str(visitor)
1023 }
1024
1025 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1026 where
1027 V: Visitor<'de>,
1028 {
1029 visitor.visit_unit()
1030 }
1031}
1032
1033struct EnumRefDeserializer<'de> {
1034 variant: &'de str,
1035 value: Option<&'de Value>,
1036}
1037
1038impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
1039 type Error = Error;
1040 type Variant = VariantRefDeserializer<'de>;
1041
1042 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
1043 where
1044 V: DeserializeSeed<'de>,
1045 {
1046 let variant: StrDeserializer<'_, Error> = self.variant.into_deserializer();
1047 let visitor: VariantRefDeserializer<'_> = VariantRefDeserializer { value: self.value };
1048 seed.deserialize(variant).map(|v: >::Value| (v, visitor))
1049 }
1050}
1051
1052struct VariantRefDeserializer<'de> {
1053 value: Option<&'de Value>,
1054}
1055
1056impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
1057 type Error = Error;
1058
1059 fn unit_variant(self) -> Result<(), Error> {
1060 match self.value {
1061 Some(value) => Deserialize::deserialize(value),
1062 None => Ok(()),
1063 }
1064 }
1065
1066 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1067 where
1068 T: DeserializeSeed<'de>,
1069 {
1070 match self.value {
1071 Some(value) => seed.deserialize(value),
1072 None => Err(serde::de::Error::invalid_type(
1073 Unexpected::UnitVariant,
1074 &"newtype variant",
1075 )),
1076 }
1077 }
1078
1079 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1080 where
1081 V: Visitor<'de>,
1082 {
1083 match self.value {
1084 Some(Value::Array(v)) => {
1085 if v.is_empty() {
1086 visitor.visit_unit()
1087 } else {
1088 visit_array_ref(v, visitor)
1089 }
1090 }
1091 Some(other) => Err(serde::de::Error::invalid_type(
1092 other.unexpected(),
1093 &"tuple variant",
1094 )),
1095 None => Err(serde::de::Error::invalid_type(
1096 Unexpected::UnitVariant,
1097 &"tuple variant",
1098 )),
1099 }
1100 }
1101
1102 fn struct_variant<V>(
1103 self,
1104 _fields: &'static [&'static str],
1105 visitor: V,
1106 ) -> Result<V::Value, Error>
1107 where
1108 V: Visitor<'de>,
1109 {
1110 match self.value {
1111 Some(Value::Object(v)) => v.deserialize_any(visitor),
1112 Some(other) => Err(serde::de::Error::invalid_type(
1113 other.unexpected(),
1114 &"struct variant",
1115 )),
1116 None => Err(serde::de::Error::invalid_type(
1117 Unexpected::UnitVariant,
1118 &"struct variant",
1119 )),
1120 }
1121 }
1122}
1123
1124struct SeqRefDeserializer<'de> {
1125 iter: slice::Iter<'de, Value>,
1126}
1127
1128impl<'de> SeqRefDeserializer<'de> {
1129 fn new(slice: &'de [Value]) -> Self {
1130 SeqRefDeserializer { iter: slice.iter() }
1131 }
1132}
1133
1134impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
1135 type Error = Error;
1136
1137 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1138 where
1139 T: DeserializeSeed<'de>,
1140 {
1141 match self.iter.next() {
1142 Some(value: &'de Value) => seed.deserialize(value).map(op:Some),
1143 None => Ok(None),
1144 }
1145 }
1146
1147 fn size_hint(&self) -> Option<usize> {
1148 match self.iter.size_hint() {
1149 (lower: usize, Some(upper: usize)) if lower == upper => Some(upper),
1150 _ => None,
1151 }
1152 }
1153}
1154
1155struct MapRefDeserializer<'de> {
1156 iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
1157 value: Option<&'de Value>,
1158}
1159
1160impl<'de> MapRefDeserializer<'de> {
1161 fn new(map: &'de Map<String, Value>) -> Self {
1162 MapRefDeserializer {
1163 iter: map.into_iter(),
1164 value: None,
1165 }
1166 }
1167}
1168
1169impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
1170 type Error = Error;
1171
1172 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1173 where
1174 T: DeserializeSeed<'de>,
1175 {
1176 match self.iter.next() {
1177 Some((key, value)) => {
1178 self.value = Some(value);
1179 let key_de = MapKeyDeserializer {
1180 key: Cow::Borrowed(&**key),
1181 };
1182 seed.deserialize(key_de).map(Some)
1183 }
1184 None => Ok(None),
1185 }
1186 }
1187
1188 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1189 where
1190 T: DeserializeSeed<'de>,
1191 {
1192 match self.value.take() {
1193 Some(value) => seed.deserialize(value),
1194 None => Err(serde::de::Error::custom("value is missing")),
1195 }
1196 }
1197
1198 fn size_hint(&self) -> Option<usize> {
1199 match self.iter.size_hint() {
1200 (lower, Some(upper)) if lower == upper => Some(upper),
1201 _ => None,
1202 }
1203 }
1204}
1205
1206struct MapKeyDeserializer<'de> {
1207 key: Cow<'de, str>,
1208}
1209
1210macro_rules! deserialize_numeric_key {
1211 ($method:ident) => {
1212 deserialize_numeric_key!($method, deserialize_number);
1213 };
1214
1215 ($method:ident, $using:ident) => {
1216 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
1217 where
1218 V: Visitor<'de>,
1219 {
1220 let mut de = crate::Deserializer::from_str(&self.key);
1221
1222 match tri!(de.peek()) {
1223 Some(b'0'..=b'9' | b'-') => {}
1224 _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)),
1225 }
1226
1227 let number = tri!(de.$using(visitor));
1228
1229 if tri!(de.peek()).is_some() {
1230 return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0));
1231 }
1232
1233 Ok(number)
1234 }
1235 };
1236}
1237
1238impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
1239 type Error = Error;
1240
1241 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1242 where
1243 V: Visitor<'de>,
1244 {
1245 BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
1246 }
1247
1248 deserialize_numeric_key!(deserialize_i8);
1249 deserialize_numeric_key!(deserialize_i16);
1250 deserialize_numeric_key!(deserialize_i32);
1251 deserialize_numeric_key!(deserialize_i64);
1252 deserialize_numeric_key!(deserialize_u8);
1253 deserialize_numeric_key!(deserialize_u16);
1254 deserialize_numeric_key!(deserialize_u32);
1255 deserialize_numeric_key!(deserialize_u64);
1256 #[cfg(not(feature = "float_roundtrip"))]
1257 deserialize_numeric_key!(deserialize_f32);
1258 deserialize_numeric_key!(deserialize_f64);
1259
1260 #[cfg(feature = "float_roundtrip")]
1261 deserialize_numeric_key!(deserialize_f32, do_deserialize_f32);
1262 deserialize_numeric_key!(deserialize_i128, do_deserialize_i128);
1263 deserialize_numeric_key!(deserialize_u128, do_deserialize_u128);
1264
1265 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
1266 where
1267 V: Visitor<'de>,
1268 {
1269 if self.key == "true" {
1270 visitor.visit_bool(true)
1271 } else if self.key == "false" {
1272 visitor.visit_bool(false)
1273 } else {
1274 Err(serde::de::Error::invalid_type(
1275 Unexpected::Str(&self.key),
1276 &visitor,
1277 ))
1278 }
1279 }
1280
1281 #[inline]
1282 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
1283 where
1284 V: Visitor<'de>,
1285 {
1286 // Map keys cannot be null.
1287 visitor.visit_some(self)
1288 }
1289
1290 #[inline]
1291 fn deserialize_newtype_struct<V>(
1292 self,
1293 _name: &'static str,
1294 visitor: V,
1295 ) -> Result<V::Value, Error>
1296 where
1297 V: Visitor<'de>,
1298 {
1299 visitor.visit_newtype_struct(self)
1300 }
1301
1302 fn deserialize_enum<V>(
1303 self,
1304 name: &'static str,
1305 variants: &'static [&'static str],
1306 visitor: V,
1307 ) -> Result<V::Value, Error>
1308 where
1309 V: Visitor<'de>,
1310 {
1311 self.key
1312 .into_deserializer()
1313 .deserialize_enum(name, variants, visitor)
1314 }
1315
1316 forward_to_deserialize_any! {
1317 char str string bytes byte_buf unit unit_struct seq tuple tuple_struct
1318 map struct identifier ignored_any
1319 }
1320}
1321
1322struct KeyClassifier;
1323
1324enum KeyClass {
1325 Map(String),
1326 #[cfg(feature = "arbitrary_precision")]
1327 Number,
1328 #[cfg(feature = "raw_value")]
1329 RawValue,
1330}
1331
1332impl<'de> DeserializeSeed<'de> for KeyClassifier {
1333 type Value = KeyClass;
1334
1335 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1336 where
1337 D: serde::Deserializer<'de>,
1338 {
1339 deserializer.deserialize_str(self)
1340 }
1341}
1342
1343impl<'de> Visitor<'de> for KeyClassifier {
1344 type Value = KeyClass;
1345
1346 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1347 formatter.write_str("a string key")
1348 }
1349
1350 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1351 where
1352 E: de::Error,
1353 {
1354 match s {
1355 #[cfg(feature = "arbitrary_precision")]
1356 crate::number::TOKEN => Ok(KeyClass::Number),
1357 #[cfg(feature = "raw_value")]
1358 crate::raw::TOKEN => Ok(KeyClass::RawValue),
1359 _ => Ok(KeyClass::Map(s.to_owned())),
1360 }
1361 }
1362
1363 #[cfg(any(feature = "std", feature = "alloc"))]
1364 fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
1365 where
1366 E: de::Error,
1367 {
1368 match s.as_str() {
1369 #[cfg(feature = "arbitrary_precision")]
1370 crate::number::TOKEN => Ok(KeyClass::Number),
1371 #[cfg(feature = "raw_value")]
1372 crate::raw::TOKEN => Ok(KeyClass::RawValue),
1373 _ => Ok(KeyClass::Map(s)),
1374 }
1375 }
1376}
1377
1378impl Value {
1379 #[cold]
1380 fn invalid_type<E>(&self, exp: &dyn Expected) -> E
1381 where
1382 E: serde::de::Error,
1383 {
1384 serde::de::Error::invalid_type(self.unexpected(), exp)
1385 }
1386
1387 #[cold]
1388 fn unexpected(&self) -> Unexpected {
1389 match self {
1390 Value::Null => Unexpected::Unit,
1391 Value::Bool(b: &bool) => Unexpected::Bool(*b),
1392 Value::Number(n: &Number) => n.unexpected(),
1393 Value::String(s: &String) => Unexpected::Str(s),
1394 Value::Array(_) => Unexpected::Seq,
1395 Value::Object(_) => Unexpected::Map,
1396 }
1397 }
1398}
1399
1400struct BorrowedCowStrDeserializer<'de> {
1401 value: Cow<'de, str>,
1402}
1403
1404impl<'de> BorrowedCowStrDeserializer<'de> {
1405 fn new(value: Cow<'de, str>) -> Self {
1406 BorrowedCowStrDeserializer { value }
1407 }
1408}
1409
1410impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
1411 type Error = Error;
1412
1413 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1414 where
1415 V: de::Visitor<'de>,
1416 {
1417 match self.value {
1418 Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
1419 #[cfg(any(feature = "std", feature = "alloc"))]
1420 Cow::Owned(string) => visitor.visit_string(string),
1421 #[cfg(not(any(feature = "std", feature = "alloc")))]
1422 Cow::Owned(_) => unreachable!(),
1423 }
1424 }
1425
1426 fn deserialize_enum<V>(
1427 self,
1428 _name: &str,
1429 _variants: &'static [&'static str],
1430 visitor: V,
1431 ) -> Result<V::Value, Error>
1432 where
1433 V: de::Visitor<'de>,
1434 {
1435 visitor.visit_enum(self)
1436 }
1437
1438 forward_to_deserialize_any! {
1439 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1440 bytes byte_buf option unit unit_struct newtype_struct seq tuple
1441 tuple_struct map struct identifier ignored_any
1442 }
1443}
1444
1445impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
1446 type Error = Error;
1447 type Variant = UnitOnly;
1448
1449 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
1450 where
1451 T: de::DeserializeSeed<'de>,
1452 {
1453 let value: >::Value = tri!(seed.deserialize(self));
1454 Ok((value, UnitOnly))
1455 }
1456}
1457
1458struct UnitOnly;
1459
1460impl<'de> de::VariantAccess<'de> for UnitOnly {
1461 type Error = Error;
1462
1463 fn unit_variant(self) -> Result<(), Error> {
1464 Ok(())
1465 }
1466
1467 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
1468 where
1469 T: de::DeserializeSeed<'de>,
1470 {
1471 Err(de::Error::invalid_type(
1472 Unexpected::UnitVariant,
1473 &"newtype variant",
1474 ))
1475 }
1476
1477 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
1478 where
1479 V: de::Visitor<'de>,
1480 {
1481 Err(de::Error::invalid_type(
1482 Unexpected::UnitVariant,
1483 &"tuple variant",
1484 ))
1485 }
1486
1487 fn struct_variant<V>(
1488 self,
1489 _fields: &'static [&'static str],
1490 _visitor: V,
1491 ) -> Result<V::Value, Error>
1492 where
1493 V: de::Visitor<'de>,
1494 {
1495 Err(de::Error::invalid_type(
1496 Unexpected::UnitVariant,
1497 &"struct variant",
1498 ))
1499 }
1500}
1501