Debian Codegraph @

.cargo/vendor/serde/src/de/value.rs

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