1 use lib::*;
2
3 use de::{
4 Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
5 };
6
7 #[cfg(any(core_duration, feature = "std", feature = "alloc"))]
8 use de::MapAccess;
9
10 use de::from_primitive::FromPrimitive;
11 use private::de::InPlaceSeed;
12
13 #[cfg(any(feature = "std", feature = "alloc"))]
14 use private::de::size_hint;
15
16 ////////////////////////////////////////////////////////////////////////////////
17
18 struct UnitVisitor;
19
20 impl<'de> Visitor<'de> for UnitVisitor {
21 type Value = ();
22
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result23 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
24 formatter.write_str("unit")
25 }
26
visit_unit<E>(self) -> Result<Self::Value, E> where E: Error,27 fn visit_unit<E>(self) -> Result<Self::Value, E>
28 where
29 E: Error,
30 {
31 Ok(())
32 }
33 }
34
35 impl<'de> Deserialize<'de> for () {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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")]
45 impl<'de> Deserialize<'de> for ! {
deserialize<D>(_deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
56 struct BoolVisitor;
57
58 impl<'de> Visitor<'de> for BoolVisitor {
59 type Value = bool;
60
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result61 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
62 formatter.write_str("a boolean")
63 }
64
visit_bool<E>(self, v: bool) -> Result<Self::Value, E> where E: Error,65 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
66 where
67 E: Error,
68 {
69 Ok(v)
70 }
71 }
72
73 impl<'de> Deserialize<'de> for bool {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
84 macro_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
99 macro_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
111 macro_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
156 impl_deserialize_num!(i8, deserialize_i8, integer);
157 impl_deserialize_num!(i16, deserialize_i16, integer);
158 impl_deserialize_num!(i32, deserialize_i32, integer);
159 impl_deserialize_num!(i64, deserialize_i64, integer);
160 impl_deserialize_num!(isize, deserialize_i64, integer);
161
162 impl_deserialize_num!(u8, deserialize_u8, integer);
163 impl_deserialize_num!(u16, deserialize_u16, integer);
164 impl_deserialize_num!(u32, deserialize_u32, integer);
165 impl_deserialize_num!(u64, deserialize_u64, integer);
166 impl_deserialize_num!(usize, deserialize_u64, integer);
167
168 impl_deserialize_num!(f32, deserialize_f32, integer, float);
169 impl_deserialize_num!(f64, deserialize_f64, integer, float);
170
171 serde_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
259 struct CharVisitor;
260
261 impl<'de> Visitor<'de> for CharVisitor {
262 type Value = char;
263
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result264 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
265 formatter.write_str("a character")
266 }
267
268 #[inline]
visit_char<E>(self, v: char) -> Result<Self::Value, E> where E: Error,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]
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,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
289 impl<'de> Deserialize<'de> for char {
290 #[inline]
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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"))]
302 struct StringVisitor;
303 #[cfg(any(feature = "std", feature = "alloc"))]
304 struct StringInPlaceVisitor<'a>(&'a mut String);
305
306 #[cfg(any(feature = "std", feature = "alloc"))]
307 impl<'de> Visitor<'de> for StringVisitor {
308 type Value = String;
309
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result310 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
311 formatter.write_str("a string")
312 }
313
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,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
visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error,321 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
322 where
323 E: Error,
324 {
325 Ok(v)
326 }
327
visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where E: Error,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
visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> where E: Error,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"))]
353 impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
354 type Value = ();
355
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result356 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
357 formatter.write_str("a string")
358 }
359
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,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
visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error,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
visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where E: Error,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
visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> where E: Error,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"))]
409 impl<'de> Deserialize<'de> for String {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,410 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
411 where
412 D: Deserializer<'de>,
413 {
414 deserializer.deserialize_string(StringVisitor)
415 }
416
deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>,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
427 struct StrVisitor;
428
429 impl<'a> Visitor<'a> for StrVisitor {
430 type Value = &'a str;
431
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result432 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
433 formatter.write_str("a borrowed string")
434 }
435
visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E> where E: Error,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
visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E> where E: Error,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
451 impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
462 struct BytesVisitor;
463
464 impl<'a> Visitor<'a> for BytesVisitor {
465 type Value = &'a [u8];
466
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result467 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
468 formatter.write_str("a borrowed byte array")
469 }
470
visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E> where E: Error,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
visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E> where E: Error,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
486 impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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")]
498 struct CStringVisitor;
499
500 #[cfg(feature = "std")]
501 impl<'de> Visitor<'de> for CStringVisitor {
502 type Value = CString;
503
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result504 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
505 formatter.write_str("byte array")
506 }
507
visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,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
visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where E: Error,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
visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> where E: Error,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
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,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
visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error,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")]
552 impl<'de> Deserialize<'de> for CString {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
561 macro_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))]
579 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
580
581 #[cfg(core_reverse)]
582 forwarded_impl!((T), Reverse<T>, Reverse);
583
584 ////////////////////////////////////////////////////////////////////////////////
585
586 struct OptionVisitor<T> {
587 marker: PhantomData<T>,
588 }
589
590 impl<'de, T> Visitor<'de> for OptionVisitor<T>
591 where
592 T: Deserialize<'de>,
593 {
594 type Value = Option<T>;
595
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result596 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
597 formatter.write_str("option")
598 }
599
600 #[inline]
visit_unit<E>(self) -> Result<Self::Value, E> where E: Error,601 fn visit_unit<E>(self) -> Result<Self::Value, E>
602 where
603 E: Error,
604 {
605 Ok(None)
606 }
607
608 #[inline]
visit_none<E>(self) -> Result<Self::Value, E> where E: Error,609 fn visit_none<E>(self) -> Result<Self::Value, E>
610 where
611 E: Error,
612 {
613 Ok(None)
614 }
615
616 #[inline]
visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,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)]
__private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()> where D: Deserializer<'de>,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
633 impl<'de, T> Deserialize<'de> for Option<T>
634 where
635 T: Deserialize<'de>,
636 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
655 struct PhantomDataVisitor<T: ?Sized> {
656 marker: PhantomData<T>,
657 }
658
659 impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
660 type Value = PhantomData<T>;
661
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result662 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
663 formatter.write_str("unit")
664 }
665
666 #[inline]
visit_unit<E>(self) -> Result<Self::Value, E> where E: Error,667 fn visit_unit<E>(self) -> Result<Self::Value, E>
668 where
669 E: Error,
670 {
671 Ok(PhantomData)
672 }
673 }
674
675 impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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"))]
690 macro_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"))]
nop_reserve<T>(_seq: T, _n: usize)784 fn nop_reserve<T>(_seq: T, _n: usize) {}
785
786 #[cfg(any(feature = "std", feature = "alloc"))]
787 seq_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"))]
797 seq_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"))]
807 seq_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")]
817 seq_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"))]
826 seq_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"))]
838 impl<'de, T> Deserialize<'de> for Vec<T>
839 where
840 T: Deserialize<'de>,
841 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>,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
930 struct ArrayVisitor<A> {
931 marker: PhantomData<A>,
932 }
933 struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
934
935 impl<A> ArrayVisitor<A> {
new() -> Self936 fn new() -> Self {
937 ArrayVisitor {
938 marker: PhantomData,
939 }
940 }
941 }
942
943 impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
944 type Value = [T; 0];
945
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result946 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
947 formatter.write_str("an empty array")
948 }
949
950 #[inline]
visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,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>.
960 impl<'de, T> Deserialize<'de> for [T; 0] {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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
969 macro_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
1047 array_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
1084 macro_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
1161 tuple_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"))]
1183 macro_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"))]
1238 map_impl!(
1239 BTreeMap<K: Ord, V>,
1240 map,
1241 BTreeMap::new());
1242
1243 #[cfg(feature = "std")]
1244 map_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")]
1252 macro_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")]
1287 macro_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")]
1362 macro_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")]
1399 impl<'de> Deserialize<'de> for net::IpAddr {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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")]
1435 parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
1436
1437 #[cfg(feature = "std")]
1438 parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
1439
1440 #[cfg(feature = "std")]
1441 macro_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")]
1476 impl<'de> Deserialize<'de> for net::SocketAddr {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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")]
1512 parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
1513
1514 #[cfg(feature = "std")]
1515 parse_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")]
1522 struct PathVisitor;
1523
1524 #[cfg(feature = "std")]
1525 impl<'a> Visitor<'a> for PathVisitor {
1526 type Value = &'a Path;
1527
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1528 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1529 formatter.write_str("a borrowed path")
1530 }
1531
visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E> where E: Error,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
visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E> where E: Error,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")]
1550 impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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")]
1560 struct PathBufVisitor;
1561
1562 #[cfg(feature = "std")]
1563 impl<'de> Visitor<'de> for PathBufVisitor {
1564 type Value = PathBuf;
1565
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1566 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1567 formatter.write_str("path string")
1568 }
1569
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,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
visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error,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
1585 #[cfg(feature = "std")]
1586 impl<'de> Deserialize<'de> for PathBuf {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1587 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1588 where
1589 D: Deserializer<'de>,
1590 {
1591 deserializer.deserialize_string(PathBufVisitor)
1592 }
1593 }
1594
1595 ////////////////////////////////////////////////////////////////////////////////
1596
1597 // If this were outside of the serde crate, it would just use:
1598 //
1599 // #[derive(Deserialize)]
1600 // #[serde(variant_identifier)]
1601 #[cfg(all(feature = "std", any(unix, windows)))]
1602 variant_identifier! {
1603 OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
1604 "`Unix` or `Windows`",
1605 OSSTR_VARIANTS
1606 }
1607
1608 #[cfg(all(feature = "std", any(unix, windows)))]
1609 struct OsStringVisitor;
1610
1611 #[cfg(all(feature = "std", any(unix, windows)))]
1612 impl<'de> Visitor<'de> for OsStringVisitor {
1613 type Value = OsString;
1614
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1615 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1616 formatter.write_str("os string")
1617 }
1618
1619 #[cfg(unix)]
visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where A: EnumAccess<'de>,1620 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1621 where
1622 A: EnumAccess<'de>,
1623 {
1624 use std::os::unix::ffi::OsStringExt;
1625
1626 match try!(data.variant()) {
1627 (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
1628 (OsStringKind::Windows, _) => Err(Error::custom(
1629 "cannot deserialize Windows OS string on Unix",
1630 )),
1631 }
1632 }
1633
1634 #[cfg(windows)]
visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where A: EnumAccess<'de>,1635 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1636 where
1637 A: EnumAccess<'de>,
1638 {
1639 use std::os::windows::ffi::OsStringExt;
1640
1641 match try!(data.variant()) {
1642 (OsStringKind::Windows, v) => v
1643 .newtype_variant::<Vec<u16>>()
1644 .map(|vec| OsString::from_wide(&vec)),
1645 (OsStringKind::Unix, _) => Err(Error::custom(
1646 "cannot deserialize Unix OS string on Windows",
1647 )),
1648 }
1649 }
1650 }
1651
1652 #[cfg(all(feature = "std", any(unix, windows)))]
1653 impl<'de> Deserialize<'de> for OsString {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1654 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1655 where
1656 D: Deserializer<'de>,
1657 {
1658 deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
1659 }
1660 }
1661
1662 ////////////////////////////////////////////////////////////////////////////////
1663
1664 #[cfg(any(feature = "std", feature = "alloc"))]
1665 forwarded_impl!((T), Box<T>, Box::new);
1666
1667 #[cfg(any(feature = "std", feature = "alloc"))]
1668 forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
1669
1670 #[cfg(any(feature = "std", feature = "alloc"))]
1671 forwarded_impl!((), Box<str>, String::into_boxed_str);
1672
1673 #[cfg(all(
1674 not(de_rc_dst),
1675 feature = "rc",
1676 any(feature = "std", feature = "alloc")
1677 ))]
1678 forwarded_impl! {
1679 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1680 ///
1681 /// Deserializing a data structure containing `Arc` will not attempt to
1682 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1683 /// will end up with a strong count of 1.
1684 ///
1685 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1686 (T), Arc<T>, Arc::new
1687 }
1688
1689 #[cfg(all(
1690 not(de_rc_dst),
1691 feature = "rc",
1692 any(feature = "std", feature = "alloc")
1693 ))]
1694 forwarded_impl! {
1695 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1696 ///
1697 /// Deserializing a data structure containing `Rc` will not attempt to
1698 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1699 /// will end up with a strong count of 1.
1700 ///
1701 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1702 (T), Rc<T>, Rc::new
1703 }
1704
1705 #[cfg(any(feature = "std", feature = "alloc"))]
1706 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
1707 where
1708 T: ToOwned,
1709 T::Owned: Deserialize<'de>,
1710 {
1711 #[inline]
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1712 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1713 where
1714 D: Deserializer<'de>,
1715 {
1716 T::Owned::deserialize(deserializer).map(Cow::Owned)
1717 }
1718 }
1719
1720 ////////////////////////////////////////////////////////////////////////////////
1721
1722 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1723 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1724 ///
1725 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1726 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1727 impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
1728 where
1729 T: Deserialize<'de>,
1730 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1731 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1732 where
1733 D: Deserializer<'de>,
1734 {
1735 try!(Option::<T>::deserialize(deserializer));
1736 Ok(RcWeak::new())
1737 }
1738 }
1739
1740 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1741 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1742 ///
1743 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1744 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1745 impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
1746 where
1747 T: Deserialize<'de>,
1748 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1749 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1750 where
1751 D: Deserializer<'de>,
1752 {
1753 try!(Option::<T>::deserialize(deserializer));
1754 Ok(ArcWeak::new())
1755 }
1756 }
1757
1758 ////////////////////////////////////////////////////////////////////////////////
1759
1760 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1761 macro_rules! box_forwarded_impl {
1762 (
1763 $(#[doc = $doc:tt])*
1764 $t:ident
1765 ) => {
1766 $(#[doc = $doc])*
1767 impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
1768 where
1769 Box<T>: Deserialize<'de>,
1770 {
1771 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1772 where
1773 D: Deserializer<'de>,
1774 {
1775 Box::deserialize(deserializer).map(Into::into)
1776 }
1777 }
1778 };
1779 }
1780
1781 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1782 box_forwarded_impl! {
1783 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1784 ///
1785 /// Deserializing a data structure containing `Rc` will not attempt to
1786 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1787 /// will end up with a strong count of 1.
1788 ///
1789 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1790 Rc
1791 }
1792
1793 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1794 box_forwarded_impl! {
1795 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1796 ///
1797 /// Deserializing a data structure containing `Arc` will not attempt to
1798 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1799 /// will end up with a strong count of 1.
1800 ///
1801 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1802 Arc
1803 }
1804
1805 ////////////////////////////////////////////////////////////////////////////////
1806
1807 impl<'de, T> Deserialize<'de> for Cell<T>
1808 where
1809 T: Deserialize<'de> + Copy,
1810 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1811 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1812 where
1813 D: Deserializer<'de>,
1814 {
1815 T::deserialize(deserializer).map(Cell::new)
1816 }
1817 }
1818
1819 forwarded_impl!((T), RefCell<T>, RefCell::new);
1820
1821 #[cfg(feature = "std")]
1822 forwarded_impl!((T), Mutex<T>, Mutex::new);
1823
1824 #[cfg(feature = "std")]
1825 forwarded_impl!((T), RwLock<T>, RwLock::new);
1826
1827 ////////////////////////////////////////////////////////////////////////////////
1828
1829 // This is a cleaned-up version of the impl generated by:
1830 //
1831 // #[derive(Deserialize)]
1832 // #[serde(deny_unknown_fields)]
1833 // struct Duration {
1834 // secs: u64,
1835 // nanos: u32,
1836 // }
1837 #[cfg(any(core_duration, feature = "std"))]
1838 impl<'de> Deserialize<'de> for Duration {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1839 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1840 where
1841 D: Deserializer<'de>,
1842 {
1843 // If this were outside of the serde crate, it would just use:
1844 //
1845 // #[derive(Deserialize)]
1846 // #[serde(field_identifier, rename_all = "lowercase")]
1847 enum Field {
1848 Secs,
1849 Nanos,
1850 };
1851
1852 impl<'de> Deserialize<'de> for Field {
1853 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1854 where
1855 D: Deserializer<'de>,
1856 {
1857 struct FieldVisitor;
1858
1859 impl<'de> Visitor<'de> for FieldVisitor {
1860 type Value = Field;
1861
1862 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1863 formatter.write_str("`secs` or `nanos`")
1864 }
1865
1866 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1867 where
1868 E: Error,
1869 {
1870 match value {
1871 "secs" => Ok(Field::Secs),
1872 "nanos" => Ok(Field::Nanos),
1873 _ => Err(Error::unknown_field(value, FIELDS)),
1874 }
1875 }
1876
1877 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1878 where
1879 E: Error,
1880 {
1881 match value {
1882 b"secs" => Ok(Field::Secs),
1883 b"nanos" => Ok(Field::Nanos),
1884 _ => {
1885 let value = ::export::from_utf8_lossy(value);
1886 Err(Error::unknown_field(&value, FIELDS))
1887 }
1888 }
1889 }
1890 }
1891
1892 deserializer.deserialize_identifier(FieldVisitor)
1893 }
1894 }
1895
1896 struct DurationVisitor;
1897
1898 impl<'de> Visitor<'de> for DurationVisitor {
1899 type Value = Duration;
1900
1901 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1902 formatter.write_str("struct Duration")
1903 }
1904
1905 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1906 where
1907 A: SeqAccess<'de>,
1908 {
1909 let secs: u64 = match try!(seq.next_element()) {
1910 Some(value) => value,
1911 None => {
1912 return Err(Error::invalid_length(0, &self));
1913 }
1914 };
1915 let nanos: u32 = match try!(seq.next_element()) {
1916 Some(value) => value,
1917 None => {
1918 return Err(Error::invalid_length(1, &self));
1919 }
1920 };
1921 Ok(Duration::new(secs, nanos))
1922 }
1923
1924 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1925 where
1926 A: MapAccess<'de>,
1927 {
1928 let mut secs: Option<u64> = None;
1929 let mut nanos: Option<u32> = None;
1930 while let Some(key) = try!(map.next_key()) {
1931 match key {
1932 Field::Secs => {
1933 if secs.is_some() {
1934 return Err(<A::Error as Error>::duplicate_field("secs"));
1935 }
1936 secs = Some(try!(map.next_value()));
1937 }
1938 Field::Nanos => {
1939 if nanos.is_some() {
1940 return Err(<A::Error as Error>::duplicate_field("nanos"));
1941 }
1942 nanos = Some(try!(map.next_value()));
1943 }
1944 }
1945 }
1946 let secs = match secs {
1947 Some(secs) => secs,
1948 None => return Err(<A::Error as Error>::missing_field("secs")),
1949 };
1950 let nanos = match nanos {
1951 Some(nanos) => nanos,
1952 None => return Err(<A::Error as Error>::missing_field("nanos")),
1953 };
1954 Ok(Duration::new(secs, nanos))
1955 }
1956 }
1957
1958 const FIELDS: &'static [&'static str] = &["secs", "nanos"];
1959 deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
1960 }
1961 }
1962
1963 ////////////////////////////////////////////////////////////////////////////////
1964
1965 #[cfg(feature = "std")]
1966 impl<'de> Deserialize<'de> for SystemTime {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1967 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1968 where
1969 D: Deserializer<'de>,
1970 {
1971 // Reuse duration
1972 enum Field {
1973 Secs,
1974 Nanos,
1975 };
1976
1977 impl<'de> Deserialize<'de> for Field {
1978 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1979 where
1980 D: Deserializer<'de>,
1981 {
1982 struct FieldVisitor;
1983
1984 impl<'de> Visitor<'de> for FieldVisitor {
1985 type Value = Field;
1986
1987 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1988 formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
1989 }
1990
1991 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1992 where
1993 E: Error,
1994 {
1995 match value {
1996 "secs_since_epoch" => Ok(Field::Secs),
1997 "nanos_since_epoch" => Ok(Field::Nanos),
1998 _ => Err(Error::unknown_field(value, FIELDS)),
1999 }
2000 }
2001
2002 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2003 where
2004 E: Error,
2005 {
2006 match value {
2007 b"secs_since_epoch" => Ok(Field::Secs),
2008 b"nanos_since_epoch" => Ok(Field::Nanos),
2009 _ => {
2010 let value = String::from_utf8_lossy(value);
2011 Err(Error::unknown_field(&value, FIELDS))
2012 }
2013 }
2014 }
2015 }
2016
2017 deserializer.deserialize_identifier(FieldVisitor)
2018 }
2019 }
2020
2021 struct DurationVisitor;
2022
2023 impl<'de> Visitor<'de> for DurationVisitor {
2024 type Value = Duration;
2025
2026 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2027 formatter.write_str("struct SystemTime")
2028 }
2029
2030 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2031 where
2032 A: SeqAccess<'de>,
2033 {
2034 let secs: u64 = match try!(seq.next_element()) {
2035 Some(value) => value,
2036 None => {
2037 return Err(Error::invalid_length(0, &self));
2038 }
2039 };
2040 let nanos: u32 = match try!(seq.next_element()) {
2041 Some(value) => value,
2042 None => {
2043 return Err(Error::invalid_length(1, &self));
2044 }
2045 };
2046 Ok(Duration::new(secs, nanos))
2047 }
2048
2049 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2050 where
2051 A: MapAccess<'de>,
2052 {
2053 let mut secs: Option<u64> = None;
2054 let mut nanos: Option<u32> = None;
2055 while let Some(key) = try!(map.next_key()) {
2056 match key {
2057 Field::Secs => {
2058 if secs.is_some() {
2059 return Err(<A::Error as Error>::duplicate_field(
2060 "secs_since_epoch",
2061 ));
2062 }
2063 secs = Some(try!(map.next_value()));
2064 }
2065 Field::Nanos => {
2066 if nanos.is_some() {
2067 return Err(<A::Error as Error>::duplicate_field(
2068 "nanos_since_epoch",
2069 ));
2070 }
2071 nanos = Some(try!(map.next_value()));
2072 }
2073 }
2074 }
2075 let secs = match secs {
2076 Some(secs) => secs,
2077 None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
2078 };
2079 let nanos = match nanos {
2080 Some(nanos) => nanos,
2081 None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
2082 };
2083 Ok(Duration::new(secs, nanos))
2084 }
2085 }
2086
2087 const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
2088 let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
2089 Ok(UNIX_EPOCH + duration)
2090 }
2091 }
2092
2093 ////////////////////////////////////////////////////////////////////////////////
2094
2095 // Similar to:
2096 //
2097 // #[derive(Deserialize)]
2098 // #[serde(deny_unknown_fields)]
2099 // struct Range {
2100 // start: u64,
2101 // end: u32,
2102 // }
2103 impl<'de, Idx> Deserialize<'de> for Range<Idx>
2104 where
2105 Idx: Deserialize<'de>,
2106 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2107 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2108 where
2109 D: Deserializer<'de>,
2110 {
2111 let (start, end) = deserializer.deserialize_struct(
2112 "Range",
2113 range::FIELDS,
2114 range::RangeVisitor {
2115 expecting: "struct Range",
2116 phantom: PhantomData,
2117 },
2118 )?;
2119 Ok(start..end)
2120 }
2121 }
2122
2123 #[cfg(range_inclusive)]
2124 impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
2125 where
2126 Idx: Deserialize<'de>,
2127 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 "RangeInclusive",
2134 range::FIELDS,
2135 range::RangeVisitor {
2136 expecting: "struct RangeInclusive",
2137 phantom: PhantomData,
2138 },
2139 )?;
2140 Ok(RangeInclusive::new(start, end))
2141 }
2142 }
2143
2144 mod range {
2145 use lib::*;
2146
2147 use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
2148
2149 pub const FIELDS: &'static [&'static str] = &["start", "end"];
2150
2151 // If this were outside of the serde crate, it would just use:
2152 //
2153 // #[derive(Deserialize)]
2154 // #[serde(field_identifier, rename_all = "lowercase")]
2155 enum Field {
2156 Start,
2157 End,
2158 }
2159
2160 impl<'de> Deserialize<'de> for Field {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2161 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2162 where
2163 D: Deserializer<'de>,
2164 {
2165 struct FieldVisitor;
2166
2167 impl<'de> Visitor<'de> for FieldVisitor {
2168 type Value = Field;
2169
2170 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2171 formatter.write_str("`start` or `end`")
2172 }
2173
2174 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2175 where
2176 E: Error,
2177 {
2178 match value {
2179 "start" => Ok(Field::Start),
2180 "end" => Ok(Field::End),
2181 _ => Err(Error::unknown_field(value, FIELDS)),
2182 }
2183 }
2184
2185 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2186 where
2187 E: Error,
2188 {
2189 match value {
2190 b"start" => Ok(Field::Start),
2191 b"end" => Ok(Field::End),
2192 _ => {
2193 let value = ::export::from_utf8_lossy(value);
2194 Err(Error::unknown_field(&value, FIELDS))
2195 }
2196 }
2197 }
2198 }
2199
2200 deserializer.deserialize_identifier(FieldVisitor)
2201 }
2202 }
2203
2204 pub struct RangeVisitor<Idx> {
2205 pub expecting: &'static str,
2206 pub phantom: PhantomData<Idx>,
2207 }
2208
2209 impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
2210 where
2211 Idx: Deserialize<'de>,
2212 {
2213 type Value = (Idx, Idx);
2214
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result2215 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2216 formatter.write_str(self.expecting)
2217 }
2218
visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,2219 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2220 where
2221 A: SeqAccess<'de>,
2222 {
2223 let start: Idx = match try!(seq.next_element()) {
2224 Some(value) => value,
2225 None => {
2226 return Err(Error::invalid_length(0, &self));
2227 }
2228 };
2229 let end: Idx = match try!(seq.next_element()) {
2230 Some(value) => value,
2231 None => {
2232 return Err(Error::invalid_length(1, &self));
2233 }
2234 };
2235 Ok((start, end))
2236 }
2237
visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: MapAccess<'de>,2238 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2239 where
2240 A: MapAccess<'de>,
2241 {
2242 let mut start: Option<Idx> = None;
2243 let mut end: Option<Idx> = None;
2244 while let Some(key) = try!(map.next_key()) {
2245 match key {
2246 Field::Start => {
2247 if start.is_some() {
2248 return Err(<A::Error as Error>::duplicate_field("start"));
2249 }
2250 start = Some(try!(map.next_value()));
2251 }
2252 Field::End => {
2253 if end.is_some() {
2254 return Err(<A::Error as Error>::duplicate_field("end"));
2255 }
2256 end = Some(try!(map.next_value()));
2257 }
2258 }
2259 }
2260 let start = match start {
2261 Some(start) => start,
2262 None => return Err(<A::Error as Error>::missing_field("start")),
2263 };
2264 let end = match end {
2265 Some(end) => end,
2266 None => return Err(<A::Error as Error>::missing_field("end")),
2267 };
2268 Ok((start, end))
2269 }
2270 }
2271 }
2272
2273 ////////////////////////////////////////////////////////////////////////////////
2274
2275 #[cfg(any(ops_bound, collections_bound))]
2276 impl<'de, T> Deserialize<'de> for Bound<T>
2277 where
2278 T: Deserialize<'de>,
2279 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2280 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2281 where
2282 D: Deserializer<'de>,
2283 {
2284 enum Field {
2285 Unbounded,
2286 Included,
2287 Excluded,
2288 }
2289
2290 impl<'de> Deserialize<'de> for Field {
2291 #[inline]
2292 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2293 where
2294 D: Deserializer<'de>,
2295 {
2296 struct FieldVisitor;
2297
2298 impl<'de> Visitor<'de> for FieldVisitor {
2299 type Value = Field;
2300
2301 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2302 formatter.write_str("`Unbounded`, `Included` or `Excluded`")
2303 }
2304
2305 fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2306 where
2307 E: Error,
2308 {
2309 match value {
2310 0 => Ok(Field::Unbounded),
2311 1 => Ok(Field::Included),
2312 2 => Ok(Field::Excluded),
2313 _ => Err(Error::invalid_value(
2314 Unexpected::Unsigned(value as u64),
2315 &self,
2316 )),
2317 }
2318 }
2319
2320 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2321 where
2322 E: Error,
2323 {
2324 match value {
2325 "Unbounded" => Ok(Field::Unbounded),
2326 "Included" => Ok(Field::Included),
2327 "Excluded" => Ok(Field::Excluded),
2328 _ => Err(Error::unknown_variant(value, VARIANTS)),
2329 }
2330 }
2331
2332 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2333 where
2334 E: Error,
2335 {
2336 match value {
2337 b"Unbounded" => Ok(Field::Unbounded),
2338 b"Included" => Ok(Field::Included),
2339 b"Excluded" => Ok(Field::Excluded),
2340 _ => match str::from_utf8(value) {
2341 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2342 Err(_) => {
2343 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2344 }
2345 },
2346 }
2347 }
2348 }
2349
2350 deserializer.deserialize_identifier(FieldVisitor)
2351 }
2352 }
2353
2354 struct BoundVisitor<T>(PhantomData<Bound<T>>);
2355
2356 impl<'de, T> Visitor<'de> for BoundVisitor<T>
2357 where
2358 T: Deserialize<'de>,
2359 {
2360 type Value = Bound<T>;
2361
2362 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2363 formatter.write_str("enum Bound")
2364 }
2365
2366 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2367 where
2368 A: EnumAccess<'de>,
2369 {
2370 match try!(data.variant()) {
2371 (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
2372 (Field::Included, v) => v.newtype_variant().map(Bound::Included),
2373 (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
2374 }
2375 }
2376 }
2377
2378 const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
2379
2380 deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
2381 }
2382 }
2383
2384 ////////////////////////////////////////////////////////////////////////////////
2385
2386 macro_rules! nonzero_integers {
2387 ( $( $T: ident, )+ ) => {
2388 $(
2389 #[cfg(num_nonzero)]
2390 impl<'de> Deserialize<'de> for num::$T {
2391 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2392 where
2393 D: Deserializer<'de>,
2394 {
2395 let value = try!(Deserialize::deserialize(deserializer));
2396 match <num::$T>::new(value) {
2397 Some(nonzero) => Ok(nonzero),
2398 None => Err(Error::custom("expected a non-zero value")),
2399 }
2400 }
2401 }
2402 )+
2403 };
2404 }
2405
2406 nonzero_integers! {
2407 NonZeroU8,
2408 NonZeroU16,
2409 NonZeroU32,
2410 NonZeroU64,
2411 NonZeroUsize,
2412 }
2413
2414 #[cfg(num_nonzero_signed)]
2415 nonzero_integers! {
2416 NonZeroI8,
2417 NonZeroI16,
2418 NonZeroI32,
2419 NonZeroI64,
2420 NonZeroIsize,
2421 }
2422
2423 // Currently 128-bit integers do not work on Emscripten targets so we need an
2424 // additional `#[cfg]`
2425 serde_if_integer128! {
2426 nonzero_integers! {
2427 NonZeroU128,
2428 }
2429
2430 #[cfg(num_nonzero_signed)]
2431 nonzero_integers! {
2432 NonZeroI128,
2433 }
2434 }
2435
2436 ////////////////////////////////////////////////////////////////////////////////
2437
2438 impl<'de, T, E> Deserialize<'de> for Result<T, E>
2439 where
2440 T: Deserialize<'de>,
2441 E: Deserialize<'de>,
2442 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2443 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2444 where
2445 D: Deserializer<'de>,
2446 {
2447 // If this were outside of the serde crate, it would just use:
2448 //
2449 // #[derive(Deserialize)]
2450 // #[serde(variant_identifier)]
2451 enum Field {
2452 Ok,
2453 Err,
2454 }
2455
2456 impl<'de> Deserialize<'de> for Field {
2457 #[inline]
2458 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2459 where
2460 D: Deserializer<'de>,
2461 {
2462 struct FieldVisitor;
2463
2464 impl<'de> Visitor<'de> for FieldVisitor {
2465 type Value = Field;
2466
2467 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2468 formatter.write_str("`Ok` or `Err`")
2469 }
2470
2471 fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2472 where
2473 E: Error,
2474 {
2475 match value {
2476 0 => Ok(Field::Ok),
2477 1 => Ok(Field::Err),
2478 _ => Err(Error::invalid_value(
2479 Unexpected::Unsigned(value as u64),
2480 &self,
2481 )),
2482 }
2483 }
2484
2485 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2486 where
2487 E: Error,
2488 {
2489 match value {
2490 "Ok" => Ok(Field::Ok),
2491 "Err" => Ok(Field::Err),
2492 _ => Err(Error::unknown_variant(value, VARIANTS)),
2493 }
2494 }
2495
2496 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2497 where
2498 E: Error,
2499 {
2500 match value {
2501 b"Ok" => Ok(Field::Ok),
2502 b"Err" => Ok(Field::Err),
2503 _ => match str::from_utf8(value) {
2504 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2505 Err(_) => {
2506 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2507 }
2508 },
2509 }
2510 }
2511 }
2512
2513 deserializer.deserialize_identifier(FieldVisitor)
2514 }
2515 }
2516
2517 struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
2518
2519 impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
2520 where
2521 T: Deserialize<'de>,
2522 E: Deserialize<'de>,
2523 {
2524 type Value = Result<T, E>;
2525
2526 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2527 formatter.write_str("enum Result")
2528 }
2529
2530 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2531 where
2532 A: EnumAccess<'de>,
2533 {
2534 match try!(data.variant()) {
2535 (Field::Ok, v) => v.newtype_variant().map(Ok),
2536 (Field::Err, v) => v.newtype_variant().map(Err),
2537 }
2538 }
2539 }
2540
2541 const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
2542
2543 deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
2544 }
2545 }
2546
2547 ////////////////////////////////////////////////////////////////////////////////
2548
2549 #[cfg(feature = "std")]
2550 impl<'de, T> Deserialize<'de> for Wrapping<T>
2551 where
2552 T: Deserialize<'de>,
2553 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2554 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2555 where
2556 D: Deserializer<'de>,
2557 {
2558 Deserialize::deserialize(deserializer).map(Wrapping)
2559 }
2560 }
2561
2562 #[cfg(all(feature = "std", std_atomic))]
2563 macro_rules! atomic_impl {
2564 ($($ty:ident)*) => {
2565 $(
2566 impl<'de> Deserialize<'de> for $ty {
2567 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2568 where
2569 D: Deserializer<'de>,
2570 {
2571 Deserialize::deserialize(deserializer).map(Self::new)
2572 }
2573 }
2574 )*
2575 };
2576 }
2577
2578 #[cfg(all(feature = "std", std_atomic))]
2579 atomic_impl! {
2580 AtomicBool
2581 AtomicI8 AtomicI16 AtomicI32 AtomicIsize
2582 AtomicU8 AtomicU16 AtomicU32 AtomicUsize
2583 }
2584
2585 #[cfg(all(feature = "std", std_atomic64))]
2586 atomic_impl! {
2587 AtomicI64 AtomicU64
2588 }
2589