serde_json/value/
de.rs

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