serde_json/value/
de.rs

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

serde_json/value/
de.rs
