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 #[cfg(any(feature = "std", feature = "alloc"))]
796 seq_impl!(
797 BTreeSet<T: Eq + Ord>,
798 seq,
799 BTreeSet::clear,
800 BTreeSet::new(),
801 nop_reserve,
802 BTreeSet::insert);
803
804 #[cfg(any(feature = "std", feature = "alloc"))]
805 seq_impl!(
806 LinkedList<T>,
807 seq,
808 LinkedList::clear,
809 LinkedList::new(),
810 nop_reserve,
811 LinkedList::push_back
812 );
813
814 #[cfg(feature = "std")]
815 seq_impl!(
816 HashSet<T: Eq + Hash, S: BuildHasher + Default>,
817 seq,
818 HashSet::clear,
819 HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
820 HashSet::reserve,
821 HashSet::insert);
822
823 #[cfg(any(feature = "std", feature = "alloc"))]
824 seq_impl!(
825 VecDeque<T>,
826 seq,
827 VecDeque::clear,
828 VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
829 VecDeque::reserve,
830 VecDeque::push_back
831 );
832
833 ////////////////////////////////////////////////////////////////////////////////
834
835 #[cfg(any(feature = "std", feature = "alloc"))]
836 impl<'de, T> Deserialize<'de> for Vec<T>
837 where
838 T: Deserialize<'de>,
839 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,840 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
841 where
842 D: Deserializer<'de>,
843 {
844 struct VecVisitor<T> {
845 marker: PhantomData<T>,
846 }
847
848 impl<'de, T> Visitor<'de> for VecVisitor<T>
849 where
850 T: Deserialize<'de>,
851 {
852 type Value = Vec<T>;
853
854 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
855 formatter.write_str("a sequence")
856 }
857
858 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
859 where
860 A: SeqAccess<'de>,
861 {
862 let mut values = Vec::with_capacity(size_hint::cautious(seq.size_hint()));
863
864 while let Some(value) = try!(seq.next_element()) {
865 values.push(value);
866 }
867
868 Ok(values)
869 }
870 }
871
872 let visitor = VecVisitor {
873 marker: PhantomData,
874 };
875 deserializer.deserialize_seq(visitor)
876 }
877
deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>,878 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
879 where
880 D: Deserializer<'de>,
881 {
882 struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
883
884 impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
885 where
886 T: Deserialize<'de>,
887 {
888 type Value = ();
889
890 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
891 formatter.write_str("a sequence")
892 }
893
894 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
895 where
896 A: SeqAccess<'de>,
897 {
898 let hint = size_hint::cautious(seq.size_hint());
899 if let Some(additional) = hint.checked_sub(self.0.len()) {
900 self.0.reserve(additional);
901 }
902
903 for i in 0..self.0.len() {
904 let next = {
905 let next_place = InPlaceSeed(&mut self.0[i]);
906 try!(seq.next_element_seed(next_place))
907 };
908 if next.is_none() {
909 self.0.truncate(i);
910 return Ok(());
911 }
912 }
913
914 while let Some(value) = try!(seq.next_element()) {
915 self.0.push(value);
916 }
917
918 Ok(())
919 }
920 }
921
922 deserializer.deserialize_seq(VecInPlaceVisitor(place))
923 }
924 }
925
926 ////////////////////////////////////////////////////////////////////////////////
927
928 struct ArrayVisitor<A> {
929 marker: PhantomData<A>,
930 }
931 struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
932
933 impl<A> ArrayVisitor<A> {
new() -> Self934 fn new() -> Self {
935 ArrayVisitor {
936 marker: PhantomData,
937 }
938 }
939 }
940
941 impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
942 type Value = [T; 0];
943
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result944 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
945 formatter.write_str("an empty array")
946 }
947
948 #[inline]
visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,949 fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
950 where
951 A: SeqAccess<'de>,
952 {
953 Ok([])
954 }
955 }
956
957 // Does not require T: Deserialize<'de>.
958 impl<'de, T> Deserialize<'de> for [T; 0] {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,959 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
960 where
961 D: Deserializer<'de>,
962 {
963 deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new())
964 }
965 }
966
967 macro_rules! array_impls {
968 ($($len:expr => ($($n:tt)+))+) => {
969 $(
970 impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
971 where
972 T: Deserialize<'de>,
973 {
974 type Value = [T; $len];
975
976 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
977 formatter.write_str(concat!("an array of length ", $len))
978 }
979
980 #[inline]
981 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
982 where
983 A: SeqAccess<'de>,
984 {
985 Ok([$(
986 match try!(seq.next_element()) {
987 Some(val) => val,
988 None => return Err(Error::invalid_length($n, &self)),
989 }
990 ),+])
991 }
992 }
993
994 impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]>
995 where
996 T: Deserialize<'de>,
997 {
998 type Value = ();
999
1000 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1001 formatter.write_str(concat!("an array of length ", $len))
1002 }
1003
1004 #[inline]
1005 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1006 where
1007 A: SeqAccess<'de>,
1008 {
1009 let mut fail_idx = None;
1010 for (idx, dest) in self.0[..].iter_mut().enumerate() {
1011 if try!(seq.next_element_seed(InPlaceSeed(dest))).is_none() {
1012 fail_idx = Some(idx);
1013 break;
1014 }
1015 }
1016 if let Some(idx) = fail_idx {
1017 return Err(Error::invalid_length(idx, &self));
1018 }
1019 Ok(())
1020 }
1021 }
1022
1023 impl<'de, T> Deserialize<'de> for [T; $len]
1024 where
1025 T: Deserialize<'de>,
1026 {
1027 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1028 where
1029 D: Deserializer<'de>,
1030 {
1031 deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new())
1032 }
1033
1034 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
1035 where
1036 D: Deserializer<'de>,
1037 {
1038 deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place))
1039 }
1040 }
1041 )+
1042 }
1043 }
1044
1045 array_impls! {
1046 1 => (0)
1047 2 => (0 1)
1048 3 => (0 1 2)
1049 4 => (0 1 2 3)
1050 5 => (0 1 2 3 4)
1051 6 => (0 1 2 3 4 5)
1052 7 => (0 1 2 3 4 5 6)
1053 8 => (0 1 2 3 4 5 6 7)
1054 9 => (0 1 2 3 4 5 6 7 8)
1055 10 => (0 1 2 3 4 5 6 7 8 9)
1056 11 => (0 1 2 3 4 5 6 7 8 9 10)
1057 12 => (0 1 2 3 4 5 6 7 8 9 10 11)
1058 13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
1059 14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
1060 15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
1061 16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
1062 17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
1063 18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
1064 19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
1065 20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
1066 21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
1067 22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
1068 23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
1069 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)
1070 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)
1071 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)
1072 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)
1073 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)
1074 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)
1075 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)
1076 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)
1077 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)
1078 }
1079
1080 ////////////////////////////////////////////////////////////////////////////////
1081
1082 macro_rules! tuple_impls {
1083 ($($len:tt => ($($n:tt $name:ident)+))+) => {
1084 $(
1085 impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
1086 #[inline]
1087 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1088 where
1089 D: Deserializer<'de>,
1090 {
1091 struct TupleVisitor<$($name,)+> {
1092 marker: PhantomData<($($name,)+)>,
1093 }
1094
1095 impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> {
1096 type Value = ($($name,)+);
1097
1098 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1099 formatter.write_str(concat!("a tuple of size ", $len))
1100 }
1101
1102 #[inline]
1103 #[allow(non_snake_case)]
1104 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1105 where
1106 A: SeqAccess<'de>,
1107 {
1108 $(
1109 let $name = match try!(seq.next_element()) {
1110 Some(value) => value,
1111 None => return Err(Error::invalid_length($n, &self)),
1112 };
1113 )+
1114
1115 Ok(($($name,)+))
1116 }
1117 }
1118
1119 deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
1120 }
1121
1122 #[inline]
1123 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
1124 where
1125 D: Deserializer<'de>,
1126 {
1127 struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+));
1128
1129 impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> {
1130 type Value = ();
1131
1132 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1133 formatter.write_str(concat!("a tuple of size ", $len))
1134 }
1135
1136 #[inline]
1137 #[allow(non_snake_case)]
1138 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1139 where
1140 A: SeqAccess<'de>,
1141 {
1142 $(
1143 if try!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() {
1144 return Err(Error::invalid_length($n, &self));
1145 }
1146 )+
1147
1148 Ok(())
1149 }
1150 }
1151
1152 deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place))
1153 }
1154 }
1155 )+
1156 }
1157 }
1158
1159 tuple_impls! {
1160 1 => (0 T0)
1161 2 => (0 T0 1 T1)
1162 3 => (0 T0 1 T1 2 T2)
1163 4 => (0 T0 1 T1 2 T2 3 T3)
1164 5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
1165 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
1166 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
1167 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
1168 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
1169 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
1170 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
1171 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)
1172 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)
1173 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)
1174 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)
1175 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)
1176 }
1177
1178 ////////////////////////////////////////////////////////////////////////////////
1179
1180 #[cfg(any(feature = "std", feature = "alloc"))]
1181 macro_rules! map_impl {
1182 (
1183 $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
1184 $access:ident,
1185 $with_capacity:expr
1186 ) => {
1187 impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
1188 where
1189 K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1190 V: Deserialize<'de>,
1191 $($typaram: $bound1 $(+ $bound2)*),*
1192 {
1193 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1194 where
1195 D: Deserializer<'de>,
1196 {
1197 struct MapVisitor<K, V $(, $typaram)*> {
1198 marker: PhantomData<$ty<K, V $(, $typaram)*>>,
1199 }
1200
1201 impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
1202 where
1203 K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1204 V: Deserialize<'de>,
1205 $($typaram: $bound1 $(+ $bound2)*),*
1206 {
1207 type Value = $ty<K, V $(, $typaram)*>;
1208
1209 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1210 formatter.write_str("a map")
1211 }
1212
1213 #[inline]
1214 fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
1215 where
1216 A: MapAccess<'de>,
1217 {
1218 let mut values = $with_capacity;
1219
1220 while let Some((key, value)) = try!($access.next_entry()) {
1221 values.insert(key, value);
1222 }
1223
1224 Ok(values)
1225 }
1226 }
1227
1228 let visitor = MapVisitor { marker: PhantomData };
1229 deserializer.deserialize_map(visitor)
1230 }
1231 }
1232 }
1233 }
1234
1235 #[cfg(any(feature = "std", feature = "alloc"))]
1236 map_impl!(
1237 BTreeMap<K: Ord, V>,
1238 map,
1239 BTreeMap::new());
1240
1241 #[cfg(feature = "std")]
1242 map_impl!(
1243 HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
1244 map,
1245 HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
1246
1247 ////////////////////////////////////////////////////////////////////////////////
1248
1249 #[cfg(feature = "std")]
1250 macro_rules! parse_ip_impl {
1251 ($expecting:tt $ty:ty; $size:tt) => {
1252 impl<'de> Deserialize<'de> for $ty {
1253 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1254 where
1255 D: Deserializer<'de>,
1256 {
1257 if deserializer.is_human_readable() {
1258 struct IpAddrVisitor;
1259
1260 impl<'de> Visitor<'de> for IpAddrVisitor {
1261 type Value = $ty;
1262
1263 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1264 formatter.write_str($expecting)
1265 }
1266
1267 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1268 where
1269 E: Error,
1270 {
1271 s.parse().map_err(Error::custom)
1272 }
1273 }
1274
1275 deserializer.deserialize_str(IpAddrVisitor)
1276 } else {
1277 <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
1278 }
1279 }
1280 }
1281 };
1282 }
1283
1284 #[cfg(feature = "std")]
1285 macro_rules! variant_identifier {
1286 (
1287 $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1288 $expecting_message: expr,
1289 $variants_name: ident
1290 ) => {
1291 enum $name_kind {
1292 $( $variant ),*
1293 }
1294
1295 static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];
1296
1297 impl<'de> Deserialize<'de> for $name_kind {
1298 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1299 where
1300 D: Deserializer<'de>,
1301 {
1302 struct KindVisitor;
1303
1304 impl<'de> Visitor<'de> for KindVisitor {
1305 type Value = $name_kind;
1306
1307 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1308 formatter.write_str($expecting_message)
1309 }
1310
1311 fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
1312 where
1313 E: Error,
1314 {
1315 match value {
1316 $(
1317 $index => Ok($name_kind :: $variant),
1318 )*
1319 _ => Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),),
1320 }
1321 }
1322
1323 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1324 where
1325 E: Error,
1326 {
1327 match value {
1328 $(
1329 stringify!($variant) => Ok($name_kind :: $variant),
1330 )*
1331 _ => Err(Error::unknown_variant(value, $variants_name)),
1332 }
1333 }
1334
1335 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1336 where
1337 E: Error,
1338 {
1339 match value {
1340 $(
1341 $bytes => Ok($name_kind :: $variant),
1342 )*
1343 _ => {
1344 match str::from_utf8(value) {
1345 Ok(value) => Err(Error::unknown_variant(value, $variants_name)),
1346 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
1347 }
1348 }
1349 }
1350 }
1351 }
1352
1353 deserializer.deserialize_identifier(KindVisitor)
1354 }
1355 }
1356 }
1357 }
1358
1359 #[cfg(feature = "std")]
1360 macro_rules! deserialize_enum {
1361 (
1362 $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1363 $expecting_message: expr,
1364 $deserializer: expr
1365 ) => {
1366 variant_identifier!{
1367 $name_kind ( $($variant; $bytes; $index),* )
1368 $expecting_message,
1369 VARIANTS
1370 }
1371
1372 struct EnumVisitor;
1373 impl<'de> Visitor<'de> for EnumVisitor {
1374 type Value = $name;
1375
1376 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1377 formatter.write_str(concat!("a ", stringify!($name)))
1378 }
1379
1380
1381 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1382 where
1383 A: EnumAccess<'de>,
1384 {
1385 match try!(data.variant()) {
1386 $(
1387 ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant),
1388 )*
1389 }
1390 }
1391 }
1392 $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor)
1393 }
1394 }
1395
1396 #[cfg(feature = "std")]
1397 impl<'de> Deserialize<'de> for net::IpAddr {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1398 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1399 where
1400 D: Deserializer<'de>,
1401 {
1402 if deserializer.is_human_readable() {
1403 struct IpAddrVisitor;
1404
1405 impl<'de> Visitor<'de> for IpAddrVisitor {
1406 type Value = net::IpAddr;
1407
1408 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1409 formatter.write_str("IP address")
1410 }
1411
1412 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1413 where
1414 E: Error,
1415 {
1416 s.parse().map_err(Error::custom)
1417 }
1418 }
1419
1420 deserializer.deserialize_str(IpAddrVisitor)
1421 } else {
1422 use lib::net::IpAddr;
1423 deserialize_enum! {
1424 IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1425 "`V4` or `V6`",
1426 deserializer
1427 }
1428 }
1429 }
1430 }
1431
1432 #[cfg(feature = "std")]
1433 parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
1434
1435 #[cfg(feature = "std")]
1436 parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
1437
1438 #[cfg(feature = "std")]
1439 macro_rules! parse_socket_impl {
1440 ($expecting:tt $ty:ty, $new:expr) => {
1441 impl<'de> Deserialize<'de> for $ty {
1442 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1443 where
1444 D: Deserializer<'de>,
1445 {
1446 if deserializer.is_human_readable() {
1447 struct SocketAddrVisitor;
1448
1449 impl<'de> Visitor<'de> for SocketAddrVisitor {
1450 type Value = $ty;
1451
1452 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1453 formatter.write_str($expecting)
1454 }
1455
1456 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1457 where
1458 E: Error,
1459 {
1460 s.parse().map_err(Error::custom)
1461 }
1462 }
1463
1464 deserializer.deserialize_str(SocketAddrVisitor)
1465 } else {
1466 <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
1467 }
1468 }
1469 }
1470 };
1471 }
1472
1473 #[cfg(feature = "std")]
1474 impl<'de> Deserialize<'de> for net::SocketAddr {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1475 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1476 where
1477 D: Deserializer<'de>,
1478 {
1479 if deserializer.is_human_readable() {
1480 struct SocketAddrVisitor;
1481
1482 impl<'de> Visitor<'de> for SocketAddrVisitor {
1483 type Value = net::SocketAddr;
1484
1485 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1486 formatter.write_str("socket address")
1487 }
1488
1489 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1490 where
1491 E: Error,
1492 {
1493 s.parse().map_err(Error::custom)
1494 }
1495 }
1496
1497 deserializer.deserialize_str(SocketAddrVisitor)
1498 } else {
1499 use lib::net::SocketAddr;
1500 deserialize_enum! {
1501 SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1502 "`V4` or `V6`",
1503 deserializer
1504 }
1505 }
1506 }
1507 }
1508
1509 #[cfg(feature = "std")]
1510 parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
1511
1512 #[cfg(feature = "std")]
1513 parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
1514 ip, port, 0, 0
1515 ));
1516
1517 ////////////////////////////////////////////////////////////////////////////////
1518
1519 #[cfg(feature = "std")]
1520 struct PathVisitor;
1521
1522 #[cfg(feature = "std")]
1523 impl<'a> Visitor<'a> for PathVisitor {
1524 type Value = &'a Path;
1525
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1526 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1527 formatter.write_str("a borrowed path")
1528 }
1529
visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E> where E: Error,1530 fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
1531 where
1532 E: Error,
1533 {
1534 Ok(v.as_ref())
1535 }
1536
visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E> where E: Error,1537 fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
1538 where
1539 E: Error,
1540 {
1541 str::from_utf8(v)
1542 .map(AsRef::as_ref)
1543 .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
1544 }
1545 }
1546
1547 #[cfg(feature = "std")]
1548 impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1549 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1550 where
1551 D: Deserializer<'de>,
1552 {
1553 deserializer.deserialize_str(PathVisitor)
1554 }
1555 }
1556
1557 #[cfg(feature = "std")]
1558 struct PathBufVisitor;
1559
1560 #[cfg(feature = "std")]
1561 impl<'de> Visitor<'de> for PathBufVisitor {
1562 type Value = PathBuf;
1563
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1564 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1565 formatter.write_str("path string")
1566 }
1567
visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error,1568 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1569 where
1570 E: Error,
1571 {
1572 Ok(From::from(v))
1573 }
1574
visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error,1575 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1576 where
1577 E: Error,
1578 {
1579 Ok(From::from(v))
1580 }
1581 }
1582
1583 #[cfg(feature = "std")]
1584 impl<'de> Deserialize<'de> for PathBuf {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1585 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1586 where
1587 D: Deserializer<'de>,
1588 {
1589 deserializer.deserialize_string(PathBufVisitor)
1590 }
1591 }
1592
1593 ////////////////////////////////////////////////////////////////////////////////
1594
1595 // If this were outside of the serde crate, it would just use:
1596 //
1597 // #[derive(Deserialize)]
1598 // #[serde(variant_identifier)]
1599 #[cfg(all(feature = "std", any(unix, windows)))]
1600 variant_identifier! {
1601 OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
1602 "`Unix` or `Windows`",
1603 OSSTR_VARIANTS
1604 }
1605
1606 #[cfg(all(feature = "std", any(unix, windows)))]
1607 struct OsStringVisitor;
1608
1609 #[cfg(all(feature = "std", any(unix, windows)))]
1610 impl<'de> Visitor<'de> for OsStringVisitor {
1611 type Value = OsString;
1612
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result1613 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1614 formatter.write_str("os string")
1615 }
1616
1617 #[cfg(unix)]
visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where A: EnumAccess<'de>,1618 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1619 where
1620 A: EnumAccess<'de>,
1621 {
1622 use std::os::unix::ffi::OsStringExt;
1623
1624 match try!(data.variant()) {
1625 (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
1626 (OsStringKind::Windows, _) => Err(Error::custom(
1627 "cannot deserialize Windows OS string on Unix",
1628 )),
1629 }
1630 }
1631
1632 #[cfg(windows)]
visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where A: EnumAccess<'de>,1633 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1634 where
1635 A: EnumAccess<'de>,
1636 {
1637 use std::os::windows::ffi::OsStringExt;
1638
1639 match try!(data.variant()) {
1640 (OsStringKind::Windows, v) => v
1641 .newtype_variant::<Vec<u16>>()
1642 .map(|vec| OsString::from_wide(&vec)),
1643 (OsStringKind::Unix, _) => Err(Error::custom(
1644 "cannot deserialize Unix OS string on Windows",
1645 )),
1646 }
1647 }
1648 }
1649
1650 #[cfg(all(feature = "std", any(unix, windows)))]
1651 impl<'de> Deserialize<'de> for OsString {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1652 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1653 where
1654 D: Deserializer<'de>,
1655 {
1656 deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
1657 }
1658 }
1659
1660 ////////////////////////////////////////////////////////////////////////////////
1661
1662 #[cfg(any(feature = "std", feature = "alloc"))]
1663 forwarded_impl!((T), Box<T>, Box::new);
1664
1665 #[cfg(any(feature = "std", feature = "alloc"))]
1666 forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
1667
1668 #[cfg(any(feature = "std", feature = "alloc"))]
1669 forwarded_impl!((), Box<str>, String::into_boxed_str);
1670
1671 #[cfg(all(
1672 not(de_rc_dst),
1673 feature = "rc",
1674 any(feature = "std", feature = "alloc")
1675 ))]
1676 forwarded_impl! {
1677 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1678 ///
1679 /// Deserializing a data structure containing `Arc` will not attempt to
1680 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1681 /// will end up with a strong count of 1.
1682 ///
1683 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1684 (T), Arc<T>, Arc::new
1685 }
1686
1687 #[cfg(all(
1688 not(de_rc_dst),
1689 feature = "rc",
1690 any(feature = "std", feature = "alloc")
1691 ))]
1692 forwarded_impl! {
1693 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1694 ///
1695 /// Deserializing a data structure containing `Rc` will not attempt to
1696 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1697 /// will end up with a strong count of 1.
1698 ///
1699 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1700 (T), Rc<T>, Rc::new
1701 }
1702
1703 #[cfg(any(feature = "std", feature = "alloc"))]
1704 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
1705 where
1706 T: ToOwned,
1707 T::Owned: Deserialize<'de>,
1708 {
1709 #[inline]
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1710 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1711 where
1712 D: Deserializer<'de>,
1713 {
1714 T::Owned::deserialize(deserializer).map(Cow::Owned)
1715 }
1716 }
1717
1718 ////////////////////////////////////////////////////////////////////////////////
1719
1720 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1721 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1722 ///
1723 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1724 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1725 impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
1726 where
1727 T: Deserialize<'de>,
1728 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1729 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1730 where
1731 D: Deserializer<'de>,
1732 {
1733 try!(Option::<T>::deserialize(deserializer));
1734 Ok(RcWeak::new())
1735 }
1736 }
1737
1738 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1739 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1740 ///
1741 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1742 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1743 impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
1744 where
1745 T: Deserialize<'de>,
1746 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1747 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1748 where
1749 D: Deserializer<'de>,
1750 {
1751 try!(Option::<T>::deserialize(deserializer));
1752 Ok(ArcWeak::new())
1753 }
1754 }
1755
1756 ////////////////////////////////////////////////////////////////////////////////
1757
1758 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1759 macro_rules! box_forwarded_impl {
1760 (
1761 $(#[doc = $doc:tt])*
1762 $t:ident
1763 ) => {
1764 $(#[doc = $doc])*
1765 impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
1766 where
1767 Box<T>: Deserialize<'de>,
1768 {
1769 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1770 where
1771 D: Deserializer<'de>,
1772 {
1773 Box::deserialize(deserializer).map(Into::into)
1774 }
1775 }
1776 };
1777 }
1778
1779 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1780 box_forwarded_impl! {
1781 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1782 ///
1783 /// Deserializing a data structure containing `Rc` will not attempt to
1784 /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1785 /// will end up with a strong count of 1.
1786 ///
1787 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1788 Rc
1789 }
1790
1791 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1792 box_forwarded_impl! {
1793 /// This impl requires the [`"rc"`] Cargo feature of Serde.
1794 ///
1795 /// Deserializing a data structure containing `Arc` will not attempt to
1796 /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1797 /// will end up with a strong count of 1.
1798 ///
1799 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1800 Arc
1801 }
1802
1803 ////////////////////////////////////////////////////////////////////////////////
1804
1805 impl<'de, T> Deserialize<'de> for Cell<T>
1806 where
1807 T: Deserialize<'de> + Copy,
1808 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1809 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1810 where
1811 D: Deserializer<'de>,
1812 {
1813 T::deserialize(deserializer).map(Cell::new)
1814 }
1815 }
1816
1817 forwarded_impl!((T), RefCell<T>, RefCell::new);
1818
1819 #[cfg(feature = "std")]
1820 forwarded_impl!((T), Mutex<T>, Mutex::new);
1821
1822 #[cfg(feature = "std")]
1823 forwarded_impl!((T), RwLock<T>, RwLock::new);
1824
1825 ////////////////////////////////////////////////////////////////////////////////
1826
1827 // This is a cleaned-up version of the impl generated by:
1828 //
1829 // #[derive(Deserialize)]
1830 // #[serde(deny_unknown_fields)]
1831 // struct Duration {
1832 // secs: u64,
1833 // nanos: u32,
1834 // }
1835 #[cfg(any(core_duration, feature = "std"))]
1836 impl<'de> Deserialize<'de> for Duration {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1837 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1838 where
1839 D: Deserializer<'de>,
1840 {
1841 // If this were outside of the serde crate, it would just use:
1842 //
1843 // #[derive(Deserialize)]
1844 // #[serde(field_identifier, rename_all = "lowercase")]
1845 enum Field {
1846 Secs,
1847 Nanos,
1848 };
1849
1850 impl<'de> Deserialize<'de> for Field {
1851 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1852 where
1853 D: Deserializer<'de>,
1854 {
1855 struct FieldVisitor;
1856
1857 impl<'de> Visitor<'de> for FieldVisitor {
1858 type Value = Field;
1859
1860 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1861 formatter.write_str("`secs` or `nanos`")
1862 }
1863
1864 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1865 where
1866 E: Error,
1867 {
1868 match value {
1869 "secs" => Ok(Field::Secs),
1870 "nanos" => Ok(Field::Nanos),
1871 _ => Err(Error::unknown_field(value, FIELDS)),
1872 }
1873 }
1874
1875 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1876 where
1877 E: Error,
1878 {
1879 match value {
1880 b"secs" => Ok(Field::Secs),
1881 b"nanos" => Ok(Field::Nanos),
1882 _ => {
1883 let value = ::export::from_utf8_lossy(value);
1884 Err(Error::unknown_field(&value, FIELDS))
1885 }
1886 }
1887 }
1888 }
1889
1890 deserializer.deserialize_identifier(FieldVisitor)
1891 }
1892 }
1893
1894 struct DurationVisitor;
1895
1896 impl<'de> Visitor<'de> for DurationVisitor {
1897 type Value = Duration;
1898
1899 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1900 formatter.write_str("struct Duration")
1901 }
1902
1903 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1904 where
1905 A: SeqAccess<'de>,
1906 {
1907 let secs: u64 = match try!(seq.next_element()) {
1908 Some(value) => value,
1909 None => {
1910 return Err(Error::invalid_length(0, &self));
1911 }
1912 };
1913 let nanos: u32 = match try!(seq.next_element()) {
1914 Some(value) => value,
1915 None => {
1916 return Err(Error::invalid_length(1, &self));
1917 }
1918 };
1919 Ok(Duration::new(secs, nanos))
1920 }
1921
1922 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1923 where
1924 A: MapAccess<'de>,
1925 {
1926 let mut secs: Option<u64> = None;
1927 let mut nanos: Option<u32> = None;
1928 while let Some(key) = try!(map.next_key()) {
1929 match key {
1930 Field::Secs => {
1931 if secs.is_some() {
1932 return Err(<A::Error as Error>::duplicate_field("secs"));
1933 }
1934 secs = Some(try!(map.next_value()));
1935 }
1936 Field::Nanos => {
1937 if nanos.is_some() {
1938 return Err(<A::Error as Error>::duplicate_field("nanos"));
1939 }
1940 nanos = Some(try!(map.next_value()));
1941 }
1942 }
1943 }
1944 let secs = match secs {
1945 Some(secs) => secs,
1946 None => return Err(<A::Error as Error>::missing_field("secs")),
1947 };
1948 let nanos = match nanos {
1949 Some(nanos) => nanos,
1950 None => return Err(<A::Error as Error>::missing_field("nanos")),
1951 };
1952 Ok(Duration::new(secs, nanos))
1953 }
1954 }
1955
1956 const FIELDS: &'static [&'static str] = &["secs", "nanos"];
1957 deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
1958 }
1959 }
1960
1961 ////////////////////////////////////////////////////////////////////////////////
1962
1963 #[cfg(feature = "std")]
1964 impl<'de> Deserialize<'de> for SystemTime {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,1965 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1966 where
1967 D: Deserializer<'de>,
1968 {
1969 // Reuse duration
1970 enum Field {
1971 Secs,
1972 Nanos,
1973 };
1974
1975 impl<'de> Deserialize<'de> for Field {
1976 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1977 where
1978 D: Deserializer<'de>,
1979 {
1980 struct FieldVisitor;
1981
1982 impl<'de> Visitor<'de> for FieldVisitor {
1983 type Value = Field;
1984
1985 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1986 formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
1987 }
1988
1989 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1990 where
1991 E: Error,
1992 {
1993 match value {
1994 "secs_since_epoch" => Ok(Field::Secs),
1995 "nanos_since_epoch" => Ok(Field::Nanos),
1996 _ => Err(Error::unknown_field(value, FIELDS)),
1997 }
1998 }
1999
2000 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2001 where
2002 E: Error,
2003 {
2004 match value {
2005 b"secs_since_epoch" => Ok(Field::Secs),
2006 b"nanos_since_epoch" => Ok(Field::Nanos),
2007 _ => {
2008 let value = String::from_utf8_lossy(value);
2009 Err(Error::unknown_field(&value, FIELDS))
2010 }
2011 }
2012 }
2013 }
2014
2015 deserializer.deserialize_identifier(FieldVisitor)
2016 }
2017 }
2018
2019 struct DurationVisitor;
2020
2021 impl<'de> Visitor<'de> for DurationVisitor {
2022 type Value = Duration;
2023
2024 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2025 formatter.write_str("struct SystemTime")
2026 }
2027
2028 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2029 where
2030 A: SeqAccess<'de>,
2031 {
2032 let secs: u64 = match try!(seq.next_element()) {
2033 Some(value) => value,
2034 None => {
2035 return Err(Error::invalid_length(0, &self));
2036 }
2037 };
2038 let nanos: u32 = match try!(seq.next_element()) {
2039 Some(value) => value,
2040 None => {
2041 return Err(Error::invalid_length(1, &self));
2042 }
2043 };
2044 Ok(Duration::new(secs, nanos))
2045 }
2046
2047 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2048 where
2049 A: MapAccess<'de>,
2050 {
2051 let mut secs: Option<u64> = None;
2052 let mut nanos: Option<u32> = None;
2053 while let Some(key) = try!(map.next_key()) {
2054 match key {
2055 Field::Secs => {
2056 if secs.is_some() {
2057 return Err(<A::Error as Error>::duplicate_field(
2058 "secs_since_epoch",
2059 ));
2060 }
2061 secs = Some(try!(map.next_value()));
2062 }
2063 Field::Nanos => {
2064 if nanos.is_some() {
2065 return Err(<A::Error as Error>::duplicate_field(
2066 "nanos_since_epoch",
2067 ));
2068 }
2069 nanos = Some(try!(map.next_value()));
2070 }
2071 }
2072 }
2073 let secs = match secs {
2074 Some(secs) => secs,
2075 None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
2076 };
2077 let nanos = match nanos {
2078 Some(nanos) => nanos,
2079 None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
2080 };
2081 Ok(Duration::new(secs, nanos))
2082 }
2083 }
2084
2085 const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
2086 let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
2087 Ok(UNIX_EPOCH + duration)
2088 }
2089 }
2090
2091 ////////////////////////////////////////////////////////////////////////////////
2092
2093 // Similar to:
2094 //
2095 // #[derive(Deserialize)]
2096 // #[serde(deny_unknown_fields)]
2097 // struct Range {
2098 // start: u64,
2099 // end: u32,
2100 // }
2101 impl<'de, Idx> Deserialize<'de> for Range<Idx>
2102 where
2103 Idx: Deserialize<'de>,
2104 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2105 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2106 where
2107 D: Deserializer<'de>,
2108 {
2109 let (start, end) = deserializer.deserialize_struct(
2110 "Range",
2111 range::FIELDS,
2112 range::RangeVisitor {
2113 expecting: "struct Range",
2114 phantom: PhantomData,
2115 },
2116 )?;
2117 Ok(start..end)
2118 }
2119 }
2120
2121 #[cfg(range_inclusive)]
2122 impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
2123 where
2124 Idx: Deserialize<'de>,
2125 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2126 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2127 where
2128 D: Deserializer<'de>,
2129 {
2130 let (start, end) = deserializer.deserialize_struct(
2131 "RangeInclusive",
2132 range::FIELDS,
2133 range::RangeVisitor {
2134 expecting: "struct RangeInclusive",
2135 phantom: PhantomData,
2136 },
2137 )?;
2138 Ok(RangeInclusive::new(start, end))
2139 }
2140 }
2141
2142 mod range {
2143 use lib::*;
2144
2145 use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
2146
2147 pub const FIELDS: &'static [&'static str] = &["start", "end"];
2148
2149 // If this were outside of the serde crate, it would just use:
2150 //
2151 // #[derive(Deserialize)]
2152 // #[serde(field_identifier, rename_all = "lowercase")]
2153 enum Field {
2154 Start,
2155 End,
2156 }
2157
2158 impl<'de> Deserialize<'de> for Field {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2159 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2160 where
2161 D: Deserializer<'de>,
2162 {
2163 struct FieldVisitor;
2164
2165 impl<'de> Visitor<'de> for FieldVisitor {
2166 type Value = Field;
2167
2168 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2169 formatter.write_str("`start` or `end`")
2170 }
2171
2172 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2173 where
2174 E: Error,
2175 {
2176 match value {
2177 "start" => Ok(Field::Start),
2178 "end" => Ok(Field::End),
2179 _ => Err(Error::unknown_field(value, FIELDS)),
2180 }
2181 }
2182
2183 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2184 where
2185 E: Error,
2186 {
2187 match value {
2188 b"start" => Ok(Field::Start),
2189 b"end" => Ok(Field::End),
2190 _ => {
2191 let value = ::export::from_utf8_lossy(value);
2192 Err(Error::unknown_field(&value, FIELDS))
2193 }
2194 }
2195 }
2196 }
2197
2198 deserializer.deserialize_identifier(FieldVisitor)
2199 }
2200 }
2201
2202 pub struct RangeVisitor<Idx> {
2203 pub expecting: &'static str,
2204 pub phantom: PhantomData<Idx>,
2205 }
2206
2207 impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
2208 where
2209 Idx: Deserialize<'de>,
2210 {
2211 type Value = (Idx, Idx);
2212
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result2213 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2214 formatter.write_str(self.expecting)
2215 }
2216
visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,2217 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2218 where
2219 A: SeqAccess<'de>,
2220 {
2221 let start: Idx = match try!(seq.next_element()) {
2222 Some(value) => value,
2223 None => {
2224 return Err(Error::invalid_length(0, &self));
2225 }
2226 };
2227 let end: Idx = match try!(seq.next_element()) {
2228 Some(value) => value,
2229 None => {
2230 return Err(Error::invalid_length(1, &self));
2231 }
2232 };
2233 Ok((start, end))
2234 }
2235
visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: MapAccess<'de>,2236 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2237 where
2238 A: MapAccess<'de>,
2239 {
2240 let mut start: Option<Idx> = None;
2241 let mut end: Option<Idx> = None;
2242 while let Some(key) = try!(map.next_key()) {
2243 match key {
2244 Field::Start => {
2245 if start.is_some() {
2246 return Err(<A::Error as Error>::duplicate_field("start"));
2247 }
2248 start = Some(try!(map.next_value()));
2249 }
2250 Field::End => {
2251 if end.is_some() {
2252 return Err(<A::Error as Error>::duplicate_field("end"));
2253 }
2254 end = Some(try!(map.next_value()));
2255 }
2256 }
2257 }
2258 let start = match start {
2259 Some(start) => start,
2260 None => return Err(<A::Error as Error>::missing_field("start")),
2261 };
2262 let end = match end {
2263 Some(end) => end,
2264 None => return Err(<A::Error as Error>::missing_field("end")),
2265 };
2266 Ok((start, end))
2267 }
2268 }
2269 }
2270
2271 ////////////////////////////////////////////////////////////////////////////////
2272
2273 #[cfg(any(ops_bound, collections_bound))]
2274 impl<'de, T> Deserialize<'de> for Bound<T>
2275 where
2276 T: Deserialize<'de>,
2277 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2278 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2279 where
2280 D: Deserializer<'de>,
2281 {
2282 enum Field {
2283 Unbounded,
2284 Included,
2285 Excluded,
2286 }
2287
2288 impl<'de> Deserialize<'de> for Field {
2289 #[inline]
2290 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2291 where
2292 D: Deserializer<'de>,
2293 {
2294 struct FieldVisitor;
2295
2296 impl<'de> Visitor<'de> for FieldVisitor {
2297 type Value = Field;
2298
2299 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2300 formatter.write_str("`Unbounded`, `Included` or `Excluded`")
2301 }
2302
2303 fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2304 where
2305 E: Error,
2306 {
2307 match value {
2308 0 => Ok(Field::Unbounded),
2309 1 => Ok(Field::Included),
2310 2 => Ok(Field::Excluded),
2311 _ => Err(Error::invalid_value(
2312 Unexpected::Unsigned(value as u64),
2313 &self,
2314 )),
2315 }
2316 }
2317
2318 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2319 where
2320 E: Error,
2321 {
2322 match value {
2323 "Unbounded" => Ok(Field::Unbounded),
2324 "Included" => Ok(Field::Included),
2325 "Excluded" => Ok(Field::Excluded),
2326 _ => Err(Error::unknown_variant(value, VARIANTS)),
2327 }
2328 }
2329
2330 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2331 where
2332 E: Error,
2333 {
2334 match value {
2335 b"Unbounded" => Ok(Field::Unbounded),
2336 b"Included" => Ok(Field::Included),
2337 b"Excluded" => Ok(Field::Excluded),
2338 _ => match str::from_utf8(value) {
2339 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2340 Err(_) => {
2341 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2342 }
2343 },
2344 }
2345 }
2346 }
2347
2348 deserializer.deserialize_identifier(FieldVisitor)
2349 }
2350 }
2351
2352 struct BoundVisitor<T>(PhantomData<Bound<T>>);
2353
2354 impl<'de, T> Visitor<'de> for BoundVisitor<T>
2355 where
2356 T: Deserialize<'de>,
2357 {
2358 type Value = Bound<T>;
2359
2360 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2361 formatter.write_str("enum Bound")
2362 }
2363
2364 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2365 where
2366 A: EnumAccess<'de>,
2367 {
2368 match try!(data.variant()) {
2369 (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
2370 (Field::Included, v) => v.newtype_variant().map(Bound::Included),
2371 (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
2372 }
2373 }
2374 }
2375
2376 const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
2377
2378 deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
2379 }
2380 }
2381
2382 ////////////////////////////////////////////////////////////////////////////////
2383
2384 macro_rules! nonzero_integers {
2385 ( $( $T: ident, )+ ) => {
2386 $(
2387 #[cfg(num_nonzero)]
2388 impl<'de> Deserialize<'de> for num::$T {
2389 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2390 where
2391 D: Deserializer<'de>,
2392 {
2393 let value = try!(Deserialize::deserialize(deserializer));
2394 match <num::$T>::new(value) {
2395 Some(nonzero) => Ok(nonzero),
2396 None => Err(Error::custom("expected a non-zero value")),
2397 }
2398 }
2399 }
2400 )+
2401 };
2402 }
2403
2404 nonzero_integers! {
2405 // Not including signed NonZeroI* since they might be removed
2406 NonZeroU8,
2407 NonZeroU16,
2408 NonZeroU32,
2409 NonZeroU64,
2410 NonZeroUsize,
2411 }
2412
2413 // Currently 128-bit integers do not work on Emscripten targets so we need an
2414 // additional `#[cfg]`
2415 serde_if_integer128! {
2416 nonzero_integers! {
2417 NonZeroU128,
2418 }
2419 }
2420
2421 ////////////////////////////////////////////////////////////////////////////////
2422
2423 impl<'de, T, E> Deserialize<'de> for Result<T, E>
2424 where
2425 T: Deserialize<'de>,
2426 E: Deserialize<'de>,
2427 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2428 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2429 where
2430 D: Deserializer<'de>,
2431 {
2432 // If this were outside of the serde crate, it would just use:
2433 //
2434 // #[derive(Deserialize)]
2435 // #[serde(variant_identifier)]
2436 enum Field {
2437 Ok,
2438 Err,
2439 }
2440
2441 impl<'de> Deserialize<'de> for Field {
2442 #[inline]
2443 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2444 where
2445 D: Deserializer<'de>,
2446 {
2447 struct FieldVisitor;
2448
2449 impl<'de> Visitor<'de> for FieldVisitor {
2450 type Value = Field;
2451
2452 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2453 formatter.write_str("`Ok` or `Err`")
2454 }
2455
2456 fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2457 where
2458 E: Error,
2459 {
2460 match value {
2461 0 => Ok(Field::Ok),
2462 1 => Ok(Field::Err),
2463 _ => Err(Error::invalid_value(
2464 Unexpected::Unsigned(value as u64),
2465 &self,
2466 )),
2467 }
2468 }
2469
2470 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2471 where
2472 E: Error,
2473 {
2474 match value {
2475 "Ok" => Ok(Field::Ok),
2476 "Err" => Ok(Field::Err),
2477 _ => Err(Error::unknown_variant(value, VARIANTS)),
2478 }
2479 }
2480
2481 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2482 where
2483 E: Error,
2484 {
2485 match value {
2486 b"Ok" => Ok(Field::Ok),
2487 b"Err" => Ok(Field::Err),
2488 _ => match str::from_utf8(value) {
2489 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2490 Err(_) => {
2491 Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2492 }
2493 },
2494 }
2495 }
2496 }
2497
2498 deserializer.deserialize_identifier(FieldVisitor)
2499 }
2500 }
2501
2502 struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
2503
2504 impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
2505 where
2506 T: Deserialize<'de>,
2507 E: Deserialize<'de>,
2508 {
2509 type Value = Result<T, E>;
2510
2511 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2512 formatter.write_str("enum Result")
2513 }
2514
2515 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2516 where
2517 A: EnumAccess<'de>,
2518 {
2519 match try!(data.variant()) {
2520 (Field::Ok, v) => v.newtype_variant().map(Ok),
2521 (Field::Err, v) => v.newtype_variant().map(Err),
2522 }
2523 }
2524 }
2525
2526 const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
2527
2528 deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
2529 }
2530 }
2531
2532 ////////////////////////////////////////////////////////////////////////////////
2533
2534 #[cfg(feature = "std")]
2535 impl<'de, T> Deserialize<'de> for Wrapping<T>
2536 where
2537 T: Deserialize<'de>,
2538 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,2539 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2540 where
2541 D: Deserializer<'de>,
2542 {
2543 Deserialize::deserialize(deserializer).map(Wrapping)
2544 }
2545 }
2546