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            #[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 = array.len();
193    let mut deserializer = SeqDeserializer::new(array);
194    let seq = tri!(visitor.visit_seq(&mut deserializer));
195    let remaining = 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 = self.variant.into_deserializer();
521        let visitor = VariantDeserializer { value: self.value };
522        seed.deserialize(variant).map(|v| (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) => seed.deserialize(value).map(Some),
635            None => Ok(None),
636        }
637    }
638
639    fn size_hint(&self) -> Option<usize> {
640        match self.iter.size_hint() {
641            (lower, Some(upper)) 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 = array.len();
729    let mut deserializer = SeqRefDeserializer::new(array);
730    let seq = tri!(visitor.visit_seq(&mut deserializer));
731    let remaining = 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 = self.variant.into_deserializer();
1047        let visitor = VariantRefDeserializer { value: self.value };
1048        seed.deserialize(variant).map(|v| (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) => seed.deserialize(value).map(Some),
1143            None => Ok(None),
1144        }
1145    }
1146
1147    fn size_hint(&self) -> Option<usize> {
1148        match self.iter.size_hint() {
1149            (lower, Some(upper)) 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) => Unexpected::Bool(*b),
1392            Value::Number(n) => n.unexpected(),
1393            Value::String(s) => 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 = 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}
serde_json/value/de.rs

serde_json/value/
de.rs
