serde/de/
impls.rs

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
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
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
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
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
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),
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
257////////////////////////////////////////////////////////////////////////////////
258
259struct 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////////////////////////////////////////////////////////////////////////////////
300
301#[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
425////////////////////////////////////////////////////////////////////////////////
426
427struct 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) // so easy
441    }
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
460////////////////////////////////////////////////////////////////////////////////
461
462struct 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////////////////////////////////////////////////////////////////////////////////
496
497#[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
584////////////////////////////////////////////////////////////////////////////////
585
586struct 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    // The Some variant's repr is opaque, so we can't play cute tricks with its
647    // tag to have deserialize_in_place build the content in place unconditionally.
648    //
649    // FIXME: investigate whether branching on the old value being Some to
650    // deserialize_in_place the value is profitable (probably data-dependent?)
651}
652
653////////////////////////////////////////////////////////////////////////////////
654
655struct 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////////////////////////////////////////////////////////////////////////////////
688
689#[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                        // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList)
768                        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// Dummy impl of reserve
783#[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////////////////////////////////////////////////////////////////////////////////
836
837#[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
928////////////////////////////////////////////////////////////////////////////////
929
930struct 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
959// Does not require T: Deserialize<'de>.
960impl<'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
1082////////////////////////////////////////////////////////////////////////////////
1083
1084macro_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////////////////////////////////////////////////////////////////////////////////
1181
1182#[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////////////////////////////////////////////////////////////////////////////////
1250
1251#[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////////////////////////////////////////////////////////////////////////////////
1520
1521#[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////////////////////////////////////////////////////////////////////////////////
1617
1618// If this were outside of the serde crate, it would just use:
1619//
1620//    #[derive(Deserialize)]
1621//    #[serde(variant_identifier)]
1622#[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////////////////////////////////////////////////////////////////////////////////
1684
1685#[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    /// This impl requires the [`"rc"`] Cargo feature of Serde.
1701    ///
1702    /// Deserializing a data structure containing `Arc` will not attempt to
1703    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1704    /// will end up with a strong count of 1.
1705    ///
1706    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1707    (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    /// This impl requires the [`"rc"`] Cargo feature of Serde.
1717    ///
1718    /// Deserializing a data structure containing `Rc` will not attempt to
1719    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1720    /// will end up with a strong count of 1.
1721    ///
1722    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1723    (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////////////////////////////////////////////////////////////////////////////////
1742
1743/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1744/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1745///
1746/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1747#[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/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1762/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1763///
1764/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1765#[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////////////////////////////////////////////////////////////////////////////////
1780
1781#[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    /// This impl requires the [`"rc"`] Cargo feature of Serde.
1805    ///
1806    /// Deserializing a data structure containing `Rc` will not attempt to
1807    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1808    /// will end up with a strong count of 1.
1809    ///
1810    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1811    Rc
1812}
1813
1814#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1815box_forwarded_impl! {
1816    /// This impl requires the [`"rc"`] Cargo feature of Serde.
1817    ///
1818    /// Deserializing a data structure containing `Arc` will not attempt to
1819    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1820    /// will end up with a strong count of 1.
1821    ///
1822    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1823    Arc
1824}
1825
1826////////////////////////////////////////////////////////////////////////////////
1827
1828impl<'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////////////////////////////////////////////////////////////////////////////////
1849
1850// This is a cleaned-up version of the impl generated by:
1851//
1852//     #[derive(Deserialize)]
1853//     #[serde(deny_unknown_fields)]
1854//     struct Duration {
1855//         secs: u64,
1856//         nanos: u32,
1857//     }
1858#[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        // If this were outside of the serde crate, it would just use:
1865        //
1866        //    #[derive(Deserialize)]
1867        //    #[serde(field_identifier, rename_all = "lowercase")]
1868        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////////////////////////////////////////////////////////////////////////////////
1985
1986#[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        // Reuse duration
1993        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
2114////////////////////////////////////////////////////////////////////////////////
2115
2116// Similar to:
2117//
2118//     #[derive(Deserialize)]
2119//     #[serde(deny_unknown_fields)]
2120//     struct Range {
2121//         start: u64,
2122//         end: u32,
2123//     }
2124impl<'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    // If this were outside of the serde crate, it would just use:
2173    //
2174    //    #[derive(Deserialize)]
2175    //    #[serde(field_identifier, rename_all = "lowercase")]
2176    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////////////////////////////////////////////////////////////////////////////////
2295
2296#[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
2405////////////////////////////////////////////////////////////////////////////////
2406
2407macro_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
2444// Currently 128-bit integers do not work on Emscripten targets so we need an
2445// additional `#[cfg]`
2446serde_if_integer128! {
2447    nonzero_integers! {
2448        NonZeroU128,
2449    }
2450
2451    #[cfg(num_nonzero_signed)]
2452    nonzero_integers! {
2453        NonZeroI128,
2454    }
2455}
2456
2457////////////////////////////////////////////////////////////////////////////////
2458
2459impl<'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        // If this were outside of the serde crate, it would just use:
2469        //
2470        //    #[derive(Deserialize)]
2471        //    #[serde(variant_identifier)]
2472        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////////////////////////////////////////////////////////////////////////////////
2569
2570#[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}