1 use crate::lib::*;
2 
3 use crate::de::value::{BorrowedBytesDeserializer, BytesDeserializer};
4 use crate::de::{
5     Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, IntoDeserializer, VariantAccess,
6     Visitor,
7 };
8 
9 #[cfg(any(feature = "std", feature = "alloc"))]
10 use crate::de::{MapAccess, Unexpected};
11 
12 #[cfg(any(feature = "std", feature = "alloc"))]
13 pub use self::content::{
14     Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
15     InternallyTaggedUnitVisitor, TagContentOtherField, TagContentOtherFieldVisitor,
16     TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
17 };
18 
19 pub use crate::seed::InPlaceSeed;
20 
21 /// If the missing field is of type `Option<T>` then treat is as `None`,
22 /// otherwise it is an error.
missing_field<'de, V, E>(field: &'static str) -> Result<V, E> where V: Deserialize<'de>, E: Error,23 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
24 where
25     V: Deserialize<'de>,
26     E: Error,
27 {
28     struct MissingFieldDeserializer<E>(&'static str, PhantomData<E>);
29 
30     impl<'de, E> Deserializer<'de> for MissingFieldDeserializer<E>
31     where
32         E: Error,
33     {
34         type Error = E;
35 
36         fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, E>
37         where
38             V: Visitor<'de>,
39         {
40             Err(Error::missing_field(self.0))
41         }
42 
43         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
44         where
45             V: Visitor<'de>,
46         {
47             visitor.visit_none()
48         }
49 
50         forward_to_deserialize_any! {
51             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
52             bytes byte_buf unit unit_struct newtype_struct seq tuple
53             tuple_struct map struct enum identifier ignored_any
54         }
55     }
56 
57     let deserializer = MissingFieldDeserializer(field, PhantomData);
58     Deserialize::deserialize(deserializer)
59 }
60 
61 #[cfg(any(feature = "std", feature = "alloc"))]
borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error> where D: Deserializer<'de>, R: From<Cow<'a, str>>,62 pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
63 where
64     D: Deserializer<'de>,
65     R: From<Cow<'a, str>>,
66 {
67     struct CowStrVisitor;
68 
69     impl<'a> Visitor<'a> for CowStrVisitor {
70         type Value = Cow<'a, str>;
71 
72         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
73             formatter.write_str("a string")
74         }
75 
76         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
77         where
78             E: Error,
79         {
80             Ok(Cow::Owned(v.to_owned()))
81         }
82 
83         fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
84         where
85             E: Error,
86         {
87             Ok(Cow::Borrowed(v))
88         }
89 
90         fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
91         where
92             E: Error,
93         {
94             Ok(Cow::Owned(v))
95         }
96 
97         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
98         where
99             E: Error,
100         {
101             match str::from_utf8(v) {
102                 Ok(s) => Ok(Cow::Owned(s.to_owned())),
103                 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
104             }
105         }
106 
107         fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
108         where
109             E: Error,
110         {
111             match str::from_utf8(v) {
112                 Ok(s) => Ok(Cow::Borrowed(s)),
113                 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
114             }
115         }
116 
117         fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
118         where
119             E: Error,
120         {
121             match String::from_utf8(v) {
122                 Ok(s) => Ok(Cow::Owned(s)),
123                 Err(e) => Err(Error::invalid_value(
124                     Unexpected::Bytes(&e.into_bytes()),
125                     &self,
126                 )),
127             }
128         }
129     }
130 
131     deserializer.deserialize_str(CowStrVisitor).map(From::from)
132 }
133 
134 #[cfg(any(feature = "std", feature = "alloc"))]
borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error> where D: Deserializer<'de>, R: From<Cow<'a, [u8]>>,135 pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
136 where
137     D: Deserializer<'de>,
138     R: From<Cow<'a, [u8]>>,
139 {
140     struct CowBytesVisitor;
141 
142     impl<'a> Visitor<'a> for CowBytesVisitor {
143         type Value = Cow<'a, [u8]>;
144 
145         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
146             formatter.write_str("a byte array")
147         }
148 
149         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
150         where
151             E: Error,
152         {
153             Ok(Cow::Owned(v.as_bytes().to_vec()))
154         }
155 
156         fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
157         where
158             E: Error,
159         {
160             Ok(Cow::Borrowed(v.as_bytes()))
161         }
162 
163         fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
164         where
165             E: Error,
166         {
167             Ok(Cow::Owned(v.into_bytes()))
168         }
169 
170         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
171         where
172             E: Error,
173         {
174             Ok(Cow::Owned(v.to_vec()))
175         }
176 
177         fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
178         where
179             E: Error,
180         {
181             Ok(Cow::Borrowed(v))
182         }
183 
184         fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
185         where
186             E: Error,
187         {
188             Ok(Cow::Owned(v))
189         }
190     }
191 
192     deserializer
193         .deserialize_bytes(CowBytesVisitor)
194         .map(From::from)
195 }
196 
197 #[cfg(any(feature = "std", feature = "alloc"))]
198 mod content {
199     // This module is private and nothing here should be used outside of
200     // generated code.
201     //
202     // We will iterate on the implementation for a few releases and only have to
203     // worry about backward compatibility for the `untagged` and `tag` attributes
204     // rather than for this entire mechanism.
205     //
206     // This issue is tracking making some of this stuff public:
207     // https://github.com/serde-rs/serde/issues/741
208 
209     use crate::lib::*;
210 
211     use crate::actually_private;
212     use crate::de::value::{MapDeserializer, SeqDeserializer};
213     use crate::de::{
214         self, size_hint, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected,
215         IgnoredAny, MapAccess, SeqAccess, Unexpected, Visitor,
216     };
217 
218     /// Used from generated code to buffer the contents of the Deserializer when
219     /// deserializing untagged enums and internally tagged enums.
220     ///
221     /// Not public API. Use serde-value instead.
222     #[derive(Debug, Clone)]
223     pub enum Content<'de> {
224         Bool(bool),
225 
226         U8(u8),
227         U16(u16),
228         U32(u32),
229         U64(u64),
230 
231         I8(i8),
232         I16(i16),
233         I32(i32),
234         I64(i64),
235 
236         F32(f32),
237         F64(f64),
238 
239         Char(char),
240         String(String),
241         Str(&'de str),
242         ByteBuf(Vec<u8>),
243         Bytes(&'de [u8]),
244 
245         None,
246         Some(Box<Content<'de>>),
247 
248         Unit,
249         Newtype(Box<Content<'de>>),
250         Seq(Vec<Content<'de>>),
251         Map(Vec<(Content<'de>, Content<'de>)>),
252     }
253 
254     impl<'de> Content<'de> {
as_str(&self) -> Option<&str>255         pub fn as_str(&self) -> Option<&str> {
256             match *self {
257                 Content::Str(x) => Some(x),
258                 Content::String(ref x) => Some(x),
259                 Content::Bytes(x) => str::from_utf8(x).ok(),
260                 Content::ByteBuf(ref x) => str::from_utf8(x).ok(),
261                 _ => None,
262             }
263         }
264 
265         #[cold]
unexpected(&self) -> Unexpected266         fn unexpected(&self) -> Unexpected {
267             match *self {
268                 Content::Bool(b) => Unexpected::Bool(b),
269                 Content::U8(n) => Unexpected::Unsigned(n as u64),
270                 Content::U16(n) => Unexpected::Unsigned(n as u64),
271                 Content::U32(n) => Unexpected::Unsigned(n as u64),
272                 Content::U64(n) => Unexpected::Unsigned(n),
273                 Content::I8(n) => Unexpected::Signed(n as i64),
274                 Content::I16(n) => Unexpected::Signed(n as i64),
275                 Content::I32(n) => Unexpected::Signed(n as i64),
276                 Content::I64(n) => Unexpected::Signed(n),
277                 Content::F32(f) => Unexpected::Float(f as f64),
278                 Content::F64(f) => Unexpected::Float(f),
279                 Content::Char(c) => Unexpected::Char(c),
280                 Content::String(ref s) => Unexpected::Str(s),
281                 Content::Str(s) => Unexpected::Str(s),
282                 Content::ByteBuf(ref b) => Unexpected::Bytes(b),
283                 Content::Bytes(b) => Unexpected::Bytes(b),
284                 Content::None | Content::Some(_) => Unexpected::Option,
285                 Content::Unit => Unexpected::Unit,
286                 Content::Newtype(_) => Unexpected::NewtypeStruct,
287                 Content::Seq(_) => Unexpected::Seq,
288                 Content::Map(_) => Unexpected::Map,
289             }
290         }
291     }
292 
293     impl<'de> Deserialize<'de> for Content<'de> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,294         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
295         where
296             D: Deserializer<'de>,
297         {
298             // Untagged and internally tagged enums are only supported in
299             // self-describing formats.
300             let visitor = ContentVisitor { value: PhantomData };
301             deserializer.__deserialize_content(actually_private::T, visitor)
302         }
303     }
304 
305     impl<'de, E> de::IntoDeserializer<'de, E> for Content<'de>
306     where
307         E: de::Error,
308     {
309         type Deserializer = ContentDeserializer<'de, E>;
310 
into_deserializer(self) -> Self::Deserializer311         fn into_deserializer(self) -> Self::Deserializer {
312             ContentDeserializer::new(self)
313         }
314     }
315 
316     struct ContentVisitor<'de> {
317         value: PhantomData<Content<'de>>,
318     }
319 
320     impl<'de> ContentVisitor<'de> {
new() -> Self321         fn new() -> Self {
322             ContentVisitor { value: PhantomData }
323         }
324     }
325 
326     impl<'de> Visitor<'de> for ContentVisitor<'de> {
327         type Value = Content<'de>;
328 
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result329         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
330             fmt.write_str("any value")
331         }
332 
visit_bool<F>(self, value: bool) -> Result<Self::Value, F> where F: de::Error,333         fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
334         where
335             F: de::Error,
336         {
337             Ok(Content::Bool(value))
338         }
339 
visit_i8<F>(self, value: i8) -> Result<Self::Value, F> where F: de::Error,340         fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
341         where
342             F: de::Error,
343         {
344             Ok(Content::I8(value))
345         }
346 
visit_i16<F>(self, value: i16) -> Result<Self::Value, F> where F: de::Error,347         fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
348         where
349             F: de::Error,
350         {
351             Ok(Content::I16(value))
352         }
353 
visit_i32<F>(self, value: i32) -> Result<Self::Value, F> where F: de::Error,354         fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
355         where
356             F: de::Error,
357         {
358             Ok(Content::I32(value))
359         }
360 
visit_i64<F>(self, value: i64) -> Result<Self::Value, F> where F: de::Error,361         fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
362         where
363             F: de::Error,
364         {
365             Ok(Content::I64(value))
366         }
367 
visit_u8<F>(self, value: u8) -> Result<Self::Value, F> where F: de::Error,368         fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
369         where
370             F: de::Error,
371         {
372             Ok(Content::U8(value))
373         }
374 
visit_u16<F>(self, value: u16) -> Result<Self::Value, F> where F: de::Error,375         fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
376         where
377             F: de::Error,
378         {
379             Ok(Content::U16(value))
380         }
381 
visit_u32<F>(self, value: u32) -> Result<Self::Value, F> where F: de::Error,382         fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
383         where
384             F: de::Error,
385         {
386             Ok(Content::U32(value))
387         }
388 
visit_u64<F>(self, value: u64) -> Result<Self::Value, F> where F: de::Error,389         fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
390         where
391             F: de::Error,
392         {
393             Ok(Content::U64(value))
394         }
395 
visit_f32<F>(self, value: f32) -> Result<Self::Value, F> where F: de::Error,396         fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
397         where
398             F: de::Error,
399         {
400             Ok(Content::F32(value))
401         }
402 
visit_f64<F>(self, value: f64) -> Result<Self::Value, F> where F: de::Error,403         fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
404         where
405             F: de::Error,
406         {
407             Ok(Content::F64(value))
408         }
409 
visit_char<F>(self, value: char) -> Result<Self::Value, F> where F: de::Error,410         fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
411         where
412             F: de::Error,
413         {
414             Ok(Content::Char(value))
415         }
416 
visit_str<F>(self, value: &str) -> Result<Self::Value, F> where F: de::Error,417         fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
418         where
419             F: de::Error,
420         {
421             Ok(Content::String(value.into()))
422         }
423 
visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F> where F: de::Error,424         fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
425         where
426             F: de::Error,
427         {
428             Ok(Content::Str(value))
429         }
430 
visit_string<F>(self, value: String) -> Result<Self::Value, F> where F: de::Error,431         fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
432         where
433             F: de::Error,
434         {
435             Ok(Content::String(value))
436         }
437 
visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F> where F: de::Error,438         fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
439         where
440             F: de::Error,
441         {
442             Ok(Content::ByteBuf(value.into()))
443         }
444 
visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F> where F: de::Error,445         fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
446         where
447             F: de::Error,
448         {
449             Ok(Content::Bytes(value))
450         }
451 
visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F> where F: de::Error,452         fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
453         where
454             F: de::Error,
455         {
456             Ok(Content::ByteBuf(value))
457         }
458 
visit_unit<F>(self) -> Result<Self::Value, F> where F: de::Error,459         fn visit_unit<F>(self) -> Result<Self::Value, F>
460         where
461             F: de::Error,
462         {
463             Ok(Content::Unit)
464         }
465 
visit_none<F>(self) -> Result<Self::Value, F> where F: de::Error,466         fn visit_none<F>(self) -> Result<Self::Value, F>
467         where
468             F: de::Error,
469         {
470             Ok(Content::None)
471         }
472 
visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,473         fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
474         where
475             D: Deserializer<'de>,
476         {
477             Deserialize::deserialize(deserializer).map(|v| Content::Some(Box::new(v)))
478         }
479 
visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,480         fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
481         where
482             D: Deserializer<'de>,
483         {
484             Deserialize::deserialize(deserializer).map(|v| Content::Newtype(Box::new(v)))
485         }
486 
visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: SeqAccess<'de>,487         fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
488         where
489             V: SeqAccess<'de>,
490         {
491             let mut vec =
492                 Vec::<Content>::with_capacity(size_hint::cautious::<Content>(visitor.size_hint()));
493             while let Some(e) = tri!(visitor.next_element()) {
494                 vec.push(e);
495             }
496             Ok(Content::Seq(vec))
497         }
498 
visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de>,499         fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
500         where
501             V: MapAccess<'de>,
502         {
503             let mut vec =
504                 Vec::<(Content, Content)>::with_capacity(
505                     size_hint::cautious::<(Content, Content)>(visitor.size_hint()),
506                 );
507             while let Some(kv) = tri!(visitor.next_entry()) {
508                 vec.push(kv);
509             }
510             Ok(Content::Map(vec))
511         }
512 
visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error> where V: EnumAccess<'de>,513         fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
514         where
515             V: EnumAccess<'de>,
516         {
517             Err(de::Error::custom(
518                 "untagged and internally tagged enums do not support enum input",
519             ))
520         }
521     }
522 
523     /// This is the type of the map keys in an internally tagged enum.
524     ///
525     /// Not public API.
526     pub enum TagOrContent<'de> {
527         Tag,
528         Content(Content<'de>),
529     }
530 
531     struct TagOrContentVisitor<'de> {
532         name: &'static str,
533         value: PhantomData<TagOrContent<'de>>,
534     }
535 
536     impl<'de> TagOrContentVisitor<'de> {
new(name: &'static str) -> Self537         fn new(name: &'static str) -> Self {
538             TagOrContentVisitor {
539                 name,
540                 value: PhantomData,
541             }
542         }
543     }
544 
545     impl<'de> DeserializeSeed<'de> for TagOrContentVisitor<'de> {
546         type Value = TagOrContent<'de>;
547 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,548         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
549         where
550             D: Deserializer<'de>,
551         {
552             // Internally tagged enums are only supported in self-describing
553             // formats.
554             deserializer.deserialize_any(self)
555         }
556     }
557 
558     impl<'de> Visitor<'de> for TagOrContentVisitor<'de> {
559         type Value = TagOrContent<'de>;
560 
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result561         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
562             write!(fmt, "a type tag `{}` or any other value", self.name)
563         }
564 
visit_bool<F>(self, value: bool) -> Result<Self::Value, F> where F: de::Error,565         fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
566         where
567             F: de::Error,
568         {
569             ContentVisitor::new()
570                 .visit_bool(value)
571                 .map(TagOrContent::Content)
572         }
573 
visit_i8<F>(self, value: i8) -> Result<Self::Value, F> where F: de::Error,574         fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
575         where
576             F: de::Error,
577         {
578             ContentVisitor::new()
579                 .visit_i8(value)
580                 .map(TagOrContent::Content)
581         }
582 
visit_i16<F>(self, value: i16) -> Result<Self::Value, F> where F: de::Error,583         fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
584         where
585             F: de::Error,
586         {
587             ContentVisitor::new()
588                 .visit_i16(value)
589                 .map(TagOrContent::Content)
590         }
591 
visit_i32<F>(self, value: i32) -> Result<Self::Value, F> where F: de::Error,592         fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
593         where
594             F: de::Error,
595         {
596             ContentVisitor::new()
597                 .visit_i32(value)
598                 .map(TagOrContent::Content)
599         }
600 
visit_i64<F>(self, value: i64) -> Result<Self::Value, F> where F: de::Error,601         fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
602         where
603             F: de::Error,
604         {
605             ContentVisitor::new()
606                 .visit_i64(value)
607                 .map(TagOrContent::Content)
608         }
609 
visit_u8<F>(self, value: u8) -> Result<Self::Value, F> where F: de::Error,610         fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
611         where
612             F: de::Error,
613         {
614             ContentVisitor::new()
615                 .visit_u8(value)
616                 .map(TagOrContent::Content)
617         }
618 
visit_u16<F>(self, value: u16) -> Result<Self::Value, F> where F: de::Error,619         fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
620         where
621             F: de::Error,
622         {
623             ContentVisitor::new()
624                 .visit_u16(value)
625                 .map(TagOrContent::Content)
626         }
627 
visit_u32<F>(self, value: u32) -> Result<Self::Value, F> where F: de::Error,628         fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
629         where
630             F: de::Error,
631         {
632             ContentVisitor::new()
633                 .visit_u32(value)
634                 .map(TagOrContent::Content)
635         }
636 
visit_u64<F>(self, value: u64) -> Result<Self::Value, F> where F: de::Error,637         fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
638         where
639             F: de::Error,
640         {
641             ContentVisitor::new()
642                 .visit_u64(value)
643                 .map(TagOrContent::Content)
644         }
645 
visit_f32<F>(self, value: f32) -> Result<Self::Value, F> where F: de::Error,646         fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
647         where
648             F: de::Error,
649         {
650             ContentVisitor::new()
651                 .visit_f32(value)
652                 .map(TagOrContent::Content)
653         }
654 
visit_f64<F>(self, value: f64) -> Result<Self::Value, F> where F: de::Error,655         fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
656         where
657             F: de::Error,
658         {
659             ContentVisitor::new()
660                 .visit_f64(value)
661                 .map(TagOrContent::Content)
662         }
663 
visit_char<F>(self, value: char) -> Result<Self::Value, F> where F: de::Error,664         fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
665         where
666             F: de::Error,
667         {
668             ContentVisitor::new()
669                 .visit_char(value)
670                 .map(TagOrContent::Content)
671         }
672 
visit_str<F>(self, value: &str) -> Result<Self::Value, F> where F: de::Error,673         fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
674         where
675             F: de::Error,
676         {
677             if value == self.name {
678                 Ok(TagOrContent::Tag)
679             } else {
680                 ContentVisitor::new()
681                     .visit_str(value)
682                     .map(TagOrContent::Content)
683             }
684         }
685 
visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F> where F: de::Error,686         fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
687         where
688             F: de::Error,
689         {
690             if value == self.name {
691                 Ok(TagOrContent::Tag)
692             } else {
693                 ContentVisitor::new()
694                     .visit_borrowed_str(value)
695                     .map(TagOrContent::Content)
696             }
697         }
698 
visit_string<F>(self, value: String) -> Result<Self::Value, F> where F: de::Error,699         fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
700         where
701             F: de::Error,
702         {
703             if value == self.name {
704                 Ok(TagOrContent::Tag)
705             } else {
706                 ContentVisitor::new()
707                     .visit_string(value)
708                     .map(TagOrContent::Content)
709             }
710         }
711 
visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F> where F: de::Error,712         fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
713         where
714             F: de::Error,
715         {
716             if value == self.name.as_bytes() {
717                 Ok(TagOrContent::Tag)
718             } else {
719                 ContentVisitor::new()
720                     .visit_bytes(value)
721                     .map(TagOrContent::Content)
722             }
723         }
724 
visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F> where F: de::Error,725         fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
726         where
727             F: de::Error,
728         {
729             if value == self.name.as_bytes() {
730                 Ok(TagOrContent::Tag)
731             } else {
732                 ContentVisitor::new()
733                     .visit_borrowed_bytes(value)
734                     .map(TagOrContent::Content)
735             }
736         }
737 
visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F> where F: de::Error,738         fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
739         where
740             F: de::Error,
741         {
742             if value == self.name.as_bytes() {
743                 Ok(TagOrContent::Tag)
744             } else {
745                 ContentVisitor::new()
746                     .visit_byte_buf(value)
747                     .map(TagOrContent::Content)
748             }
749         }
750 
visit_unit<F>(self) -> Result<Self::Value, F> where F: de::Error,751         fn visit_unit<F>(self) -> Result<Self::Value, F>
752         where
753             F: de::Error,
754         {
755             ContentVisitor::new()
756                 .visit_unit()
757                 .map(TagOrContent::Content)
758         }
759 
visit_none<F>(self) -> Result<Self::Value, F> where F: de::Error,760         fn visit_none<F>(self) -> Result<Self::Value, F>
761         where
762             F: de::Error,
763         {
764             ContentVisitor::new()
765                 .visit_none()
766                 .map(TagOrContent::Content)
767         }
768 
visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,769         fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
770         where
771             D: Deserializer<'de>,
772         {
773             ContentVisitor::new()
774                 .visit_some(deserializer)
775                 .map(TagOrContent::Content)
776         }
777 
visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,778         fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
779         where
780             D: Deserializer<'de>,
781         {
782             ContentVisitor::new()
783                 .visit_newtype_struct(deserializer)
784                 .map(TagOrContent::Content)
785         }
786 
visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: SeqAccess<'de>,787         fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
788         where
789             V: SeqAccess<'de>,
790         {
791             ContentVisitor::new()
792                 .visit_seq(visitor)
793                 .map(TagOrContent::Content)
794         }
795 
visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de>,796         fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
797         where
798             V: MapAccess<'de>,
799         {
800             ContentVisitor::new()
801                 .visit_map(visitor)
802                 .map(TagOrContent::Content)
803         }
804 
visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: EnumAccess<'de>,805         fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
806         where
807             V: EnumAccess<'de>,
808         {
809             ContentVisitor::new()
810                 .visit_enum(visitor)
811                 .map(TagOrContent::Content)
812         }
813     }
814 
815     /// Used by generated code to deserialize an internally tagged enum.
816     ///
817     /// Not public API.
818     pub struct TaggedContentVisitor<T> {
819         tag_name: &'static str,
820         expecting: &'static str,
821         value: PhantomData<T>,
822     }
823 
824     impl<T> TaggedContentVisitor<T> {
825         /// Visitor for the content of an internally tagged enum with the given
826         /// tag name.
new(name: &'static str, expecting: &'static str) -> Self827         pub fn new(name: &'static str, expecting: &'static str) -> Self {
828             TaggedContentVisitor {
829                 tag_name: name,
830                 expecting,
831                 value: PhantomData,
832             }
833         }
834     }
835 
836     impl<'de, T> Visitor<'de> for TaggedContentVisitor<T>
837     where
838         T: Deserialize<'de>,
839     {
840         type Value = (T, Content<'de>);
841 
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result842         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
843             fmt.write_str(self.expecting)
844         }
845 
visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error> where S: SeqAccess<'de>,846         fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
847         where
848             S: SeqAccess<'de>,
849         {
850             let tag = match tri!(seq.next_element()) {
851                 Some(tag) => tag,
852                 None => {
853                     return Err(de::Error::missing_field(self.tag_name));
854                 }
855             };
856             let rest = de::value::SeqAccessDeserializer::new(seq);
857             Ok((tag, tri!(Content::deserialize(rest))))
858         }
859 
visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> where M: MapAccess<'de>,860         fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
861         where
862             M: MapAccess<'de>,
863         {
864             let mut tag = None;
865             let mut vec = Vec::<(Content, Content)>::with_capacity(size_hint::cautious::<(
866                 Content,
867                 Content,
868             )>(map.size_hint()));
869             while let Some(k) = tri!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
870                 match k {
871                     TagOrContent::Tag => {
872                         if tag.is_some() {
873                             return Err(de::Error::duplicate_field(self.tag_name));
874                         }
875                         tag = Some(tri!(map.next_value()));
876                     }
877                     TagOrContent::Content(k) => {
878                         let v = tri!(map.next_value());
879                         vec.push((k, v));
880                     }
881                 }
882             }
883             match tag {
884                 None => Err(de::Error::missing_field(self.tag_name)),
885                 Some(tag) => Ok((tag, Content::Map(vec))),
886             }
887         }
888     }
889 
890     /// Used by generated code to deserialize an adjacently tagged enum.
891     ///
892     /// Not public API.
893     pub enum TagOrContentField {
894         Tag,
895         Content,
896     }
897 
898     /// Not public API.
899     pub struct TagOrContentFieldVisitor {
900         pub tag: &'static str,
901         pub content: &'static str,
902     }
903 
904     impl<'de> DeserializeSeed<'de> for TagOrContentFieldVisitor {
905         type Value = TagOrContentField;
906 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,907         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
908         where
909             D: Deserializer<'de>,
910         {
911             deserializer.deserialize_identifier(self)
912         }
913     }
914 
915     impl<'de> Visitor<'de> for TagOrContentFieldVisitor {
916         type Value = TagOrContentField;
917 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result918         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
919             write!(formatter, "{:?} or {:?}", self.tag, self.content)
920         }
921 
visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E> where E: de::Error,922         fn visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E>
923         where
924             E: de::Error,
925         {
926             match field_index {
927                 0 => Ok(TagOrContentField::Tag),
928                 1 => Ok(TagOrContentField::Content),
929                 _ => Err(de::Error::invalid_value(
930                     Unexpected::Unsigned(field_index),
931                     &self,
932                 )),
933             }
934         }
935 
visit_str<E>(self, field: &str) -> Result<Self::Value, E> where E: de::Error,936         fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
937         where
938             E: de::Error,
939         {
940             if field == self.tag {
941                 Ok(TagOrContentField::Tag)
942             } else if field == self.content {
943                 Ok(TagOrContentField::Content)
944             } else {
945                 Err(de::Error::invalid_value(Unexpected::Str(field), &self))
946             }
947         }
948 
visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E> where E: de::Error,949         fn visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E>
950         where
951             E: de::Error,
952         {
953             if field == self.tag.as_bytes() {
954                 Ok(TagOrContentField::Tag)
955             } else if field == self.content.as_bytes() {
956                 Ok(TagOrContentField::Content)
957             } else {
958                 Err(de::Error::invalid_value(Unexpected::Bytes(field), &self))
959             }
960         }
961     }
962 
963     /// Used by generated code to deserialize an adjacently tagged enum when
964     /// ignoring unrelated fields is allowed.
965     ///
966     /// Not public API.
967     pub enum TagContentOtherField {
968         Tag,
969         Content,
970         Other,
971     }
972 
973     /// Not public API.
974     pub struct TagContentOtherFieldVisitor {
975         pub tag: &'static str,
976         pub content: &'static str,
977     }
978 
979     impl<'de> DeserializeSeed<'de> for TagContentOtherFieldVisitor {
980         type Value = TagContentOtherField;
981 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,982         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
983         where
984             D: Deserializer<'de>,
985         {
986             deserializer.deserialize_identifier(self)
987         }
988     }
989 
990     impl<'de> Visitor<'de> for TagContentOtherFieldVisitor {
991         type Value = TagContentOtherField;
992 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result993         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
994             write!(
995                 formatter,
996                 "{:?}, {:?}, or other ignored fields",
997                 self.tag, self.content
998             )
999         }
1000 
visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E> where E: de::Error,1001         fn visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E>
1002         where
1003             E: de::Error,
1004         {
1005             match field_index {
1006                 0 => Ok(TagContentOtherField::Tag),
1007                 1 => Ok(TagContentOtherField::Content),
1008                 _ => Ok(TagContentOtherField::Other),
1009             }
1010         }
1011 
visit_str<E>(self, field: &str) -> Result<Self::Value, E> where E: de::Error,1012         fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
1013         where
1014             E: de::Error,
1015         {
1016             self.visit_bytes(field.as_bytes())
1017         }
1018 
visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E> where E: de::Error,1019         fn visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E>
1020         where
1021             E: de::Error,
1022         {
1023             if field == self.tag.as_bytes() {
1024                 Ok(TagContentOtherField::Tag)
1025             } else if field == self.content.as_bytes() {
1026                 Ok(TagContentOtherField::Content)
1027             } else {
1028                 Ok(TagContentOtherField::Other)
1029             }
1030         }
1031     }
1032 
1033     /// Not public API
1034     pub struct ContentDeserializer<'de, E> {
1035         content: Content<'de>,
1036         err: PhantomData<E>,
1037     }
1038 
1039     impl<'de, E> ContentDeserializer<'de, E>
1040     where
1041         E: de::Error,
1042     {
1043         #[cold]
invalid_type(self, exp: &Expected) -> E1044         fn invalid_type(self, exp: &Expected) -> E {
1045             de::Error::invalid_type(self.content.unexpected(), exp)
1046         }
1047 
deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1048         fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
1049         where
1050             V: Visitor<'de>,
1051         {
1052             match self.content {
1053                 Content::U8(v) => visitor.visit_u8(v),
1054                 Content::U16(v) => visitor.visit_u16(v),
1055                 Content::U32(v) => visitor.visit_u32(v),
1056                 Content::U64(v) => visitor.visit_u64(v),
1057                 Content::I8(v) => visitor.visit_i8(v),
1058                 Content::I16(v) => visitor.visit_i16(v),
1059                 Content::I32(v) => visitor.visit_i32(v),
1060                 Content::I64(v) => visitor.visit_i64(v),
1061                 _ => Err(self.invalid_type(&visitor)),
1062             }
1063         }
1064 
deserialize_float<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1065         fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
1066         where
1067             V: Visitor<'de>,
1068         {
1069             match self.content {
1070                 Content::F32(v) => visitor.visit_f32(v),
1071                 Content::F64(v) => visitor.visit_f64(v),
1072                 Content::U8(v) => visitor.visit_u8(v),
1073                 Content::U16(v) => visitor.visit_u16(v),
1074                 Content::U32(v) => visitor.visit_u32(v),
1075                 Content::U64(v) => visitor.visit_u64(v),
1076                 Content::I8(v) => visitor.visit_i8(v),
1077                 Content::I16(v) => visitor.visit_i16(v),
1078                 Content::I32(v) => visitor.visit_i32(v),
1079                 Content::I64(v) => visitor.visit_i64(v),
1080                 _ => Err(self.invalid_type(&visitor)),
1081             }
1082         }
1083     }
1084 
visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>, E: de::Error,1085     fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
1086     where
1087         V: Visitor<'de>,
1088         E: de::Error,
1089     {
1090         let seq = content.into_iter().map(ContentDeserializer::new);
1091         let mut seq_visitor = SeqDeserializer::new(seq);
1092         let value = tri!(visitor.visit_seq(&mut seq_visitor));
1093         tri!(seq_visitor.end());
1094         Ok(value)
1095     }
1096 
visit_content_map<'de, V, E>( content: Vec<(Content<'de>, Content<'de>)>, visitor: V, ) -> Result<V::Value, E> where V: Visitor<'de>, E: de::Error,1097     fn visit_content_map<'de, V, E>(
1098         content: Vec<(Content<'de>, Content<'de>)>,
1099         visitor: V,
1100     ) -> Result<V::Value, E>
1101     where
1102         V: Visitor<'de>,
1103         E: de::Error,
1104     {
1105         let map = content
1106             .into_iter()
1107             .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
1108         let mut map_visitor = MapDeserializer::new(map);
1109         let value = tri!(visitor.visit_map(&mut map_visitor));
1110         tri!(map_visitor.end());
1111         Ok(value)
1112     }
1113 
1114     /// Used when deserializing an internally tagged enum because the content
1115     /// will be used exactly once.
1116     impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
1117     where
1118         E: de::Error,
1119     {
1120         type Error = E;
1121 
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1122         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1123         where
1124             V: Visitor<'de>,
1125         {
1126             match self.content {
1127                 Content::Bool(v) => visitor.visit_bool(v),
1128                 Content::U8(v) => visitor.visit_u8(v),
1129                 Content::U16(v) => visitor.visit_u16(v),
1130                 Content::U32(v) => visitor.visit_u32(v),
1131                 Content::U64(v) => visitor.visit_u64(v),
1132                 Content::I8(v) => visitor.visit_i8(v),
1133                 Content::I16(v) => visitor.visit_i16(v),
1134                 Content::I32(v) => visitor.visit_i32(v),
1135                 Content::I64(v) => visitor.visit_i64(v),
1136                 Content::F32(v) => visitor.visit_f32(v),
1137                 Content::F64(v) => visitor.visit_f64(v),
1138                 Content::Char(v) => visitor.visit_char(v),
1139                 Content::String(v) => visitor.visit_string(v),
1140                 Content::Str(v) => visitor.visit_borrowed_str(v),
1141                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1142                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1143                 Content::Unit => visitor.visit_unit(),
1144                 Content::None => visitor.visit_none(),
1145                 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1146                 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
1147                 Content::Seq(v) => visit_content_seq(v, visitor),
1148                 Content::Map(v) => visit_content_map(v, visitor),
1149             }
1150         }
1151 
deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1152         fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1153         where
1154             V: Visitor<'de>,
1155         {
1156             match self.content {
1157                 Content::Bool(v) => visitor.visit_bool(v),
1158                 _ => Err(self.invalid_type(&visitor)),
1159             }
1160         }
1161 
deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1162         fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1163         where
1164             V: Visitor<'de>,
1165         {
1166             self.deserialize_integer(visitor)
1167         }
1168 
deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1169         fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1170         where
1171             V: Visitor<'de>,
1172         {
1173             self.deserialize_integer(visitor)
1174         }
1175 
deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1176         fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1177         where
1178             V: Visitor<'de>,
1179         {
1180             self.deserialize_integer(visitor)
1181         }
1182 
deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1183         fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1184         where
1185             V: Visitor<'de>,
1186         {
1187             self.deserialize_integer(visitor)
1188         }
1189 
deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1190         fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1191         where
1192             V: Visitor<'de>,
1193         {
1194             self.deserialize_integer(visitor)
1195         }
1196 
deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1197         fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1198         where
1199             V: Visitor<'de>,
1200         {
1201             self.deserialize_integer(visitor)
1202         }
1203 
deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1204         fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1205         where
1206             V: Visitor<'de>,
1207         {
1208             self.deserialize_integer(visitor)
1209         }
1210 
deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1211         fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1212         where
1213             V: Visitor<'de>,
1214         {
1215             self.deserialize_integer(visitor)
1216         }
1217 
deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1218         fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1219         where
1220             V: Visitor<'de>,
1221         {
1222             self.deserialize_float(visitor)
1223         }
1224 
deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1225         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1226         where
1227             V: Visitor<'de>,
1228         {
1229             self.deserialize_float(visitor)
1230         }
1231 
deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1232         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1233         where
1234             V: Visitor<'de>,
1235         {
1236             match self.content {
1237                 Content::Char(v) => visitor.visit_char(v),
1238                 Content::String(v) => visitor.visit_string(v),
1239                 Content::Str(v) => visitor.visit_borrowed_str(v),
1240                 _ => Err(self.invalid_type(&visitor)),
1241             }
1242         }
1243 
deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1244         fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1245         where
1246             V: Visitor<'de>,
1247         {
1248             self.deserialize_string(visitor)
1249         }
1250 
deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1251         fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1252         where
1253             V: Visitor<'de>,
1254         {
1255             match self.content {
1256                 Content::String(v) => visitor.visit_string(v),
1257                 Content::Str(v) => visitor.visit_borrowed_str(v),
1258                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1259                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1260                 _ => Err(self.invalid_type(&visitor)),
1261             }
1262         }
1263 
deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1264         fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1265         where
1266             V: Visitor<'de>,
1267         {
1268             self.deserialize_byte_buf(visitor)
1269         }
1270 
deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1271         fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1272         where
1273             V: Visitor<'de>,
1274         {
1275             match self.content {
1276                 Content::String(v) => visitor.visit_string(v),
1277                 Content::Str(v) => visitor.visit_borrowed_str(v),
1278                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1279                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1280                 Content::Seq(v) => visit_content_seq(v, visitor),
1281                 _ => Err(self.invalid_type(&visitor)),
1282             }
1283         }
1284 
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1285         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1286         where
1287             V: Visitor<'de>,
1288         {
1289             match self.content {
1290                 Content::None => visitor.visit_none(),
1291                 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1292                 Content::Unit => visitor.visit_unit(),
1293                 _ => visitor.visit_some(self),
1294             }
1295         }
1296 
deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1297         fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1298         where
1299             V: Visitor<'de>,
1300         {
1301             match self.content {
1302                 Content::Unit => visitor.visit_unit(),
1303 
1304                 // Allow deserializing newtype variant containing unit.
1305                 //
1306                 //     #[derive(Deserialize)]
1307                 //     #[serde(tag = "result")]
1308                 //     enum Response<T> {
1309                 //         Success(T),
1310                 //     }
1311                 //
1312                 // We want {"result":"Success"} to deserialize into Response<()>.
1313                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
1314                 _ => Err(self.invalid_type(&visitor)),
1315             }
1316         }
1317 
deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1318         fn deserialize_unit_struct<V>(
1319             self,
1320             _name: &'static str,
1321             visitor: V,
1322         ) -> Result<V::Value, Self::Error>
1323         where
1324             V: Visitor<'de>,
1325         {
1326             match self.content {
1327                 // As a special case, allow deserializing untagged newtype
1328                 // variant containing unit struct.
1329                 //
1330                 //     #[derive(Deserialize)]
1331                 //     struct Info;
1332                 //
1333                 //     #[derive(Deserialize)]
1334                 //     #[serde(tag = "topic")]
1335                 //     enum Message {
1336                 //         Info(Info),
1337                 //     }
1338                 //
1339                 // We want {"topic":"Info"} to deserialize even though
1340                 // ordinarily unit structs do not deserialize from empty map/seq.
1341                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
1342                 Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
1343                 _ => self.deserialize_any(visitor),
1344             }
1345         }
1346 
deserialize_newtype_struct<V>( self, _name: &str, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1347         fn deserialize_newtype_struct<V>(
1348             self,
1349             _name: &str,
1350             visitor: V,
1351         ) -> Result<V::Value, Self::Error>
1352         where
1353             V: Visitor<'de>,
1354         {
1355             match self.content {
1356                 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
1357                 _ => visitor.visit_newtype_struct(self),
1358             }
1359         }
1360 
deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1361         fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1362         where
1363             V: Visitor<'de>,
1364         {
1365             match self.content {
1366                 Content::Seq(v) => visit_content_seq(v, visitor),
1367                 _ => Err(self.invalid_type(&visitor)),
1368             }
1369         }
1370 
deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1371         fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1372         where
1373             V: Visitor<'de>,
1374         {
1375             self.deserialize_seq(visitor)
1376         }
1377 
deserialize_tuple_struct<V>( self, _name: &'static str, _len: usize, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1378         fn deserialize_tuple_struct<V>(
1379             self,
1380             _name: &'static str,
1381             _len: usize,
1382             visitor: V,
1383         ) -> Result<V::Value, Self::Error>
1384         where
1385             V: Visitor<'de>,
1386         {
1387             self.deserialize_seq(visitor)
1388         }
1389 
deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1390         fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1391         where
1392             V: Visitor<'de>,
1393         {
1394             match self.content {
1395                 Content::Map(v) => visit_content_map(v, visitor),
1396                 _ => Err(self.invalid_type(&visitor)),
1397             }
1398         }
1399 
deserialize_struct<V>( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1400         fn deserialize_struct<V>(
1401             self,
1402             _name: &'static str,
1403             _fields: &'static [&'static str],
1404             visitor: V,
1405         ) -> Result<V::Value, Self::Error>
1406         where
1407             V: Visitor<'de>,
1408         {
1409             match self.content {
1410                 Content::Seq(v) => visit_content_seq(v, visitor),
1411                 Content::Map(v) => visit_content_map(v, visitor),
1412                 _ => Err(self.invalid_type(&visitor)),
1413             }
1414         }
1415 
deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1416         fn deserialize_enum<V>(
1417             self,
1418             _name: &str,
1419             _variants: &'static [&'static str],
1420             visitor: V,
1421         ) -> Result<V::Value, Self::Error>
1422         where
1423             V: Visitor<'de>,
1424         {
1425             let (variant, value) = match self.content {
1426                 Content::Map(value) => {
1427                     let mut iter = value.into_iter();
1428                     let (variant, value) = match iter.next() {
1429                         Some(v) => v,
1430                         None => {
1431                             return Err(de::Error::invalid_value(
1432                                 de::Unexpected::Map,
1433                                 &"map with a single key",
1434                             ));
1435                         }
1436                     };
1437                     // enums are encoded in json as maps with a single key:value pair
1438                     if iter.next().is_some() {
1439                         return Err(de::Error::invalid_value(
1440                             de::Unexpected::Map,
1441                             &"map with a single key",
1442                         ));
1443                     }
1444                     (variant, Some(value))
1445                 }
1446                 s @ Content::String(_) | s @ Content::Str(_) => (s, None),
1447                 other => {
1448                     return Err(de::Error::invalid_type(
1449                         other.unexpected(),
1450                         &"string or map",
1451                     ));
1452                 }
1453             };
1454 
1455             visitor.visit_enum(EnumDeserializer::new(variant, value))
1456         }
1457 
deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1458         fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1459         where
1460             V: Visitor<'de>,
1461         {
1462             match self.content {
1463                 Content::String(v) => visitor.visit_string(v),
1464                 Content::Str(v) => visitor.visit_borrowed_str(v),
1465                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1466                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1467                 Content::U8(v) => visitor.visit_u8(v),
1468                 Content::U64(v) => visitor.visit_u64(v),
1469                 _ => Err(self.invalid_type(&visitor)),
1470             }
1471         }
1472 
deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1473         fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1474         where
1475             V: Visitor<'de>,
1476         {
1477             drop(self);
1478             visitor.visit_unit()
1479         }
1480 
__deserialize_content<V>( self, _: actually_private::T, visitor: V, ) -> Result<Content<'de>, Self::Error> where V: Visitor<'de, Value = Content<'de>>,1481         fn __deserialize_content<V>(
1482             self,
1483             _: actually_private::T,
1484             visitor: V,
1485         ) -> Result<Content<'de>, Self::Error>
1486         where
1487             V: Visitor<'de, Value = Content<'de>>,
1488         {
1489             let _ = visitor;
1490             Ok(self.content)
1491         }
1492     }
1493 
1494     impl<'de, E> ContentDeserializer<'de, E> {
1495         /// private API, don't use
new(content: Content<'de>) -> Self1496         pub fn new(content: Content<'de>) -> Self {
1497             ContentDeserializer {
1498                 content,
1499                 err: PhantomData,
1500             }
1501         }
1502     }
1503 
1504     pub struct EnumDeserializer<'de, E>
1505     where
1506         E: de::Error,
1507     {
1508         variant: Content<'de>,
1509         value: Option<Content<'de>>,
1510         err: PhantomData<E>,
1511     }
1512 
1513     impl<'de, E> EnumDeserializer<'de, E>
1514     where
1515         E: de::Error,
1516     {
new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E>1517         pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
1518             EnumDeserializer {
1519                 variant,
1520                 value,
1521                 err: PhantomData,
1522             }
1523         }
1524     }
1525 
1526     impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<'de, E>
1527     where
1528         E: de::Error,
1529     {
1530         type Error = E;
1531         type Variant = VariantDeserializer<'de, Self::Error>;
1532 
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E> where V: de::DeserializeSeed<'de>,1533         fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
1534         where
1535             V: de::DeserializeSeed<'de>,
1536         {
1537             let visitor = VariantDeserializer {
1538                 value: self.value,
1539                 err: PhantomData,
1540             };
1541             seed.deserialize(ContentDeserializer::new(self.variant))
1542                 .map(|v| (v, visitor))
1543         }
1544     }
1545 
1546     pub struct VariantDeserializer<'de, E>
1547     where
1548         E: de::Error,
1549     {
1550         value: Option<Content<'de>>,
1551         err: PhantomData<E>,
1552     }
1553 
1554     impl<'de, E> de::VariantAccess<'de> for VariantDeserializer<'de, E>
1555     where
1556         E: de::Error,
1557     {
1558         type Error = E;
1559 
unit_variant(self) -> Result<(), E>1560         fn unit_variant(self) -> Result<(), E> {
1561             match self.value {
1562                 Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)),
1563                 None => Ok(()),
1564             }
1565         }
1566 
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> where T: de::DeserializeSeed<'de>,1567         fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
1568         where
1569             T: de::DeserializeSeed<'de>,
1570         {
1571             match self.value {
1572                 Some(value) => seed.deserialize(ContentDeserializer::new(value)),
1573                 None => Err(de::Error::invalid_type(
1574                     de::Unexpected::UnitVariant,
1575                     &"newtype variant",
1576                 )),
1577             }
1578         }
1579 
tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1580         fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1581         where
1582             V: de::Visitor<'de>,
1583         {
1584             match self.value {
1585                 Some(Content::Seq(v)) => {
1586                     de::Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
1587                 }
1588                 Some(other) => Err(de::Error::invalid_type(
1589                     other.unexpected(),
1590                     &"tuple variant",
1591                 )),
1592                 None => Err(de::Error::invalid_type(
1593                     de::Unexpected::UnitVariant,
1594                     &"tuple variant",
1595                 )),
1596             }
1597         }
1598 
struct_variant<V>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1599         fn struct_variant<V>(
1600             self,
1601             _fields: &'static [&'static str],
1602             visitor: V,
1603         ) -> Result<V::Value, Self::Error>
1604         where
1605             V: de::Visitor<'de>,
1606         {
1607             match self.value {
1608                 Some(Content::Map(v)) => {
1609                     de::Deserializer::deserialize_any(MapDeserializer::new(v.into_iter()), visitor)
1610                 }
1611                 Some(Content::Seq(v)) => {
1612                     de::Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
1613                 }
1614                 Some(other) => Err(de::Error::invalid_type(
1615                     other.unexpected(),
1616                     &"struct variant",
1617                 )),
1618                 None => Err(de::Error::invalid_type(
1619                     de::Unexpected::UnitVariant,
1620                     &"struct variant",
1621                 )),
1622             }
1623         }
1624     }
1625 
1626     /// Not public API.
1627     pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
1628         content: &'a Content<'de>,
1629         err: PhantomData<E>,
1630     }
1631 
1632     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E>
1633     where
1634         E: de::Error,
1635     {
1636         #[cold]
invalid_type(self, exp: &Expected) -> E1637         fn invalid_type(self, exp: &Expected) -> E {
1638             de::Error::invalid_type(self.content.unexpected(), exp)
1639         }
1640 
deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1641         fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
1642         where
1643             V: Visitor<'de>,
1644         {
1645             match *self.content {
1646                 Content::U8(v) => visitor.visit_u8(v),
1647                 Content::U16(v) => visitor.visit_u16(v),
1648                 Content::U32(v) => visitor.visit_u32(v),
1649                 Content::U64(v) => visitor.visit_u64(v),
1650                 Content::I8(v) => visitor.visit_i8(v),
1651                 Content::I16(v) => visitor.visit_i16(v),
1652                 Content::I32(v) => visitor.visit_i32(v),
1653                 Content::I64(v) => visitor.visit_i64(v),
1654                 _ => Err(self.invalid_type(&visitor)),
1655             }
1656         }
1657 
deserialize_float<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1658         fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
1659         where
1660             V: Visitor<'de>,
1661         {
1662             match *self.content {
1663                 Content::F32(v) => visitor.visit_f32(v),
1664                 Content::F64(v) => visitor.visit_f64(v),
1665                 Content::U8(v) => visitor.visit_u8(v),
1666                 Content::U16(v) => visitor.visit_u16(v),
1667                 Content::U32(v) => visitor.visit_u32(v),
1668                 Content::U64(v) => visitor.visit_u64(v),
1669                 Content::I8(v) => visitor.visit_i8(v),
1670                 Content::I16(v) => visitor.visit_i16(v),
1671                 Content::I32(v) => visitor.visit_i32(v),
1672                 Content::I64(v) => visitor.visit_i64(v),
1673                 _ => Err(self.invalid_type(&visitor)),
1674             }
1675         }
1676     }
1677 
visit_content_seq_ref<'a, 'de, V, E>( content: &'a [Content<'de>], visitor: V, ) -> Result<V::Value, E> where V: Visitor<'de>, E: de::Error,1678     fn visit_content_seq_ref<'a, 'de, V, E>(
1679         content: &'a [Content<'de>],
1680         visitor: V,
1681     ) -> Result<V::Value, E>
1682     where
1683         V: Visitor<'de>,
1684         E: de::Error,
1685     {
1686         let seq = content.iter().map(ContentRefDeserializer::new);
1687         let mut seq_visitor = SeqDeserializer::new(seq);
1688         let value = tri!(visitor.visit_seq(&mut seq_visitor));
1689         tri!(seq_visitor.end());
1690         Ok(value)
1691     }
1692 
visit_content_map_ref<'a, 'de, V, E>( content: &'a [(Content<'de>, Content<'de>)], visitor: V, ) -> Result<V::Value, E> where V: Visitor<'de>, E: de::Error,1693     fn visit_content_map_ref<'a, 'de, V, E>(
1694         content: &'a [(Content<'de>, Content<'de>)],
1695         visitor: V,
1696     ) -> Result<V::Value, E>
1697     where
1698         V: Visitor<'de>,
1699         E: de::Error,
1700     {
1701         let map = content.iter().map(|(k, v)| {
1702             (
1703                 ContentRefDeserializer::new(k),
1704                 ContentRefDeserializer::new(v),
1705             )
1706         });
1707         let mut map_visitor = MapDeserializer::new(map);
1708         let value = tri!(visitor.visit_map(&mut map_visitor));
1709         tri!(map_visitor.end());
1710         Ok(value)
1711     }
1712 
1713     /// Used when deserializing an untagged enum because the content may need
1714     /// to be used more than once.
1715     impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
1716     where
1717         E: de::Error,
1718     {
1719         type Error = E;
1720 
deserialize_any<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1721         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E>
1722         where
1723             V: Visitor<'de>,
1724         {
1725             match *self.content {
1726                 Content::Bool(v) => visitor.visit_bool(v),
1727                 Content::U8(v) => visitor.visit_u8(v),
1728                 Content::U16(v) => visitor.visit_u16(v),
1729                 Content::U32(v) => visitor.visit_u32(v),
1730                 Content::U64(v) => visitor.visit_u64(v),
1731                 Content::I8(v) => visitor.visit_i8(v),
1732                 Content::I16(v) => visitor.visit_i16(v),
1733                 Content::I32(v) => visitor.visit_i32(v),
1734                 Content::I64(v) => visitor.visit_i64(v),
1735                 Content::F32(v) => visitor.visit_f32(v),
1736                 Content::F64(v) => visitor.visit_f64(v),
1737                 Content::Char(v) => visitor.visit_char(v),
1738                 Content::String(ref v) => visitor.visit_str(v),
1739                 Content::Str(v) => visitor.visit_borrowed_str(v),
1740                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1741                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1742                 Content::Unit => visitor.visit_unit(),
1743                 Content::None => visitor.visit_none(),
1744                 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
1745                 Content::Newtype(ref v) => {
1746                     visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
1747                 }
1748                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1749                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
1750             }
1751         }
1752 
deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1753         fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1754         where
1755             V: Visitor<'de>,
1756         {
1757             match *self.content {
1758                 Content::Bool(v) => visitor.visit_bool(v),
1759                 _ => Err(self.invalid_type(&visitor)),
1760             }
1761         }
1762 
deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1763         fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1764         where
1765             V: Visitor<'de>,
1766         {
1767             self.deserialize_integer(visitor)
1768         }
1769 
deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1770         fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1771         where
1772             V: Visitor<'de>,
1773         {
1774             self.deserialize_integer(visitor)
1775         }
1776 
deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1777         fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1778         where
1779             V: Visitor<'de>,
1780         {
1781             self.deserialize_integer(visitor)
1782         }
1783 
deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1784         fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1785         where
1786             V: Visitor<'de>,
1787         {
1788             self.deserialize_integer(visitor)
1789         }
1790 
deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1791         fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1792         where
1793             V: Visitor<'de>,
1794         {
1795             self.deserialize_integer(visitor)
1796         }
1797 
deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1798         fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1799         where
1800             V: Visitor<'de>,
1801         {
1802             self.deserialize_integer(visitor)
1803         }
1804 
deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1805         fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1806         where
1807             V: Visitor<'de>,
1808         {
1809             self.deserialize_integer(visitor)
1810         }
1811 
deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1812         fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1813         where
1814             V: Visitor<'de>,
1815         {
1816             self.deserialize_integer(visitor)
1817         }
1818 
deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1819         fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1820         where
1821             V: Visitor<'de>,
1822         {
1823             self.deserialize_float(visitor)
1824         }
1825 
deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1826         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1827         where
1828             V: Visitor<'de>,
1829         {
1830             self.deserialize_float(visitor)
1831         }
1832 
deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1833         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1834         where
1835             V: Visitor<'de>,
1836         {
1837             match *self.content {
1838                 Content::Char(v) => visitor.visit_char(v),
1839                 Content::String(ref v) => visitor.visit_str(v),
1840                 Content::Str(v) => visitor.visit_borrowed_str(v),
1841                 _ => Err(self.invalid_type(&visitor)),
1842             }
1843         }
1844 
deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1845         fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1846         where
1847             V: Visitor<'de>,
1848         {
1849             match *self.content {
1850                 Content::String(ref v) => visitor.visit_str(v),
1851                 Content::Str(v) => visitor.visit_borrowed_str(v),
1852                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1853                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1854                 _ => Err(self.invalid_type(&visitor)),
1855             }
1856         }
1857 
deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1858         fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1859         where
1860             V: Visitor<'de>,
1861         {
1862             self.deserialize_str(visitor)
1863         }
1864 
deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1865         fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1866         where
1867             V: Visitor<'de>,
1868         {
1869             match *self.content {
1870                 Content::String(ref v) => visitor.visit_str(v),
1871                 Content::Str(v) => visitor.visit_borrowed_str(v),
1872                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1873                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1874                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1875                 _ => Err(self.invalid_type(&visitor)),
1876             }
1877         }
1878 
deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1879         fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1880         where
1881             V: Visitor<'de>,
1882         {
1883             self.deserialize_bytes(visitor)
1884         }
1885 
deserialize_option<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1886         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
1887         where
1888             V: Visitor<'de>,
1889         {
1890             match *self.content {
1891                 Content::None => visitor.visit_none(),
1892                 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
1893                 Content::Unit => visitor.visit_unit(),
1894                 _ => visitor.visit_some(self),
1895             }
1896         }
1897 
deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1898         fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1899         where
1900             V: Visitor<'de>,
1901         {
1902             match *self.content {
1903                 Content::Unit => visitor.visit_unit(),
1904                 _ => Err(self.invalid_type(&visitor)),
1905             }
1906         }
1907 
deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1908         fn deserialize_unit_struct<V>(
1909             self,
1910             _name: &'static str,
1911             visitor: V,
1912         ) -> Result<V::Value, Self::Error>
1913         where
1914             V: Visitor<'de>,
1915         {
1916             self.deserialize_unit(visitor)
1917         }
1918 
deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1919         fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
1920         where
1921             V: Visitor<'de>,
1922         {
1923             match *self.content {
1924                 Content::Newtype(ref v) => {
1925                     visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
1926                 }
1927                 _ => visitor.visit_newtype_struct(self),
1928             }
1929         }
1930 
deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1931         fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1932         where
1933             V: Visitor<'de>,
1934         {
1935             match *self.content {
1936                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1937                 _ => Err(self.invalid_type(&visitor)),
1938             }
1939         }
1940 
deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1941         fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1942         where
1943             V: Visitor<'de>,
1944         {
1945             self.deserialize_seq(visitor)
1946         }
1947 
deserialize_tuple_struct<V>( self, _name: &'static str, _len: usize, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1948         fn deserialize_tuple_struct<V>(
1949             self,
1950             _name: &'static str,
1951             _len: usize,
1952             visitor: V,
1953         ) -> Result<V::Value, Self::Error>
1954         where
1955             V: Visitor<'de>,
1956         {
1957             self.deserialize_seq(visitor)
1958         }
1959 
deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1960         fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1961         where
1962             V: Visitor<'de>,
1963         {
1964             match *self.content {
1965                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
1966                 _ => Err(self.invalid_type(&visitor)),
1967             }
1968         }
1969 
deserialize_struct<V>( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1970         fn deserialize_struct<V>(
1971             self,
1972             _name: &'static str,
1973             _fields: &'static [&'static str],
1974             visitor: V,
1975         ) -> Result<V::Value, Self::Error>
1976         where
1977             V: Visitor<'de>,
1978         {
1979             match *self.content {
1980                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1981                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
1982                 _ => Err(self.invalid_type(&visitor)),
1983             }
1984         }
1985 
deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1986         fn deserialize_enum<V>(
1987             self,
1988             _name: &str,
1989             _variants: &'static [&'static str],
1990             visitor: V,
1991         ) -> Result<V::Value, Self::Error>
1992         where
1993             V: Visitor<'de>,
1994         {
1995             let (variant, value) = match *self.content {
1996                 Content::Map(ref value) => {
1997                     let mut iter = value.iter();
1998                     let (variant, value) = match iter.next() {
1999                         Some(v) => v,
2000                         None => {
2001                             return Err(de::Error::invalid_value(
2002                                 de::Unexpected::Map,
2003                                 &"map with a single key",
2004                             ));
2005                         }
2006                     };
2007                     // enums are encoded in json as maps with a single key:value pair
2008                     if iter.next().is_some() {
2009                         return Err(de::Error::invalid_value(
2010                             de::Unexpected::Map,
2011                             &"map with a single key",
2012                         ));
2013                     }
2014                     (variant, Some(value))
2015                 }
2016                 ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
2017                 ref other => {
2018                     return Err(de::Error::invalid_type(
2019                         other.unexpected(),
2020                         &"string or map",
2021                     ));
2022                 }
2023             };
2024 
2025             visitor.visit_enum(EnumRefDeserializer {
2026                 variant,
2027                 value,
2028                 err: PhantomData,
2029             })
2030         }
2031 
deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2032         fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2033         where
2034             V: Visitor<'de>,
2035         {
2036             match *self.content {
2037                 Content::String(ref v) => visitor.visit_str(v),
2038                 Content::Str(v) => visitor.visit_borrowed_str(v),
2039                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
2040                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
2041                 Content::U8(v) => visitor.visit_u8(v),
2042                 Content::U64(v) => visitor.visit_u64(v),
2043                 _ => Err(self.invalid_type(&visitor)),
2044             }
2045         }
2046 
deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2047         fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2048         where
2049             V: Visitor<'de>,
2050         {
2051             visitor.visit_unit()
2052         }
2053 
__deserialize_content<V>( self, _: actually_private::T, visitor: V, ) -> Result<Content<'de>, Self::Error> where V: Visitor<'de, Value = Content<'de>>,2054         fn __deserialize_content<V>(
2055             self,
2056             _: actually_private::T,
2057             visitor: V,
2058         ) -> Result<Content<'de>, Self::Error>
2059         where
2060             V: Visitor<'de, Value = Content<'de>>,
2061         {
2062             let _ = visitor;
2063             Ok(self.content.clone())
2064         }
2065     }
2066 
2067     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
2068         /// private API, don't use
new(content: &'a Content<'de>) -> Self2069         pub fn new(content: &'a Content<'de>) -> Self {
2070             ContentRefDeserializer {
2071                 content,
2072                 err: PhantomData,
2073             }
2074         }
2075     }
2076 
2077     impl<'a, 'de: 'a, E> Copy for ContentRefDeserializer<'a, 'de, E> {}
2078 
2079     impl<'a, 'de: 'a, E> Clone for ContentRefDeserializer<'a, 'de, E> {
clone(&self) -> Self2080         fn clone(&self) -> Self {
2081             *self
2082         }
2083     }
2084 
2085     struct EnumRefDeserializer<'a, 'de: 'a, E>
2086     where
2087         E: de::Error,
2088     {
2089         variant: &'a Content<'de>,
2090         value: Option<&'a Content<'de>>,
2091         err: PhantomData<E>,
2092     }
2093 
2094     impl<'de, 'a, E> de::EnumAccess<'de> for EnumRefDeserializer<'a, 'de, E>
2095     where
2096         E: de::Error,
2097     {
2098         type Error = E;
2099         type Variant = VariantRefDeserializer<'a, 'de, Self::Error>;
2100 
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,2101         fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
2102         where
2103             V: de::DeserializeSeed<'de>,
2104         {
2105             let visitor = VariantRefDeserializer {
2106                 value: self.value,
2107                 err: PhantomData,
2108             };
2109             seed.deserialize(ContentRefDeserializer::new(self.variant))
2110                 .map(|v| (v, visitor))
2111         }
2112     }
2113 
2114     struct VariantRefDeserializer<'a, 'de: 'a, E>
2115     where
2116         E: de::Error,
2117     {
2118         value: Option<&'a Content<'de>>,
2119         err: PhantomData<E>,
2120     }
2121 
2122     impl<'de, 'a, E> de::VariantAccess<'de> for VariantRefDeserializer<'a, 'de, E>
2123     where
2124         E: de::Error,
2125     {
2126         type Error = E;
2127 
unit_variant(self) -> Result<(), E>2128         fn unit_variant(self) -> Result<(), E> {
2129             match self.value {
2130                 Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
2131                 None => Ok(()),
2132             }
2133         }
2134 
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> where T: de::DeserializeSeed<'de>,2135         fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
2136         where
2137             T: de::DeserializeSeed<'de>,
2138         {
2139             match self.value {
2140                 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2141                 None => Err(de::Error::invalid_type(
2142                     de::Unexpected::UnitVariant,
2143                     &"newtype variant",
2144                 )),
2145             }
2146         }
2147 
tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,2148         fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
2149         where
2150             V: de::Visitor<'de>,
2151         {
2152             match self.value {
2153                 Some(Content::Seq(v)) => {
2154                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
2155                 }
2156                 Some(other) => Err(de::Error::invalid_type(
2157                     other.unexpected(),
2158                     &"tuple variant",
2159                 )),
2160                 None => Err(de::Error::invalid_type(
2161                     de::Unexpected::UnitVariant,
2162                     &"tuple variant",
2163                 )),
2164             }
2165         }
2166 
struct_variant<V>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,2167         fn struct_variant<V>(
2168             self,
2169             _fields: &'static [&'static str],
2170             visitor: V,
2171         ) -> Result<V::Value, Self::Error>
2172         where
2173             V: de::Visitor<'de>,
2174         {
2175             match self.value {
2176                 Some(Content::Map(v)) => {
2177                     de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
2178                 }
2179                 Some(Content::Seq(v)) => {
2180                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
2181                 }
2182                 Some(other) => Err(de::Error::invalid_type(
2183                     other.unexpected(),
2184                     &"struct variant",
2185                 )),
2186                 None => Err(de::Error::invalid_type(
2187                     de::Unexpected::UnitVariant,
2188                     &"struct variant",
2189                 )),
2190             }
2191         }
2192     }
2193 
2194     struct SeqRefDeserializer<'a, 'de: 'a, E>
2195     where
2196         E: de::Error,
2197     {
2198         iter: <&'a [Content<'de>] as IntoIterator>::IntoIter,
2199         err: PhantomData<E>,
2200     }
2201 
2202     impl<'a, 'de, E> SeqRefDeserializer<'a, 'de, E>
2203     where
2204         E: de::Error,
2205     {
new(slice: &'a [Content<'de>]) -> Self2206         fn new(slice: &'a [Content<'de>]) -> Self {
2207             SeqRefDeserializer {
2208                 iter: slice.iter(),
2209                 err: PhantomData,
2210             }
2211         }
2212     }
2213 
2214     impl<'de, 'a, E> de::Deserializer<'de> for SeqRefDeserializer<'a, 'de, E>
2215     where
2216         E: de::Error,
2217     {
2218         type Error = E;
2219 
2220         #[inline]
deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,2221         fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
2222         where
2223             V: de::Visitor<'de>,
2224         {
2225             let len = self.iter.len();
2226             if len == 0 {
2227                 visitor.visit_unit()
2228             } else {
2229                 let ret = tri!(visitor.visit_seq(&mut self));
2230                 let remaining = self.iter.len();
2231                 if remaining == 0 {
2232                     Ok(ret)
2233                 } else {
2234                     Err(de::Error::invalid_length(len, &"fewer elements in array"))
2235                 }
2236             }
2237         }
2238 
2239         forward_to_deserialize_any! {
2240             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2241             bytes byte_buf option unit unit_struct newtype_struct seq tuple
2242             tuple_struct map struct enum identifier ignored_any
2243         }
2244     }
2245 
2246     impl<'de, 'a, E> de::SeqAccess<'de> for SeqRefDeserializer<'a, 'de, E>
2247     where
2248         E: de::Error,
2249     {
2250         type Error = E;
2251 
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,2252         fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2253         where
2254             T: de::DeserializeSeed<'de>,
2255         {
2256             match self.iter.next() {
2257                 Some(value) => seed
2258                     .deserialize(ContentRefDeserializer::new(value))
2259                     .map(Some),
2260                 None => Ok(None),
2261             }
2262         }
2263 
size_hint(&self) -> Option<usize>2264         fn size_hint(&self) -> Option<usize> {
2265             size_hint::from_bounds(&self.iter)
2266         }
2267     }
2268 
2269     struct MapRefDeserializer<'a, 'de: 'a, E>
2270     where
2271         E: de::Error,
2272     {
2273         iter: <&'a [(Content<'de>, Content<'de>)] as IntoIterator>::IntoIter,
2274         value: Option<&'a Content<'de>>,
2275         err: PhantomData<E>,
2276     }
2277 
2278     impl<'a, 'de, E> MapRefDeserializer<'a, 'de, E>
2279     where
2280         E: de::Error,
2281     {
new(map: &'a [(Content<'de>, Content<'de>)]) -> Self2282         fn new(map: &'a [(Content<'de>, Content<'de>)]) -> Self {
2283             MapRefDeserializer {
2284                 iter: map.iter(),
2285                 value: None,
2286                 err: PhantomData,
2287             }
2288         }
2289     }
2290 
2291     impl<'de, 'a, E> de::MapAccess<'de> for MapRefDeserializer<'a, 'de, E>
2292     where
2293         E: de::Error,
2294     {
2295         type Error = E;
2296 
next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,2297         fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2298         where
2299             T: de::DeserializeSeed<'de>,
2300         {
2301             match self.iter.next() {
2302                 Some((key, value)) => {
2303                     self.value = Some(value);
2304                     seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
2305                 }
2306                 None => Ok(None),
2307             }
2308         }
2309 
next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,2310         fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2311         where
2312             T: de::DeserializeSeed<'de>,
2313         {
2314             match self.value.take() {
2315                 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2316                 None => Err(de::Error::custom("value is missing")),
2317             }
2318         }
2319 
size_hint(&self) -> Option<usize>2320         fn size_hint(&self) -> Option<usize> {
2321             size_hint::from_bounds(&self.iter)
2322         }
2323     }
2324 
2325     impl<'de, 'a, E> de::Deserializer<'de> for MapRefDeserializer<'a, 'de, E>
2326     where
2327         E: de::Error,
2328     {
2329         type Error = E;
2330 
2331         #[inline]
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,2332         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2333         where
2334             V: de::Visitor<'de>,
2335         {
2336             visitor.visit_map(self)
2337         }
2338 
2339         forward_to_deserialize_any! {
2340             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2341             bytes byte_buf option unit unit_struct newtype_struct seq tuple
2342             tuple_struct map struct enum identifier ignored_any
2343         }
2344     }
2345 
2346     impl<'de, E> de::IntoDeserializer<'de, E> for ContentDeserializer<'de, E>
2347     where
2348         E: de::Error,
2349     {
2350         type Deserializer = Self;
2351 
into_deserializer(self) -> Self2352         fn into_deserializer(self) -> Self {
2353             self
2354         }
2355     }
2356 
2357     impl<'de, 'a, E> de::IntoDeserializer<'de, E> for ContentRefDeserializer<'a, 'de, E>
2358     where
2359         E: de::Error,
2360     {
2361         type Deserializer = Self;
2362 
into_deserializer(self) -> Self2363         fn into_deserializer(self) -> Self {
2364             self
2365         }
2366     }
2367 
2368     /// Visitor for deserializing an internally tagged unit variant.
2369     ///
2370     /// Not public API.
2371     pub struct InternallyTaggedUnitVisitor<'a> {
2372         type_name: &'a str,
2373         variant_name: &'a str,
2374     }
2375 
2376     impl<'a> InternallyTaggedUnitVisitor<'a> {
2377         /// Not public API.
new(type_name: &'a str, variant_name: &'a str) -> Self2378         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
2379             InternallyTaggedUnitVisitor {
2380                 type_name,
2381                 variant_name,
2382             }
2383         }
2384     }
2385 
2386     impl<'de, 'a> Visitor<'de> for InternallyTaggedUnitVisitor<'a> {
2387         type Value = ();
2388 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result2389         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2390             write!(
2391                 formatter,
2392                 "unit variant {}::{}",
2393                 self.type_name, self.variant_name
2394             )
2395         }
2396 
visit_seq<S>(self, _: S) -> Result<(), S::Error> where S: SeqAccess<'de>,2397         fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
2398         where
2399             S: SeqAccess<'de>,
2400         {
2401             Ok(())
2402         }
2403 
visit_map<M>(self, mut access: M) -> Result<(), M::Error> where M: MapAccess<'de>,2404         fn visit_map<M>(self, mut access: M) -> Result<(), M::Error>
2405         where
2406             M: MapAccess<'de>,
2407         {
2408             while tri!(access.next_entry::<IgnoredAny, IgnoredAny>()).is_some() {}
2409             Ok(())
2410         }
2411     }
2412 
2413     /// Visitor for deserializing an untagged unit variant.
2414     ///
2415     /// Not public API.
2416     pub struct UntaggedUnitVisitor<'a> {
2417         type_name: &'a str,
2418         variant_name: &'a str,
2419     }
2420 
2421     impl<'a> UntaggedUnitVisitor<'a> {
2422         /// Not public API.
new(type_name: &'a str, variant_name: &'a str) -> Self2423         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
2424             UntaggedUnitVisitor {
2425                 type_name,
2426                 variant_name,
2427             }
2428         }
2429     }
2430 
2431     impl<'de, 'a> Visitor<'de> for UntaggedUnitVisitor<'a> {
2432         type Value = ();
2433 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result2434         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2435             write!(
2436                 formatter,
2437                 "unit variant {}::{}",
2438                 self.type_name, self.variant_name
2439             )
2440         }
2441 
visit_unit<E>(self) -> Result<(), E> where E: de::Error,2442         fn visit_unit<E>(self) -> Result<(), E>
2443         where
2444             E: de::Error,
2445         {
2446             Ok(())
2447         }
2448 
visit_none<E>(self) -> Result<(), E> where E: de::Error,2449         fn visit_none<E>(self) -> Result<(), E>
2450         where
2451             E: de::Error,
2452         {
2453             Ok(())
2454         }
2455     }
2456 }
2457 
2458 ////////////////////////////////////////////////////////////////////////////////
2459 
2460 // Like `IntoDeserializer` but also implemented for `&[u8]`. This is used for
2461 // the newtype fallthrough case of `field_identifier`.
2462 //
2463 //    #[derive(Deserialize)]
2464 //    #[serde(field_identifier)]
2465 //    enum F {
2466 //        A,
2467 //        B,
2468 //        Other(String), // deserialized using IdentifierDeserializer
2469 //    }
2470 pub trait IdentifierDeserializer<'de, E: Error> {
2471     type Deserializer: Deserializer<'de, Error = E>;
2472 
from(self) -> Self::Deserializer2473     fn from(self) -> Self::Deserializer;
2474 }
2475 
2476 pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
2477 
2478 impl<'de, E> IdentifierDeserializer<'de, E> for u64
2479 where
2480     E: Error,
2481 {
2482     type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
2483 
from(self) -> Self::Deserializer2484     fn from(self) -> Self::Deserializer {
2485         self.into_deserializer()
2486     }
2487 }
2488 
2489 pub struct StrDeserializer<'a, E> {
2490     value: &'a str,
2491     marker: PhantomData<E>,
2492 }
2493 
2494 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
2495 where
2496     E: Error,
2497 {
2498     type Error = E;
2499 
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2500     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2501     where
2502         V: Visitor<'de>,
2503     {
2504         visitor.visit_str(self.value)
2505     }
2506 
2507     forward_to_deserialize_any! {
2508         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2509         bytes byte_buf option unit unit_struct newtype_struct seq tuple
2510         tuple_struct map struct enum identifier ignored_any
2511     }
2512 }
2513 
2514 pub struct BorrowedStrDeserializer<'de, E> {
2515     value: &'de str,
2516     marker: PhantomData<E>,
2517 }
2518 
2519 impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
2520 where
2521     E: Error,
2522 {
2523     type Error = E;
2524 
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2525     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2526     where
2527         V: Visitor<'de>,
2528     {
2529         visitor.visit_borrowed_str(self.value)
2530     }
2531 
2532     forward_to_deserialize_any! {
2533         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2534         bytes byte_buf option unit unit_struct newtype_struct seq tuple
2535         tuple_struct map struct enum identifier ignored_any
2536     }
2537 }
2538 
2539 impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
2540 where
2541     E: Error,
2542 {
2543     type Deserializer = StrDeserializer<'a, E>;
2544 
from(self) -> Self::Deserializer2545     fn from(self) -> Self::Deserializer {
2546         StrDeserializer {
2547             value: self,
2548             marker: PhantomData,
2549         }
2550     }
2551 }
2552 
2553 impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
2554 where
2555     E: Error,
2556 {
2557     type Deserializer = BorrowedStrDeserializer<'de, E>;
2558 
from(self) -> Self::Deserializer2559     fn from(self) -> Self::Deserializer {
2560         BorrowedStrDeserializer {
2561             value: self.0,
2562             marker: PhantomData,
2563         }
2564     }
2565 }
2566 
2567 impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
2568 where
2569     E: Error,
2570 {
2571     type Deserializer = BytesDeserializer<'a, E>;
2572 
from(self) -> Self::Deserializer2573     fn from(self) -> Self::Deserializer {
2574         BytesDeserializer::new(self)
2575     }
2576 }
2577 
2578 impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
2579 where
2580     E: Error,
2581 {
2582     type Deserializer = BorrowedBytesDeserializer<'de, E>;
2583 
from(self) -> Self::Deserializer2584     fn from(self) -> Self::Deserializer {
2585         BorrowedBytesDeserializer::new(self.0)
2586     }
2587 }
2588 
2589 #[cfg(any(feature = "std", feature = "alloc"))]
2590 pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
2591     pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,
2592     pub PhantomData<E>,
2593 );
2594 
2595 #[cfg(any(feature = "std", feature = "alloc"))]
2596 impl<'a, 'de, E> FlatMapDeserializer<'a, 'de, E>
2597 where
2598     E: Error,
2599 {
deserialize_other<V>() -> Result<V, E>2600     fn deserialize_other<V>() -> Result<V, E> {
2601         Err(Error::custom("can only flatten structs and maps"))
2602     }
2603 }
2604 
2605 #[cfg(any(feature = "std", feature = "alloc"))]
2606 macro_rules! forward_to_deserialize_other {
2607     ($($func:ident ($($arg:ty),*))*) => {
2608         $(
2609             fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
2610             where
2611                 V: Visitor<'de>,
2612             {
2613                 Self::deserialize_other()
2614             }
2615         )*
2616     }
2617 }
2618 
2619 #[cfg(any(feature = "std", feature = "alloc"))]
2620 impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
2621 where
2622     E: Error,
2623 {
2624     type Error = E;
2625 
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2626     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2627     where
2628         V: Visitor<'de>,
2629     {
2630         self.deserialize_map(visitor)
2631     }
2632 
deserialize_enum<V>( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2633     fn deserialize_enum<V>(
2634         self,
2635         name: &'static str,
2636         variants: &'static [&'static str],
2637         visitor: V,
2638     ) -> Result<V::Value, Self::Error>
2639     where
2640         V: Visitor<'de>,
2641     {
2642         for entry in self.0 {
2643             if let Some((key, value)) = flat_map_take_entry(entry, variants) {
2644                 return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
2645             }
2646         }
2647 
2648         Err(Error::custom(format_args!(
2649             "no variant of enum {} found in flattened data",
2650             name
2651         )))
2652     }
2653 
deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2654     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2655     where
2656         V: Visitor<'de>,
2657     {
2658         visitor.visit_map(FlatMapAccess {
2659             iter: self.0.iter(),
2660             pending_content: None,
2661             _marker: PhantomData,
2662         })
2663     }
2664 
deserialize_struct<V>( self, _: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2665     fn deserialize_struct<V>(
2666         self,
2667         _: &'static str,
2668         fields: &'static [&'static str],
2669         visitor: V,
2670     ) -> Result<V::Value, Self::Error>
2671     where
2672         V: Visitor<'de>,
2673     {
2674         visitor.visit_map(FlatStructAccess {
2675             iter: self.0.iter_mut(),
2676             pending_content: None,
2677             fields,
2678             _marker: PhantomData,
2679         })
2680     }
2681 
deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2682     fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
2683     where
2684         V: Visitor<'de>,
2685     {
2686         visitor.visit_newtype_struct(self)
2687     }
2688 
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2689     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2690     where
2691         V: Visitor<'de>,
2692     {
2693         match visitor.__private_visit_untagged_option(self) {
2694             Ok(value) => Ok(value),
2695             Err(()) => Self::deserialize_other(),
2696         }
2697     }
2698 
deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2699     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2700     where
2701         V: Visitor<'de>,
2702     {
2703         visitor.visit_unit()
2704     }
2705 
deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2706     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2707     where
2708         V: Visitor<'de>,
2709     {
2710         visitor.visit_unit()
2711     }
2712 
2713     forward_to_deserialize_other! {
2714         deserialize_bool()
2715         deserialize_i8()
2716         deserialize_i16()
2717         deserialize_i32()
2718         deserialize_i64()
2719         deserialize_u8()
2720         deserialize_u16()
2721         deserialize_u32()
2722         deserialize_u64()
2723         deserialize_f32()
2724         deserialize_f64()
2725         deserialize_char()
2726         deserialize_str()
2727         deserialize_string()
2728         deserialize_bytes()
2729         deserialize_byte_buf()
2730         deserialize_unit_struct(&'static str)
2731         deserialize_seq()
2732         deserialize_tuple(usize)
2733         deserialize_tuple_struct(&'static str, usize)
2734         deserialize_identifier()
2735     }
2736 }
2737 
2738 #[cfg(any(feature = "std", feature = "alloc"))]
2739 struct FlatMapAccess<'a, 'de: 'a, E> {
2740     iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
2741     pending_content: Option<&'a Content<'de>>,
2742     _marker: PhantomData<E>,
2743 }
2744 
2745 #[cfg(any(feature = "std", feature = "alloc"))]
2746 impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
2747 where
2748     E: Error,
2749 {
2750     type Error = E;
2751 
next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: DeserializeSeed<'de>,2752     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2753     where
2754         T: DeserializeSeed<'de>,
2755     {
2756         for item in &mut self.iter {
2757             // Items in the vector are nulled out when used by a struct.
2758             if let Some((ref key, ref content)) = *item {
2759                 // Do not take(), instead borrow this entry. The internally tagged
2760                 // enum does its own buffering so we can't tell whether this entry
2761                 // is going to be consumed. Borrowing here leaves the entry
2762                 // available for later flattened fields.
2763                 self.pending_content = Some(content);
2764                 return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
2765             }
2766         }
2767         Ok(None)
2768     }
2769 
next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: DeserializeSeed<'de>,2770     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2771     where
2772         T: DeserializeSeed<'de>,
2773     {
2774         match self.pending_content.take() {
2775             Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2776             None => Err(Error::custom("value is missing")),
2777         }
2778     }
2779 }
2780 
2781 #[cfg(any(feature = "std", feature = "alloc"))]
2782 struct FlatStructAccess<'a, 'de: 'a, E> {
2783     iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
2784     pending_content: Option<Content<'de>>,
2785     fields: &'static [&'static str],
2786     _marker: PhantomData<E>,
2787 }
2788 
2789 #[cfg(any(feature = "std", feature = "alloc"))]
2790 impl<'a, 'de, E> MapAccess<'de> for FlatStructAccess<'a, 'de, E>
2791 where
2792     E: Error,
2793 {
2794     type Error = E;
2795 
next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: DeserializeSeed<'de>,2796     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2797     where
2798         T: DeserializeSeed<'de>,
2799     {
2800         for entry in self.iter.by_ref() {
2801             if let Some((key, content)) = flat_map_take_entry(entry, self.fields) {
2802                 self.pending_content = Some(content);
2803                 return seed.deserialize(ContentDeserializer::new(key)).map(Some);
2804             }
2805         }
2806         Ok(None)
2807     }
2808 
next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: DeserializeSeed<'de>,2809     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2810     where
2811         T: DeserializeSeed<'de>,
2812     {
2813         match self.pending_content.take() {
2814             Some(value) => seed.deserialize(ContentDeserializer::new(value)),
2815             None => Err(Error::custom("value is missing")),
2816         }
2817     }
2818 }
2819 
2820 /// Claims one key-value pair from a FlatMapDeserializer's field buffer if the
2821 /// field name matches any of the recognized ones.
2822 #[cfg(any(feature = "std", feature = "alloc"))]
flat_map_take_entry<'de>( entry: &mut Option<(Content<'de>, Content<'de>)>, recognized: &[&str], ) -> Option<(Content<'de>, Content<'de>)>2823 fn flat_map_take_entry<'de>(
2824     entry: &mut Option<(Content<'de>, Content<'de>)>,
2825     recognized: &[&str],
2826 ) -> Option<(Content<'de>, Content<'de>)> {
2827     // Entries in the FlatMapDeserializer buffer are nulled out as they get
2828     // claimed for deserialization. We only use an entry if it is still present
2829     // and if the field is one recognized by the current data structure.
2830     let is_recognized = match entry {
2831         None => false,
2832         Some((k, _v)) => k.as_str().map_or(false, |name| recognized.contains(&name)),
2833     };
2834 
2835     if is_recognized {
2836         entry.take()
2837     } else {
2838         None
2839     }
2840 }
2841 
2842 pub struct AdjacentlyTaggedEnumVariantSeed<F> {
2843     pub enum_name: &'static str,
2844     pub variants: &'static [&'static str],
2845     pub fields_enum: PhantomData<F>,
2846 }
2847 
2848 pub struct AdjacentlyTaggedEnumVariantVisitor<F> {
2849     enum_name: &'static str,
2850     fields_enum: PhantomData<F>,
2851 }
2852 
2853 impl<'de, F> Visitor<'de> for AdjacentlyTaggedEnumVariantVisitor<F>
2854 where
2855     F: Deserialize<'de>,
2856 {
2857     type Value = F;
2858 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result2859     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2860         write!(formatter, "variant of enum {}", self.enum_name)
2861     }
2862 
visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where A: EnumAccess<'de>,2863     fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2864     where
2865         A: EnumAccess<'de>,
2866     {
2867         let (variant, variant_access) = tri!(data.variant());
2868         tri!(variant_access.unit_variant());
2869         Ok(variant)
2870     }
2871 }
2872 
2873 impl<'de, F> DeserializeSeed<'de> for AdjacentlyTaggedEnumVariantSeed<F>
2874 where
2875     F: Deserialize<'de>,
2876 {
2877     type Value = F;
2878 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,2879     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
2880     where
2881         D: Deserializer<'de>,
2882     {
2883         deserializer.deserialize_enum(
2884             self.enum_name,
2885             self.variants,
2886             AdjacentlyTaggedEnumVariantVisitor {
2887                 enum_name: self.enum_name,
2888                 fields_enum: PhantomData,
2889             },
2890         )
2891     }
2892 }
2893