]> git.proxmox.com Git - rustc.git/blame - vendor/serde/src/de/impls.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.48.0~beta.8+dfsg1
[rustc.git] / vendor / serde / src / de / impls.rs
CommitLineData
041b39d2
XL		 1use lib::*;
2
8faf50e0
XL		 3use de::{
4 Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
5};
041b39d2 6
8faf50e0 7#[cfg(any(core_duration, feature = "std", feature = "alloc"))]
041b39d2
XL		 8use de::MapAccess;
9
10use de::from_primitive::FromPrimitive;
ff7c6d11 11use private::de::InPlaceSeed;
041b39d2
XL		 12
13#[cfg(any(feature = "std", feature = "alloc"))]
14use private::de::size_hint;
15
16////////////////////////////////////////////////////////////////////////////////
17
18struct UnitVisitor;
19
20impl<'de> Visitor<'de> for UnitVisitor {
21 type Value = ();
22
23 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
24 formatter.write_str("unit")
25 }
26
8faf50e0 27 fn visit_unit<E>(self) -> Result<Self::Value, E>
041b39d2
XL		 28 where
29 E: Error,
30 {
31 Ok(())
32 }
33}
34
35impl<'de> Deserialize<'de> for () {
8faf50e0 36 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 37 where
38 D: Deserializer<'de>,
39 {
40 deserializer.deserialize_unit(UnitVisitor)
41 }
42}
43
8faf50e0
XL		 44#[cfg(feature = "unstable")]
45impl<'de> Deserialize<'de> for ! {
46 fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
47 where
48 D: Deserializer<'de>,
49 {
50 Err(Error::custom("cannot deserialize `!`"))
51 }
52}
53
041b39d2
XL		 54////////////////////////////////////////////////////////////////////////////////
55
56struct BoolVisitor;
57
58impl<'de> Visitor<'de> for BoolVisitor {
59 type Value = bool;
60
61 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
62 formatter.write_str("a boolean")
63 }
64
8faf50e0 65 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
041b39d2
XL		 66 where
67 E: Error,
68 {
69 Ok(v)
70 }
71}
72
73impl<'de> Deserialize<'de> for bool {
8faf50e0 74 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 75 where
76 D: Deserializer<'de>,
77 {
78 deserializer.deserialize_bool(BoolVisitor)
79 }
80}
81
82////////////////////////////////////////////////////////////////////////////////
83
84macro_rules! visit_integer_method {
85 ($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
86 #[inline]
87 fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
88 where
89 E: Error,
90 {
91 match FromPrimitive::$from_method(v) {
92 Some(v) => Ok(v),
f035d41b
XL		 93 None => Err(Error::invalid_value(
94 Unexpected::$group(v as $group_ty),
95 &self,
96 )),
041b39d2
XL		 97 }
98 }
f035d41b 99 };
041b39d2
XL		 100}
101
102macro_rules! visit_float_method {
103 ($src_ty:ident, $method:ident) => {
104 #[inline]
105 fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
106 where
107 E: Error,
108 {
109 Ok(v as Self::Value)
110 }
f035d41b 111 };
041b39d2
XL		 112}
113
114macro_rules! impl_deserialize_num {
115 ($ty:ident, $method:ident, $($visit:ident),*) => {
116 impl<'de> Deserialize<'de> for $ty {
117 #[inline]
8faf50e0 118 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 119 where
120 D: Deserializer<'de>,
121 {
122 struct PrimitiveVisitor;
123
124 impl<'de> Visitor<'de> for PrimitiveVisitor {
125 type Value = $ty;
126
127 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
128 formatter.write_str(stringify!($ty))
129 }
130
131 $(
132 impl_deserialize_num!($visit $ty);
133 )*
134 }
135
136 deserializer.$method(PrimitiveVisitor)
137 }
138 }
139 };
140
141 (integer $ty:ident) => {
142 visit_integer_method!(i8, visit_i8, from_i8, Signed, i64);
143 visit_integer_method!(i16, visit_i16, from_i16, Signed, i64);
144 visit_integer_method!(i32, visit_i32, from_i32, Signed, i64);
145 visit_integer_method!(i64, visit_i64, from_i64, Signed, i64);
146
147 visit_integer_method!(u8, visit_u8, from_u8, Unsigned, u64);
148 visit_integer_method!(u16, visit_u16, from_u16, Unsigned, u64);
149 visit_integer_method!(u32, visit_u32, from_u32, Unsigned, u64);
150 visit_integer_method!(u64, visit_u64, from_u64, Unsigned, u64);
151 };
152
153 (float $ty:ident) => {
154 visit_float_method!(f32, visit_f32);
155 visit_float_method!(f64, visit_f64);
156 };
157}
158
159impl_deserialize_num!(i8, deserialize_i8, integer);
160impl_deserialize_num!(i16, deserialize_i16, integer);
161impl_deserialize_num!(i32, deserialize_i32, integer);
162impl_deserialize_num!(i64, deserialize_i64, integer);
163impl_deserialize_num!(isize, deserialize_i64, integer);
164
165impl_deserialize_num!(u8, deserialize_u8, integer);
166impl_deserialize_num!(u16, deserialize_u16, integer);
167impl_deserialize_num!(u32, deserialize_u32, integer);
168impl_deserialize_num!(u64, deserialize_u64, integer);
169impl_deserialize_num!(usize, deserialize_u64, integer);
170
171impl_deserialize_num!(f32, deserialize_f32, integer, float);
172impl_deserialize_num!(f64, deserialize_f64, integer, float);
173
8faf50e0
XL		 174serde_if_integer128! {
175 impl<'de> Deserialize<'de> for i128 {
176 #[inline]
177 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
178 where
179 D: Deserializer<'de>,
180 {
181 struct PrimitiveVisitor;
182
183 impl<'de> Visitor<'de> for PrimitiveVisitor {
184 type Value = i128;
185
186 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
187 formatter.write_str("i128")
188 }
189
190 impl_deserialize_num!(integer i128);
191
192 #[inline]
193 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
194 where
195 E: Error,
196 {
197 Ok(v)
198 }
199
200 #[inline]
201 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
202 where
203 E: Error,
204 {
205 if v <= i128::max_value() as u128 {
206 Ok(v as i128)
207 } else {
208 Err(Error::invalid_value(Unexpected::Other("u128"), &self))
209 }
210 }
211 }
212
213 deserializer.deserialize_i128(PrimitiveVisitor)
214 }
215 }
216
217 impl<'de> Deserialize<'de> for u128 {
218 #[inline]
219 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
220 where
221 D: Deserializer<'de>,
222 {
223 struct PrimitiveVisitor;
224
225 impl<'de> Visitor<'de> for PrimitiveVisitor {
226 type Value = u128;
227
228 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
229 formatter.write_str("u128")
230 }
231
232 impl_deserialize_num!(integer u128);
233
234 #[inline]
235 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
236 where
237 E: Error,
238 {
239 if v >= 0 {
240 Ok(v as u128)
241 } else {
242 Err(Error::invalid_value(Unexpected::Other("i128"), &self))
243 }
244 }
245
246 #[inline]
247 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
248 where
249 E: Error,
250 {
251 Ok(v)
252 }
253 }
254
255 deserializer.deserialize_u128(PrimitiveVisitor)
256 }
257 }
258}
259
041b39d2
XL		 260////////////////////////////////////////////////////////////////////////////////
261
262struct CharVisitor;
263
264impl<'de> Visitor<'de> for CharVisitor {
265 type Value = char;
266
267 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
268 formatter.write_str("a character")
269 }
270
271 #[inline]
8faf50e0 272 fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
041b39d2
XL		 273 where
274 E: Error,
275 {
276 Ok(v)
277 }
278
279 #[inline]
8faf50e0 280 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
041b39d2
XL		 281 where
282 E: Error,
283 {
284 let mut iter = v.chars();
285 match (iter.next(), iter.next()) {
286 (Some(c), None) => Ok(c),
287 _ => Err(Error::invalid_value(Unexpected::Str(v), &self)),
288 }
289 }
290}
291
292impl<'de> Deserialize<'de> for char {
293 #[inline]
8faf50e0 294 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 295 where
296 D: Deserializer<'de>,
297 {
298 deserializer.deserialize_char(CharVisitor)
299 }
300}
301
302////////////////////////////////////////////////////////////////////////////////
303
304#[cfg(any(feature = "std", feature = "alloc"))]
305struct StringVisitor;
ff7c6d11
XL		 306#[cfg(any(feature = "std", feature = "alloc"))]
307struct StringInPlaceVisitor<'a>(&'a mut String);
041b39d2
XL		 308
309#[cfg(any(feature = "std", feature = "alloc"))]
310impl<'de> Visitor<'de> for StringVisitor {
311 type Value = String;
312
313 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
314 formatter.write_str("a string")
315 }
316
8faf50e0 317 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
041b39d2
XL		 318 where
319 E: Error,
320 {
321 Ok(v.to_owned())
322 }
323
8faf50e0 324 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
041b39d2
XL		 325 where
326 E: Error,
327 {
328 Ok(v)
329 }
330
8faf50e0 331 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
041b39d2
XL		 332 where
333 E: Error,
334 {
335 match str::from_utf8(v) {
336 Ok(s) => Ok(s.to_owned()),
337 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
338 }
339 }
340
8faf50e0 341 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
041b39d2
XL		 342 where
343 E: Error,
344 {
345 match String::from_utf8(v) {
346 Ok(s) => Ok(s),
ff7c6d11
XL		 347 Err(e) => Err(Error::invalid_value(
348 Unexpected::Bytes(&e.into_bytes()),
349 &self,
350 )),
351 }
352 }
353}
354
355#[cfg(any(feature = "std", feature = "alloc"))]
356impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
357 type Value = ();
358
359 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
360 formatter.write_str("a string")
361 }
362
8faf50e0 363 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
ff7c6d11
XL		 364 where
365 E: Error,
366 {
367 self.0.clear();
368 self.0.push_str(v);
369 Ok(())
370 }
371
8faf50e0 372 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
ff7c6d11
XL		 373 where
374 E: Error,
375 {
376 *self.0 = v;
377 Ok(())
378 }
379
8faf50e0 380 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
ff7c6d11
XL		 381 where
382 E: Error,
383 {
384 match str::from_utf8(v) {
385 Ok(s) => {
386 self.0.clear();
387 self.0.push_str(s);
388 Ok(())
389 }
390 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
391 }
392 }
393
8faf50e0 394 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
ff7c6d11
XL		 395 where
396 E: Error,
397 {
398 match String::from_utf8(v) {
399 Ok(s) => {
400 *self.0 = s;
401 Ok(())
402 }
403 Err(e) => Err(Error::invalid_value(
404 Unexpected::Bytes(&e.into_bytes()),
405 &self,
406 )),
041b39d2
XL		 407 }
408 }
409}
410
411#[cfg(any(feature = "std", feature = "alloc"))]
412impl<'de> Deserialize<'de> for String {
8faf50e0 413 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 414 where
415 D: Deserializer<'de>,
416 {
417 deserializer.deserialize_string(StringVisitor)
418 }
ff7c6d11
XL		 419
420 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
421 where
422 D: Deserializer<'de>,
423 {
424 deserializer.deserialize_string(StringInPlaceVisitor(place))
425 }
041b39d2
XL		 426}
427
428////////////////////////////////////////////////////////////////////////////////
429
430struct StrVisitor;
431
432impl<'a> Visitor<'a> for StrVisitor {
433 type Value = &'a str;
434
435 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
436 formatter.write_str("a borrowed string")
437 }
438
439 fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
440 where
441 E: Error,
442 {
443 Ok(v) // so easy
444 }
445
446 fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
447 where
448 E: Error,
449 {
450 str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
451 }
452}
453
454impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
455 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
456 where
457 D: Deserializer<'de>,
458 {
459 deserializer.deserialize_str(StrVisitor)
460 }
461}
462
463////////////////////////////////////////////////////////////////////////////////
464
465struct BytesVisitor;
466
467impl<'a> Visitor<'a> for BytesVisitor {
468 type Value = &'a [u8];
469
470 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
471 formatter.write_str("a borrowed byte array")
472 }
473
474 fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
475 where
476 E: Error,
477 {
478 Ok(v)
479 }
480
481 fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
482 where
483 E: Error,
484 {
485 Ok(v.as_bytes())
486 }
487}
488
489impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
490 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
491 where
492 D: Deserializer<'de>,
493 {
494 deserializer.deserialize_bytes(BytesVisitor)
495 }
496}
497
498////////////////////////////////////////////////////////////////////////////////
499
500#[cfg(feature = "std")]
501struct CStringVisitor;
502
503#[cfg(feature = "std")]
504impl<'de> Visitor<'de> for CStringVisitor {
505 type Value = CString;
506
507 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
508 formatter.write_str("byte array")
509 }
510
8faf50e0 511 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 512 where
513 A: SeqAccess<'de>,
514 {
515 let len = size_hint::cautious(seq.size_hint());
516 let mut values = Vec::with_capacity(len);
517
518 while let Some(value) = try!(seq.next_element()) {
519 values.push(value);
520 }
521
522 CString::new(values).map_err(Error::custom)
523 }
524
8faf50e0 525 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
041b39d2
XL		 526 where
527 E: Error,
528 {
529 CString::new(v).map_err(Error::custom)
530 }
531
8faf50e0 532 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
041b39d2
XL		 533 where
534 E: Error,
535 {
536 CString::new(v).map_err(Error::custom)
537 }
538
8faf50e0 539 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
041b39d2
XL		 540 where
541 E: Error,
542 {
543 CString::new(v).map_err(Error::custom)
544 }
545
8faf50e0 546 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
041b39d2
XL		 547 where
548 E: Error,
549 {
550 CString::new(v).map_err(Error::custom)
551 }
552}
553
554#[cfg(feature = "std")]
555impl<'de> Deserialize<'de> for CString {
8faf50e0 556 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 557 where
558 D: Deserializer<'de>,
559 {
560 deserializer.deserialize_byte_buf(CStringVisitor)
561 }
562}
563
3b2f2976 564macro_rules! forwarded_impl {
83c7162d
XL		 565 (
566 $(#[doc = $doc:tt])*
567 ( $($id: ident),* ), $ty: ty, $func: expr
568 ) => {
569 $(#[doc = $doc])*
3b2f2976
XL		 570 impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
571 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
572 where
573 D: Deserializer<'de>,
574 {
575 Deserialize::deserialize(deserializer).map($func)
576 }
577 }
041b39d2
XL		 578 }
579}
580
8faf50e0 581#[cfg(all(feature = "std", de_boxed_c_str))]
3b2f2976
XL		 582forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
583
dc9dc135
XL		 584#[cfg(core_reverse)]
585forwarded_impl!((T), Reverse<T>, Reverse);
586
041b39d2
XL		 587////////////////////////////////////////////////////////////////////////////////
588
589struct OptionVisitor<T> {
590 marker: PhantomData<T>,
591}
592
593impl<'de, T> Visitor<'de> for OptionVisitor<T>
594where
595 T: Deserialize<'de>,
596{
597 type Value = Option<T>;
598
599 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
600 formatter.write_str("option")
601 }
602
603 #[inline]
8faf50e0 604 fn visit_unit<E>(self) -> Result<Self::Value, E>
041b39d2
XL		 605 where
606 E: Error,
607 {
608 Ok(None)
609 }
610
611 #[inline]
8faf50e0 612 fn visit_none<E>(self) -> Result<Self::Value, E>
041b39d2
XL		 613 where
614 E: Error,
615 {
616 Ok(None)
617 }
618
619 #[inline]
8faf50e0 620 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
041b39d2
XL		 621 where
622 D: Deserializer<'de>,
623 {
624 T::deserialize(deserializer).map(Some)
625 }
8faf50e0
XL		 626
627 #[doc(hidden)]
628 fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
629 where
630 D: Deserializer<'de>,
631 {
632 Ok(T::deserialize(deserializer).ok())
633 }
041b39d2
XL		 634}
635
636impl<'de, T> Deserialize<'de> for Option<T>
637where
638 T: Deserialize<'de>,
639{
8faf50e0 640 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 641 where
642 D: Deserializer<'de>,
643 {
ff7c6d11
XL		 644 deserializer.deserialize_option(OptionVisitor {
645 marker: PhantomData,
646 })
041b39d2 647 }
ff7c6d11
XL		 648
649 // The Some variant's repr is opaque, so we can't play cute tricks with its
650 // tag to have deserialize_in_place build the content in place unconditionally.
651 //
652 // FIXME: investigate whether branching on the old value being Some to
653 // deserialize_in_place the value is profitable (probably data-dependent?)
041b39d2
XL		 654}
655
656////////////////////////////////////////////////////////////////////////////////
657
2c00a5a8 658struct PhantomDataVisitor<T: ?Sized> {
041b39d2
XL		 659 marker: PhantomData<T>,
660}
661
2c00a5a8 662impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
041b39d2
XL		 663 type Value = PhantomData<T>;
664
665 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
666 formatter.write_str("unit")
667 }
668
669 #[inline]
8faf50e0 670 fn visit_unit<E>(self) -> Result<Self::Value, E>
041b39d2
XL		 671 where
672 E: Error,
673 {
674 Ok(PhantomData)
675 }
676}
677
2c00a5a8 678impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
8faf50e0 679 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 680 where
681 D: Deserializer<'de>,
682 {
ff7c6d11
XL		 683 let visitor = PhantomDataVisitor {
684 marker: PhantomData,
685 };
041b39d2
XL		 686 deserializer.deserialize_unit_struct("PhantomData", visitor)
687 }
688}
689
690////////////////////////////////////////////////////////////////////////////////
691
692#[cfg(any(feature = "std", feature = "alloc"))]
693macro_rules! seq_impl {
694 (
695 $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
696 $access:ident,
ff7c6d11 697 $clear:expr,
041b39d2 698 $with_capacity:expr,
ff7c6d11 699 $reserve:expr,
041b39d2
XL		 700 $insert:expr
701 ) => {
702 impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty<T $(, $typaram)*>
703 where
704 T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
705 $($typaram: $bound1 $(+ $bound2)*,)*
706 {
707 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
708 where
709 D: Deserializer<'de>,
710 {
711 struct SeqVisitor<T $(, $typaram)*> {
712 marker: PhantomData<$ty<T $(, $typaram)*>>,
713 }
714
715 impl<'de, T $(, $typaram)*> Visitor<'de> for SeqVisitor<T $(, $typaram)*>
716 where
717 T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
718 $($typaram: $bound1 $(+ $bound2)*,)*
719 {
720 type Value = $ty<T $(, $typaram)*>;
721
722 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
723 formatter.write_str("a sequence")
724 }
725
726 #[inline]
727 fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
728 where
729 A: SeqAccess<'de>,
730 {
731 let mut values = $with_capacity;
732
733 while let Some(value) = try!($access.next_element()) {
734 $insert(&mut values, value);
735 }
736
737 Ok(values)
738 }
739 }
740
741 let visitor = SeqVisitor { marker: PhantomData };
742 deserializer.deserialize_seq(visitor)
743 }
ff7c6d11
XL		 744
745 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
746 where
747 D: Deserializer<'de>,
748 {
749 struct SeqInPlaceVisitor<'a, T: 'a $(, $typaram: 'a)*>(&'a mut $ty<T $(, $typaram)*>);
750
751 impl<'a, 'de, T $(, $typaram)*> Visitor<'de> for SeqInPlaceVisitor<'a, T $(, $typaram)*>
752 where
753 T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
754 $($typaram: $bound1 $(+ $bound2)*,)*
755 {
756 type Value = ();
757
758 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
759 formatter.write_str("a sequence")
760 }
761
762 #[inline]
8faf50e0 763 fn visit_seq<A>(mut self, mut $access: A) -> Result<Self::Value, A::Error>
ff7c6d11
XL		 764 where
765 A: SeqAccess<'de>,
766 {
767 $clear(&mut self.0);
768 $reserve(&mut self.0, size_hint::cautious($access.size_hint()));
769
770 // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList)
771 while let Some(value) = try!($access.next_element()) {
772 $insert(&mut self.0, value);
773 }
774
775 Ok(())
776 }
777 }
778
779 deserializer.deserialize_seq(SeqInPlaceVisitor(place))
780 }
041b39d2
XL		 781 }
782 }
783}
784
ff7c6d11
XL		 785// Dummy impl of reserve
786#[cfg(any(feature = "std", feature = "alloc"))]
787fn nop_reserve<T>(_seq: T, _n: usize) {}
788
041b39d2
XL		 789#[cfg(any(feature = "std", feature = "alloc"))]
790seq_impl!(
791 BinaryHeap<T: Ord>,
792 seq,
ff7c6d11 793 BinaryHeap::clear,
041b39d2 794 BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
ff7c6d11 795 BinaryHeap::reserve,
e1599b0c
XL		 796 BinaryHeap::push
797);
041b39d2
XL		 798
799#[cfg(any(feature = "std", feature = "alloc"))]
800seq_impl!(
801 BTreeSet<T: Eq + Ord>,
802 seq,
ff7c6d11 803 BTreeSet::clear,
041b39d2 804 BTreeSet::new(),
ff7c6d11 805 nop_reserve,
e1599b0c
XL		 806 BTreeSet::insert
807);
041b39d2
XL		 808
809#[cfg(any(feature = "std", feature = "alloc"))]
810seq_impl!(
811 LinkedList<T>,
812 seq,
ff7c6d11 813 LinkedList::clear,
041b39d2 814 LinkedList::new(),
ff7c6d11
XL		 815 nop_reserve,
816 LinkedList::push_back
817);
041b39d2
XL		 818
819#[cfg(feature = "std")]
820seq_impl!(
821 HashSet<T: Eq + Hash, S: BuildHasher + Default>,
822 seq,
ff7c6d11 823 HashSet::clear,
041b39d2 824 HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
ff7c6d11 825 HashSet::reserve,
041b39d2
XL		 826 HashSet::insert);
827
041b39d2
XL		 828#[cfg(any(feature = "std", feature = "alloc"))]
829seq_impl!(
830 VecDeque<T>,
831 seq,
ff7c6d11 832 VecDeque::clear,
041b39d2 833 VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
ff7c6d11
XL		 834 VecDeque::reserve,
835 VecDeque::push_back
836);
041b39d2
XL		 837
838////////////////////////////////////////////////////////////////////////////////
839
0731742a
XL		 840#[cfg(any(feature = "std", feature = "alloc"))]
841impl<'de, T> Deserialize<'de> for Vec<T>
842where
843 T: Deserialize<'de>,
844{
845 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
846 where
847 D: Deserializer<'de>,
848 {
849 struct VecVisitor<T> {
850 marker: PhantomData<T>,
851 }
852
853 impl<'de, T> Visitor<'de> for VecVisitor<T>
854 where
855 T: Deserialize<'de>,
856 {
857 type Value = Vec<T>;
858
859 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
860 formatter.write_str("a sequence")
861 }
862
863 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
864 where
865 A: SeqAccess<'de>,
866 {
867 let mut values = Vec::with_capacity(size_hint::cautious(seq.size_hint()));
868
869 while let Some(value) = try!(seq.next_element()) {
870 values.push(value);
871 }
872
873 Ok(values)
874 }
875 }
876
877 let visitor = VecVisitor {
878 marker: PhantomData,
879 };
880 deserializer.deserialize_seq(visitor)
881 }
882
883 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
884 where
885 D: Deserializer<'de>,
886 {
887 struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
888
889 impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
890 where
891 T: Deserialize<'de>,
892 {
893 type Value = ();
894
895 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
896 formatter.write_str("a sequence")
897 }
898
899 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
900 where
901 A: SeqAccess<'de>,
902 {
903 let hint = size_hint::cautious(seq.size_hint());
904 if let Some(additional) = hint.checked_sub(self.0.len()) {
905 self.0.reserve(additional);
906 }
907
908 for i in 0..self.0.len() {
909 let next = {
910 let next_place = InPlaceSeed(&mut self.0[i]);
911 try!(seq.next_element_seed(next_place))
912 };
913 if next.is_none() {
914 self.0.truncate(i);
915 return Ok(());
916 }
917 }
918
919 while let Some(value) = try!(seq.next_element()) {
920 self.0.push(value);
921 }
922
923 Ok(())
924 }
925 }
926
927 deserializer.deserialize_seq(VecInPlaceVisitor(place))
928 }
929}
930
931////////////////////////////////////////////////////////////////////////////////
932
041b39d2
XL		 933struct ArrayVisitor<A> {
934 marker: PhantomData<A>,
935}
ff7c6d11 936struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
041b39d2
XL		 937
938impl<A> ArrayVisitor<A> {
939 fn new() -> Self {
ff7c6d11
XL		 940 ArrayVisitor {
941 marker: PhantomData,
942 }
041b39d2
XL		 943 }
944}
945
946impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
947 type Value = [T; 0];
948
949 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
950 formatter.write_str("an empty array")
951 }
952
953 #[inline]
8faf50e0 954 fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 955 where
956 A: SeqAccess<'de>,
957 {
958 Ok([])
959 }
960}
961
962// Does not require T: Deserialize<'de>.
963impl<'de, T> Deserialize<'de> for [T; 0] {
8faf50e0 964 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 965 where
966 D: Deserializer<'de>,
967 {
968 deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new())
969 }
970}
971
972macro_rules! array_impls {
dc9dc135 973 ($($len:expr => ($($n:tt)+))+) => {
041b39d2
XL		 974 $(
975 impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
976 where
977 T: Deserialize<'de>,
978 {
979 type Value = [T; $len];
980
981 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
982 formatter.write_str(concat!("an array of length ", $len))
983 }
984
985 #[inline]
8faf50e0 986 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 987 where
988 A: SeqAccess<'de>,
989 {
dc9dc135
XL		 990 Ok([$(
991 match try!(seq.next_element()) {
041b39d2
XL		 992 Some(val) => val,
993 None => return Err(Error::invalid_length($n, &self)),
dc9dc135
XL		 994 }
995 ),+])
041b39d2
XL		 996 }
997 }
998
ff7c6d11
XL		 999 impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]>
1000 where
1001 T: Deserialize<'de>,
1002 {
1003 type Value = ();
1004
1005 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1006 formatter.write_str(concat!("an array of length ", $len))
1007 }
1008
1009 #[inline]
8faf50e0 1010 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
ff7c6d11
XL		 1011 where
1012 A: SeqAccess<'de>,
1013 {
1014 let mut fail_idx = None;
1015 for (idx, dest) in self.0[..].iter_mut().enumerate() {
1016 if try!(seq.next_element_seed(InPlaceSeed(dest))).is_none() {
1017 fail_idx = Some(idx);
1018 break;
1019 }
1020 }
1021 if let Some(idx) = fail_idx {
1022 return Err(Error::invalid_length(idx, &self));
1023 }
1024 Ok(())
1025 }
1026 }
1027
041b39d2
XL		 1028 impl<'de, T> Deserialize<'de> for [T; $len]
1029 where
1030 T: Deserialize<'de>,
1031 {
8faf50e0 1032 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1033 where
1034 D: Deserializer<'de>,
1035 {
1036 deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new())
1037 }
ff7c6d11
XL		 1038
1039 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
1040 where
1041 D: Deserializer<'de>,
1042 {
1043 deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place))
1044 }
041b39d2
XL		 1045 }
1046 )+
1047 }
1048}
1049
1050array_impls! {
dc9dc135
XL		 1051 1 => (0)
1052 2 => (0 1)
1053 3 => (0 1 2)
1054 4 => (0 1 2 3)
1055 5 => (0 1 2 3 4)
1056 6 => (0 1 2 3 4 5)
1057 7 => (0 1 2 3 4 5 6)
1058 8 => (0 1 2 3 4 5 6 7)
1059 9 => (0 1 2 3 4 5 6 7 8)
1060 10 => (0 1 2 3 4 5 6 7 8 9)
1061 11 => (0 1 2 3 4 5 6 7 8 9 10)
1062 12 => (0 1 2 3 4 5 6 7 8 9 10 11)
1063 13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
1064 14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
1065 15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
1066 16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
1067 17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
1068 18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
1069 19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
1070 20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
1071 21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
1072 22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
1073 23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
1074 24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
1075 25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
1076 26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
1077 27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
1078 28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
1079 29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
1080 30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
1081 31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
1082 32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
041b39d2
XL		 1083}
1084
1085////////////////////////////////////////////////////////////////////////////////
1086
1087macro_rules! tuple_impls {
ff7c6d11 1088 ($($len:tt => ($($n:tt $name:ident)+))+) => {
041b39d2 1089 $(
ff7c6d11
XL		 1090 impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
1091 #[inline]
8faf50e0 1092 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
ff7c6d11
XL		 1093 where
1094 D: Deserializer<'de>,
1095 {
1096 struct TupleVisitor<$($name,)+> {
1097 marker: PhantomData<($($name,)+)>,
1098 }
041b39d2 1099
ff7c6d11
XL		 1100 impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> {
1101 type Value = ($($name,)+);
041b39d2 1102
ff7c6d11
XL		 1103 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1104 formatter.write_str(concat!("a tuple of size ", $len))
1105 }
041b39d2 1106
ff7c6d11
XL		 1107 #[inline]
1108 #[allow(non_snake_case)]
8faf50e0 1109 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
ff7c6d11
XL		 1110 where
1111 A: SeqAccess<'de>,
1112 {
1113 $(
1114 let $name = match try!(seq.next_element()) {
1115 Some(value) => value,
1116 None => return Err(Error::invalid_length($n, &self)),
1117 };
1118 )+
041b39d2 1119
ff7c6d11
XL		 1120 Ok(($($name,)+))
1121 }
1122 }
041b39d2 1123
ff7c6d11 1124 deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
041b39d2 1125 }
041b39d2 1126
041b39d2 1127 #[inline]
ff7c6d11 1128 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
041b39d2
XL		 1129 where
1130 D: Deserializer<'de>,
1131 {
ff7c6d11
XL		 1132 struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+));
1133
1134 impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> {
1135 type Value = ();
1136
1137 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1138 formatter.write_str(concat!("a tuple of size ", $len))
1139 }
1140
1141 #[inline]
1142 #[allow(non_snake_case)]
8faf50e0 1143 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
ff7c6d11
XL		 1144 where
1145 A: SeqAccess<'de>,
1146 {
1147 $(
1148 if try!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() {
1149 return Err(Error::invalid_length($n, &self));
1150 }
1151 )+
1152
1153 Ok(())
1154 }
1155 }
1156
1157 deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place))
041b39d2
XL		 1158 }
1159 }
1160 )+
1161 }
1162}
1163
1164tuple_impls! {
ff7c6d11
XL		 1165 1 => (0 T0)
1166 2 => (0 T0 1 T1)
1167 3 => (0 T0 1 T1 2 T2)
1168 4 => (0 T0 1 T1 2 T2 3 T3)
1169 5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
1170 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
1171 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
1172 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
1173 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
1174 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
1175 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
1176 12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
1177 13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
1178 14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
1179 15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
1180 16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
041b39d2
XL		 1181}
1182
1183////////////////////////////////////////////////////////////////////////////////
1184
1185#[cfg(any(feature = "std", feature = "alloc"))]
1186macro_rules! map_impl {
1187 (
1188 $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
1189 $access:ident,
041b39d2
XL		 1190 $with_capacity:expr
1191 ) => {
1192 impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
1193 where
1194 K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1195 V: Deserialize<'de>,
1196 $($typaram: $bound1 $(+ $bound2)*),*
1197 {
1198 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1199 where
1200 D: Deserializer<'de>,
1201 {
1202 struct MapVisitor<K, V $(, $typaram)*> {
1203 marker: PhantomData<$ty<K, V $(, $typaram)*>>,
1204 }
1205
1206 impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
1207 where
1208 K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1209 V: Deserialize<'de>,
1210 $($typaram: $bound1 $(+ $bound2)*),*
1211 {
1212 type Value = $ty<K, V $(, $typaram)*>;
1213
1214 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1215 formatter.write_str("a map")
1216 }
1217
1218 #[inline]
1219 fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
1220 where
1221 A: MapAccess<'de>,
1222 {
1223 let mut values = $with_capacity;
1224
1225 while let Some((key, value)) = try!($access.next_entry()) {
1226 values.insert(key, value);
1227 }
1228
1229 Ok(values)
1230 }
1231 }
1232
1233 let visitor = MapVisitor { marker: PhantomData };
1234 deserializer.deserialize_map(visitor)
1235 }
1236 }
1237 }
1238}
1239
1240#[cfg(any(feature = "std", feature = "alloc"))]
1241map_impl!(
1242 BTreeMap<K: Ord, V>,
1243 map,
041b39d2
XL		 1244 BTreeMap::new());
1245
1246#[cfg(feature = "std")]
1247map_impl!(
1248 HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
1249 map,
041b39d2
XL		 1250 HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
1251
1252////////////////////////////////////////////////////////////////////////////////
1253
1254#[cfg(feature = "std")]
abe05a73 1255macro_rules! parse_ip_impl {
8faf50e0 1256 ($expecting:tt $ty:ty; $size:tt) => {
041b39d2
XL		 1257 impl<'de> Deserialize<'de> for $ty {
1258 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1259 where
1260 D: Deserializer<'de>,
1261 {
abe05a73 1262 if deserializer.is_human_readable() {
8faf50e0
XL		 1263 struct IpAddrVisitor;
1264
1265 impl<'de> Visitor<'de> for IpAddrVisitor {
1266 type Value = $ty;
1267
1268 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1269 formatter.write_str($expecting)
1270 }
1271
1272 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1273 where
1274 E: Error,
1275 {
1276 s.parse().map_err(Error::custom)
1277 }
1278 }
1279
1280 deserializer.deserialize_str(IpAddrVisitor)
abe05a73
XL		 1281 } else {
1282 <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
1283 }
1284 }
1285 }
83c7162d 1286 };
abe05a73
XL		 1287}
1288
1289#[cfg(feature = "std")]
1290macro_rules! variant_identifier {
1291 (
1292 $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1293 $expecting_message: expr,
1294 $variants_name: ident
1295 ) => {
1296 enum $name_kind {
1297 $( $variant ),*
1298 }
1299
1300 static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];
1301
1302 impl<'de> Deserialize<'de> for $name_kind {
1303 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1304 where
1305 D: Deserializer<'de>,
1306 {
1307 struct KindVisitor;
1308
1309 impl<'de> Visitor<'de> for KindVisitor {
1310 type Value = $name_kind;
1311
1312 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1313 formatter.write_str($expecting_message)
1314 }
1315
1b1a35ee 1316 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
abe05a73
XL		 1317 where
1318 E: Error,
1319 {
1320 match value {
1321 $(
1322 $index => Ok($name_kind :: $variant),
1323 )*
1b1a35ee 1324 _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self),),
abe05a73
XL		 1325 }
1326 }
1327
1328 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1329 where
1330 E: Error,
1331 {
1332 match value {
1333 $(
1334 stringify!($variant) => Ok($name_kind :: $variant),
1335 )*
1336 _ => Err(Error::unknown_variant(value, $variants_name)),
1337 }
1338 }
1339
1340 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1341 where
1342 E: Error,
1343 {
1344 match value {
1345 $(
1346 $bytes => Ok($name_kind :: $variant),
1347 )*
1348 _ => {
1349 match str::from_utf8(value) {
1350 Ok(value) => Err(Error::unknown_variant(value, $variants_name)),
1351 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
1352 }
1353 }
1354 }
1355 }
1356 }
1357
1358 deserializer.deserialize_identifier(KindVisitor)
1359 }
1360 }
1361 }
1362}
1363
1364#[cfg(feature = "std")]
1365macro_rules! deserialize_enum {
1366 (
1367 $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1368 $expecting_message: expr,
1369 $deserializer: expr
1370 ) => {
1371 variant_identifier!{
1372 $name_kind ( $($variant; $bytes; $index),* )
1373 $expecting_message,
1374 VARIANTS
1375 }
1376
1377 struct EnumVisitor;
1378 impl<'de> Visitor<'de> for EnumVisitor {
1379 type Value = $name;
1380
1381 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1382 formatter.write_str(concat!("a ", stringify!($name)))
1383 }
1384
1385
1386 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1387 where
1388 A: EnumAccess<'de>,
1389 {
1390 match try!(data.variant()) {
1391 $(
1392 ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant),
1393 )*
1394 }
1395 }
1396 }
1397 $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor)
1398 }
1399}
1400
1401#[cfg(feature = "std")]
1402impl<'de> Deserialize<'de> for net::IpAddr {
1403 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1404 where
1405 D: Deserializer<'de>,
1406 {
1407 if deserializer.is_human_readable() {
8faf50e0
XL		 1408 struct IpAddrVisitor;
1409
1410 impl<'de> Visitor<'de> for IpAddrVisitor {
1411 type Value = net::IpAddr;
1412
1413 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1414 formatter.write_str("IP address")
1415 }
1416
1417 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1418 where
1419 E: Error,
1420 {
1421 s.parse().map_err(Error::custom)
1422 }
1423 }
1424
1425 deserializer.deserialize_str(IpAddrVisitor)
abe05a73
XL		 1426 } else {
1427 use lib::net::IpAddr;
0731742a 1428 deserialize_enum! {
abe05a73
XL		 1429 IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1430 "`V4` or `V6`",
1431 deserializer
041b39d2
XL		 1432 }
1433 }
1434 }
1435}
1436
1437#[cfg(feature = "std")]
8faf50e0 1438parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
041b39d2
XL		 1439
1440#[cfg(feature = "std")]
8faf50e0 1441parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
041b39d2
XL		 1442
1443#[cfg(feature = "std")]
abe05a73 1444macro_rules! parse_socket_impl {
8faf50e0 1445 ($expecting:tt $ty:ty, $new:expr) => {
abe05a73
XL		 1446 impl<'de> Deserialize<'de> for $ty {
1447 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1448 where
1449 D: Deserializer<'de>,
1450 {
1451 if deserializer.is_human_readable() {
8faf50e0
XL		 1452 struct SocketAddrVisitor;
1453
1454 impl<'de> Visitor<'de> for SocketAddrVisitor {
1455 type Value = $ty;
1456
1457 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1458 formatter.write_str($expecting)
1459 }
1460
1461 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1462 where
1463 E: Error,
1464 {
1465 s.parse().map_err(Error::custom)
1466 }
1467 }
1468
1469 deserializer.deserialize_str(SocketAddrVisitor)
abe05a73
XL		 1470 } else {
1471 <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
1472 }
1473 }
1474 }
83c7162d 1475 };
abe05a73 1476}
041b39d2
XL		 1477
1478#[cfg(feature = "std")]
abe05a73
XL		 1479impl<'de> Deserialize<'de> for net::SocketAddr {
1480 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1481 where
1482 D: Deserializer<'de>,
1483 {
1484 if deserializer.is_human_readable() {
8faf50e0
XL		 1485 struct SocketAddrVisitor;
1486
1487 impl<'de> Visitor<'de> for SocketAddrVisitor {
1488 type Value = net::SocketAddr;
1489
1490 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1491 formatter.write_str("socket address")
1492 }
1493
1494 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1495 where
1496 E: Error,
1497 {
1498 s.parse().map_err(Error::custom)
1499 }
1500 }
1501
1502 deserializer.deserialize_str(SocketAddrVisitor)
abe05a73
XL		 1503 } else {
1504 use lib::net::SocketAddr;
0731742a 1505 deserialize_enum! {
abe05a73
XL		 1506 SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1507 "`V4` or `V6`",
1508 deserializer
1509 }
1510 }
1511 }
1512}
041b39d2
XL		 1513
1514#[cfg(feature = "std")]
8faf50e0 1515parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
041b39d2
XL		 1516
1517#[cfg(feature = "std")]
8faf50e0 1518parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
83c7162d 1519 ip, port, 0, 0
ff7c6d11 1520));
041b39d2
XL		 1521
1522////////////////////////////////////////////////////////////////////////////////
1523
1524#[cfg(feature = "std")]
1525struct PathVisitor;
1526
1527#[cfg(feature = "std")]
1528impl<'a> Visitor<'a> for PathVisitor {
1529 type Value = &'a Path;
1530
1531 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1532 formatter.write_str("a borrowed path")
1533 }
1534
1535 fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
1536 where
1537 E: Error,
1538 {
1539 Ok(v.as_ref())
1540 }
1541
1542 fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
1543 where
1544 E: Error,
1545 {
1546 str::from_utf8(v)
1547 .map(AsRef::as_ref)
1548 .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
1549 }
1550}
1551
1552#[cfg(feature = "std")]
1553impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
1554 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1555 where
1556 D: Deserializer<'de>,
1557 {
1558 deserializer.deserialize_str(PathVisitor)
1559 }
1560}
1561
1562#[cfg(feature = "std")]
1563struct PathBufVisitor;
1564
1565#[cfg(feature = "std")]
1566impl<'de> Visitor<'de> for PathBufVisitor {
1567 type Value = PathBuf;
1568
1569 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1570 formatter.write_str("path string")
1571 }
1572
8faf50e0 1573 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
041b39d2
XL		 1574 where
1575 E: Error,
1576 {
1577 Ok(From::from(v))
1578 }
1579
8faf50e0 1580 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
041b39d2
XL		 1581 where
1582 E: Error,
1583 {
1584 Ok(From::from(v))
1585 }
f035d41b
XL		 1586
1587 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1588 where
1589 E: Error,
1590 {
1591 str::from_utf8(v)
1592 .map(From::from)
1593 .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
1594 }
1595
1596 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1597 where
1598 E: Error,
1599 {
1600 String::from_utf8(v)
1601 .map(From::from)
1602 .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self))
1603 }
041b39d2
XL		 1604}
1605
1606#[cfg(feature = "std")]
1607impl<'de> Deserialize<'de> for PathBuf {
8faf50e0 1608 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1609 where
1610 D: Deserializer<'de>,
1611 {
1612 deserializer.deserialize_string(PathBufVisitor)
1613 }
1614}
1615
f035d41b
XL		 1616#[cfg(all(feature = "std", de_boxed_path))]
1617forwarded_impl!((), Box<Path>, PathBuf::into_boxed_path);
1618
041b39d2
XL		 1619////////////////////////////////////////////////////////////////////////////////
1620
1621// If this were outside of the serde crate, it would just use:
1622//
1623// #[derive(Deserialize)]
1624// #[serde(variant_identifier)]
1625#[cfg(all(feature = "std", any(unix, windows)))]
0731742a 1626variant_identifier! {
abe05a73
XL		 1627 OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
1628 "`Unix` or `Windows`",
1629 OSSTR_VARIANTS
041b39d2
XL		 1630}
1631
1632#[cfg(all(feature = "std", any(unix, windows)))]
1633struct OsStringVisitor;
1634
1635#[cfg(all(feature = "std", any(unix, windows)))]
1636impl<'de> Visitor<'de> for OsStringVisitor {
1637 type Value = OsString;
1638
1639 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1640 formatter.write_str("os string")
1641 }
1642
1643 #[cfg(unix)]
8faf50e0 1644 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 1645 where
1646 A: EnumAccess<'de>,
1647 {
1648 use std::os::unix::ffi::OsStringExt;
1649
1650 match try!(data.variant()) {
1651 (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
ff7c6d11
XL		 1652 (OsStringKind::Windows, _) => Err(Error::custom(
1653 "cannot deserialize Windows OS string on Unix",
1654 )),
041b39d2
XL		 1655 }
1656 }
1657
1658 #[cfg(windows)]
8faf50e0 1659 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 1660 where
1661 A: EnumAccess<'de>,
1662 {
1663 use std::os::windows::ffi::OsStringExt;
1664
1665 match try!(data.variant()) {
8faf50e0
XL		 1666 (OsStringKind::Windows, v) => v
1667 .newtype_variant::<Vec<u16>>()
ff7c6d11
XL		 1668 .map(|vec| OsString::from_wide(&vec)),
1669 (OsStringKind::Unix, _) => Err(Error::custom(
1670 "cannot deserialize Unix OS string on Windows",
1671 )),
041b39d2
XL		 1672 }
1673 }
1674}
1675
1676#[cfg(all(feature = "std", any(unix, windows)))]
1677impl<'de> Deserialize<'de> for OsString {
8faf50e0 1678 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1679 where
1680 D: Deserializer<'de>,
1681 {
1682 deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
1683 }
1684}
1685
1686////////////////////////////////////////////////////////////////////////////////
1687
1688#[cfg(any(feature = "std", feature = "alloc"))]
3b2f2976 1689forwarded_impl!((T), Box<T>, Box::new);
041b39d2
XL		 1690
1691#[cfg(any(feature = "std", feature = "alloc"))]
3b2f2976 1692forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
041b39d2
XL		 1693
1694#[cfg(any(feature = "std", feature = "alloc"))]
3b2f2976 1695forwarded_impl!((), Box<str>, String::into_boxed_str);
041b39d2 1696
b7449926
XL		 1697#[cfg(all(
1698 not(de_rc_dst),
1699 feature = "rc",
1700 any(feature = "std", feature = "alloc")
1701))]
83c7162d
XL		 1702forwarded_impl! {
1703 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1704 ///
1705 /// Deserializing a data structure containing `Arc` will not attempt to
1706 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1707 /// will end up with a strong count of 1.
1708 ///
1709 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1710 (T), Arc<T>, Arc::new
1711}
041b39d2 1712
b7449926
XL		 1713#[cfg(all(
1714 not(de_rc_dst),
1715 feature = "rc",
1716 any(feature = "std", feature = "alloc")
1717))]
83c7162d
XL		 1718forwarded_impl! {
1719 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1720 ///
1721 /// Deserializing a data structure containing `Rc` will not attempt to
1722 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1723 /// will end up with a strong count of 1.
1724 ///
1725 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1726 (T), Rc<T>, Rc::new
1727}
041b39d2
XL		 1728
1729#[cfg(any(feature = "std", feature = "alloc"))]
1730impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
1731where
1732 T: ToOwned,
1733 T::Owned: Deserialize<'de>,
1734{
1735 #[inline]
8faf50e0 1736 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1737 where
1738 D: Deserializer<'de>,
1739 {
1740 T::Owned::deserialize(deserializer).map(Cow::Owned)
1741 }
1742}
1743
1744////////////////////////////////////////////////////////////////////////////////
ea8adc8c 1745
8faf50e0
XL		 1746/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1747/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1748///
1749/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1750#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1751impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
1752where
1753 T: Deserialize<'de>,
1754{
1755 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1756 where
1757 D: Deserializer<'de>,
1758 {
1759 try!(Option::<T>::deserialize(deserializer));
1760 Ok(RcWeak::new())
1761 }
1762}
1763
1764/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1765/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1766///
1767/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1768#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1769impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
1770where
1771 T: Deserialize<'de>,
1772{
1773 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1774 where
1775 D: Deserializer<'de>,
1776 {
1777 try!(Option::<T>::deserialize(deserializer));
1778 Ok(ArcWeak::new())
1779 }
1780}
1781
1782////////////////////////////////////////////////////////////////////////////////
1783
0731742a 1784#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
ea8adc8c 1785macro_rules! box_forwarded_impl {
83c7162d
XL		 1786 (
1787 $(#[doc = $doc:tt])*
1788 $t:ident
1789 ) => {
1790 $(#[doc = $doc])*
ea8adc8c
XL		 1791 impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
1792 where
1793 Box<T>: Deserialize<'de>,
1794 {
1795 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1796 where
1797 D: Deserializer<'de>,
1798 {
1799 Box::deserialize(deserializer).map(Into::into)
1800 }
1801 }
83c7162d 1802 };
ea8adc8c
XL		 1803}
1804
0731742a 1805#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
83c7162d
XL		 1806box_forwarded_impl! {
1807 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1808 ///
1809 /// Deserializing a data structure containing `Rc` will not attempt to
1810 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1811 /// will end up with a strong count of 1.
1812 ///
1813 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1814 Rc
1815}
ea8adc8c 1816
0731742a 1817#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
83c7162d
XL		 1818box_forwarded_impl! {
1819 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1820 ///
1821 /// Deserializing a data structure containing `Arc` will not attempt to
1822 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1823 /// will end up with a strong count of 1.
1824 ///
1825 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1826 Arc
1827}
ea8adc8c
XL		 1828
1829////////////////////////////////////////////////////////////////////////////////
041b39d2
XL		 1830
1831impl<'de, T> Deserialize<'de> for Cell<T>
1832where
1833 T: Deserialize<'de> + Copy,
1834{
8faf50e0 1835 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1836 where
1837 D: Deserializer<'de>,
1838 {
1839 T::deserialize(deserializer).map(Cell::new)
1840 }
1841}
1842
3b2f2976 1843forwarded_impl!((T), RefCell<T>, RefCell::new);
041b39d2
XL		 1844
1845#[cfg(feature = "std")]
3b2f2976 1846forwarded_impl!((T), Mutex<T>, Mutex::new);
041b39d2
XL		 1847
1848#[cfg(feature = "std")]
3b2f2976 1849forwarded_impl!((T), RwLock<T>, RwLock::new);
041b39d2
XL		 1850
1851////////////////////////////////////////////////////////////////////////////////
1852
1853// This is a cleaned-up version of the impl generated by:
1854//
1855// #[derive(Deserialize)]
1856// #[serde(deny_unknown_fields)]
1857// struct Duration {
1858// secs: u64,
1859// nanos: u32,
1860// }
8faf50e0 1861#[cfg(any(core_duration, feature = "std"))]
041b39d2
XL		 1862impl<'de> Deserialize<'de> for Duration {
1863 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1864 where
1865 D: Deserializer<'de>,
1866 {
1867 // If this were outside of the serde crate, it would just use:
1868 //
1869 // #[derive(Deserialize)]
1870 // #[serde(field_identifier, rename_all = "lowercase")]
1871 enum Field {
1872 Secs,
1873 Nanos,
1874 };
1875
1876 impl<'de> Deserialize<'de> for Field {
8faf50e0 1877 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 1878 where
1879 D: Deserializer<'de>,
1880 {
1881 struct FieldVisitor;
1882
1883 impl<'de> Visitor<'de> for FieldVisitor {
1884 type Value = Field;
1885
1886 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1887 formatter.write_str("`secs` or `nanos`")
1888 }
1889
8faf50e0 1890 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
041b39d2
XL		 1891 where
1892 E: Error,
1893 {
1894 match value {
1895 "secs" => Ok(Field::Secs),
1896 "nanos" => Ok(Field::Nanos),
1897 _ => Err(Error::unknown_field(value, FIELDS)),
1898 }
1899 }
1900
8faf50e0 1901 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
041b39d2
XL		 1902 where
1903 E: Error,
1904 {
1905 match value {
1906 b"secs" => Ok(Field::Secs),
1907 b"nanos" => Ok(Field::Nanos),
1908 _ => {
8faf50e0 1909 let value = ::export::from_utf8_lossy(value);
041b39d2
XL		 1910 Err(Error::unknown_field(&value, FIELDS))
1911 }
1912 }
1913 }
1914 }
1915
1916 deserializer.deserialize_identifier(FieldVisitor)
1917 }
1918 }
1919
1920 struct DurationVisitor;
1921
1922 impl<'de> Visitor<'de> for DurationVisitor {
1923 type Value = Duration;
1924
1925 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1926 formatter.write_str("struct Duration")
1927 }
1928
8faf50e0 1929 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 1930 where
1931 A: SeqAccess<'de>,
1932 {
1933 let secs: u64 = match try!(seq.next_element()) {
1934 Some(value) => value,
1935 None => {
1936 return Err(Error::invalid_length(0, &self));
1937 }
1938 };
1939 let nanos: u32 = match try!(seq.next_element()) {
1940 Some(value) => value,
1941 None => {
1942 return Err(Error::invalid_length(1, &self));
1943 }
1944 };
1945 Ok(Duration::new(secs, nanos))
1946 }
1947
8faf50e0 1948 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 1949 where
1950 A: MapAccess<'de>,
1951 {
1952 let mut secs: Option<u64> = None;
1953 let mut nanos: Option<u32> = None;
1954 while let Some(key) = try!(map.next_key()) {
1955 match key {
1956 Field::Secs => {
1957 if secs.is_some() {
1958 return Err(<A::Error as Error>::duplicate_field("secs"));
1959 }
1960 secs = Some(try!(map.next_value()));
1961 }
1962 Field::Nanos => {
1963 if nanos.is_some() {
1964 return Err(<A::Error as Error>::duplicate_field("nanos"));
1965 }
1966 nanos = Some(try!(map.next_value()));
1967 }
1968 }
1969 }
1970 let secs = match secs {
1971 Some(secs) => secs,
1972 None => return Err(<A::Error as Error>::missing_field("secs")),
1973 };
1974 let nanos = match nanos {
1975 Some(nanos) => nanos,
1976 None => return Err(<A::Error as Error>::missing_field("nanos")),
1977 };
1978 Ok(Duration::new(secs, nanos))
1979 }
1980 }
1981
1982 const FIELDS: &'static [&'static str] = &["secs", "nanos"];
1983 deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
1984 }
1985}
1986
1987////////////////////////////////////////////////////////////////////////////////
1988
1989#[cfg(feature = "std")]
1990impl<'de> Deserialize<'de> for SystemTime {
1991 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1992 where
1993 D: Deserializer<'de>,
1994 {
1995 // Reuse duration
1996 enum Field {
1997 Secs,
1998 Nanos,
1999 };
2000
2001 impl<'de> Deserialize<'de> for Field {
8faf50e0 2002 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 2003 where
2004 D: Deserializer<'de>,
2005 {
2006 struct FieldVisitor;
2007
2008 impl<'de> Visitor<'de> for FieldVisitor {
2009 type Value = Field;
2010
2011 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2012 formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
2013 }
2014
8faf50e0 2015 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
041b39d2
XL		 2016 where
2017 E: Error,
2018 {
2019 match value {
2020 "secs_since_epoch" => Ok(Field::Secs),
2021 "nanos_since_epoch" => Ok(Field::Nanos),
2022 _ => Err(Error::unknown_field(value, FIELDS)),
2023 }
2024 }
2025
8faf50e0 2026 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
041b39d2
XL		 2027 where
2028 E: Error,
2029 {
2030 match value {
2031 b"secs_since_epoch" => Ok(Field::Secs),
2032 b"nanos_since_epoch" => Ok(Field::Nanos),
2033 _ => {
2034 let value = String::from_utf8_lossy(value);
2035 Err(Error::unknown_field(&value, FIELDS))
2036 }
2037 }
2038 }
2039 }
2040
2041 deserializer.deserialize_identifier(FieldVisitor)
2042 }
2043 }
2044
2045 struct DurationVisitor;
2046
2047 impl<'de> Visitor<'de> for DurationVisitor {
2048 type Value = Duration;
2049
2050 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2051 formatter.write_str("struct SystemTime")
2052 }
2053
8faf50e0 2054 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 2055 where
2056 A: SeqAccess<'de>,
2057 {
2058 let secs: u64 = match try!(seq.next_element()) {
2059 Some(value) => value,
2060 None => {
2061 return Err(Error::invalid_length(0, &self));
2062 }
2063 };
2064 let nanos: u32 = match try!(seq.next_element()) {
2065 Some(value) => value,
2066 None => {
2067 return Err(Error::invalid_length(1, &self));
2068 }
2069 };
2070 Ok(Duration::new(secs, nanos))
2071 }
2072
8faf50e0 2073 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 2074 where
2075 A: MapAccess<'de>,
2076 {
2077 let mut secs: Option<u64> = None;
2078 let mut nanos: Option<u32> = None;
2079 while let Some(key) = try!(map.next_key()) {
2080 match key {
2081 Field::Secs => {
2082 if secs.is_some() {
ff7c6d11
XL		 2083 return Err(<A::Error as Error>::duplicate_field(
2084 "secs_since_epoch",
2085 ));
041b39d2
XL		 2086 }
2087 secs = Some(try!(map.next_value()));
2088 }
2089 Field::Nanos => {
2090 if nanos.is_some() {
ff7c6d11
XL		 2091 return Err(<A::Error as Error>::duplicate_field(
2092 "nanos_since_epoch",
2093 ));
041b39d2
XL		 2094 }
2095 nanos = Some(try!(map.next_value()));
2096 }
2097 }
2098 }
2099 let secs = match secs {
2100 Some(secs) => secs,
2101 None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
2102 };
2103 let nanos = match nanos {
2104 Some(nanos) => nanos,
2105 None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
2106 };
2107 Ok(Duration::new(secs, nanos))
2108 }
2109 }
2110
2111 const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
2112 let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
2113 Ok(UNIX_EPOCH + duration)
2114 }
2115}
2116
2117////////////////////////////////////////////////////////////////////////////////
2118
2119// Similar to:
2120//
2121// #[derive(Deserialize)]
2122// #[serde(deny_unknown_fields)]
2123// struct Range {
2124// start: u64,
2125// end: u32,
2126// }
b7449926 2127impl<'de, Idx> Deserialize<'de> for Range<Idx>
041b39d2
XL		 2128where
2129 Idx: Deserialize<'de>,
2130{
2131 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2132 where
2133 D: Deserializer<'de>,
2134 {
b7449926
XL		 2135 let (start, end) = deserializer.deserialize_struct(
2136 "Range",
2137 range::FIELDS,
2138 range::RangeVisitor {
2139 expecting: "struct Range",
2140 phantom: PhantomData,
2141 },
2142 )?;
2143 Ok(start..end)
2144 }
2145}
041b39d2 2146
b7449926
XL		 2147#[cfg(range_inclusive)]
2148impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
2149where
2150 Idx: Deserialize<'de>,
2151{
2152 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2153 where
2154 D: Deserializer<'de>,
2155 {
2156 let (start, end) = deserializer.deserialize_struct(
2157 "RangeInclusive",
2158 range::FIELDS,
2159 range::RangeVisitor {
2160 expecting: "struct RangeInclusive",
2161 phantom: PhantomData,
2162 },
2163 )?;
2164 Ok(RangeInclusive::new(start, end))
2165 }
2166}
041b39d2 2167
b7449926
XL		 2168mod range {
2169 use lib::*;
041b39d2 2170
b7449926 2171 use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
041b39d2 2172
b7449926
XL		 2173 pub const FIELDS: &'static [&'static str] = &["start", "end"];
2174
2175 // If this were outside of the serde crate, it would just use:
2176 //
2177 // #[derive(Deserialize)]
2178 // #[serde(field_identifier, rename_all = "lowercase")]
2179 enum Field {
2180 Start,
2181 End,
2182 }
2183
2184 impl<'de> Deserialize<'de> for Field {
2185 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2186 where
2187 D: Deserializer<'de>,
2188 {
2189 struct FieldVisitor;
2190
2191 impl<'de> Visitor<'de> for FieldVisitor {
2192 type Value = Field;
2193
2194 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2195 formatter.write_str("`start` or `end`")
2196 }
2197
2198 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2199 where
2200 E: Error,
2201 {
2202 match value {
2203 "start" => Ok(Field::Start),
2204 "end" => Ok(Field::End),
2205 _ => Err(Error::unknown_field(value, FIELDS)),
041b39d2 2206 }
b7449926 2207 }
041b39d2 2208
b7449926
XL		 2209 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2210 where
2211 E: Error,
2212 {
2213 match value {
2214 b"start" => Ok(Field::Start),
2215 b"end" => Ok(Field::End),
2216 _ => {
2217 let value = ::export::from_utf8_lossy(value);
2218 Err(Error::unknown_field(&value, FIELDS))
041b39d2
XL		 2219 }
2220 }
2221 }
041b39d2 2222 }
b7449926
XL		 2223
2224 deserializer.deserialize_identifier(FieldVisitor)
041b39d2 2225 }
b7449926 2226 }
041b39d2 2227
b7449926
XL		 2228 pub struct RangeVisitor<Idx> {
2229 pub expecting: &'static str,
2230 pub phantom: PhantomData<Idx>,
2231 }
2232
2233 impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
2234 where
2235 Idx: Deserialize<'de>,
2236 {
2237 type Value = (Idx, Idx);
2238
2239 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2240 formatter.write_str(self.expecting)
041b39d2
XL		 2241 }
2242
b7449926 2243 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
041b39d2 2244 where
b7449926 2245 A: SeqAccess<'de>,
041b39d2 2246 {
b7449926
XL		 2247 let start: Idx = match try!(seq.next_element()) {
2248 Some(value) => value,
2249 None => {
2250 return Err(Error::invalid_length(0, &self));
2251 }
2252 };
2253 let end: Idx = match try!(seq.next_element()) {
2254 Some(value) => value,
2255 None => {
2256 return Err(Error::invalid_length(1, &self));
2257 }
2258 };
2259 Ok((start, end))
2260 }
041b39d2 2261
b7449926
XL		 2262 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2263 where
2264 A: MapAccess<'de>,
2265 {
2266 let mut start: Option<Idx> = None;
2267 let mut end: Option<Idx> = None;
2268 while let Some(key) = try!(map.next_key()) {
2269 match key {
2270 Field::Start => {
2271 if start.is_some() {
2272 return Err(<A::Error as Error>::duplicate_field("start"));
041b39d2 2273 }
b7449926
XL		 2274 start = Some(try!(map.next_value()));
2275 }
2276 Field::End => {
2277 if end.is_some() {
2278 return Err(<A::Error as Error>::duplicate_field("end"));
041b39d2 2279 }
b7449926 2280 end = Some(try!(map.next_value()));
041b39d2
XL		 2281 }
2282 }
041b39d2 2283 }
b7449926
XL		 2284 let start = match start {
2285 Some(start) => start,
2286 None => return Err(<A::Error as Error>::missing_field("start")),
2287 };
2288 let end = match end {
2289 Some(end) => end,
2290 None => return Err(<A::Error as Error>::missing_field("end")),
2291 };
2292 Ok((start, end))
041b39d2 2293 }
041b39d2
XL		 2294 }
2295}
2296
2297////////////////////////////////////////////////////////////////////////////////
2298
dc9dc135
XL		 2299#[cfg(any(ops_bound, collections_bound))]
2300impl<'de, T> Deserialize<'de> for Bound<T>
2301where
2302 T: Deserialize<'de>,
2303{
2304 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2305 where
2306 D: Deserializer<'de>,
2307 {
2308 enum Field {
2309 Unbounded,
2310 Included,
2311 Excluded,
2312 }
2313
2314 impl<'de> Deserialize<'de> for Field {
2315 #[inline]
2316 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2317 where
2318 D: Deserializer<'de>,
2319 {
2320 struct FieldVisitor;
2321
2322 impl<'de> Visitor<'de> for FieldVisitor {
2323 type Value = Field;
2324
2325 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2326 formatter.write_str("`Unbounded`, `Included` or `Excluded`")
2327 }
2328
1b1a35ee 2329 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
dc9dc135
XL		 2330 where
2331 E: Error,
2332 {
2333 match value {
2334 0 => Ok(Field::Unbounded),
2335 1 => Ok(Field::Included),
2336 2 => Ok(Field::Excluded),
2337 _ => Err(Error::invalid_value(
1b1a35ee 2338 Unexpected::Unsigned(value),
dc9dc135
XL		 2339 &self,
2340 )),
2341 }
2342 }
2343
2344 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2345 where
2346 E: Error,
2347 {
2348 match value {
2349 "Unbounded" => Ok(Field::Unbounded),
2350 "Included" => Ok(Field::Included),
2351 "Excluded" => Ok(Field::Excluded),
2352 _ => Err(Error::unknown_variant(value, VARIANTS)),
2353 }
2354 }
2355
2356 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2357 where
2358 E: Error,
2359 {
2360 match value {
2361 b"Unbounded" => Ok(Field::Unbounded),
2362 b"Included" => Ok(Field::Included),
2363 b"Excluded" => Ok(Field::Excluded),
2364 _ => match str::from_utf8(value) {
2365 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2366 Err(_) => {
2367 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2368 }
2369 },
2370 }
2371 }
2372 }
2373
2374 deserializer.deserialize_identifier(FieldVisitor)
2375 }
2376 }
2377
2378 struct BoundVisitor<T>(PhantomData<Bound<T>>);
2379
2380 impl<'de, T> Visitor<'de> for BoundVisitor<T>
2381 where
2382 T: Deserialize<'de>,
2383 {
2384 type Value = Bound<T>;
2385
2386 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2387 formatter.write_str("enum Bound")
2388 }
2389
2390 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2391 where
2392 A: EnumAccess<'de>,
2393 {
2394 match try!(data.variant()) {
2395 (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
2396 (Field::Included, v) => v.newtype_variant().map(Bound::Included),
2397 (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
2398 }
2399 }
2400 }
2401
2402 const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
2403
2404 deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
2405 }
2406}
2407
2408////////////////////////////////////////////////////////////////////////////////
2409
0531ce1d 2410macro_rules! nonzero_integers {
8faf50e0 2411 ( $( $T: ident, )+ ) => {
0531ce1d 2412 $(
8faf50e0
XL		 2413 #[cfg(num_nonzero)]
2414 impl<'de> Deserialize<'de> for num::$T {
2415 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
0531ce1d
XL		 2416 where
2417 D: Deserializer<'de>,
2418 {
2419 let value = try!(Deserialize::deserialize(deserializer));
8faf50e0 2420 match <num::$T>::new(value) {
0531ce1d
XL		 2421 Some(nonzero) => Ok(nonzero),
2422 None => Err(Error::custom("expected a non-zero value")),
2423 }
2424 }
2425 }
2426 )+
2427 };
2428}
2429
2430nonzero_integers! {
0531ce1d
XL		 2431 NonZeroU8,
2432 NonZeroU16,
2433 NonZeroU32,
2434 NonZeroU64,
0531ce1d
XL		 2435 NonZeroUsize,
2436}
2437
e1599b0c
XL		 2438#[cfg(num_nonzero_signed)]
2439nonzero_integers! {
2440 NonZeroI8,
2441 NonZeroI16,
2442 NonZeroI32,
2443 NonZeroI64,
2444 NonZeroIsize,
2445}
2446
0731742a
XL		 2447// Currently 128-bit integers do not work on Emscripten targets so we need an
2448// additional `#[cfg]`
2449serde_if_integer128! {
2450 nonzero_integers! {
2451 NonZeroU128,
2452 }
e1599b0c
XL		 2453
2454 #[cfg(num_nonzero_signed)]
2455 nonzero_integers! {
2456 NonZeroI128,
2457 }
0731742a
XL		 2458}
2459
041b39d2
XL		 2460////////////////////////////////////////////////////////////////////////////////
2461
2462impl<'de, T, E> Deserialize<'de> for Result<T, E>
2463where
2464 T: Deserialize<'de>,
2465 E: Deserialize<'de>,
2466{
8faf50e0 2467 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 2468 where
2469 D: Deserializer<'de>,
2470 {
2471 // If this were outside of the serde crate, it would just use:
2472 //
2473 // #[derive(Deserialize)]
2474 // #[serde(variant_identifier)]
2475 enum Field {
2476 Ok,
2477 Err,
2478 }
2479
2480 impl<'de> Deserialize<'de> for Field {
2481 #[inline]
8faf50e0 2482 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
041b39d2
XL		 2483 where
2484 D: Deserializer<'de>,
2485 {
2486 struct FieldVisitor;
2487
2488 impl<'de> Visitor<'de> for FieldVisitor {
2489 type Value = Field;
2490
2491 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2492 formatter.write_str("`Ok` or `Err`")
2493 }
2494
1b1a35ee 2495 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
041b39d2
XL		 2496 where
2497 E: Error,
2498 {
2499 match value {
2500 0 => Ok(Field::Ok),
2501 1 => Ok(Field::Err),
ff7c6d11 2502 _ => Err(Error::invalid_value(
1b1a35ee 2503 Unexpected::Unsigned(value),
ff7c6d11
XL		 2504 &self,
2505 )),
041b39d2
XL		 2506 }
2507 }
2508
8faf50e0 2509 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
041b39d2
XL		 2510 where
2511 E: Error,
2512 {
2513 match value {
2514 "Ok" => Ok(Field::Ok),
2515 "Err" => Ok(Field::Err),
2516 _ => Err(Error::unknown_variant(value, VARIANTS)),
2517 }
2518 }
2519
8faf50e0 2520 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
041b39d2
XL		 2521 where
2522 E: Error,
2523 {
2524 match value {
2525 b"Ok" => Ok(Field::Ok),
2526 b"Err" => Ok(Field::Err),
ff7c6d11
XL		 2527 _ => match str::from_utf8(value) {
2528 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2529 Err(_) => {
2530 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
041b39d2 2531 }
ff7c6d11 2532 },
041b39d2
XL		 2533 }
2534 }
2535 }
2536
2537 deserializer.deserialize_identifier(FieldVisitor)
2538 }
2539 }
2540
2541 struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
2542
2543 impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
2544 where
2545 T: Deserialize<'de>,
2546 E: Deserialize<'de>,
2547 {
2548 type Value = Result<T, E>;
2549
2550 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2551 formatter.write_str("enum Result")
2552 }
2553
8faf50e0 2554 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
041b39d2
XL		 2555 where
2556 A: EnumAccess<'de>,
2557 {
2558 match try!(data.variant()) {
2559 (Field::Ok, v) => v.newtype_variant().map(Ok),
2560 (Field::Err, v) => v.newtype_variant().map(Err),
2561 }
2562 }
2563 }
2564
2565 const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
2566
2567 deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
2568 }
2569}
abe05a73
XL		 2570
2571////////////////////////////////////////////////////////////////////////////////
2572
2573#[cfg(feature = "std")]
2574impl<'de, T> Deserialize<'de> for Wrapping<T>
2575where
ff7c6d11 2576 T: Deserialize<'de>,
abe05a73 2577{
8faf50e0 2578 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
abe05a73
XL		 2579 where
2580 D: Deserializer<'de>,
2581 {
2582 Deserialize::deserialize(deserializer).map(Wrapping)
2583 }
2584}
e1599b0c
XL		 2585
2586#[cfg(all(feature = "std", std_atomic))]
2587macro_rules! atomic_impl {
2588 ($($ty:ident)*) => {
2589 $(
2590 impl<'de> Deserialize<'de> for $ty {
2591 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2592 where
2593 D: Deserializer<'de>,
2594 {
2595 Deserialize::deserialize(deserializer).map(Self::new)
2596 }
2597 }
2598 )*
2599 };
2600}
2601
2602#[cfg(all(feature = "std", std_atomic))]
2603atomic_impl! {
2604 AtomicBool
2605 AtomicI8 AtomicI16 AtomicI32 AtomicIsize
2606 AtomicU8 AtomicU16 AtomicU32 AtomicUsize
2607}
2608
2609#[cfg(all(feature = "std", std_atomic64))]
2610atomic_impl! {
2611 AtomicI64 AtomicU64
2612}
backport for Debian buster