serde/de/
value.rs

1//! Building blocks for deserializing basic values using the `IntoDeserializer`
2//! trait.
3//!
4//! ```edition2018
5//! use std::str::FromStr;
6//! use serde::Deserialize;
7//! use serde::de::{value, IntoDeserializer};
8//!
9//! #[derive(Deserialize)]
10//! enum Setting {
11//!     On,
12//!     Off,
13//! }
14//!
15//! impl FromStr for Setting {
16//!     type Err = value::Error;
17//!
18//!     fn from_str(s: &str) -> Result<Self, Self::Err> {
19//!         Self::deserialize(s.into_deserializer())
20//!     }
21//! }
22//! ```
23
24use lib::*;
25
26use self::private::{First, Second};
27use de::{self, Expected, IntoDeserializer, SeqAccess};
28use private::de::size_hint;
29use ser;
30
31////////////////////////////////////////////////////////////////////////////////
32
33// For structs that contain a PhantomData. We do not want the trait
34// bound `E: Clone` inferred by derive(Clone).
35macro_rules! impl_copy_clone {
36    ($ty:ident $(<$lifetime:tt>)*) => {
37        impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
38
39        impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
40            fn clone(&self) -> Self {
41                *self
42            }
43        }
44    };
45}
46
47////////////////////////////////////////////////////////////////////////////////
48
49/// A minimal representation of all possible errors that can occur using the
50/// `IntoDeserializer` trait.
51#[derive(Clone, Debug, PartialEq)]
52pub struct Error {
53    err: ErrorImpl,
54}
55
56#[cfg(any(feature = "std", feature = "alloc"))]
57type ErrorImpl = Box<str>;
58#[cfg(not(any(feature = "std", feature = "alloc")))]
59type ErrorImpl = ();
60
61impl de::Error for Error {
62    #[cfg(any(feature = "std", feature = "alloc"))]
63    #[cold]
64    fn custom<T>(msg: T) -> Self
65    where
66        T: Display,
67    {
68        Error {
69            err: msg.to_string().into_boxed_str(),
70        }
71    }
72
73    #[cfg(not(any(feature = "std", feature = "alloc")))]
74    #[cold]
75    fn custom<T>(msg: T) -> Self
76    where
77        T: Display,
78    {
79        let _ = msg;
80        Error { err: () }
81    }
82}
83
84impl ser::Error for Error {
85    #[cold]
86    fn custom<T>(msg: T) -> Self
87    where
88        T: Display,
89    {
90        de::Error::custom(msg)
91    }
92}
93
94impl Display for Error {
95    #[cfg(any(feature = "std", feature = "alloc"))]
96    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
97        formatter.write_str(&self.err)
98    }
99
100    #[cfg(not(any(feature = "std", feature = "alloc")))]
101    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
102        formatter.write_str("Serde deserialization error")
103    }
104}
105
106#[cfg(feature = "std")]
107impl error::Error for Error {
108    fn description(&self) -> &str {
109        &self.err
110    }
111}
112
113////////////////////////////////////////////////////////////////////////////////
114
115impl<'de, E> IntoDeserializer<'de, E> for ()
116where
117    E: de::Error,
118{
119    type Deserializer = UnitDeserializer<E>;
120
121    fn into_deserializer(self) -> UnitDeserializer<E> {
122        UnitDeserializer {
123            marker: PhantomData,
124        }
125    }
126}
127
128/// A deserializer holding a `()`.
129#[derive(Debug)]
130pub struct UnitDeserializer<E> {
131    marker: PhantomData<E>,
132}
133
134impl_copy_clone!(UnitDeserializer);
135
136impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
137where
138    E: de::Error,
139{
140    type Error = E;
141
142    forward_to_deserialize_any! {
143        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
144        bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
145        map struct enum identifier ignored_any
146    }
147
148    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
149    where
150        V: de::Visitor<'de>,
151    {
152        visitor.visit_unit()
153    }
154
155    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
156    where
157        V: de::Visitor<'de>,
158    {
159        visitor.visit_none()
160    }
161}
162
163////////////////////////////////////////////////////////////////////////////////
164
165/// A deserializer that cannot be instantiated.
166#[cfg(feature = "unstable")]
167pub struct NeverDeserializer<E> {
168    never: !,
169    marker: PhantomData<E>,
170}
171
172#[cfg(feature = "unstable")]
173impl<'de, E> IntoDeserializer<'de, E> for !
174where
175    E: de::Error,
176{
177    type Deserializer = NeverDeserializer<E>;
178
179    fn into_deserializer(self) -> Self::Deserializer {
180        self
181    }
182}
183
184#[cfg(feature = "unstable")]
185impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
186where
187    E: de::Error,
188{
189    type Error = E;
190
191    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
192    where
193        V: de::Visitor<'de>,
194    {
195        self.never
196    }
197
198    forward_to_deserialize_any! {
199        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
200        bytes byte_buf option unit unit_struct newtype_struct seq tuple
201        tuple_struct map struct enum identifier ignored_any
202    }
203}
204
205////////////////////////////////////////////////////////////////////////////////
206
207macro_rules! primitive_deserializer {
208    ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
209        #[doc = "A deserializer holding"]
210        #[doc = $doc]
211        #[derive(Debug)]
212        pub struct $name<E> {
213            value: $ty,
214            marker: PhantomData<E>
215        }
216
217        impl_copy_clone!($name);
218
219        impl<'de, E> IntoDeserializer<'de, E> for $ty
220        where
221            E: de::Error,
222        {
223            type Deserializer = $name<E>;
224
225            fn into_deserializer(self) -> $name<E> {
226                $name {
227                    value: self,
228                    marker: PhantomData,
229                }
230            }
231        }
232
233        impl<'de, E> de::Deserializer<'de> for $name<E>
234        where
235            E: de::Error,
236        {
237            type Error = E;
238
239            forward_to_deserialize_any! {
240                bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
241                string bytes byte_buf option unit unit_struct newtype_struct seq
242                tuple tuple_struct map struct enum identifier ignored_any
243            }
244
245            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
246            where
247                V: de::Visitor<'de>,
248            {
249                visitor.$method(self.value $($cast)*)
250            }
251        }
252    }
253}
254
255primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool);
256primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
257primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
258primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
259primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
260primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
261primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
262primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
263primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
264primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
265primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
266primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
267primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
268
269serde_if_integer128! {
270    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
271    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
272}
273
274/// A deserializer holding a `u32`.
275#[derive(Debug)]
276pub struct U32Deserializer<E> {
277    value: u32,
278    marker: PhantomData<E>,
279}
280
281impl_copy_clone!(U32Deserializer);
282
283impl<'de, E> IntoDeserializer<'de, E> for u32
284where
285    E: de::Error,
286{
287    type Deserializer = U32Deserializer<E>;
288
289    fn into_deserializer(self) -> U32Deserializer<E> {
290        U32Deserializer {
291            value: self,
292            marker: PhantomData,
293        }
294    }
295}
296
297impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
298where
299    E: de::Error,
300{
301    type Error = E;
302
303    forward_to_deserialize_any! {
304        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
305        bytes byte_buf option unit unit_struct newtype_struct seq tuple
306        tuple_struct map struct identifier ignored_any
307    }
308
309    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
310    where
311        V: de::Visitor<'de>,
312    {
313        visitor.visit_u32(self.value)
314    }
315
316    fn deserialize_enum<V>(
317        self,
318        name: &str,
319        variants: &'static [&'static str],
320        visitor: V,
321    ) -> Result<V::Value, Self::Error>
322    where
323        V: de::Visitor<'de>,
324    {
325        let _ = name;
326        let _ = variants;
327        visitor.visit_enum(self)
328    }
329}
330
331impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E>
332where
333    E: de::Error,
334{
335    type Error = E;
336    type Variant = private::UnitOnly<E>;
337
338    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
339    where
340        T: de::DeserializeSeed<'de>,
341    {
342        seed.deserialize(self).map(private::unit_only)
343    }
344}
345
346////////////////////////////////////////////////////////////////////////////////
347
348/// A deserializer holding a `&str`.
349#[derive(Debug)]
350pub struct StrDeserializer<'a, E> {
351    value: &'a str,
352    marker: PhantomData<E>,
353}
354
355impl_copy_clone!(StrDeserializer<'de>);
356
357impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
358where
359    E: de::Error,
360{
361    type Deserializer = StrDeserializer<'a, E>;
362
363    fn into_deserializer(self) -> StrDeserializer<'a, E> {
364        StrDeserializer {
365            value: self,
366            marker: PhantomData,
367        }
368    }
369}
370
371impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
372where
373    E: de::Error,
374{
375    type Error = E;
376
377    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
378    where
379        V: de::Visitor<'de>,
380    {
381        visitor.visit_str(self.value)
382    }
383
384    fn deserialize_enum<V>(
385        self,
386        name: &str,
387        variants: &'static [&'static str],
388        visitor: V,
389    ) -> Result<V::Value, Self::Error>
390    where
391        V: de::Visitor<'de>,
392    {
393        let _ = name;
394        let _ = variants;
395        visitor.visit_enum(self)
396    }
397
398    forward_to_deserialize_any! {
399        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
400        bytes byte_buf option unit unit_struct newtype_struct seq tuple
401        tuple_struct map struct identifier ignored_any
402    }
403}
404
405impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E>
406where
407    E: de::Error,
408{
409    type Error = E;
410    type Variant = private::UnitOnly<E>;
411
412    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
413    where
414        T: de::DeserializeSeed<'de>,
415    {
416        seed.deserialize(self).map(private::unit_only)
417    }
418}
419
420////////////////////////////////////////////////////////////////////////////////
421
422/// A deserializer holding a `&str` with a lifetime tied to another
423/// deserializer.
424#[derive(Debug)]
425pub struct BorrowedStrDeserializer<'de, E> {
426    value: &'de str,
427    marker: PhantomData<E>,
428}
429
430impl_copy_clone!(BorrowedStrDeserializer<'de>);
431
432impl<'de, E> BorrowedStrDeserializer<'de, E> {
433    /// Create a new borrowed deserializer from the given string.
434    pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
435        BorrowedStrDeserializer {
436            value: value,
437            marker: PhantomData,
438        }
439    }
440}
441
442impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
443where
444    E: de::Error,
445{
446    type Error = E;
447
448    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
449    where
450        V: de::Visitor<'de>,
451    {
452        visitor.visit_borrowed_str(self.value)
453    }
454
455    fn deserialize_enum<V>(
456        self,
457        name: &str,
458        variants: &'static [&'static str],
459        visitor: V,
460    ) -> Result<V::Value, Self::Error>
461    where
462        V: de::Visitor<'de>,
463    {
464        let _ = name;
465        let _ = variants;
466        visitor.visit_enum(self)
467    }
468
469    forward_to_deserialize_any! {
470        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
471        bytes byte_buf option unit unit_struct newtype_struct seq tuple
472        tuple_struct map struct identifier ignored_any
473    }
474}
475
476impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
477where
478    E: de::Error,
479{
480    type Error = E;
481    type Variant = private::UnitOnly<E>;
482
483    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
484    where
485        T: de::DeserializeSeed<'de>,
486    {
487        seed.deserialize(self).map(private::unit_only)
488    }
489}
490
491////////////////////////////////////////////////////////////////////////////////
492
493/// A deserializer holding a `String`.
494#[cfg(any(feature = "std", feature = "alloc"))]
495#[derive(Debug)]
496pub struct StringDeserializer<E> {
497    value: String,
498    marker: PhantomData<E>,
499}
500
501#[cfg(any(feature = "std", feature = "alloc"))]
502impl<E> Clone for StringDeserializer<E> {
503    fn clone(&self) -> Self {
504        StringDeserializer {
505            value: self.value.clone(),
506            marker: PhantomData,
507        }
508    }
509}
510
511#[cfg(any(feature = "std", feature = "alloc"))]
512impl<'de, E> IntoDeserializer<'de, E> for String
513where
514    E: de::Error,
515{
516    type Deserializer = StringDeserializer<E>;
517
518    fn into_deserializer(self) -> StringDeserializer<E> {
519        StringDeserializer {
520            value: self,
521            marker: PhantomData,
522        }
523    }
524}
525
526#[cfg(any(feature = "std", feature = "alloc"))]
527impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
528where
529    E: de::Error,
530{
531    type Error = E;
532
533    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
534    where
535        V: de::Visitor<'de>,
536    {
537        visitor.visit_string(self.value)
538    }
539
540    fn deserialize_enum<V>(
541        self,
542        name: &str,
543        variants: &'static [&'static str],
544        visitor: V,
545    ) -> Result<V::Value, Self::Error>
546    where
547        V: de::Visitor<'de>,
548    {
549        let _ = name;
550        let _ = variants;
551        visitor.visit_enum(self)
552    }
553
554    forward_to_deserialize_any! {
555        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
556        bytes byte_buf option unit unit_struct newtype_struct seq tuple
557        tuple_struct map struct identifier ignored_any
558    }
559}
560
561#[cfg(any(feature = "std", feature = "alloc"))]
562impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
563where
564    E: de::Error,
565{
566    type Error = E;
567    type Variant = private::UnitOnly<E>;
568
569    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
570    where
571        T: de::DeserializeSeed<'de>,
572    {
573        seed.deserialize(self).map(private::unit_only)
574    }
575}
576
577////////////////////////////////////////////////////////////////////////////////
578
579/// A deserializer holding a `Cow<str>`.
580#[cfg(any(feature = "std", feature = "alloc"))]
581#[derive(Debug)]
582pub struct CowStrDeserializer<'a, E> {
583    value: Cow<'a, str>,
584    marker: PhantomData<E>,
585}
586
587#[cfg(any(feature = "std", feature = "alloc"))]
588impl<'a, E> Clone for CowStrDeserializer<'a, E> {
589    fn clone(&self) -> Self {
590        CowStrDeserializer {
591            value: self.value.clone(),
592            marker: PhantomData,
593        }
594    }
595}
596
597#[cfg(any(feature = "std", feature = "alloc"))]
598impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
599where
600    E: de::Error,
601{
602    type Deserializer = CowStrDeserializer<'a, E>;
603
604    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
605        CowStrDeserializer {
606            value: self,
607            marker: PhantomData,
608        }
609    }
610}
611
612#[cfg(any(feature = "std", feature = "alloc"))]
613impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
614where
615    E: de::Error,
616{
617    type Error = E;
618
619    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
620    where
621        V: de::Visitor<'de>,
622    {
623        match self.value {
624            Cow::Borrowed(string) => visitor.visit_str(string),
625            Cow::Owned(string) => visitor.visit_string(string),
626        }
627    }
628
629    fn deserialize_enum<V>(
630        self,
631        name: &str,
632        variants: &'static [&'static str],
633        visitor: V,
634    ) -> Result<V::Value, Self::Error>
635    where
636        V: de::Visitor<'de>,
637    {
638        let _ = name;
639        let _ = variants;
640        visitor.visit_enum(self)
641    }
642
643    forward_to_deserialize_any! {
644        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
645        bytes byte_buf option unit unit_struct newtype_struct seq tuple
646        tuple_struct map struct identifier ignored_any
647    }
648}
649
650#[cfg(any(feature = "std", feature = "alloc"))]
651impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
652where
653    E: de::Error,
654{
655    type Error = E;
656    type Variant = private::UnitOnly<E>;
657
658    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
659    where
660        T: de::DeserializeSeed<'de>,
661    {
662        seed.deserialize(self).map(private::unit_only)
663    }
664}
665
666////////////////////////////////////////////////////////////////////////////////
667
668/// A deserializer holding a `&[u8]` with a lifetime tied to another
669/// deserializer.
670#[derive(Debug)]
671pub struct BorrowedBytesDeserializer<'de, E> {
672    value: &'de [u8],
673    marker: PhantomData<E>,
674}
675
676impl_copy_clone!(BorrowedBytesDeserializer<'de>);
677
678impl<'de, E> BorrowedBytesDeserializer<'de, E> {
679    /// Create a new borrowed deserializer from the given byte slice.
680    pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {
681        BorrowedBytesDeserializer {
682            value: value,
683            marker: PhantomData,
684        }
685    }
686}
687
688impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
689where
690    E: de::Error,
691{
692    type Error = E;
693
694    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
695    where
696        V: de::Visitor<'de>,
697    {
698        visitor.visit_borrowed_bytes(self.value)
699    }
700
701    forward_to_deserialize_any! {
702        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
703        bytes byte_buf option unit unit_struct newtype_struct seq tuple
704        tuple_struct map struct identifier ignored_any enum
705    }
706}
707
708////////////////////////////////////////////////////////////////////////////////
709
710/// A deserializer that iterates over a sequence.
711#[derive(Clone, Debug)]
712pub struct SeqDeserializer<I, E> {
713    iter: iter::Fuse<I>,
714    count: usize,
715    marker: PhantomData<E>,
716}
717
718impl<I, E> SeqDeserializer<I, E>
719where
720    I: Iterator,
721{
722    /// Construct a new `SeqDeserializer<I, E>`.
723    pub fn new(iter: I) -> Self {
724        SeqDeserializer {
725            iter: iter.fuse(),
726            count: 0,
727            marker: PhantomData,
728        }
729    }
730}
731
732impl<I, E> SeqDeserializer<I, E>
733where
734    I: Iterator,
735    E: de::Error,
736{
737    /// Check for remaining elements after passing a `SeqDeserializer` to
738    /// `Visitor::visit_seq`.
739    pub fn end(self) -> Result<(), E> {
740        let remaining = self.iter.count();
741        if remaining == 0 {
742            Ok(())
743        } else {
744            // First argument is the number of elements in the data, second
745            // argument is the number of elements expected by the Deserialize.
746            Err(de::Error::invalid_length(
747                self.count + remaining,
748                &ExpectedInSeq(self.count),
749            ))
750        }
751    }
752}
753
754impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
755where
756    I: Iterator<Item = T>,
757    T: IntoDeserializer<'de, E>,
758    E: de::Error,
759{
760    type Error = E;
761
762    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
763    where
764        V: de::Visitor<'de>,
765    {
766        let v = try!(visitor.visit_seq(&mut self));
767        try!(self.end());
768        Ok(v)
769    }
770
771    forward_to_deserialize_any! {
772        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
773        bytes byte_buf option unit unit_struct newtype_struct seq tuple
774        tuple_struct map struct enum identifier ignored_any
775    }
776}
777
778impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E>
779where
780    I: Iterator<Item = T>,
781    T: IntoDeserializer<'de, E>,
782    E: de::Error,
783{
784    type Error = E;
785
786    fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
787    where
788        V: de::DeserializeSeed<'de>,
789    {
790        match self.iter.next() {
791            Some(value) => {
792                self.count += 1;
793                seed.deserialize(value.into_deserializer()).map(Some)
794            }
795            None => Ok(None),
796        }
797    }
798
799    fn size_hint(&self) -> Option<usize> {
800        size_hint::from_bounds(&self.iter)
801    }
802}
803
804struct ExpectedInSeq(usize);
805
806impl Expected for ExpectedInSeq {
807    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
808        if self.0 == 1 {
809            write!(formatter, "1 element in sequence")
810        } else {
811            write!(formatter, "{} elements in sequence", self.0)
812        }
813    }
814}
815
816////////////////////////////////////////////////////////////////////////////////
817
818#[cfg(any(feature = "std", feature = "alloc"))]
819impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
820where
821    T: IntoDeserializer<'de, E>,
822    E: de::Error,
823{
824    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
825
826    fn into_deserializer(self) -> Self::Deserializer {
827        SeqDeserializer::new(self.into_iter())
828    }
829}
830
831#[cfg(any(feature = "std", feature = "alloc"))]
832impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
833where
834    T: IntoDeserializer<'de, E> + Eq + Ord,
835    E: de::Error,
836{
837    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
838
839    fn into_deserializer(self) -> Self::Deserializer {
840        SeqDeserializer::new(self.into_iter())
841    }
842}
843
844#[cfg(feature = "std")]
845impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
846where
847    T: IntoDeserializer<'de, E> + Eq + Hash,
848    S: BuildHasher,
849    E: de::Error,
850{
851    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
852
853    fn into_deserializer(self) -> Self::Deserializer {
854        SeqDeserializer::new(self.into_iter())
855    }
856}
857
858////////////////////////////////////////////////////////////////////////////////
859
860/// A deserializer holding a `SeqAccess`.
861#[derive(Clone, Debug)]
862pub struct SeqAccessDeserializer<A> {
863    seq: A,
864}
865
866impl<A> SeqAccessDeserializer<A> {
867    /// Construct a new `SeqAccessDeserializer<A>`.
868    pub fn new(seq: A) -> Self {
869        SeqAccessDeserializer { seq: seq }
870    }
871}
872
873impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A>
874where
875    A: de::SeqAccess<'de>,
876{
877    type Error = A::Error;
878
879    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
880    where
881        V: de::Visitor<'de>,
882    {
883        visitor.visit_seq(self.seq)
884    }
885
886    forward_to_deserialize_any! {
887        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
888        bytes byte_buf option unit unit_struct newtype_struct seq tuple
889        tuple_struct map struct enum identifier ignored_any
890    }
891}
892
893////////////////////////////////////////////////////////////////////////////////
894
895/// A deserializer that iterates over a map.
896pub struct MapDeserializer<'de, I, E>
897where
898    I: Iterator,
899    I::Item: private::Pair,
900{
901    iter: iter::Fuse<I>,
902    value: Option<Second<I::Item>>,
903    count: usize,
904    lifetime: PhantomData<&'de ()>,
905    error: PhantomData<E>,
906}
907
908impl<'de, I, E> MapDeserializer<'de, I, E>
909where
910    I: Iterator,
911    I::Item: private::Pair,
912{
913    /// Construct a new `MapDeserializer<I, E>`.
914    pub fn new(iter: I) -> Self {
915        MapDeserializer {
916            iter: iter.fuse(),
917            value: None,
918            count: 0,
919            lifetime: PhantomData,
920            error: PhantomData,
921        }
922    }
923}
924
925impl<'de, I, E> MapDeserializer<'de, I, E>
926where
927    I: Iterator,
928    I::Item: private::Pair,
929    E: de::Error,
930{
931    /// Check for remaining elements after passing a `MapDeserializer` to
932    /// `Visitor::visit_map`.
933    pub fn end(self) -> Result<(), E> {
934        let remaining = self.iter.count();
935        if remaining == 0 {
936            Ok(())
937        } else {
938            // First argument is the number of elements in the data, second
939            // argument is the number of elements expected by the Deserialize.
940            Err(de::Error::invalid_length(
941                self.count + remaining,
942                &ExpectedInMap(self.count),
943            ))
944        }
945    }
946}
947
948impl<'de, I, E> MapDeserializer<'de, I, E>
949where
950    I: Iterator,
951    I::Item: private::Pair,
952{
953    fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> {
954        match self.iter.next() {
955            Some(kv) => {
956                self.count += 1;
957                Some(private::Pair::split(kv))
958            }
959            None => None,
960        }
961    }
962}
963
964impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
965where
966    I: Iterator,
967    I::Item: private::Pair,
968    First<I::Item>: IntoDeserializer<'de, E>,
969    Second<I::Item>: IntoDeserializer<'de, E>,
970    E: de::Error,
971{
972    type Error = E;
973
974    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
975    where
976        V: de::Visitor<'de>,
977    {
978        let value = try!(visitor.visit_map(&mut self));
979        try!(self.end());
980        Ok(value)
981    }
982
983    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
984    where
985        V: de::Visitor<'de>,
986    {
987        let value = try!(visitor.visit_seq(&mut self));
988        try!(self.end());
989        Ok(value)
990    }
991
992    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
993    where
994        V: de::Visitor<'de>,
995    {
996        let _ = len;
997        self.deserialize_seq(visitor)
998    }
999
1000    forward_to_deserialize_any! {
1001        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1002        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
1003        struct enum identifier ignored_any
1004    }
1005}
1006
1007impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E>
1008where
1009    I: Iterator,
1010    I::Item: private::Pair,
1011    First<I::Item>: IntoDeserializer<'de, E>,
1012    Second<I::Item>: IntoDeserializer<'de, E>,
1013    E: de::Error,
1014{
1015    type Error = E;
1016
1017    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1018    where
1019        T: de::DeserializeSeed<'de>,
1020    {
1021        match self.next_pair() {
1022            Some((key, value)) => {
1023                self.value = Some(value);
1024                seed.deserialize(key.into_deserializer()).map(Some)
1025            }
1026            None => Ok(None),
1027        }
1028    }
1029
1030    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
1031    where
1032        T: de::DeserializeSeed<'de>,
1033    {
1034        let value = self.value.take();
1035        // Panic because this indicates a bug in the program rather than an
1036        // expected failure.
1037        let value = value.expect("MapAccess::visit_value called before visit_key");
1038        seed.deserialize(value.into_deserializer())
1039    }
1040
1041    fn next_entry_seed<TK, TV>(
1042        &mut self,
1043        kseed: TK,
1044        vseed: TV,
1045    ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
1046    where
1047        TK: de::DeserializeSeed<'de>,
1048        TV: de::DeserializeSeed<'de>,
1049    {
1050        match self.next_pair() {
1051            Some((key, value)) => {
1052                let key = try!(kseed.deserialize(key.into_deserializer()));
1053                let value = try!(vseed.deserialize(value.into_deserializer()));
1054                Ok(Some((key, value)))
1055            }
1056            None => Ok(None),
1057        }
1058    }
1059
1060    fn size_hint(&self) -> Option<usize> {
1061        size_hint::from_bounds(&self.iter)
1062    }
1063}
1064
1065impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
1066where
1067    I: Iterator,
1068    I::Item: private::Pair,
1069    First<I::Item>: IntoDeserializer<'de, E>,
1070    Second<I::Item>: IntoDeserializer<'de, E>,
1071    E: de::Error,
1072{
1073    type Error = E;
1074
1075    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1076    where
1077        T: de::DeserializeSeed<'de>,
1078    {
1079        match self.next_pair() {
1080            Some((k, v)) => {
1081                let de = PairDeserializer(k, v, PhantomData);
1082                seed.deserialize(de).map(Some)
1083            }
1084            None => Ok(None),
1085        }
1086    }
1087
1088    fn size_hint(&self) -> Option<usize> {
1089        size_hint::from_bounds(&self.iter)
1090    }
1091}
1092
1093// Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.
1094impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
1095where
1096    I: Iterator + Clone,
1097    I::Item: private::Pair,
1098    Second<I::Item>: Clone,
1099{
1100    fn clone(&self) -> Self {
1101        MapDeserializer {
1102            iter: self.iter.clone(),
1103            value: self.value.clone(),
1104            count: self.count,
1105            lifetime: self.lifetime,
1106            error: self.error,
1107        }
1108    }
1109}
1110
1111// Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`.
1112impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
1113where
1114    I: Iterator + Debug,
1115    I::Item: private::Pair,
1116    Second<I::Item>: Debug,
1117{
1118    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1119        formatter
1120            .debug_struct("MapDeserializer")
1121            .field("iter", &self.iter)
1122            .field("value", &self.value)
1123            .field("count", &self.count)
1124            .field("lifetime", &self.lifetime)
1125            .field("error", &self.error)
1126            .finish()
1127    }
1128}
1129
1130// Used in the `impl SeqAccess for MapDeserializer` to visit the map as a
1131// sequence of pairs.
1132struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
1133
1134impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
1135where
1136    A: IntoDeserializer<'de, E>,
1137    B: IntoDeserializer<'de, E>,
1138    E: de::Error,
1139{
1140    type Error = E;
1141
1142    forward_to_deserialize_any! {
1143        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1144        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
1145        struct enum identifier ignored_any
1146    }
1147
1148    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1149    where
1150        V: de::Visitor<'de>,
1151    {
1152        self.deserialize_seq(visitor)
1153    }
1154
1155    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1156    where
1157        V: de::Visitor<'de>,
1158    {
1159        let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
1160        let pair = try!(visitor.visit_seq(&mut pair_visitor));
1161        if pair_visitor.1.is_none() {
1162            Ok(pair)
1163        } else {
1164            let remaining = pair_visitor.size_hint().unwrap();
1165            // First argument is the number of elements in the data, second
1166            // argument is the number of elements expected by the Deserialize.
1167            Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining)))
1168        }
1169    }
1170
1171    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1172    where
1173        V: de::Visitor<'de>,
1174    {
1175        if len == 2 {
1176            self.deserialize_seq(visitor)
1177        } else {
1178            // First argument is the number of elements in the data, second
1179            // argument is the number of elements expected by the Deserialize.
1180            Err(de::Error::invalid_length(2, &ExpectedInSeq(len)))
1181        }
1182    }
1183}
1184
1185struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
1186
1187impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E>
1188where
1189    A: IntoDeserializer<'de, E>,
1190    B: IntoDeserializer<'de, E>,
1191    E: de::Error,
1192{
1193    type Error = E;
1194
1195    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1196    where
1197        T: de::DeserializeSeed<'de>,
1198    {
1199        if let Some(k) = self.0.take() {
1200            seed.deserialize(k.into_deserializer()).map(Some)
1201        } else if let Some(v) = self.1.take() {
1202            seed.deserialize(v.into_deserializer()).map(Some)
1203        } else {
1204            Ok(None)
1205        }
1206    }
1207
1208    fn size_hint(&self) -> Option<usize> {
1209        if self.0.is_some() {
1210            Some(2)
1211        } else if self.1.is_some() {
1212            Some(1)
1213        } else {
1214            Some(0)
1215        }
1216    }
1217}
1218
1219struct ExpectedInMap(usize);
1220
1221impl Expected for ExpectedInMap {
1222    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1223        if self.0 == 1 {
1224            write!(formatter, "1 element in map")
1225        } else {
1226            write!(formatter, "{} elements in map", self.0)
1227        }
1228    }
1229}
1230
1231////////////////////////////////////////////////////////////////////////////////
1232
1233#[cfg(any(feature = "std", feature = "alloc"))]
1234impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
1235where
1236    K: IntoDeserializer<'de, E> + Eq + Ord,
1237    V: IntoDeserializer<'de, E>,
1238    E: de::Error,
1239{
1240    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
1241
1242    fn into_deserializer(self) -> Self::Deserializer {
1243        MapDeserializer::new(self.into_iter())
1244    }
1245}
1246
1247#[cfg(feature = "std")]
1248impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
1249where
1250    K: IntoDeserializer<'de, E> + Eq + Hash,
1251    V: IntoDeserializer<'de, E>,
1252    S: BuildHasher,
1253    E: de::Error,
1254{
1255    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
1256
1257    fn into_deserializer(self) -> Self::Deserializer {
1258        MapDeserializer::new(self.into_iter())
1259    }
1260}
1261
1262////////////////////////////////////////////////////////////////////////////////
1263
1264/// A deserializer holding a `MapAccess`.
1265#[derive(Clone, Debug)]
1266pub struct MapAccessDeserializer<A> {
1267    map: A,
1268}
1269
1270impl<A> MapAccessDeserializer<A> {
1271    /// Construct a new `MapAccessDeserializer<A>`.
1272    pub fn new(map: A) -> Self {
1273        MapAccessDeserializer { map: map }
1274    }
1275}
1276
1277impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A>
1278where
1279    A: de::MapAccess<'de>,
1280{
1281    type Error = A::Error;
1282
1283    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1284    where
1285        V: de::Visitor<'de>,
1286    {
1287        visitor.visit_map(self.map)
1288    }
1289
1290    fn deserialize_enum<V>(
1291        self,
1292        _name: &str,
1293        _variants: &'static [&'static str],
1294        visitor: V,
1295    ) -> Result<V::Value, Self::Error>
1296    where
1297        V: de::Visitor<'de>,
1298    {
1299        visitor.visit_enum(self)
1300    }
1301
1302    forward_to_deserialize_any! {
1303        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1304        bytes byte_buf option unit unit_struct newtype_struct seq tuple
1305        tuple_struct map struct identifier ignored_any
1306    }
1307}
1308
1309impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
1310where
1311    A: de::MapAccess<'de>,
1312{
1313    type Error = A::Error;
1314    type Variant = private::MapAsEnum<A>;
1315
1316    fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
1317    where
1318        T: de::DeserializeSeed<'de>,
1319    {
1320        match self.map.next_key_seed(seed)? {
1321            Some(key) => Ok((key, private::map_as_enum(self.map))),
1322            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
1323        }
1324    }
1325}
1326
1327////////////////////////////////////////////////////////////////////////////////
1328
1329mod private {
1330    use lib::*;
1331
1332    use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};
1333
1334    #[derive(Clone, Debug)]
1335    pub struct UnitOnly<E> {
1336        marker: PhantomData<E>,
1337    }
1338
1339    pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
1340        (
1341            t,
1342            UnitOnly {
1343                marker: PhantomData,
1344            },
1345        )
1346    }
1347
1348    impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
1349    where
1350        E: de::Error,
1351    {
1352        type Error = E;
1353
1354        fn unit_variant(self) -> Result<(), Self::Error> {
1355            Ok(())
1356        }
1357
1358        fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
1359        where
1360            T: de::DeserializeSeed<'de>,
1361        {
1362            Err(de::Error::invalid_type(
1363                Unexpected::UnitVariant,
1364                &"newtype variant",
1365            ))
1366        }
1367
1368        fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
1369        where
1370            V: de::Visitor<'de>,
1371        {
1372            Err(de::Error::invalid_type(
1373                Unexpected::UnitVariant,
1374                &"tuple variant",
1375            ))
1376        }
1377
1378        fn struct_variant<V>(
1379            self,
1380            _fields: &'static [&'static str],
1381            _visitor: V,
1382        ) -> Result<V::Value, Self::Error>
1383        where
1384            V: de::Visitor<'de>,
1385        {
1386            Err(de::Error::invalid_type(
1387                Unexpected::UnitVariant,
1388                &"struct variant",
1389            ))
1390        }
1391    }
1392
1393    #[derive(Clone, Debug)]
1394    pub struct MapAsEnum<A> {
1395        map: A,
1396    }
1397
1398    pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
1399        MapAsEnum { map: map }
1400    }
1401
1402    impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
1403    where
1404        A: MapAccess<'de>,
1405    {
1406        type Error = A::Error;
1407
1408        fn unit_variant(mut self) -> Result<(), Self::Error> {
1409            self.map.next_value()
1410        }
1411
1412        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
1413        where
1414            T: DeserializeSeed<'de>,
1415        {
1416            self.map.next_value_seed(seed)
1417        }
1418
1419        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1420        where
1421            V: Visitor<'de>,
1422        {
1423            self.map.next_value_seed(SeedTupleVariant {
1424                len: len,
1425                visitor: visitor,
1426            })
1427        }
1428
1429        fn struct_variant<V>(
1430            mut self,
1431            _fields: &'static [&'static str],
1432            visitor: V,
1433        ) -> Result<V::Value, Self::Error>
1434        where
1435            V: Visitor<'de>,
1436        {
1437            self.map
1438                .next_value_seed(SeedStructVariant { visitor: visitor })
1439        }
1440    }
1441
1442    struct SeedTupleVariant<V> {
1443        len: usize,
1444        visitor: V,
1445    }
1446
1447    impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
1448    where
1449        V: Visitor<'de>,
1450    {
1451        type Value = V::Value;
1452
1453        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1454        where
1455            D: Deserializer<'de>,
1456        {
1457            deserializer.deserialize_tuple(self.len, self.visitor)
1458        }
1459    }
1460
1461    struct SeedStructVariant<V> {
1462        visitor: V,
1463    }
1464
1465    impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
1466    where
1467        V: Visitor<'de>,
1468    {
1469        type Value = V::Value;
1470
1471        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1472        where
1473            D: Deserializer<'de>,
1474        {
1475            deserializer.deserialize_map(self.visitor)
1476        }
1477    }
1478
1479    /// Avoid having to restate the generic types on `MapDeserializer`. The
1480    /// `Iterator::Item` contains enough information to figure out K and V.
1481    pub trait Pair {
1482        type First;
1483        type Second;
1484        fn split(self) -> (Self::First, Self::Second);
1485    }
1486
1487    impl<A, B> Pair for (A, B) {
1488        type First = A;
1489        type Second = B;
1490        fn split(self) -> (A, B) {
1491            self
1492        }
1493    }
1494
1495    pub type First<T> = <T as Pair>::First;
1496    pub type Second<T> = <T as Pair>::Second;
1497}
serde/de/value.rs

serde/de/
value.rs
