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