1 // Copyright 2017 Serde Developers
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8
9 use lib::*;
10
11 use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
12
13 #[cfg(any(feature = "std", feature = "alloc"))]
14 use de::Unexpected;
15
16 #[cfg(any(feature = "std", feature = "alloc"))]
17 pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer,
18 InternallyTaggedUnitVisitor, TagContentOtherField,
19 TagContentOtherFieldVisitor, TagOrContentField, TagOrContentFieldVisitor,
20 TaggedContentVisitor, UntaggedUnitVisitor};
21
22 /// If the missing field is of type `Option<T>` then treat is as `None`,
23 /// otherwise it is an error.
missing_field<'de, V, E>(field: &'static str) -> Result<V, E> where V: Deserialize<'de>, E: Error,24 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
25 where
26 V: Deserialize<'de>,
27 E: Error,
28 {
29 struct MissingFieldDeserializer<E>(&'static str, PhantomData<E>);
30
31 impl<'de, E> Deserializer<'de> for MissingFieldDeserializer<E>
32 where
33 E: Error,
34 {
35 type Error = E;
36
37 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, E>
38 where
39 V: Visitor<'de>,
40 {
41 Err(Error::missing_field(self.0))
42 }
43
44 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
45 where
46 V: Visitor<'de>,
47 {
48 visitor.visit_none()
49 }
50
51 forward_to_deserialize_any! {
52 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
53 byte_buf unit unit_struct newtype_struct seq tuple tuple_struct map
54 struct enum identifier ignored_any
55 }
56 }
57
58 let deserializer = MissingFieldDeserializer(field, PhantomData);
59 Deserialize::deserialize(deserializer)
60 }
61
62 #[cfg(any(feature = "std", feature = "alloc"))]
borrow_cow_str<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, str>, D::Error> where D: Deserializer<'de>,63 pub fn borrow_cow_str<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, str>, D::Error>
64 where
65 D: Deserializer<'de>,
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)
132 }
133
134 #[cfg(any(feature = "std", feature = "alloc"))]
borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, [u8]>, D::Error> where D: Deserializer<'de>,135 pub fn borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<Cow<'a, [u8]>, D::Error>
136 where
137 D: Deserializer<'de>,
138 {
139 struct CowBytesVisitor;
140
141 impl<'a> Visitor<'a> for CowBytesVisitor {
142 type Value = Cow<'a, [u8]>;
143
144 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
145 formatter.write_str("a byte array")
146 }
147
148 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
149 where
150 E: Error,
151 {
152 Ok(Cow::Owned(v.as_bytes().to_vec()))
153 }
154
155 fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
156 where
157 E: Error,
158 {
159 Ok(Cow::Borrowed(v.as_bytes()))
160 }
161
162 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
163 where
164 E: Error,
165 {
166 Ok(Cow::Owned(v.into_bytes()))
167 }
168
169 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
170 where
171 E: Error,
172 {
173 Ok(Cow::Owned(v.to_vec()))
174 }
175
176 fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
177 where
178 E: Error,
179 {
180 Ok(Cow::Borrowed(v))
181 }
182
183 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
184 where
185 E: Error,
186 {
187 Ok(Cow::Owned(v))
188 }
189 }
190
191 deserializer.deserialize_str(CowBytesVisitor)
192 }
193
194 pub mod size_hint {
195 use lib::*;
196
from_bounds<I>(iter: &I) -> Option<usize> where I: Iterator,197 pub fn from_bounds<I>(iter: &I) -> Option<usize>
198 where
199 I: Iterator,
200 {
201 helper(iter.size_hint())
202 }
203
204 #[inline]
cautious(hint: Option<usize>) -> usize205 pub fn cautious(hint: Option<usize>) -> usize {
206 cmp::min(hint.unwrap_or(0), 4096)
207 }
208
helper(bounds: (usize, Option<usize>)) -> Option<usize>209 fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
210 match bounds {
211 (lower, Some(upper)) if lower == upper => Some(upper),
212 _ => None,
213 }
214 }
215 }
216
217 #[cfg(any(feature = "std", feature = "alloc"))]
218 mod content {
219 // This module is private and nothing here should be used outside of
220 // generated code.
221 //
222 // We will iterate on the implementation for a few releases and only have to
223 // worry about backward compatibility for the `untagged` and `tag` attributes
224 // rather than for this entire mechanism.
225 //
226 // This issue is tracking making some of this stuff public:
227 // https://github.com/serde-rs/serde/issues/741
228
229 use lib::*;
230
231 use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess,
232 Unexpected, Visitor};
233 use super::size_hint;
234
235 /// Used from generated code to buffer the contents of the Deserializer when
236 /// deserializing untagged enums and internally tagged enums.
237 ///
238 /// Not public API. Use serde-value instead.
239 #[derive(Debug)]
240 pub enum Content<'de> {
241 Bool(bool),
242
243 U8(u8),
244 U16(u16),
245 U32(u32),
246 U64(u64),
247
248 I8(i8),
249 I16(i16),
250 I32(i32),
251 I64(i64),
252
253 F32(f32),
254 F64(f64),
255
256 Char(char),
257 String(String),
258 Str(&'de str),
259 ByteBuf(Vec<u8>),
260 Bytes(&'de [u8]),
261
262 None,
263 Some(Box<Content<'de>>),
264
265 Unit,
266 Newtype(Box<Content<'de>>),
267 Seq(Vec<Content<'de>>),
268 Map(Vec<(Content<'de>, Content<'de>)>),
269 }
270
271 impl<'de> Content<'de> {
unexpected(&self) -> Unexpected272 fn unexpected(&self) -> Unexpected {
273 match *self {
274 Content::Bool(b) => Unexpected::Bool(b),
275 Content::U8(n) => Unexpected::Unsigned(n as u64),
276 Content::U16(n) => Unexpected::Unsigned(n as u64),
277 Content::U32(n) => Unexpected::Unsigned(n as u64),
278 Content::U64(n) => Unexpected::Unsigned(n),
279 Content::I8(n) => Unexpected::Signed(n as i64),
280 Content::I16(n) => Unexpected::Signed(n as i64),
281 Content::I32(n) => Unexpected::Signed(n as i64),
282 Content::I64(n) => Unexpected::Signed(n),
283 Content::F32(f) => Unexpected::Float(f as f64),
284 Content::F64(f) => Unexpected::Float(f),
285 Content::Char(c) => Unexpected::Char(c),
286 Content::String(ref s) => Unexpected::Str(s),
287 Content::Str(s) => Unexpected::Str(s),
288 Content::ByteBuf(ref b) => Unexpected::Bytes(b),
289 Content::Bytes(b) => Unexpected::Bytes(b),
290 Content::None | Content::Some(_) => Unexpected::Option,
291 Content::Unit => Unexpected::Unit,
292 Content::Newtype(_) => Unexpected::NewtypeStruct,
293 Content::Seq(_) => Unexpected::Seq,
294 Content::Map(_) => Unexpected::Map,
295 }
296 }
297 }
298
299 impl<'de> Deserialize<'de> for Content<'de> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,300 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
301 where
302 D: Deserializer<'de>,
303 {
304 // Untagged and internally tagged enums are only supported in
305 // self-describing formats.
306 let visitor = ContentVisitor { value: PhantomData };
307 deserializer.deserialize_any(visitor)
308 }
309 }
310
311 struct ContentVisitor<'de> {
312 value: PhantomData<Content<'de>>,
313 }
314
315 impl<'de> ContentVisitor<'de> {
new() -> Self316 fn new() -> Self {
317 ContentVisitor { value: PhantomData }
318 }
319 }
320
321 impl<'de> Visitor<'de> for ContentVisitor<'de> {
322 type Value = Content<'de>;
323
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result324 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
325 fmt.write_str("any value")
326 }
327
visit_bool<F>(self, value: bool) -> Result<Self::Value, F> where F: de::Error,328 fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
329 where
330 F: de::Error,
331 {
332 Ok(Content::Bool(value))
333 }
334
visit_i8<F>(self, value: i8) -> Result<Self::Value, F> where F: de::Error,335 fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
336 where
337 F: de::Error,
338 {
339 Ok(Content::I8(value))
340 }
341
visit_i16<F>(self, value: i16) -> Result<Self::Value, F> where F: de::Error,342 fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
343 where
344 F: de::Error,
345 {
346 Ok(Content::I16(value))
347 }
348
visit_i32<F>(self, value: i32) -> Result<Self::Value, F> where F: de::Error,349 fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
350 where
351 F: de::Error,
352 {
353 Ok(Content::I32(value))
354 }
355
visit_i64<F>(self, value: i64) -> Result<Self::Value, F> where F: de::Error,356 fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
357 where
358 F: de::Error,
359 {
360 Ok(Content::I64(value))
361 }
362
visit_u8<F>(self, value: u8) -> Result<Self::Value, F> where F: de::Error,363 fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
364 where
365 F: de::Error,
366 {
367 Ok(Content::U8(value))
368 }
369
visit_u16<F>(self, value: u16) -> Result<Self::Value, F> where F: de::Error,370 fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
371 where
372 F: de::Error,
373 {
374 Ok(Content::U16(value))
375 }
376
visit_u32<F>(self, value: u32) -> Result<Self::Value, F> where F: de::Error,377 fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
378 where
379 F: de::Error,
380 {
381 Ok(Content::U32(value))
382 }
383
visit_u64<F>(self, value: u64) -> Result<Self::Value, F> where F: de::Error,384 fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
385 where
386 F: de::Error,
387 {
388 Ok(Content::U64(value))
389 }
390
visit_f32<F>(self, value: f32) -> Result<Self::Value, F> where F: de::Error,391 fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
392 where
393 F: de::Error,
394 {
395 Ok(Content::F32(value))
396 }
397
visit_f64<F>(self, value: f64) -> Result<Self::Value, F> where F: de::Error,398 fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
399 where
400 F: de::Error,
401 {
402 Ok(Content::F64(value))
403 }
404
visit_char<F>(self, value: char) -> Result<Self::Value, F> where F: de::Error,405 fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
406 where
407 F: de::Error,
408 {
409 Ok(Content::Char(value))
410 }
411
visit_str<F>(self, value: &str) -> Result<Self::Value, F> where F: de::Error,412 fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
413 where
414 F: de::Error,
415 {
416 Ok(Content::String(value.into()))
417 }
418
visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F> where F: de::Error,419 fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
420 where
421 F: de::Error,
422 {
423 Ok(Content::Str(value))
424 }
425
visit_string<F>(self, value: String) -> Result<Self::Value, F> where F: de::Error,426 fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
427 where
428 F: de::Error,
429 {
430 Ok(Content::String(value))
431 }
432
visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F> where F: de::Error,433 fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
434 where
435 F: de::Error,
436 {
437 Ok(Content::ByteBuf(value.into()))
438 }
439
visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F> where F: de::Error,440 fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
441 where
442 F: de::Error,
443 {
444 Ok(Content::Bytes(value))
445 }
446
visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F> where F: de::Error,447 fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
448 where
449 F: de::Error,
450 {
451 Ok(Content::ByteBuf(value))
452 }
453
visit_unit<F>(self) -> Result<Self::Value, F> where F: de::Error,454 fn visit_unit<F>(self) -> Result<Self::Value, F>
455 where
456 F: de::Error,
457 {
458 Ok(Content::Unit)
459 }
460
visit_none<F>(self) -> Result<Self::Value, F> where F: de::Error,461 fn visit_none<F>(self) -> Result<Self::Value, F>
462 where
463 F: de::Error,
464 {
465 Ok(Content::None)
466 }
467
visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,468 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
469 where
470 D: Deserializer<'de>,
471 {
472 Deserialize::deserialize(deserializer).map(|v| Content::Some(Box::new(v)))
473 }
474
visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,475 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
476 where
477 D: Deserializer<'de>,
478 {
479 Deserialize::deserialize(deserializer).map(|v| Content::Newtype(Box::new(v)))
480 }
481
visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: SeqAccess<'de>,482 fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
483 where
484 V: SeqAccess<'de>,
485 {
486 let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
487 while let Some(e) = try!(visitor.next_element()) {
488 vec.push(e);
489 }
490 Ok(Content::Seq(vec))
491 }
492
visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de>,493 fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
494 where
495 V: MapAccess<'de>,
496 {
497 let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
498 while let Some(kv) = try!(visitor.next_entry()) {
499 vec.push(kv);
500 }
501 Ok(Content::Map(vec))
502 }
503
visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error> where V: EnumAccess<'de>,504 fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
505 where
506 V: EnumAccess<'de>,
507 {
508 Err(de::Error::custom(
509 "untagged and internally tagged enums do not support enum input",
510 ))
511 }
512 }
513
514 /// This is the type of the map keys in an internally tagged enum.
515 ///
516 /// Not public API.
517 pub enum TagOrContent<'de> {
518 Tag,
519 Content(Content<'de>),
520 }
521
522 struct TagOrContentVisitor<'de> {
523 name: &'static str,
524 value: PhantomData<TagOrContent<'de>>,
525 }
526
527 impl<'de> TagOrContentVisitor<'de> {
new(name: &'static str) -> Self528 fn new(name: &'static str) -> Self {
529 TagOrContentVisitor {
530 name: name,
531 value: PhantomData,
532 }
533 }
534 }
535
536 impl<'de> DeserializeSeed<'de> for TagOrContentVisitor<'de> {
537 type Value = TagOrContent<'de>;
538
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,539 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
540 where
541 D: Deserializer<'de>,
542 {
543 // Internally tagged enums are only supported in self-describing
544 // formats.
545 deserializer.deserialize_any(self)
546 }
547 }
548
549 impl<'de> Visitor<'de> for TagOrContentVisitor<'de> {
550 type Value = TagOrContent<'de>;
551
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result552 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
553 write!(fmt, "a type tag `{}` or any other value", self.name)
554 }
555
visit_bool<F>(self, value: bool) -> Result<Self::Value, F> where F: de::Error,556 fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
557 where
558 F: de::Error,
559 {
560 ContentVisitor::new()
561 .visit_bool(value)
562 .map(TagOrContent::Content)
563 }
564
visit_i8<F>(self, value: i8) -> Result<Self::Value, F> where F: de::Error,565 fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
566 where
567 F: de::Error,
568 {
569 ContentVisitor::new()
570 .visit_i8(value)
571 .map(TagOrContent::Content)
572 }
573
visit_i16<F>(self, value: i16) -> Result<Self::Value, F> where F: de::Error,574 fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
575 where
576 F: de::Error,
577 {
578 ContentVisitor::new()
579 .visit_i16(value)
580 .map(TagOrContent::Content)
581 }
582
visit_i32<F>(self, value: i32) -> Result<Self::Value, F> where F: de::Error,583 fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
584 where
585 F: de::Error,
586 {
587 ContentVisitor::new()
588 .visit_i32(value)
589 .map(TagOrContent::Content)
590 }
591
visit_i64<F>(self, value: i64) -> Result<Self::Value, F> where F: de::Error,592 fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
593 where
594 F: de::Error,
595 {
596 ContentVisitor::new()
597 .visit_i64(value)
598 .map(TagOrContent::Content)
599 }
600
visit_u8<F>(self, value: u8) -> Result<Self::Value, F> where F: de::Error,601 fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
602 where
603 F: de::Error,
604 {
605 ContentVisitor::new()
606 .visit_u8(value)
607 .map(TagOrContent::Content)
608 }
609
visit_u16<F>(self, value: u16) -> Result<Self::Value, F> where F: de::Error,610 fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
611 where
612 F: de::Error,
613 {
614 ContentVisitor::new()
615 .visit_u16(value)
616 .map(TagOrContent::Content)
617 }
618
visit_u32<F>(self, value: u32) -> Result<Self::Value, F> where F: de::Error,619 fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
620 where
621 F: de::Error,
622 {
623 ContentVisitor::new()
624 .visit_u32(value)
625 .map(TagOrContent::Content)
626 }
627
visit_u64<F>(self, value: u64) -> Result<Self::Value, F> where F: de::Error,628 fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
629 where
630 F: de::Error,
631 {
632 ContentVisitor::new()
633 .visit_u64(value)
634 .map(TagOrContent::Content)
635 }
636
visit_f32<F>(self, value: f32) -> Result<Self::Value, F> where F: de::Error,637 fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
638 where
639 F: de::Error,
640 {
641 ContentVisitor::new()
642 .visit_f32(value)
643 .map(TagOrContent::Content)
644 }
645
visit_f64<F>(self, value: f64) -> Result<Self::Value, F> where F: de::Error,646 fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
647 where
648 F: de::Error,
649 {
650 ContentVisitor::new()
651 .visit_f64(value)
652 .map(TagOrContent::Content)
653 }
654
visit_char<F>(self, value: char) -> Result<Self::Value, F> where F: de::Error,655 fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
656 where
657 F: de::Error,
658 {
659 ContentVisitor::new()
660 .visit_char(value)
661 .map(TagOrContent::Content)
662 }
663
visit_str<F>(self, value: &str) -> Result<Self::Value, F> where F: de::Error,664 fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
665 where
666 F: de::Error,
667 {
668 if value == self.name {
669 Ok(TagOrContent::Tag)
670 } else {
671 ContentVisitor::new()
672 .visit_str(value)
673 .map(TagOrContent::Content)
674 }
675 }
676
visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F> where F: de::Error,677 fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
678 where
679 F: de::Error,
680 {
681 if value == self.name {
682 Ok(TagOrContent::Tag)
683 } else {
684 ContentVisitor::new()
685 .visit_borrowed_str(value)
686 .map(TagOrContent::Content)
687 }
688 }
689
visit_string<F>(self, value: String) -> Result<Self::Value, F> where F: de::Error,690 fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
691 where
692 F: de::Error,
693 {
694 if value == self.name {
695 Ok(TagOrContent::Tag)
696 } else {
697 ContentVisitor::new()
698 .visit_string(value)
699 .map(TagOrContent::Content)
700 }
701 }
702
visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F> where F: de::Error,703 fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
704 where
705 F: de::Error,
706 {
707 if value == self.name.as_bytes() {
708 Ok(TagOrContent::Tag)
709 } else {
710 ContentVisitor::new()
711 .visit_bytes(value)
712 .map(TagOrContent::Content)
713 }
714 }
715
visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F> where F: de::Error,716 fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
717 where
718 F: de::Error,
719 {
720 if value == self.name.as_bytes() {
721 Ok(TagOrContent::Tag)
722 } else {
723 ContentVisitor::new()
724 .visit_borrowed_bytes(value)
725 .map(TagOrContent::Content)
726 }
727 }
728
visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F> where F: de::Error,729 fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
730 where
731 F: de::Error,
732 {
733 if value == self.name.as_bytes() {
734 Ok(TagOrContent::Tag)
735 } else {
736 ContentVisitor::new()
737 .visit_byte_buf(value)
738 .map(TagOrContent::Content)
739 }
740 }
741
visit_unit<F>(self) -> Result<Self::Value, F> where F: de::Error,742 fn visit_unit<F>(self) -> Result<Self::Value, F>
743 where
744 F: de::Error,
745 {
746 ContentVisitor::new()
747 .visit_unit()
748 .map(TagOrContent::Content)
749 }
750
visit_none<F>(self) -> Result<Self::Value, F> where F: de::Error,751 fn visit_none<F>(self) -> Result<Self::Value, F>
752 where
753 F: de::Error,
754 {
755 ContentVisitor::new()
756 .visit_none()
757 .map(TagOrContent::Content)
758 }
759
visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,760 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
761 where
762 D: Deserializer<'de>,
763 {
764 ContentVisitor::new()
765 .visit_some(deserializer)
766 .map(TagOrContent::Content)
767 }
768
visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,769 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
770 where
771 D: Deserializer<'de>,
772 {
773 ContentVisitor::new()
774 .visit_newtype_struct(deserializer)
775 .map(TagOrContent::Content)
776 }
777
visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: SeqAccess<'de>,778 fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
779 where
780 V: SeqAccess<'de>,
781 {
782 ContentVisitor::new()
783 .visit_seq(visitor)
784 .map(TagOrContent::Content)
785 }
786
visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de>,787 fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
788 where
789 V: MapAccess<'de>,
790 {
791 ContentVisitor::new()
792 .visit_map(visitor)
793 .map(TagOrContent::Content)
794 }
795
visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error> where V: EnumAccess<'de>,796 fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
797 where
798 V: EnumAccess<'de>,
799 {
800 ContentVisitor::new()
801 .visit_enum(visitor)
802 .map(TagOrContent::Content)
803 }
804 }
805
806 /// Used by generated code to deserialize an internally tagged enum.
807 ///
808 /// Not public API.
809 pub struct TaggedContent<'de, T> {
810 pub tag: T,
811 pub content: Content<'de>,
812 }
813
814 /// Not public API.
815 pub struct TaggedContentVisitor<'de, T> {
816 tag_name: &'static str,
817 value: PhantomData<TaggedContent<'de, T>>,
818 }
819
820 impl<'de, T> TaggedContentVisitor<'de, T> {
821 /// Visitor for the content of an internally tagged enum with the given tag
822 /// name.
new(name: &'static str) -> Self823 pub fn new(name: &'static str) -> Self {
824 TaggedContentVisitor {
825 tag_name: name,
826 value: PhantomData,
827 }
828 }
829 }
830
831 impl<'de, T> DeserializeSeed<'de> for TaggedContentVisitor<'de, T>
832 where
833 T: Deserialize<'de>,
834 {
835 type Value = TaggedContent<'de, T>;
836
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,837 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
838 where
839 D: Deserializer<'de>,
840 {
841 // Internally tagged enums are only supported in self-describing
842 // formats.
843 deserializer.deserialize_any(self)
844 }
845 }
846
847 impl<'de, T> Visitor<'de> for TaggedContentVisitor<'de, T>
848 where
849 T: Deserialize<'de>,
850 {
851 type Value = TaggedContent<'de, T>;
852
expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result853 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
854 fmt.write_str("internally tagged enum")
855 }
856
visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error> where S: SeqAccess<'de>,857 fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
858 where
859 S: SeqAccess<'de>,
860 {
861 let tag = match try!(seq.next_element()) {
862 Some(tag) => tag,
863 None => {
864 return Err(de::Error::missing_field(self.tag_name));
865 }
866 };
867 let rest = de::value::SeqAccessDeserializer::new(seq);
868 Ok(TaggedContent {
869 tag: tag,
870 content: try!(Content::deserialize(rest)),
871 })
872 }
873
visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> where M: MapAccess<'de>,874 fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
875 where
876 M: MapAccess<'de>,
877 {
878 let mut tag = None;
879 let mut vec = Vec::with_capacity(size_hint::cautious(map.size_hint()));
880 while let Some(k) = try!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
881 match k {
882 TagOrContent::Tag => {
883 if tag.is_some() {
884 return Err(de::Error::duplicate_field(self.tag_name));
885 }
886 tag = Some(try!(map.next_value()));
887 }
888 TagOrContent::Content(k) => {
889 let v = try!(map.next_value());
890 vec.push((k, v));
891 }
892 }
893 }
894 match tag {
895 None => Err(de::Error::missing_field(self.tag_name)),
896 Some(tag) => Ok(TaggedContent {
897 tag: tag,
898 content: Content::Map(vec),
899 }),
900 }
901 }
902 }
903
904 /// Used by generated code to deserialize an adjacently tagged enum.
905 ///
906 /// Not public API.
907 pub enum TagOrContentField {
908 Tag,
909 Content,
910 }
911
912 /// Not public API.
913 pub struct TagOrContentFieldVisitor {
914 pub tag: &'static str,
915 pub content: &'static str,
916 }
917
918 impl<'de> DeserializeSeed<'de> for TagOrContentFieldVisitor {
919 type Value = TagOrContentField;
920
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,921 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
922 where
923 D: Deserializer<'de>,
924 {
925 deserializer.deserialize_str(self)
926 }
927 }
928
929 impl<'de> Visitor<'de> for TagOrContentFieldVisitor {
930 type Value = TagOrContentField;
931
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result932 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
933 write!(formatter, "{:?} or {:?}", self.tag, self.content)
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 }
949
950 /// Used by generated code to deserialize an adjacently tagged enum when
951 /// ignoring unrelated fields is allowed.
952 ///
953 /// Not public API.
954 pub enum TagContentOtherField {
955 Tag,
956 Content,
957 Other,
958 }
959
960 /// Not public API.
961 pub struct TagContentOtherFieldVisitor {
962 pub tag: &'static str,
963 pub content: &'static str,
964 }
965
966 impl<'de> DeserializeSeed<'de> for TagContentOtherFieldVisitor {
967 type Value = TagContentOtherField;
968
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,969 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
970 where
971 D: Deserializer<'de>,
972 {
973 deserializer.deserialize_str(self)
974 }
975 }
976
977 impl<'de> Visitor<'de> for TagContentOtherFieldVisitor {
978 type Value = TagContentOtherField;
979
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result980 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
981 write!(
982 formatter,
983 "{:?}, {:?}, or other ignored fields",
984 self.tag, self.content
985 )
986 }
987
visit_str<E>(self, field: &str) -> Result<Self::Value, E> where E: de::Error,988 fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
989 where
990 E: de::Error,
991 {
992 if field == self.tag {
993 Ok(TagContentOtherField::Tag)
994 } else if field == self.content {
995 Ok(TagContentOtherField::Content)
996 } else {
997 Ok(TagContentOtherField::Other)
998 }
999 }
1000 }
1001
1002 /// Not public API
1003 pub struct ContentDeserializer<'de, E> {
1004 content: Content<'de>,
1005 err: PhantomData<E>,
1006 }
1007
1008 /// Used when deserializing an internally tagged enum because the content will
1009 /// be used exactly once.
1010 impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
1011 where
1012 E: de::Error,
1013 {
1014 type Error = E;
1015
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1016 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1017 where
1018 V: Visitor<'de>,
1019 {
1020 match self.content {
1021 Content::Bool(v) => visitor.visit_bool(v),
1022 Content::U8(v) => visitor.visit_u8(v),
1023 Content::U16(v) => visitor.visit_u16(v),
1024 Content::U32(v) => visitor.visit_u32(v),
1025 Content::U64(v) => visitor.visit_u64(v),
1026 Content::I8(v) => visitor.visit_i8(v),
1027 Content::I16(v) => visitor.visit_i16(v),
1028 Content::I32(v) => visitor.visit_i32(v),
1029 Content::I64(v) => visitor.visit_i64(v),
1030 Content::F32(v) => visitor.visit_f32(v),
1031 Content::F64(v) => visitor.visit_f64(v),
1032 Content::Char(v) => visitor.visit_char(v),
1033 Content::String(v) => visitor.visit_string(v),
1034 Content::Str(v) => visitor.visit_borrowed_str(v),
1035 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1036 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1037 Content::Unit => visitor.visit_unit(),
1038 Content::None => visitor.visit_none(),
1039 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1040 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
1041 Content::Seq(v) => {
1042 let seq = v.into_iter().map(ContentDeserializer::new);
1043 let mut seq_visitor = de::value::SeqDeserializer::new(seq);
1044 let value = try!(visitor.visit_seq(&mut seq_visitor));
1045 try!(seq_visitor.end());
1046 Ok(value)
1047 }
1048 Content::Map(v) => {
1049 let map = v.into_iter()
1050 .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
1051 let mut map_visitor = de::value::MapDeserializer::new(map);
1052 let value = try!(visitor.visit_map(&mut map_visitor));
1053 try!(map_visitor.end());
1054 Ok(value)
1055 }
1056 }
1057 }
1058
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1059 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1060 where
1061 V: Visitor<'de>,
1062 {
1063 match self.content {
1064 Content::None => visitor.visit_none(),
1065 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1066 Content::Unit => visitor.visit_unit(),
1067 _ => visitor.visit_some(self),
1068 }
1069 }
1070
deserialize_newtype_struct<V>( self, _name: &str, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1071 fn deserialize_newtype_struct<V>(
1072 self,
1073 _name: &str,
1074 visitor: V,
1075 ) -> Result<V::Value, Self::Error>
1076 where
1077 V: Visitor<'de>,
1078 {
1079 visitor.visit_newtype_struct(self)
1080 }
1081
deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1082 fn deserialize_enum<V>(
1083 self,
1084 _name: &str,
1085 _variants: &'static [&'static str],
1086 visitor: V,
1087 ) -> Result<V::Value, Self::Error>
1088 where
1089 V: Visitor<'de>,
1090 {
1091 let (variant, value) = match self.content {
1092 Content::Map(value) => {
1093 let mut iter = value.into_iter();
1094 let (variant, value) = match iter.next() {
1095 Some(v) => v,
1096 None => {
1097 return Err(de::Error::invalid_value(
1098 de::Unexpected::Map,
1099 &"map with a single key",
1100 ));
1101 }
1102 };
1103 // enums are encoded in json as maps with a single key:value pair
1104 if iter.next().is_some() {
1105 return Err(de::Error::invalid_value(
1106 de::Unexpected::Map,
1107 &"map with a single key",
1108 ));
1109 }
1110 (variant, Some(value))
1111 }
1112 s @ Content::String(_) | s @ Content::Str(_) => (s, None),
1113 other => {
1114 return Err(de::Error::invalid_type(
1115 other.unexpected(),
1116 &"string or map",
1117 ));
1118 }
1119 };
1120
1121 visitor.visit_enum(EnumDeserializer {
1122 variant: variant,
1123 value: value,
1124 err: PhantomData,
1125 })
1126 }
1127
deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1128 fn deserialize_unit_struct<V>(
1129 self,
1130 _name: &'static str,
1131 visitor: V,
1132 ) -> Result<V::Value, Self::Error>
1133 where
1134 V: Visitor<'de>,
1135 {
1136 match self.content {
1137 // As a special case, allow deserializing untagged newtype
1138 // variant containing unit struct.
1139 //
1140 // #[derive(Deserialize)]
1141 // struct Info;
1142 //
1143 // #[derive(Deserialize)]
1144 // #[serde(tag = "topic")]
1145 // enum Message {
1146 // Info(Info),
1147 // }
1148 //
1149 // We want {"topic":"Info"} to deserialize even though
1150 // ordinarily unit structs do not deserialize from empty map.
1151 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
1152 _ => self.deserialize_any(visitor),
1153 }
1154 }
1155
1156 forward_to_deserialize_any! {
1157 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1158 byte_buf unit seq tuple tuple_struct map struct identifier
1159 ignored_any
1160 }
1161 }
1162
1163 impl<'de, E> ContentDeserializer<'de, E> {
1164 /// private API, don't use
new(content: Content<'de>) -> Self1165 pub fn new(content: Content<'de>) -> Self {
1166 ContentDeserializer {
1167 content: content,
1168 err: PhantomData,
1169 }
1170 }
1171 }
1172
1173 struct EnumDeserializer<'de, E>
1174 where
1175 E: de::Error,
1176 {
1177 variant: Content<'de>,
1178 value: Option<Content<'de>>,
1179 err: PhantomData<E>,
1180 }
1181
1182 impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<'de, E>
1183 where
1184 E: de::Error,
1185 {
1186 type Error = E;
1187 type Variant = VariantDeserializer<'de, Self::Error>;
1188
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E> where V: de::DeserializeSeed<'de>,1189 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
1190 where
1191 V: de::DeserializeSeed<'de>,
1192 {
1193 let visitor = VariantDeserializer {
1194 value: self.value,
1195 err: PhantomData,
1196 };
1197 seed.deserialize(ContentDeserializer::new(self.variant))
1198 .map(|v| (v, visitor))
1199 }
1200 }
1201
1202 struct VariantDeserializer<'de, E>
1203 where
1204 E: de::Error,
1205 {
1206 value: Option<Content<'de>>,
1207 err: PhantomData<E>,
1208 }
1209
1210 impl<'de, E> de::VariantAccess<'de> for VariantDeserializer<'de, E>
1211 where
1212 E: de::Error,
1213 {
1214 type Error = E;
1215
unit_variant(self) -> Result<(), E>1216 fn unit_variant(self) -> Result<(), E> {
1217 match self.value {
1218 Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)),
1219 None => Ok(()),
1220 }
1221 }
1222
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> where T: de::DeserializeSeed<'de>,1223 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
1224 where
1225 T: de::DeserializeSeed<'de>,
1226 {
1227 match self.value {
1228 Some(value) => seed.deserialize(ContentDeserializer::new(value)),
1229 None => Err(de::Error::invalid_type(
1230 de::Unexpected::UnitVariant,
1231 &"newtype variant",
1232 )),
1233 }
1234 }
1235
tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1236 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1237 where
1238 V: de::Visitor<'de>,
1239 {
1240 match self.value {
1241 Some(Content::Seq(v)) => {
1242 de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
1243 }
1244 Some(other) => Err(de::Error::invalid_type(
1245 other.unexpected(),
1246 &"tuple variant",
1247 )),
1248 None => Err(de::Error::invalid_type(
1249 de::Unexpected::UnitVariant,
1250 &"tuple variant",
1251 )),
1252 }
1253 }
1254
struct_variant<V>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1255 fn struct_variant<V>(
1256 self,
1257 _fields: &'static [&'static str],
1258 visitor: V,
1259 ) -> Result<V::Value, Self::Error>
1260 where
1261 V: de::Visitor<'de>,
1262 {
1263 match self.value {
1264 Some(Content::Map(v)) => {
1265 de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
1266 }
1267 Some(Content::Seq(v)) => {
1268 de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
1269 }
1270 Some(other) => Err(de::Error::invalid_type(
1271 other.unexpected(),
1272 &"struct variant",
1273 )),
1274 _ => Err(de::Error::invalid_type(
1275 de::Unexpected::UnitVariant,
1276 &"struct variant",
1277 )),
1278 }
1279 }
1280 }
1281
1282 struct SeqDeserializer<'de, E>
1283 where
1284 E: de::Error,
1285 {
1286 iter: <Vec<Content<'de>> as IntoIterator>::IntoIter,
1287 err: PhantomData<E>,
1288 }
1289
1290 impl<'de, E> SeqDeserializer<'de, E>
1291 where
1292 E: de::Error,
1293 {
new(vec: Vec<Content<'de>>) -> Self1294 fn new(vec: Vec<Content<'de>>) -> Self {
1295 SeqDeserializer {
1296 iter: vec.into_iter(),
1297 err: PhantomData,
1298 }
1299 }
1300 }
1301
1302 impl<'de, E> de::Deserializer<'de> for SeqDeserializer<'de, E>
1303 where
1304 E: de::Error,
1305 {
1306 type Error = E;
1307
1308 #[inline]
deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1309 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1310 where
1311 V: de::Visitor<'de>,
1312 {
1313 let len = self.iter.len();
1314 if len == 0 {
1315 visitor.visit_unit()
1316 } else {
1317 let ret = try!(visitor.visit_seq(&mut self));
1318 let remaining = self.iter.len();
1319 if remaining == 0 {
1320 Ok(ret)
1321 } else {
1322 Err(de::Error::invalid_length(len, &"fewer elements in array"))
1323 }
1324 }
1325 }
1326
1327 forward_to_deserialize_any! {
1328 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1329 byte_buf option unit unit_struct newtype_struct seq tuple
1330 tuple_struct map struct enum identifier ignored_any
1331 }
1332 }
1333
1334 impl<'de, E> de::SeqAccess<'de> for SeqDeserializer<'de, E>
1335 where
1336 E: de::Error,
1337 {
1338 type Error = E;
1339
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1340 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1341 where
1342 T: de::DeserializeSeed<'de>,
1343 {
1344 match self.iter.next() {
1345 Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
1346 None => Ok(None),
1347 }
1348 }
1349
size_hint(&self) -> Option<usize>1350 fn size_hint(&self) -> Option<usize> {
1351 size_hint::from_bounds(&self.iter)
1352 }
1353 }
1354
1355 struct MapDeserializer<'de, E>
1356 where
1357 E: de::Error,
1358 {
1359 iter: <Vec<(Content<'de>, Content<'de>)> as IntoIterator>::IntoIter,
1360 value: Option<Content<'de>>,
1361 err: PhantomData<E>,
1362 }
1363
1364 impl<'de, E> MapDeserializer<'de, E>
1365 where
1366 E: de::Error,
1367 {
new(map: Vec<(Content<'de>, Content<'de>)>) -> Self1368 fn new(map: Vec<(Content<'de>, Content<'de>)>) -> Self {
1369 MapDeserializer {
1370 iter: map.into_iter(),
1371 value: None,
1372 err: PhantomData,
1373 }
1374 }
1375 }
1376
1377 impl<'de, E> de::MapAccess<'de> for MapDeserializer<'de, E>
1378 where
1379 E: de::Error,
1380 {
1381 type Error = E;
1382
next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1383 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1384 where
1385 T: de::DeserializeSeed<'de>,
1386 {
1387 match self.iter.next() {
1388 Some((key, value)) => {
1389 self.value = Some(value);
1390 seed.deserialize(ContentDeserializer::new(key)).map(Some)
1391 }
1392 None => Ok(None),
1393 }
1394 }
1395
next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1396 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
1397 where
1398 T: de::DeserializeSeed<'de>,
1399 {
1400 match self.value.take() {
1401 Some(value) => seed.deserialize(ContentDeserializer::new(value)),
1402 None => Err(de::Error::custom("value is missing")),
1403 }
1404 }
1405
size_hint(&self) -> Option<usize>1406 fn size_hint(&self) -> Option<usize> {
1407 size_hint::from_bounds(&self.iter)
1408 }
1409 }
1410
1411 impl<'de, E> de::Deserializer<'de> for MapDeserializer<'de, E>
1412 where
1413 E: de::Error,
1414 {
1415 type Error = E;
1416
1417 #[inline]
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1418 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1419 where
1420 V: de::Visitor<'de>,
1421 {
1422 visitor.visit_map(self)
1423 }
1424
1425 forward_to_deserialize_any! {
1426 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1427 byte_buf option unit unit_struct newtype_struct seq tuple
1428 tuple_struct map struct enum identifier ignored_any
1429 }
1430 }
1431
1432 /// Not public API.
1433 pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
1434 content: &'a Content<'de>,
1435 err: PhantomData<E>,
1436 }
1437
1438 /// Used when deserializing an untagged enum because the content may need to be
1439 /// used more than once.
1440 impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
1441 where
1442 E: de::Error,
1443 {
1444 type Error = E;
1445
deserialize_any<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1446 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E>
1447 where
1448 V: Visitor<'de>,
1449 {
1450 match *self.content {
1451 Content::Bool(v) => visitor.visit_bool(v),
1452 Content::U8(v) => visitor.visit_u8(v),
1453 Content::U16(v) => visitor.visit_u16(v),
1454 Content::U32(v) => visitor.visit_u32(v),
1455 Content::U64(v) => visitor.visit_u64(v),
1456 Content::I8(v) => visitor.visit_i8(v),
1457 Content::I16(v) => visitor.visit_i16(v),
1458 Content::I32(v) => visitor.visit_i32(v),
1459 Content::I64(v) => visitor.visit_i64(v),
1460 Content::F32(v) => visitor.visit_f32(v),
1461 Content::F64(v) => visitor.visit_f64(v),
1462 Content::Char(v) => visitor.visit_char(v),
1463 Content::String(ref v) => visitor.visit_str(v),
1464 Content::Str(v) => visitor.visit_borrowed_str(v),
1465 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1466 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1467 Content::Unit => visitor.visit_unit(),
1468 Content::None => visitor.visit_none(),
1469 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
1470 Content::Newtype(ref v) => {
1471 visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
1472 }
1473 Content::Seq(ref v) => {
1474 let seq = v.into_iter().map(ContentRefDeserializer::new);
1475 let mut seq_visitor = de::value::SeqDeserializer::new(seq);
1476 let value = try!(visitor.visit_seq(&mut seq_visitor));
1477 try!(seq_visitor.end());
1478 Ok(value)
1479 }
1480 Content::Map(ref v) => {
1481 let map = v.into_iter().map(|&(ref k, ref v)| {
1482 (
1483 ContentRefDeserializer::new(k),
1484 ContentRefDeserializer::new(v),
1485 )
1486 });
1487 let mut map_visitor = de::value::MapDeserializer::new(map);
1488 let value = try!(visitor.visit_map(&mut map_visitor));
1489 try!(map_visitor.end());
1490 Ok(value)
1491 }
1492 }
1493 }
1494
deserialize_option<V>(self, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1495 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
1496 where
1497 V: Visitor<'de>,
1498 {
1499 match *self.content {
1500 Content::None => visitor.visit_none(),
1501 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
1502 Content::Unit => visitor.visit_unit(),
1503 _ => visitor.visit_some(self),
1504 }
1505 }
1506
deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E> where V: Visitor<'de>,1507 fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
1508 where
1509 V: Visitor<'de>,
1510 {
1511 visitor.visit_newtype_struct(self)
1512 }
1513
deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1514 fn deserialize_enum<V>(
1515 self,
1516 _name: &str,
1517 _variants: &'static [&'static str],
1518 visitor: V,
1519 ) -> Result<V::Value, Self::Error>
1520 where
1521 V: Visitor<'de>,
1522 {
1523 let (variant, value) = match *self.content {
1524 Content::Map(ref value) => {
1525 let mut iter = value.into_iter();
1526 let &(ref variant, ref value) = match iter.next() {
1527 Some(v) => v,
1528 None => {
1529 return Err(de::Error::invalid_value(
1530 de::Unexpected::Map,
1531 &"map with a single key",
1532 ));
1533 }
1534 };
1535 // enums are encoded in json as maps with a single key:value pair
1536 if iter.next().is_some() {
1537 return Err(de::Error::invalid_value(
1538 de::Unexpected::Map,
1539 &"map with a single key",
1540 ));
1541 }
1542 (variant, Some(value))
1543 }
1544 ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
1545 ref other => {
1546 return Err(de::Error::invalid_type(
1547 other.unexpected(),
1548 &"string or map",
1549 ));
1550 }
1551 };
1552
1553 visitor.visit_enum(EnumRefDeserializer {
1554 variant: variant,
1555 value: value,
1556 err: PhantomData,
1557 })
1558 }
1559
1560 forward_to_deserialize_any! {
1561 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1562 byte_buf unit unit_struct seq tuple tuple_struct map struct
1563 identifier ignored_any
1564 }
1565 }
1566
1567 impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
1568 /// private API, don't use
new(content: &'a Content<'de>) -> Self1569 pub fn new(content: &'a Content<'de>) -> Self {
1570 ContentRefDeserializer {
1571 content: content,
1572 err: PhantomData,
1573 }
1574 }
1575 }
1576
1577 struct EnumRefDeserializer<'a, 'de: 'a, E>
1578 where
1579 E: de::Error,
1580 {
1581 variant: &'a Content<'de>,
1582 value: Option<&'a Content<'de>>,
1583 err: PhantomData<E>,
1584 }
1585
1586 impl<'de, 'a, E> de::EnumAccess<'de> for EnumRefDeserializer<'a, 'de, E>
1587 where
1588 E: de::Error,
1589 {
1590 type Error = E;
1591 type Variant = VariantRefDeserializer<'a, 'de, Self::Error>;
1592
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,1593 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1594 where
1595 V: de::DeserializeSeed<'de>,
1596 {
1597 let visitor = VariantRefDeserializer {
1598 value: self.value,
1599 err: PhantomData,
1600 };
1601 seed.deserialize(ContentRefDeserializer::new(self.variant))
1602 .map(|v| (v, visitor))
1603 }
1604 }
1605
1606 struct VariantRefDeserializer<'a, 'de: 'a, E>
1607 where
1608 E: de::Error,
1609 {
1610 value: Option<&'a Content<'de>>,
1611 err: PhantomData<E>,
1612 }
1613
1614 impl<'de, 'a, E> de::VariantAccess<'de> for VariantRefDeserializer<'a, 'de, E>
1615 where
1616 E: de::Error,
1617 {
1618 type Error = E;
1619
unit_variant(self) -> Result<(), E>1620 fn unit_variant(self) -> Result<(), E> {
1621 match self.value {
1622 Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
1623 None => Ok(()),
1624 }
1625 }
1626
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> where T: de::DeserializeSeed<'de>,1627 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
1628 where
1629 T: de::DeserializeSeed<'de>,
1630 {
1631 match self.value {
1632 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
1633 None => Err(de::Error::invalid_type(
1634 de::Unexpected::UnitVariant,
1635 &"newtype variant",
1636 )),
1637 }
1638 }
1639
tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1640 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1641 where
1642 V: de::Visitor<'de>,
1643 {
1644 match self.value {
1645 Some(&Content::Seq(ref v)) => {
1646 de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
1647 }
1648 Some(other) => Err(de::Error::invalid_type(
1649 other.unexpected(),
1650 &"tuple variant",
1651 )),
1652 None => Err(de::Error::invalid_type(
1653 de::Unexpected::UnitVariant,
1654 &"tuple variant",
1655 )),
1656 }
1657 }
1658
struct_variant<V>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1659 fn struct_variant<V>(
1660 self,
1661 _fields: &'static [&'static str],
1662 visitor: V,
1663 ) -> Result<V::Value, Self::Error>
1664 where
1665 V: de::Visitor<'de>,
1666 {
1667 match self.value {
1668 Some(&Content::Map(ref v)) => {
1669 de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
1670 }
1671 Some(&Content::Seq(ref v)) => {
1672 de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
1673 }
1674 Some(other) => Err(de::Error::invalid_type(
1675 other.unexpected(),
1676 &"struct variant",
1677 )),
1678 _ => Err(de::Error::invalid_type(
1679 de::Unexpected::UnitVariant,
1680 &"struct variant",
1681 )),
1682 }
1683 }
1684 }
1685
1686 struct SeqRefDeserializer<'a, 'de: 'a, E>
1687 where
1688 E: de::Error,
1689 {
1690 iter: <&'a [Content<'de>] as IntoIterator>::IntoIter,
1691 err: PhantomData<E>,
1692 }
1693
1694 impl<'a, 'de, E> SeqRefDeserializer<'a, 'de, E>
1695 where
1696 E: de::Error,
1697 {
new(vec: &'a [Content<'de>]) -> Self1698 fn new(vec: &'a [Content<'de>]) -> Self {
1699 SeqRefDeserializer {
1700 iter: vec.into_iter(),
1701 err: PhantomData,
1702 }
1703 }
1704 }
1705
1706 impl<'de, 'a, E> de::Deserializer<'de> for SeqRefDeserializer<'a, 'de, E>
1707 where
1708 E: de::Error,
1709 {
1710 type Error = E;
1711
1712 #[inline]
deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1713 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1714 where
1715 V: de::Visitor<'de>,
1716 {
1717 let len = self.iter.len();
1718 if len == 0 {
1719 visitor.visit_unit()
1720 } else {
1721 let ret = try!(visitor.visit_seq(&mut self));
1722 let remaining = self.iter.len();
1723 if remaining == 0 {
1724 Ok(ret)
1725 } else {
1726 Err(de::Error::invalid_length(len, &"fewer elements in array"))
1727 }
1728 }
1729 }
1730
1731 forward_to_deserialize_any! {
1732 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1733 byte_buf option unit unit_struct newtype_struct seq tuple
1734 tuple_struct map struct enum identifier ignored_any
1735 }
1736 }
1737
1738 impl<'de, 'a, E> de::SeqAccess<'de> for SeqRefDeserializer<'a, 'de, E>
1739 where
1740 E: de::Error,
1741 {
1742 type Error = E;
1743
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1744 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1745 where
1746 T: de::DeserializeSeed<'de>,
1747 {
1748 match self.iter.next() {
1749 Some(value) => seed.deserialize(ContentRefDeserializer::new(value))
1750 .map(Some),
1751 None => Ok(None),
1752 }
1753 }
1754
size_hint(&self) -> Option<usize>1755 fn size_hint(&self) -> Option<usize> {
1756 size_hint::from_bounds(&self.iter)
1757 }
1758 }
1759
1760 struct MapRefDeserializer<'a, 'de: 'a, E>
1761 where
1762 E: de::Error,
1763 {
1764 iter: <&'a [(Content<'de>, Content<'de>)] as IntoIterator>::IntoIter,
1765 value: Option<&'a Content<'de>>,
1766 err: PhantomData<E>,
1767 }
1768
1769 impl<'a, 'de, E> MapRefDeserializer<'a, 'de, E>
1770 where
1771 E: de::Error,
1772 {
new(map: &'a [(Content<'de>, Content<'de>)]) -> Self1773 fn new(map: &'a [(Content<'de>, Content<'de>)]) -> Self {
1774 MapRefDeserializer {
1775 iter: map.into_iter(),
1776 value: None,
1777 err: PhantomData,
1778 }
1779 }
1780 }
1781
1782 impl<'de, 'a, E> de::MapAccess<'de> for MapRefDeserializer<'a, 'de, E>
1783 where
1784 E: de::Error,
1785 {
1786 type Error = E;
1787
next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1788 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1789 where
1790 T: de::DeserializeSeed<'de>,
1791 {
1792 match self.iter.next() {
1793 Some(&(ref key, ref value)) => {
1794 self.value = Some(value);
1795 seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
1796 }
1797 None => Ok(None),
1798 }
1799 }
1800
next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1801 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
1802 where
1803 T: de::DeserializeSeed<'de>,
1804 {
1805 match self.value.take() {
1806 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
1807 None => Err(de::Error::custom("value is missing")),
1808 }
1809 }
1810
size_hint(&self) -> Option<usize>1811 fn size_hint(&self) -> Option<usize> {
1812 size_hint::from_bounds(&self.iter)
1813 }
1814 }
1815
1816 impl<'de, 'a, E> de::Deserializer<'de> for MapRefDeserializer<'a, 'de, E>
1817 where
1818 E: de::Error,
1819 {
1820 type Error = E;
1821
1822 #[inline]
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1823 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1824 where
1825 V: de::Visitor<'de>,
1826 {
1827 visitor.visit_map(self)
1828 }
1829
1830 forward_to_deserialize_any! {
1831 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1832 byte_buf option unit unit_struct newtype_struct seq tuple
1833 tuple_struct map struct enum identifier ignored_any
1834 }
1835 }
1836
1837 impl<'de, E> de::IntoDeserializer<'de, E> for ContentDeserializer<'de, E>
1838 where
1839 E: de::Error,
1840 {
1841 type Deserializer = Self;
1842
into_deserializer(self) -> Self1843 fn into_deserializer(self) -> Self {
1844 self
1845 }
1846 }
1847
1848 impl<'de, 'a, E> de::IntoDeserializer<'de, E> for ContentRefDeserializer<'a, 'de, E>
1849 where
1850 E: de::Error,
1851 {
1852 type Deserializer = Self;
1853
into_deserializer(self) -> Self1854 fn into_deserializer(self) -> Self {
1855 self
1856 }
1857 }
1858
1859 /// Visitor for deserializing an internally tagged unit variant.
1860 ///
1861 /// Not public API.
1862 pub struct InternallyTaggedUnitVisitor<'a> {
1863 type_name: &'a str,
1864 variant_name: &'a str,
1865 }
1866
1867 impl<'a> InternallyTaggedUnitVisitor<'a> {
1868 /// Not public API.
new(type_name: &'a str, variant_name: &'a str) -> Self1869 pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
1870 InternallyTaggedUnitVisitor {
1871 type_name: type_name,
1872 variant_name: variant_name,
1873 }
1874 }
1875 }
1876
1877 impl<'de, 'a> Visitor<'de> for InternallyTaggedUnitVisitor<'a> {
1878 type Value = ();
1879
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1880 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1881 write!(
1882 formatter,
1883 "unit variant {}::{}",
1884 self.type_name, self.variant_name
1885 )
1886 }
1887
visit_seq<S>(self, _: S) -> Result<(), S::Error> where S: SeqAccess<'de>,1888 fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
1889 where
1890 S: SeqAccess<'de>,
1891 {
1892 Ok(())
1893 }
1894
visit_map<M>(self, _: M) -> Result<(), M::Error> where M: MapAccess<'de>,1895 fn visit_map<M>(self, _: M) -> Result<(), M::Error>
1896 where
1897 M: MapAccess<'de>,
1898 {
1899 Ok(())
1900 }
1901 }
1902
1903 /// Visitor for deserializing an untagged unit variant.
1904 ///
1905 /// Not public API.
1906 pub struct UntaggedUnitVisitor<'a> {
1907 type_name: &'a str,
1908 variant_name: &'a str,
1909 }
1910
1911 impl<'a> UntaggedUnitVisitor<'a> {
1912 /// Not public API.
new(type_name: &'a str, variant_name: &'a str) -> Self1913 pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
1914 UntaggedUnitVisitor {
1915 type_name: type_name,
1916 variant_name: variant_name,
1917 }
1918 }
1919 }
1920
1921 impl<'de, 'a> Visitor<'de> for UntaggedUnitVisitor<'a> {
1922 type Value = ();
1923
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1924 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1925 write!(
1926 formatter,
1927 "unit variant {}::{}",
1928 self.type_name, self.variant_name
1929 )
1930 }
1931
visit_unit<E>(self) -> Result<(), E> where E: de::Error,1932 fn visit_unit<E>(self) -> Result<(), E>
1933 where
1934 E: de::Error,
1935 {
1936 Ok(())
1937 }
1938 }
1939 }
1940
1941 ////////////////////////////////////////////////////////////////////////////////
1942
1943 // Like `IntoDeserializer` but also implemented for `&[u8]`. This is used for
1944 // the newtype fallthrough case of `field_identifier`.
1945 //
1946 // #[derive(Deserialize)]
1947 // #[serde(field_identifier)]
1948 // enum F {
1949 // A,
1950 // B,
1951 // Other(String), // deserialized using IdentifierDeserializer
1952 // }
1953 pub trait IdentifierDeserializer<'de, E: Error> {
1954 type Deserializer: Deserializer<'de, Error = E>;
1955
from(self) -> Self::Deserializer1956 fn from(self) -> Self::Deserializer;
1957 }
1958
1959 impl<'de, E> IdentifierDeserializer<'de, E> for u32
1960 where
1961 E: Error,
1962 {
1963 type Deserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
1964
from(self) -> Self::Deserializer1965 fn from(self) -> Self::Deserializer {
1966 self.into_deserializer()
1967 }
1968 }
1969
1970 pub struct StrDeserializer<'a, E> {
1971 value: &'a str,
1972 marker: PhantomData<E>,
1973 }
1974
1975 impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
1976 where
1977 E: Error,
1978 {
1979 type Deserializer = StrDeserializer<'a, E>;
1980
from(self) -> Self::Deserializer1981 fn from(self) -> Self::Deserializer {
1982 StrDeserializer {
1983 value: self,
1984 marker: PhantomData,
1985 }
1986 }
1987 }
1988
1989 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
1990 where
1991 E: Error,
1992 {
1993 type Error = E;
1994
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1995 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1996 where
1997 V: Visitor<'de>,
1998 {
1999 visitor.visit_str(self.value)
2000 }
2001
2002 forward_to_deserialize_any! {
2003 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
2004 byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
2005 map struct enum identifier ignored_any
2006 }
2007 }
2008
2009 pub struct BytesDeserializer<'a, E> {
2010 value: &'a [u8],
2011 marker: PhantomData<E>,
2012 }
2013
2014 impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
2015 where
2016 E: Error,
2017 {
2018 type Deserializer = BytesDeserializer<'a, E>;
2019
from(self) -> Self::Deserializer2020 fn from(self) -> Self::Deserializer {
2021 BytesDeserializer {
2022 value: self,
2023 marker: PhantomData,
2024 }
2025 }
2026 }
2027
2028 impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
2029 where
2030 E: Error,
2031 {
2032 type Error = E;
2033
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,2034 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2035 where
2036 V: Visitor<'de>,
2037 {
2038 visitor.visit_bytes(self.value)
2039 }
2040
2041 forward_to_deserialize_any! {
2042 bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
2043 byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
2044 map struct enum identifier ignored_any
2045 }
2046 }
2047
2048 /// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
2049 ///
2050 /// Wraps a mutable reference and calls deserialize_in_place on it.
2051 pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
2052
2053 impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
2054 where
2055 T: Deserialize<'de>,
2056 {
2057 type Value = ();
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,2058 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
2059 where
2060 D: Deserializer<'de>,
2061 {
2062 T::deserialize_in_place(deserializer, self.0)
2063 }
2064 }
2065