1 //! Building blocks for deserializing basic values using the `IntoDeserializer` 2 //! trait. 3 //! 4 //! ```edition2018 5 //! use std::str::FromStr; 6 //! use serde::Deserialize; 7 //! use serde::de::{value, IntoDeserializer}; 8 //! 9 //! #[derive(Deserialize)] 10 //! enum Setting { 11 //! On, 12 //! Off, 13 //! } 14 //! 15 //! impl FromStr for Setting { 16 //! type Err = value::Error; 17 //! 18 //! fn from_str(s: &str) -> Result<Self, Self::Err> { 19 //! Self::deserialize(s.into_deserializer()) 20 //! } 21 //! } 22 //! ``` 23 24 use lib::*; 25 26 use self::private::{First, Second}; 27 use __private::size_hint; 28 use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor}; 29 use ser; 30 31 //////////////////////////////////////////////////////////////////////////////// 32 33 // For structs that contain a PhantomData. We do not want the trait 34 // bound `E: Clone` inferred by derive(Clone). 35 macro_rules! impl_copy_clone { 36 ($ty:ident $(<$lifetime:tt>)*) => { 37 impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {} 38 39 impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> { 40 fn clone(&self) -> Self { 41 *self 42 } 43 } 44 }; 45 } 46 47 //////////////////////////////////////////////////////////////////////////////// 48 49 /// A minimal representation of all possible errors that can occur using the 50 /// `IntoDeserializer` trait. 51 #[derive(Clone, PartialEq)] 52 pub struct Error { 53 err: ErrorImpl, 54 } 55 56 #[cfg(any(feature = "std", feature = "alloc"))] 57 type ErrorImpl = Box<str>; 58 #[cfg(not(any(feature = "std", feature = "alloc")))] 59 type ErrorImpl = (); 60 61 impl de::Error for Error { 62 #[cfg(any(feature = "std", feature = "alloc"))] 63 #[cold] custom<T>(msg: T) -> Self where T: Display,64 fn custom<T>(msg: T) -> Self 65 where 66 T: Display, 67 { 68 Error { 69 err: msg.to_string().into_boxed_str(), 70 } 71 } 72 73 #[cfg(not(any(feature = "std", feature = "alloc")))] 74 #[cold] custom<T>(msg: T) -> Self where T: Display,75 fn custom<T>(msg: T) -> Self 76 where 77 T: Display, 78 { 79 let _ = msg; 80 Error { err: () } 81 } 82 } 83 84 impl ser::Error for Error { 85 #[cold] custom<T>(msg: T) -> Self where T: Display,86 fn custom<T>(msg: T) -> Self 87 where 88 T: Display, 89 { 90 de::Error::custom(msg) 91 } 92 } 93 94 impl Display for Error { 95 #[cfg(any(feature = "std", feature = "alloc"))] fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result96 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 97 formatter.write_str(&self.err) 98 } 99 100 #[cfg(not(any(feature = "std", feature = "alloc")))] fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result101 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 102 formatter.write_str("Serde deserialization error") 103 } 104 } 105 106 impl Debug for Error { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result107 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 108 let mut debug = formatter.debug_tuple("Error"); 109 #[cfg(any(feature = "std", feature = "alloc"))] 110 debug.field(&self.err); 111 debug.finish() 112 } 113 } 114 115 #[cfg(feature = "std")] 116 impl error::Error for Error { description(&self) -> &str117 fn description(&self) -> &str { 118 &self.err 119 } 120 } 121 122 //////////////////////////////////////////////////////////////////////////////// 123 124 impl<'de, E> IntoDeserializer<'de, E> for () 125 where 126 E: de::Error, 127 { 128 type Deserializer = UnitDeserializer<E>; 129 into_deserializer(self) -> UnitDeserializer<E>130 fn into_deserializer(self) -> UnitDeserializer<E> { 131 UnitDeserializer { 132 marker: PhantomData, 133 } 134 } 135 } 136 137 /// A deserializer holding a `()`. 138 pub struct UnitDeserializer<E> { 139 marker: PhantomData<E>, 140 } 141 142 impl_copy_clone!(UnitDeserializer); 143 144 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> 145 where 146 E: de::Error, 147 { 148 type Error = E; 149 150 forward_to_deserialize_any! { 151 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 152 bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct 153 map struct enum identifier ignored_any 154 } 155 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,156 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 157 where 158 V: de::Visitor<'de>, 159 { 160 visitor.visit_unit() 161 } 162 deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,163 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> 164 where 165 V: de::Visitor<'de>, 166 { 167 visitor.visit_none() 168 } 169 } 170 171 impl<E> Debug for UnitDeserializer<E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result172 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 173 formatter.debug_struct("UnitDeserializer").finish() 174 } 175 } 176 177 //////////////////////////////////////////////////////////////////////////////// 178 179 /// A deserializer that cannot be instantiated. 180 #[cfg(feature = "unstable")] 181 pub struct NeverDeserializer<E> { 182 never: !, 183 marker: PhantomData<E>, 184 } 185 186 #[cfg(feature = "unstable")] 187 impl<'de, E> IntoDeserializer<'de, E> for ! 188 where 189 E: de::Error, 190 { 191 type Deserializer = NeverDeserializer<E>; 192 into_deserializer(self) -> Self::Deserializer193 fn into_deserializer(self) -> Self::Deserializer { 194 self 195 } 196 } 197 198 #[cfg(feature = "unstable")] 199 impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E> 200 where 201 E: de::Error, 202 { 203 type Error = E; 204 deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,205 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error> 206 where 207 V: de::Visitor<'de>, 208 { 209 self.never 210 } 211 212 forward_to_deserialize_any! { 213 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 214 bytes byte_buf option unit unit_struct newtype_struct seq tuple 215 tuple_struct map struct enum identifier ignored_any 216 } 217 } 218 219 //////////////////////////////////////////////////////////////////////////////// 220 221 macro_rules! primitive_deserializer { 222 ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => { 223 #[doc = "A deserializer holding"] 224 #[doc = $doc] 225 pub struct $name<E> { 226 value: $ty, 227 marker: PhantomData<E> 228 } 229 230 impl_copy_clone!($name); 231 232 impl<'de, E> IntoDeserializer<'de, E> for $ty 233 where 234 E: de::Error, 235 { 236 type Deserializer = $name<E>; 237 238 fn into_deserializer(self) -> $name<E> { 239 $name { 240 value: self, 241 marker: PhantomData, 242 } 243 } 244 } 245 246 impl<'de, E> de::Deserializer<'de> for $name<E> 247 where 248 E: de::Error, 249 { 250 type Error = E; 251 252 forward_to_deserialize_any! { 253 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str 254 string bytes byte_buf option unit unit_struct newtype_struct seq 255 tuple tuple_struct map struct enum identifier ignored_any 256 } 257 258 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 259 where 260 V: de::Visitor<'de>, 261 { 262 visitor.$method(self.value $($cast)*) 263 } 264 } 265 266 impl<E> Debug for $name<E> { 267 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 268 formatter 269 .debug_struct(stringify!($name)) 270 .field("value", &self.value) 271 .finish() 272 } 273 } 274 } 275 } 276 277 primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool); 278 primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8); 279 primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16); 280 primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32); 281 primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64); 282 primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64); 283 primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8); 284 primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16); 285 primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64); 286 primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64); 287 primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32); 288 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64); 289 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char); 290 291 serde_if_integer128! { 292 primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128); 293 primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128); 294 } 295 296 /// A deserializer holding a `u32`. 297 pub struct U32Deserializer<E> { 298 value: u32, 299 marker: PhantomData<E>, 300 } 301 302 impl_copy_clone!(U32Deserializer); 303 304 impl<'de, E> IntoDeserializer<'de, E> for u32 305 where 306 E: de::Error, 307 { 308 type Deserializer = U32Deserializer<E>; 309 into_deserializer(self) -> U32Deserializer<E>310 fn into_deserializer(self) -> U32Deserializer<E> { 311 U32Deserializer { 312 value: self, 313 marker: PhantomData, 314 } 315 } 316 } 317 318 impl<'de, E> de::Deserializer<'de> for U32Deserializer<E> 319 where 320 E: de::Error, 321 { 322 type Error = E; 323 324 forward_to_deserialize_any! { 325 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 326 bytes byte_buf option unit unit_struct newtype_struct seq tuple 327 tuple_struct map struct identifier ignored_any 328 } 329 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,330 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 331 where 332 V: de::Visitor<'de>, 333 { 334 visitor.visit_u32(self.value) 335 } 336 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,337 fn deserialize_enum<V>( 338 self, 339 name: &str, 340 variants: &'static [&'static str], 341 visitor: V, 342 ) -> Result<V::Value, Self::Error> 343 where 344 V: de::Visitor<'de>, 345 { 346 let _ = name; 347 let _ = variants; 348 visitor.visit_enum(self) 349 } 350 } 351 352 impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E> 353 where 354 E: de::Error, 355 { 356 type Error = E; 357 type Variant = private::UnitOnly<E>; 358 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,359 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 360 where 361 T: de::DeserializeSeed<'de>, 362 { 363 seed.deserialize(self).map(private::unit_only) 364 } 365 } 366 367 impl<E> Debug for U32Deserializer<E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result368 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 369 formatter 370 .debug_struct("U32Deserializer") 371 .field("value", &self.value) 372 .finish() 373 } 374 } 375 376 //////////////////////////////////////////////////////////////////////////////// 377 378 /// A deserializer holding a `&str`. 379 pub struct StrDeserializer<'a, E> { 380 value: &'a str, 381 marker: PhantomData<E>, 382 } 383 384 impl_copy_clone!(StrDeserializer<'de>); 385 386 impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str 387 where 388 E: de::Error, 389 { 390 type Deserializer = StrDeserializer<'a, E>; 391 into_deserializer(self) -> StrDeserializer<'a, E>392 fn into_deserializer(self) -> StrDeserializer<'a, E> { 393 StrDeserializer { 394 value: self, 395 marker: PhantomData, 396 } 397 } 398 } 399 400 impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E> 401 where 402 E: de::Error, 403 { 404 type Error = E; 405 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,406 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 407 where 408 V: de::Visitor<'de>, 409 { 410 visitor.visit_str(self.value) 411 } 412 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,413 fn deserialize_enum<V>( 414 self, 415 name: &str, 416 variants: &'static [&'static str], 417 visitor: V, 418 ) -> Result<V::Value, Self::Error> 419 where 420 V: de::Visitor<'de>, 421 { 422 let _ = name; 423 let _ = variants; 424 visitor.visit_enum(self) 425 } 426 427 forward_to_deserialize_any! { 428 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 429 bytes byte_buf option unit unit_struct newtype_struct seq tuple 430 tuple_struct map struct identifier ignored_any 431 } 432 } 433 434 impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> 435 where 436 E: de::Error, 437 { 438 type Error = E; 439 type Variant = private::UnitOnly<E>; 440 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,441 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 442 where 443 T: de::DeserializeSeed<'de>, 444 { 445 seed.deserialize(self).map(private::unit_only) 446 } 447 } 448 449 impl<'a, E> Debug for StrDeserializer<'a, E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result450 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 451 formatter 452 .debug_struct("StrDeserializer") 453 .field("value", &self.value) 454 .finish() 455 } 456 } 457 458 //////////////////////////////////////////////////////////////////////////////// 459 460 /// A deserializer holding a `&str` with a lifetime tied to another 461 /// deserializer. 462 pub struct BorrowedStrDeserializer<'de, E> { 463 value: &'de str, 464 marker: PhantomData<E>, 465 } 466 467 impl_copy_clone!(BorrowedStrDeserializer<'de>); 468 469 impl<'de, E> BorrowedStrDeserializer<'de, E> { 470 /// Create a new borrowed deserializer from the given string. new(value: &'de str) -> BorrowedStrDeserializer<'de, E>471 pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> { 472 BorrowedStrDeserializer { 473 value: value, 474 marker: PhantomData, 475 } 476 } 477 } 478 479 impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E> 480 where 481 E: de::Error, 482 { 483 type Error = E; 484 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,485 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 486 where 487 V: de::Visitor<'de>, 488 { 489 visitor.visit_borrowed_str(self.value) 490 } 491 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,492 fn deserialize_enum<V>( 493 self, 494 name: &str, 495 variants: &'static [&'static str], 496 visitor: V, 497 ) -> Result<V::Value, Self::Error> 498 where 499 V: de::Visitor<'de>, 500 { 501 let _ = name; 502 let _ = variants; 503 visitor.visit_enum(self) 504 } 505 506 forward_to_deserialize_any! { 507 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 508 bytes byte_buf option unit unit_struct newtype_struct seq tuple 509 tuple_struct map struct identifier ignored_any 510 } 511 } 512 513 impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E> 514 where 515 E: de::Error, 516 { 517 type Error = E; 518 type Variant = private::UnitOnly<E>; 519 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,520 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 521 where 522 T: de::DeserializeSeed<'de>, 523 { 524 seed.deserialize(self).map(private::unit_only) 525 } 526 } 527 528 impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result529 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 530 formatter 531 .debug_struct("BorrowedStrDeserializer") 532 .field("value", &self.value) 533 .finish() 534 } 535 } 536 537 //////////////////////////////////////////////////////////////////////////////// 538 539 /// A deserializer holding a `String`. 540 #[cfg(any(feature = "std", feature = "alloc"))] 541 pub struct StringDeserializer<E> { 542 value: String, 543 marker: PhantomData<E>, 544 } 545 546 #[cfg(any(feature = "std", feature = "alloc"))] 547 impl<E> Clone for StringDeserializer<E> { clone(&self) -> Self548 fn clone(&self) -> Self { 549 StringDeserializer { 550 value: self.value.clone(), 551 marker: PhantomData, 552 } 553 } 554 } 555 556 #[cfg(any(feature = "std", feature = "alloc"))] 557 impl<'de, E> IntoDeserializer<'de, E> for String 558 where 559 E: de::Error, 560 { 561 type Deserializer = StringDeserializer<E>; 562 into_deserializer(self) -> StringDeserializer<E>563 fn into_deserializer(self) -> StringDeserializer<E> { 564 StringDeserializer { 565 value: self, 566 marker: PhantomData, 567 } 568 } 569 } 570 571 #[cfg(any(feature = "std", feature = "alloc"))] 572 impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> 573 where 574 E: de::Error, 575 { 576 type Error = E; 577 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,578 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 579 where 580 V: de::Visitor<'de>, 581 { 582 visitor.visit_string(self.value) 583 } 584 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,585 fn deserialize_enum<V>( 586 self, 587 name: &str, 588 variants: &'static [&'static str], 589 visitor: V, 590 ) -> Result<V::Value, Self::Error> 591 where 592 V: de::Visitor<'de>, 593 { 594 let _ = name; 595 let _ = variants; 596 visitor.visit_enum(self) 597 } 598 599 forward_to_deserialize_any! { 600 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 601 bytes byte_buf option unit unit_struct newtype_struct seq tuple 602 tuple_struct map struct identifier ignored_any 603 } 604 } 605 606 #[cfg(any(feature = "std", feature = "alloc"))] 607 impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E> 608 where 609 E: de::Error, 610 { 611 type Error = E; 612 type Variant = private::UnitOnly<E>; 613 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,614 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 615 where 616 T: de::DeserializeSeed<'de>, 617 { 618 seed.deserialize(self).map(private::unit_only) 619 } 620 } 621 622 #[cfg(any(feature = "std", feature = "alloc"))] 623 impl<E> Debug for StringDeserializer<E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result624 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 625 formatter 626 .debug_struct("StringDeserializer") 627 .field("value", &self.value) 628 .finish() 629 } 630 } 631 632 //////////////////////////////////////////////////////////////////////////////// 633 634 /// A deserializer holding a `Cow<str>`. 635 #[cfg(any(feature = "std", feature = "alloc"))] 636 pub struct CowStrDeserializer<'a, E> { 637 value: Cow<'a, str>, 638 marker: PhantomData<E>, 639 } 640 641 #[cfg(any(feature = "std", feature = "alloc"))] 642 impl<'a, E> Clone for CowStrDeserializer<'a, E> { clone(&self) -> Self643 fn clone(&self) -> Self { 644 CowStrDeserializer { 645 value: self.value.clone(), 646 marker: PhantomData, 647 } 648 } 649 } 650 651 #[cfg(any(feature = "std", feature = "alloc"))] 652 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> 653 where 654 E: de::Error, 655 { 656 type Deserializer = CowStrDeserializer<'a, E>; 657 into_deserializer(self) -> CowStrDeserializer<'a, E>658 fn into_deserializer(self) -> CowStrDeserializer<'a, E> { 659 CowStrDeserializer { 660 value: self, 661 marker: PhantomData, 662 } 663 } 664 } 665 666 #[cfg(any(feature = "std", feature = "alloc"))] 667 impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E> 668 where 669 E: de::Error, 670 { 671 type Error = E; 672 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,673 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 674 where 675 V: de::Visitor<'de>, 676 { 677 match self.value { 678 Cow::Borrowed(string) => visitor.visit_str(string), 679 Cow::Owned(string) => visitor.visit_string(string), 680 } 681 } 682 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,683 fn deserialize_enum<V>( 684 self, 685 name: &str, 686 variants: &'static [&'static str], 687 visitor: V, 688 ) -> Result<V::Value, Self::Error> 689 where 690 V: de::Visitor<'de>, 691 { 692 let _ = name; 693 let _ = variants; 694 visitor.visit_enum(self) 695 } 696 697 forward_to_deserialize_any! { 698 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 699 bytes byte_buf option unit unit_struct newtype_struct seq tuple 700 tuple_struct map struct identifier ignored_any 701 } 702 } 703 704 #[cfg(any(feature = "std", feature = "alloc"))] 705 impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E> 706 where 707 E: de::Error, 708 { 709 type Error = E; 710 type Variant = private::UnitOnly<E>; 711 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,712 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 713 where 714 T: de::DeserializeSeed<'de>, 715 { 716 seed.deserialize(self).map(private::unit_only) 717 } 718 } 719 720 #[cfg(any(feature = "std", feature = "alloc"))] 721 impl<'a, E> Debug for CowStrDeserializer<'a, E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result722 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 723 formatter 724 .debug_struct("CowStrDeserializer") 725 .field("value", &self.value) 726 .finish() 727 } 728 } 729 730 //////////////////////////////////////////////////////////////////////////////// 731 732 /// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`]. 733 pub struct BytesDeserializer<'a, E> { 734 value: &'a [u8], 735 marker: PhantomData<E>, 736 } 737 738 impl<'a, E> BytesDeserializer<'a, E> { 739 /// Create a new deserializer from the given bytes. new(value: &'a [u8]) -> Self740 pub fn new(value: &'a [u8]) -> Self { 741 BytesDeserializer { 742 value: value, 743 marker: PhantomData, 744 } 745 } 746 } 747 748 impl_copy_clone!(BytesDeserializer<'a>); 749 750 impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8] 751 where 752 E: de::Error, 753 { 754 type Deserializer = BytesDeserializer<'a, E>; 755 into_deserializer(self) -> BytesDeserializer<'a, E>756 fn into_deserializer(self) -> BytesDeserializer<'a, E> { 757 BytesDeserializer::new(self) 758 } 759 } 760 761 impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E> 762 where 763 E: de::Error, 764 { 765 type Error = E; 766 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,767 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 768 where 769 V: Visitor<'de>, 770 { 771 visitor.visit_bytes(self.value) 772 } 773 774 forward_to_deserialize_any! { 775 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 776 bytes byte_buf option unit unit_struct newtype_struct seq tuple 777 tuple_struct map struct enum identifier ignored_any 778 } 779 } 780 781 impl<'a, E> Debug for BytesDeserializer<'a, E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result782 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 783 formatter 784 .debug_struct("BytesDeserializer") 785 .field("value", &self.value) 786 .finish() 787 } 788 } 789 790 /// A deserializer holding a `&[u8]` with a lifetime tied to another 791 /// deserializer. Always calls [`Visitor::visit_borrowed_bytes`]. 792 pub struct BorrowedBytesDeserializer<'de, E> { 793 value: &'de [u8], 794 marker: PhantomData<E>, 795 } 796 797 impl<'de, E> BorrowedBytesDeserializer<'de, E> { 798 /// Create a new borrowed deserializer from the given borrowed bytes. new(value: &'de [u8]) -> Self799 pub fn new(value: &'de [u8]) -> Self { 800 BorrowedBytesDeserializer { 801 value: value, 802 marker: PhantomData, 803 } 804 } 805 } 806 807 impl_copy_clone!(BorrowedBytesDeserializer<'de>); 808 809 impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E> 810 where 811 E: de::Error, 812 { 813 type Error = E; 814 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,815 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 816 where 817 V: Visitor<'de>, 818 { 819 visitor.visit_borrowed_bytes(self.value) 820 } 821 822 forward_to_deserialize_any! { 823 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 824 bytes byte_buf option unit unit_struct newtype_struct seq tuple 825 tuple_struct map struct enum identifier ignored_any 826 } 827 } 828 829 impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result830 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 831 formatter 832 .debug_struct("BorrowedBytesDeserializer") 833 .field("value", &self.value) 834 .finish() 835 } 836 } 837 838 //////////////////////////////////////////////////////////////////////////////// 839 840 /// A deserializer that iterates over a sequence. 841 #[derive(Clone)] 842 pub struct SeqDeserializer<I, E> { 843 iter: iter::Fuse<I>, 844 count: usize, 845 marker: PhantomData<E>, 846 } 847 848 impl<I, E> SeqDeserializer<I, E> 849 where 850 I: Iterator, 851 { 852 /// Construct a new `SeqDeserializer<I, E>`. new(iter: I) -> Self853 pub fn new(iter: I) -> Self { 854 SeqDeserializer { 855 iter: iter.fuse(), 856 count: 0, 857 marker: PhantomData, 858 } 859 } 860 } 861 862 impl<I, E> SeqDeserializer<I, E> 863 where 864 I: Iterator, 865 E: de::Error, 866 { 867 /// Check for remaining elements after passing a `SeqDeserializer` to 868 /// `Visitor::visit_seq`. end(self) -> Result<(), E>869 pub fn end(self) -> Result<(), E> { 870 let remaining = self.iter.count(); 871 if remaining == 0 { 872 Ok(()) 873 } else { 874 // First argument is the number of elements in the data, second 875 // argument is the number of elements expected by the Deserialize. 876 Err(de::Error::invalid_length( 877 self.count + remaining, 878 &ExpectedInSeq(self.count), 879 )) 880 } 881 } 882 } 883 884 impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E> 885 where 886 I: Iterator<Item = T>, 887 T: IntoDeserializer<'de, E>, 888 E: de::Error, 889 { 890 type Error = E; 891 deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,892 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 893 where 894 V: de::Visitor<'de>, 895 { 896 let v = try!(visitor.visit_seq(&mut self)); 897 try!(self.end()); 898 Ok(v) 899 } 900 901 forward_to_deserialize_any! { 902 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 903 bytes byte_buf option unit unit_struct newtype_struct seq tuple 904 tuple_struct map struct enum identifier ignored_any 905 } 906 } 907 908 impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> 909 where 910 I: Iterator<Item = T>, 911 T: IntoDeserializer<'de, E>, 912 E: de::Error, 913 { 914 type Error = E; 915 next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> where V: de::DeserializeSeed<'de>,916 fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> 917 where 918 V: de::DeserializeSeed<'de>, 919 { 920 match self.iter.next() { 921 Some(value) => { 922 self.count += 1; 923 seed.deserialize(value.into_deserializer()).map(Some) 924 } 925 None => Ok(None), 926 } 927 } 928 size_hint(&self) -> Option<usize>929 fn size_hint(&self) -> Option<usize> { 930 size_hint::from_bounds(&self.iter) 931 } 932 } 933 934 struct ExpectedInSeq(usize); 935 936 impl Expected for ExpectedInSeq { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result937 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 938 if self.0 == 1 { 939 write!(formatter, "1 element in sequence") 940 } else { 941 write!(formatter, "{} elements in sequence", self.0) 942 } 943 } 944 } 945 946 impl<I, E> Debug for SeqDeserializer<I, E> 947 where 948 I: Debug, 949 { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result950 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 951 formatter 952 .debug_struct("SeqDeserializer") 953 .field("iter", &self.iter) 954 .field("count", &self.count) 955 .finish() 956 } 957 } 958 959 //////////////////////////////////////////////////////////////////////////////// 960 961 #[cfg(any(feature = "std", feature = "alloc"))] 962 impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> 963 where 964 T: IntoDeserializer<'de, E>, 965 E: de::Error, 966 { 967 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; 968 into_deserializer(self) -> Self::Deserializer969 fn into_deserializer(self) -> Self::Deserializer { 970 SeqDeserializer::new(self.into_iter()) 971 } 972 } 973 974 #[cfg(any(feature = "std", feature = "alloc"))] 975 impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> 976 where 977 T: IntoDeserializer<'de, E> + Eq + Ord, 978 E: de::Error, 979 { 980 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; 981 into_deserializer(self) -> Self::Deserializer982 fn into_deserializer(self) -> Self::Deserializer { 983 SeqDeserializer::new(self.into_iter()) 984 } 985 } 986 987 #[cfg(feature = "std")] 988 impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> 989 where 990 T: IntoDeserializer<'de, E> + Eq + Hash, 991 S: BuildHasher, 992 E: de::Error, 993 { 994 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; 995 into_deserializer(self) -> Self::Deserializer996 fn into_deserializer(self) -> Self::Deserializer { 997 SeqDeserializer::new(self.into_iter()) 998 } 999 } 1000 1001 //////////////////////////////////////////////////////////////////////////////// 1002 1003 /// A deserializer holding a `SeqAccess`. 1004 #[derive(Clone, Debug)] 1005 pub struct SeqAccessDeserializer<A> { 1006 seq: A, 1007 } 1008 1009 impl<A> SeqAccessDeserializer<A> { 1010 /// Construct a new `SeqAccessDeserializer<A>`. new(seq: A) -> Self1011 pub fn new(seq: A) -> Self { 1012 SeqAccessDeserializer { seq: seq } 1013 } 1014 } 1015 1016 impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> 1017 where 1018 A: de::SeqAccess<'de>, 1019 { 1020 type Error = A::Error; 1021 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1022 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1023 where 1024 V: de::Visitor<'de>, 1025 { 1026 visitor.visit_seq(self.seq) 1027 } 1028 1029 forward_to_deserialize_any! { 1030 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1031 bytes byte_buf option unit unit_struct newtype_struct seq tuple 1032 tuple_struct map struct enum identifier ignored_any 1033 } 1034 } 1035 1036 //////////////////////////////////////////////////////////////////////////////// 1037 1038 /// A deserializer that iterates over a map. 1039 pub struct MapDeserializer<'de, I, E> 1040 where 1041 I: Iterator, 1042 I::Item: private::Pair, 1043 { 1044 iter: iter::Fuse<I>, 1045 value: Option<Second<I::Item>>, 1046 count: usize, 1047 lifetime: PhantomData<&'de ()>, 1048 error: PhantomData<E>, 1049 } 1050 1051 impl<'de, I, E> MapDeserializer<'de, I, E> 1052 where 1053 I: Iterator, 1054 I::Item: private::Pair, 1055 { 1056 /// Construct a new `MapDeserializer<I, E>`. new(iter: I) -> Self1057 pub fn new(iter: I) -> Self { 1058 MapDeserializer { 1059 iter: iter.fuse(), 1060 value: None, 1061 count: 0, 1062 lifetime: PhantomData, 1063 error: PhantomData, 1064 } 1065 } 1066 } 1067 1068 impl<'de, I, E> MapDeserializer<'de, I, E> 1069 where 1070 I: Iterator, 1071 I::Item: private::Pair, 1072 E: de::Error, 1073 { 1074 /// Check for remaining elements after passing a `MapDeserializer` to 1075 /// `Visitor::visit_map`. end(self) -> Result<(), E>1076 pub fn end(self) -> Result<(), E> { 1077 let remaining = self.iter.count(); 1078 if remaining == 0 { 1079 Ok(()) 1080 } else { 1081 // First argument is the number of elements in the data, second 1082 // argument is the number of elements expected by the Deserialize. 1083 Err(de::Error::invalid_length( 1084 self.count + remaining, 1085 &ExpectedInMap(self.count), 1086 )) 1087 } 1088 } 1089 } 1090 1091 impl<'de, I, E> MapDeserializer<'de, I, E> 1092 where 1093 I: Iterator, 1094 I::Item: private::Pair, 1095 { next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)>1096 fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> { 1097 match self.iter.next() { 1098 Some(kv) => { 1099 self.count += 1; 1100 Some(private::Pair::split(kv)) 1101 } 1102 None => None, 1103 } 1104 } 1105 } 1106 1107 impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E> 1108 where 1109 I: Iterator, 1110 I::Item: private::Pair, 1111 First<I::Item>: IntoDeserializer<'de, E>, 1112 Second<I::Item>: IntoDeserializer<'de, E>, 1113 E: de::Error, 1114 { 1115 type Error = E; 1116 deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1117 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 1118 where 1119 V: de::Visitor<'de>, 1120 { 1121 let value = try!(visitor.visit_map(&mut self)); 1122 try!(self.end()); 1123 Ok(value) 1124 } 1125 deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1126 fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 1127 where 1128 V: de::Visitor<'de>, 1129 { 1130 let value = try!(visitor.visit_seq(&mut self)); 1131 try!(self.end()); 1132 Ok(value) 1133 } 1134 deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1135 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> 1136 where 1137 V: de::Visitor<'de>, 1138 { 1139 let _ = len; 1140 self.deserialize_seq(visitor) 1141 } 1142 1143 forward_to_deserialize_any! { 1144 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1145 bytes byte_buf option unit unit_struct newtype_struct tuple_struct map 1146 struct enum identifier ignored_any 1147 } 1148 } 1149 1150 impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E> 1151 where 1152 I: Iterator, 1153 I::Item: private::Pair, 1154 First<I::Item>: IntoDeserializer<'de, E>, 1155 Second<I::Item>: IntoDeserializer<'de, E>, 1156 E: de::Error, 1157 { 1158 type Error = E; 1159 next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1160 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1161 where 1162 T: de::DeserializeSeed<'de>, 1163 { 1164 match self.next_pair() { 1165 Some((key, value)) => { 1166 self.value = Some(value); 1167 seed.deserialize(key.into_deserializer()).map(Some) 1168 } 1169 None => Ok(None), 1170 } 1171 } 1172 next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1173 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> 1174 where 1175 T: de::DeserializeSeed<'de>, 1176 { 1177 let value = self.value.take(); 1178 // Panic because this indicates a bug in the program rather than an 1179 // expected failure. 1180 let value = value.expect("MapAccess::next_value called before next_key"); 1181 seed.deserialize(value.into_deserializer()) 1182 } 1183 next_entry_seed<TK, TV>( &mut self, kseed: TK, vseed: TV, ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> where TK: de::DeserializeSeed<'de>, TV: de::DeserializeSeed<'de>,1184 fn next_entry_seed<TK, TV>( 1185 &mut self, 1186 kseed: TK, 1187 vseed: TV, 1188 ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> 1189 where 1190 TK: de::DeserializeSeed<'de>, 1191 TV: de::DeserializeSeed<'de>, 1192 { 1193 match self.next_pair() { 1194 Some((key, value)) => { 1195 let key = try!(kseed.deserialize(key.into_deserializer())); 1196 let value = try!(vseed.deserialize(value.into_deserializer())); 1197 Ok(Some((key, value))) 1198 } 1199 None => Ok(None), 1200 } 1201 } 1202 size_hint(&self) -> Option<usize>1203 fn size_hint(&self) -> Option<usize> { 1204 size_hint::from_bounds(&self.iter) 1205 } 1206 } 1207 1208 impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E> 1209 where 1210 I: Iterator, 1211 I::Item: private::Pair, 1212 First<I::Item>: IntoDeserializer<'de, E>, 1213 Second<I::Item>: IntoDeserializer<'de, E>, 1214 E: de::Error, 1215 { 1216 type Error = E; 1217 next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1218 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1219 where 1220 T: de::DeserializeSeed<'de>, 1221 { 1222 match self.next_pair() { 1223 Some((k, v)) => { 1224 let de = PairDeserializer(k, v, PhantomData); 1225 seed.deserialize(de).map(Some) 1226 } 1227 None => Ok(None), 1228 } 1229 } 1230 size_hint(&self) -> Option<usize>1231 fn size_hint(&self) -> Option<usize> { 1232 size_hint::from_bounds(&self.iter) 1233 } 1234 } 1235 1236 // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`. 1237 impl<'de, I, E> Clone for MapDeserializer<'de, I, E> 1238 where 1239 I: Iterator + Clone, 1240 I::Item: private::Pair, 1241 Second<I::Item>: Clone, 1242 { clone(&self) -> Self1243 fn clone(&self) -> Self { 1244 MapDeserializer { 1245 iter: self.iter.clone(), 1246 value: self.value.clone(), 1247 count: self.count, 1248 lifetime: self.lifetime, 1249 error: self.error, 1250 } 1251 } 1252 } 1253 1254 impl<'de, I, E> Debug for MapDeserializer<'de, I, E> 1255 where 1256 I: Iterator + Debug, 1257 I::Item: private::Pair, 1258 Second<I::Item>: Debug, 1259 { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1260 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1261 formatter 1262 .debug_struct("MapDeserializer") 1263 .field("iter", &self.iter) 1264 .field("value", &self.value) 1265 .field("count", &self.count) 1266 .finish() 1267 } 1268 } 1269 1270 // Used in the `impl SeqAccess for MapDeserializer` to visit the map as a 1271 // sequence of pairs. 1272 struct PairDeserializer<A, B, E>(A, B, PhantomData<E>); 1273 1274 impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E> 1275 where 1276 A: IntoDeserializer<'de, E>, 1277 B: IntoDeserializer<'de, E>, 1278 E: de::Error, 1279 { 1280 type Error = E; 1281 1282 forward_to_deserialize_any! { 1283 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1284 bytes byte_buf option unit unit_struct newtype_struct tuple_struct map 1285 struct enum identifier ignored_any 1286 } 1287 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1288 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1289 where 1290 V: de::Visitor<'de>, 1291 { 1292 self.deserialize_seq(visitor) 1293 } 1294 deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1295 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1296 where 1297 V: de::Visitor<'de>, 1298 { 1299 let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData); 1300 let pair = try!(visitor.visit_seq(&mut pair_visitor)); 1301 if pair_visitor.1.is_none() { 1302 Ok(pair) 1303 } else { 1304 let remaining = pair_visitor.size_hint().unwrap(); 1305 // First argument is the number of elements in the data, second 1306 // argument is the number of elements expected by the Deserialize. 1307 Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining))) 1308 } 1309 } 1310 deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1311 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> 1312 where 1313 V: de::Visitor<'de>, 1314 { 1315 if len == 2 { 1316 self.deserialize_seq(visitor) 1317 } else { 1318 // First argument is the number of elements in the data, second 1319 // argument is the number of elements expected by the Deserialize. 1320 Err(de::Error::invalid_length(2, &ExpectedInSeq(len))) 1321 } 1322 } 1323 } 1324 1325 struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>); 1326 1327 impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> 1328 where 1329 A: IntoDeserializer<'de, E>, 1330 B: IntoDeserializer<'de, E>, 1331 E: de::Error, 1332 { 1333 type Error = E; 1334 next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1335 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1336 where 1337 T: de::DeserializeSeed<'de>, 1338 { 1339 if let Some(k) = self.0.take() { 1340 seed.deserialize(k.into_deserializer()).map(Some) 1341 } else if let Some(v) = self.1.take() { 1342 seed.deserialize(v.into_deserializer()).map(Some) 1343 } else { 1344 Ok(None) 1345 } 1346 } 1347 size_hint(&self) -> Option<usize>1348 fn size_hint(&self) -> Option<usize> { 1349 if self.0.is_some() { 1350 Some(2) 1351 } else if self.1.is_some() { 1352 Some(1) 1353 } else { 1354 Some(0) 1355 } 1356 } 1357 } 1358 1359 struct ExpectedInMap(usize); 1360 1361 impl Expected for ExpectedInMap { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1362 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1363 if self.0 == 1 { 1364 write!(formatter, "1 element in map") 1365 } else { 1366 write!(formatter, "{} elements in map", self.0) 1367 } 1368 } 1369 } 1370 1371 //////////////////////////////////////////////////////////////////////////////// 1372 1373 #[cfg(any(feature = "std", feature = "alloc"))] 1374 impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> 1375 where 1376 K: IntoDeserializer<'de, E> + Eq + Ord, 1377 V: IntoDeserializer<'de, E>, 1378 E: de::Error, 1379 { 1380 type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; 1381 into_deserializer(self) -> Self::Deserializer1382 fn into_deserializer(self) -> Self::Deserializer { 1383 MapDeserializer::new(self.into_iter()) 1384 } 1385 } 1386 1387 #[cfg(feature = "std")] 1388 impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S> 1389 where 1390 K: IntoDeserializer<'de, E> + Eq + Hash, 1391 V: IntoDeserializer<'de, E>, 1392 S: BuildHasher, 1393 E: de::Error, 1394 { 1395 type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; 1396 into_deserializer(self) -> Self::Deserializer1397 fn into_deserializer(self) -> Self::Deserializer { 1398 MapDeserializer::new(self.into_iter()) 1399 } 1400 } 1401 1402 //////////////////////////////////////////////////////////////////////////////// 1403 1404 /// A deserializer holding a `MapAccess`. 1405 #[derive(Clone, Debug)] 1406 pub struct MapAccessDeserializer<A> { 1407 map: A, 1408 } 1409 1410 impl<A> MapAccessDeserializer<A> { 1411 /// Construct a new `MapAccessDeserializer<A>`. new(map: A) -> Self1412 pub fn new(map: A) -> Self { 1413 MapAccessDeserializer { map: map } 1414 } 1415 } 1416 1417 impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> 1418 where 1419 A: de::MapAccess<'de>, 1420 { 1421 type Error = A::Error; 1422 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1423 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1424 where 1425 V: de::Visitor<'de>, 1426 { 1427 visitor.visit_map(self.map) 1428 } 1429 deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1430 fn deserialize_enum<V>( 1431 self, 1432 _name: &str, 1433 _variants: &'static [&'static str], 1434 visitor: V, 1435 ) -> Result<V::Value, Self::Error> 1436 where 1437 V: de::Visitor<'de>, 1438 { 1439 visitor.visit_enum(self) 1440 } 1441 1442 forward_to_deserialize_any! { 1443 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1444 bytes byte_buf option unit unit_struct newtype_struct seq tuple 1445 tuple_struct map struct identifier ignored_any 1446 } 1447 } 1448 1449 impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A> 1450 where 1451 A: de::MapAccess<'de>, 1452 { 1453 type Error = A::Error; 1454 type Variant = private::MapAsEnum<A>; 1455 variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,1456 fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 1457 where 1458 T: de::DeserializeSeed<'de>, 1459 { 1460 match self.map.next_key_seed(seed)? { 1461 Some(key) => Ok((key, private::map_as_enum(self.map))), 1462 None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")), 1463 } 1464 } 1465 } 1466 1467 //////////////////////////////////////////////////////////////////////////////// 1468 1469 mod private { 1470 use lib::*; 1471 1472 use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor}; 1473 1474 pub struct UnitOnly<E> { 1475 marker: PhantomData<E>, 1476 } 1477 unit_only<T, E>(t: T) -> (T, UnitOnly<E>)1478 pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) { 1479 ( 1480 t, 1481 UnitOnly { 1482 marker: PhantomData, 1483 }, 1484 ) 1485 } 1486 1487 impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> 1488 where 1489 E: de::Error, 1490 { 1491 type Error = E; 1492 unit_variant(self) -> Result<(), Self::Error>1493 fn unit_variant(self) -> Result<(), Self::Error> { 1494 Ok(()) 1495 } 1496 newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1497 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> 1498 where 1499 T: de::DeserializeSeed<'de>, 1500 { 1501 Err(de::Error::invalid_type( 1502 Unexpected::UnitVariant, 1503 &"newtype variant", 1504 )) 1505 } 1506 tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1507 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> 1508 where 1509 V: de::Visitor<'de>, 1510 { 1511 Err(de::Error::invalid_type( 1512 Unexpected::UnitVariant, 1513 &"tuple variant", 1514 )) 1515 } 1516 struct_variant<V>( self, _fields: &'static [&'static str], _visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1517 fn struct_variant<V>( 1518 self, 1519 _fields: &'static [&'static str], 1520 _visitor: V, 1521 ) -> Result<V::Value, Self::Error> 1522 where 1523 V: de::Visitor<'de>, 1524 { 1525 Err(de::Error::invalid_type( 1526 Unexpected::UnitVariant, 1527 &"struct variant", 1528 )) 1529 } 1530 } 1531 1532 pub struct MapAsEnum<A> { 1533 map: A, 1534 } 1535 map_as_enum<A>(map: A) -> MapAsEnum<A>1536 pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> { 1537 MapAsEnum { map: map } 1538 } 1539 1540 impl<'de, A> VariantAccess<'de> for MapAsEnum<A> 1541 where 1542 A: MapAccess<'de>, 1543 { 1544 type Error = A::Error; 1545 unit_variant(mut self) -> Result<(), Self::Error>1546 fn unit_variant(mut self) -> Result<(), Self::Error> { 1547 self.map.next_value() 1548 } 1549 newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error> where T: DeserializeSeed<'de>,1550 fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error> 1551 where 1552 T: DeserializeSeed<'de>, 1553 { 1554 self.map.next_value_seed(seed) 1555 } 1556 tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1557 fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> 1558 where 1559 V: Visitor<'de>, 1560 { 1561 self.map.next_value_seed(SeedTupleVariant { 1562 len: len, 1563 visitor: visitor, 1564 }) 1565 } 1566 struct_variant<V>( mut self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,1567 fn struct_variant<V>( 1568 mut self, 1569 _fields: &'static [&'static str], 1570 visitor: V, 1571 ) -> Result<V::Value, Self::Error> 1572 where 1573 V: Visitor<'de>, 1574 { 1575 self.map 1576 .next_value_seed(SeedStructVariant { visitor: visitor }) 1577 } 1578 } 1579 1580 struct SeedTupleVariant<V> { 1581 len: usize, 1582 visitor: V, 1583 } 1584 1585 impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V> 1586 where 1587 V: Visitor<'de>, 1588 { 1589 type Value = V::Value; 1590 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,1591 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 1592 where 1593 D: Deserializer<'de>, 1594 { 1595 deserializer.deserialize_tuple(self.len, self.visitor) 1596 } 1597 } 1598 1599 struct SeedStructVariant<V> { 1600 visitor: V, 1601 } 1602 1603 impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V> 1604 where 1605 V: Visitor<'de>, 1606 { 1607 type Value = V::Value; 1608 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,1609 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 1610 where 1611 D: Deserializer<'de>, 1612 { 1613 deserializer.deserialize_map(self.visitor) 1614 } 1615 } 1616 1617 /// Avoid having to restate the generic types on `MapDeserializer`. The 1618 /// `Iterator::Item` contains enough information to figure out K and V. 1619 pub trait Pair { 1620 type First; 1621 type Second; split(self) -> (Self::First, Self::Second)1622 fn split(self) -> (Self::First, Self::Second); 1623 } 1624 1625 impl<A, B> Pair for (A, B) { 1626 type First = A; 1627 type Second = B; split(self) -> (A, B)1628 fn split(self) -> (A, B) { 1629 self 1630 } 1631 } 1632 1633 pub type First<T> = <T as Pair>::First; 1634 pub type Second<T> = <T as Pair>::Second; 1635 } 1636