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