serde_json_bytes/value/
de.rs

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

serde_json_bytes/value/
de.rs
