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