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

serde_json/value/
de.rs
