serde/de/
value.rs

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

serde/de/
value.rs
