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