1 // Copyright 2017 Serde Developers 2 // 3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or 4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your 6 // option. This file may not be copied, modified, or distributed 7 // except according to those terms. 8 9 //! Building blocks for deserializing basic values using the `IntoDeserializer` 10 //! trait. 11 //! 12 //! ```rust 13 //! #[macro_use] 14 //! extern crate serde_derive; 15 //! 16 //! extern crate serde; 17 //! 18 //! use std::str::FromStr; 19 //! use serde::de::{value, Deserialize, IntoDeserializer}; 20 //! 21 //! #[derive(Deserialize)] 22 //! enum Setting { 23 //! On, 24 //! Off, 25 //! } 26 //! 27 //! impl FromStr for Setting { 28 //! type Err = value::Error; 29 //! 30 //! fn from_str(s: &str) -> Result<Self, Self::Err> { 31 //! Self::deserialize(s.into_deserializer()) 32 //! } 33 //! } 34 //! # 35 //! # fn main() {} 36 //! ``` 37 38 use lib::*; 39 40 use self::private::{First, Second}; 41 use de::{self, Expected, IntoDeserializer, SeqAccess}; 42 use private::de::size_hint; 43 use ser; 44 45 //////////////////////////////////////////////////////////////////////////////// 46 47 // For structs that contain a PhantomData. We do not want the trait 48 // bound `E: Clone` inferred by derive(Clone). 49 macro_rules! impl_copy_clone { 50 ($ty:ident $(<$lifetime:tt>)*) => { 51 impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {} 52 53 impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> { 54 fn clone(&self) -> Self { 55 *self 56 } 57 } 58 }; 59 } 60 61 //////////////////////////////////////////////////////////////////////////////// 62 63 /// A minimal representation of all possible errors that can occur using the 64 /// `IntoDeserializer` trait. 65 #[derive(Clone, Debug, PartialEq)] 66 pub struct Error { 67 err: ErrorImpl, 68 } 69 70 #[cfg(any(feature = "std", feature = "alloc"))] 71 type ErrorImpl = Box<str>; 72 #[cfg(not(any(feature = "std", feature = "alloc")))] 73 type ErrorImpl = (); 74 75 impl de::Error for Error { 76 #[cfg(any(feature = "std", feature = "alloc"))] 77 #[cold] custom<T>(msg: T) -> Self where T: Display,78 fn custom<T>(msg: T) -> Self 79 where 80 T: Display, 81 { 82 Error { 83 err: msg.to_string().into_boxed_str(), 84 } 85 } 86 87 #[cfg(not(any(feature = "std", feature = "alloc")))] 88 #[cold] custom<T>(msg: T) -> Self where T: Display,89 fn custom<T>(msg: T) -> Self 90 where 91 T: Display, 92 { 93 let _ = msg; 94 Error { err: () } 95 } 96 } 97 98 impl ser::Error for Error { 99 #[cold] custom<T>(msg: T) -> Self where T: Display,100 fn custom<T>(msg: T) -> Self 101 where 102 T: Display, 103 { 104 de::Error::custom(msg) 105 } 106 } 107 108 impl Display for Error { 109 #[cfg(any(feature = "std", feature = "alloc"))] fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error>110 fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { 111 formatter.write_str(&self.err) 112 } 113 114 #[cfg(not(any(feature = "std", feature = "alloc")))] fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error>115 fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { 116 formatter.write_str("Serde deserialization error") 117 } 118 } 119 120 #[cfg(feature = "std")] 121 impl error::Error for Error { description(&self) -> &str122 fn description(&self) -> &str { 123 &self.err 124 } 125 } 126 127 //////////////////////////////////////////////////////////////////////////////// 128 129 impl<'de, E> IntoDeserializer<'de, E> for () 130 where 131 E: de::Error, 132 { 133 type Deserializer = UnitDeserializer<E>; 134 into_deserializer(self) -> UnitDeserializer<E>135 fn into_deserializer(self) -> UnitDeserializer<E> { 136 UnitDeserializer { 137 marker: PhantomData, 138 } 139 } 140 } 141 142 /// A deserializer holding a `()`. 143 #[derive(Debug)] 144 pub struct UnitDeserializer<E> { 145 marker: PhantomData<E>, 146 } 147 148 impl_copy_clone!(UnitDeserializer); 149 150 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> 151 where 152 E: de::Error, 153 { 154 type Error = E; 155 156 forward_to_deserialize_any! { 157 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 158 bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct 159 map struct enum identifier ignored_any 160 } 161 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,162 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 163 where 164 V: de::Visitor<'de>, 165 { 166 visitor.visit_unit() 167 } 168 deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,169 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> 170 where 171 V: de::Visitor<'de>, 172 { 173 visitor.visit_none() 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 #[derive(Debug)] 226 pub struct $name<E> { 227 value: $ty, 228 marker: PhantomData<E> 229 } 230 231 impl_copy_clone!($name); 232 233 impl<'de, E> IntoDeserializer<'de, E> for $ty 234 where 235 E: de::Error, 236 { 237 type Deserializer = $name<E>; 238 239 fn into_deserializer(self) -> $name<E> { 240 $name { 241 value: self, 242 marker: PhantomData, 243 } 244 } 245 } 246 247 impl<'de, E> de::Deserializer<'de> for $name<E> 248 where 249 E: de::Error, 250 { 251 type Error = E; 252 253 forward_to_deserialize_any! { 254 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str 255 string bytes byte_buf option unit unit_struct newtype_struct seq 256 tuple tuple_struct map struct enum identifier ignored_any 257 } 258 259 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 260 where 261 V: de::Visitor<'de>, 262 { 263 visitor.$method(self.value $($cast)*) 264 } 265 } 266 } 267 } 268 269 primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool); 270 primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8); 271 primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16); 272 primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32); 273 primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64); 274 primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64); 275 primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8); 276 primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16); 277 primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64); 278 primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64); 279 primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32); 280 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64); 281 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char); 282 283 serde_if_integer128! { 284 primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128); 285 primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128); 286 } 287 288 /// A deserializer holding a `u32`. 289 #[derive(Debug)] 290 pub struct U32Deserializer<E> { 291 value: u32, 292 marker: PhantomData<E>, 293 } 294 295 impl_copy_clone!(U32Deserializer); 296 297 impl<'de, E> IntoDeserializer<'de, E> for u32 298 where 299 E: de::Error, 300 { 301 type Deserializer = U32Deserializer<E>; 302 into_deserializer(self) -> U32Deserializer<E>303 fn into_deserializer(self) -> U32Deserializer<E> { 304 U32Deserializer { 305 value: self, 306 marker: PhantomData, 307 } 308 } 309 } 310 311 impl<'de, E> de::Deserializer<'de> for U32Deserializer<E> 312 where 313 E: de::Error, 314 { 315 type Error = E; 316 317 forward_to_deserialize_any! { 318 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 319 bytes byte_buf option unit unit_struct newtype_struct seq tuple 320 tuple_struct map struct identifier ignored_any 321 } 322 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,323 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 324 where 325 V: de::Visitor<'de>, 326 { 327 visitor.visit_u32(self.value) 328 } 329 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,330 fn deserialize_enum<V>( 331 self, 332 name: &str, 333 variants: &'static [&'static str], 334 visitor: V, 335 ) -> Result<V::Value, Self::Error> 336 where 337 V: de::Visitor<'de>, 338 { 339 let _ = name; 340 let _ = variants; 341 visitor.visit_enum(self) 342 } 343 } 344 345 impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E> 346 where 347 E: de::Error, 348 { 349 type Error = E; 350 type Variant = private::UnitOnly<E>; 351 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,352 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 353 where 354 T: de::DeserializeSeed<'de>, 355 { 356 seed.deserialize(self).map(private::unit_only) 357 } 358 } 359 360 //////////////////////////////////////////////////////////////////////////////// 361 362 /// A deserializer holding a `&str`. 363 #[derive(Debug)] 364 pub struct StrDeserializer<'a, E> { 365 value: &'a str, 366 marker: PhantomData<E>, 367 } 368 369 impl_copy_clone!(StrDeserializer<'de>); 370 371 impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str 372 where 373 E: de::Error, 374 { 375 type Deserializer = StrDeserializer<'a, E>; 376 into_deserializer(self) -> StrDeserializer<'a, E>377 fn into_deserializer(self) -> StrDeserializer<'a, E> { 378 StrDeserializer { 379 value: self, 380 marker: PhantomData, 381 } 382 } 383 } 384 385 impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E> 386 where 387 E: de::Error, 388 { 389 type Error = E; 390 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,391 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 392 where 393 V: de::Visitor<'de>, 394 { 395 visitor.visit_str(self.value) 396 } 397 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,398 fn deserialize_enum<V>( 399 self, 400 name: &str, 401 variants: &'static [&'static str], 402 visitor: V, 403 ) -> Result<V::Value, Self::Error> 404 where 405 V: de::Visitor<'de>, 406 { 407 let _ = name; 408 let _ = variants; 409 visitor.visit_enum(self) 410 } 411 412 forward_to_deserialize_any! { 413 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 414 bytes byte_buf option unit unit_struct newtype_struct seq tuple 415 tuple_struct map struct identifier ignored_any 416 } 417 } 418 419 impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> 420 where 421 E: de::Error, 422 { 423 type Error = E; 424 type Variant = private::UnitOnly<E>; 425 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,426 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 427 where 428 T: de::DeserializeSeed<'de>, 429 { 430 seed.deserialize(self).map(private::unit_only) 431 } 432 } 433 434 //////////////////////////////////////////////////////////////////////////////// 435 436 /// A deserializer holding a `&str` with a lifetime tied to another 437 /// deserializer. 438 #[derive(Debug)] 439 pub struct BorrowedStrDeserializer<'de, E> { 440 value: &'de str, 441 marker: PhantomData<E>, 442 } 443 444 impl_copy_clone!(BorrowedStrDeserializer<'de>); 445 446 impl<'de, E> BorrowedStrDeserializer<'de, E> { 447 /// Create a new borrowed deserializer from the given string. new(value: &'de str) -> BorrowedStrDeserializer<'de, E>448 pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> { 449 BorrowedStrDeserializer { 450 value: value, 451 marker: PhantomData, 452 } 453 } 454 } 455 456 impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E> 457 where 458 E: de::Error, 459 { 460 type Error = E; 461 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,462 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 463 where 464 V: de::Visitor<'de>, 465 { 466 visitor.visit_borrowed_str(self.value) 467 } 468 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,469 fn deserialize_enum<V>( 470 self, 471 name: &str, 472 variants: &'static [&'static str], 473 visitor: V, 474 ) -> Result<V::Value, Self::Error> 475 where 476 V: de::Visitor<'de>, 477 { 478 let _ = name; 479 let _ = variants; 480 visitor.visit_enum(self) 481 } 482 483 forward_to_deserialize_any! { 484 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 485 bytes byte_buf option unit unit_struct newtype_struct seq tuple 486 tuple_struct map struct identifier ignored_any 487 } 488 } 489 490 impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E> 491 where 492 E: de::Error, 493 { 494 type Error = E; 495 type Variant = private::UnitOnly<E>; 496 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,497 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 498 where 499 T: de::DeserializeSeed<'de>, 500 { 501 seed.deserialize(self).map(private::unit_only) 502 } 503 } 504 505 //////////////////////////////////////////////////////////////////////////////// 506 507 /// A deserializer holding a `String`. 508 #[cfg(any(feature = "std", feature = "alloc"))] 509 #[derive(Debug)] 510 pub struct StringDeserializer<E> { 511 value: String, 512 marker: PhantomData<E>, 513 } 514 515 #[cfg(any(feature = "std", feature = "alloc"))] 516 impl<E> Clone for StringDeserializer<E> { clone(&self) -> Self517 fn clone(&self) -> Self { 518 StringDeserializer { 519 value: self.value.clone(), 520 marker: PhantomData, 521 } 522 } 523 } 524 525 #[cfg(any(feature = "std", feature = "alloc"))] 526 impl<'de, E> IntoDeserializer<'de, E> for String 527 where 528 E: de::Error, 529 { 530 type Deserializer = StringDeserializer<E>; 531 into_deserializer(self) -> StringDeserializer<E>532 fn into_deserializer(self) -> StringDeserializer<E> { 533 StringDeserializer { 534 value: self, 535 marker: PhantomData, 536 } 537 } 538 } 539 540 #[cfg(any(feature = "std", feature = "alloc"))] 541 impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> 542 where 543 E: de::Error, 544 { 545 type Error = E; 546 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,547 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 548 where 549 V: de::Visitor<'de>, 550 { 551 visitor.visit_string(self.value) 552 } 553 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,554 fn deserialize_enum<V>( 555 self, 556 name: &str, 557 variants: &'static [&'static str], 558 visitor: V, 559 ) -> Result<V::Value, Self::Error> 560 where 561 V: de::Visitor<'de>, 562 { 563 let _ = name; 564 let _ = variants; 565 visitor.visit_enum(self) 566 } 567 568 forward_to_deserialize_any! { 569 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 570 bytes byte_buf option unit unit_struct newtype_struct seq tuple 571 tuple_struct map struct identifier ignored_any 572 } 573 } 574 575 #[cfg(any(feature = "std", feature = "alloc"))] 576 impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E> 577 where 578 E: de::Error, 579 { 580 type Error = E; 581 type Variant = private::UnitOnly<E>; 582 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,583 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 584 where 585 T: de::DeserializeSeed<'de>, 586 { 587 seed.deserialize(self).map(private::unit_only) 588 } 589 } 590 591 //////////////////////////////////////////////////////////////////////////////// 592 593 /// A deserializer holding a `Cow<str>`. 594 #[cfg(any(feature = "std", feature = "alloc"))] 595 #[derive(Debug)] 596 pub struct CowStrDeserializer<'a, E> { 597 value: Cow<'a, str>, 598 marker: PhantomData<E>, 599 } 600 601 #[cfg(any(feature = "std", feature = "alloc"))] 602 impl<'a, E> Clone for CowStrDeserializer<'a, E> { clone(&self) -> Self603 fn clone(&self) -> Self { 604 CowStrDeserializer { 605 value: self.value.clone(), 606 marker: PhantomData, 607 } 608 } 609 } 610 611 #[cfg(any(feature = "std", feature = "alloc"))] 612 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> 613 where 614 E: de::Error, 615 { 616 type Deserializer = CowStrDeserializer<'a, E>; 617 into_deserializer(self) -> CowStrDeserializer<'a, E>618 fn into_deserializer(self) -> CowStrDeserializer<'a, E> { 619 CowStrDeserializer { 620 value: self, 621 marker: PhantomData, 622 } 623 } 624 } 625 626 #[cfg(any(feature = "std", feature = "alloc"))] 627 impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E> 628 where 629 E: de::Error, 630 { 631 type Error = E; 632 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,633 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 634 where 635 V: de::Visitor<'de>, 636 { 637 match self.value { 638 Cow::Borrowed(string) => visitor.visit_str(string), 639 Cow::Owned(string) => visitor.visit_string(string), 640 } 641 } 642 deserialize_enum<V>( self, name: &str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,643 fn deserialize_enum<V>( 644 self, 645 name: &str, 646 variants: &'static [&'static str], 647 visitor: V, 648 ) -> Result<V::Value, Self::Error> 649 where 650 V: de::Visitor<'de>, 651 { 652 let _ = name; 653 let _ = variants; 654 visitor.visit_enum(self) 655 } 656 657 forward_to_deserialize_any! { 658 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 659 bytes byte_buf option unit unit_struct newtype_struct seq tuple 660 tuple_struct map struct identifier ignored_any 661 } 662 } 663 664 #[cfg(any(feature = "std", feature = "alloc"))] 665 impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E> 666 where 667 E: de::Error, 668 { 669 type Error = E; 670 type Variant = private::UnitOnly<E>; 671 variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>,672 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> 673 where 674 T: de::DeserializeSeed<'de>, 675 { 676 seed.deserialize(self).map(private::unit_only) 677 } 678 } 679 680 //////////////////////////////////////////////////////////////////////////////// 681 682 /// A deserializer holding a `&[u8]` with a lifetime tied to another 683 /// deserializer. 684 #[derive(Debug)] 685 pub struct BorrowedBytesDeserializer<'de, E> { 686 value: &'de [u8], 687 marker: PhantomData<E>, 688 } 689 690 impl_copy_clone!(BorrowedBytesDeserializer<'de>); 691 692 impl<'de, E> BorrowedBytesDeserializer<'de, E> { 693 /// Create a new borrowed deserializer from the given byte slice. new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E>694 pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> { 695 BorrowedBytesDeserializer { 696 value: value, 697 marker: PhantomData, 698 } 699 } 700 } 701 702 impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E> 703 where 704 E: de::Error, 705 { 706 type Error = E; 707 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,708 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 709 where 710 V: de::Visitor<'de>, 711 { 712 visitor.visit_borrowed_bytes(self.value) 713 } 714 715 forward_to_deserialize_any! { 716 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 717 bytes byte_buf option unit unit_struct newtype_struct seq tuple 718 tuple_struct map struct identifier ignored_any enum 719 } 720 } 721 722 //////////////////////////////////////////////////////////////////////////////// 723 724 /// A deserializer that iterates over a sequence. 725 #[derive(Clone, Debug)] 726 pub struct SeqDeserializer<I, E> { 727 iter: iter::Fuse<I>, 728 count: usize, 729 marker: PhantomData<E>, 730 } 731 732 impl<I, E> SeqDeserializer<I, E> 733 where 734 I: Iterator, 735 { 736 /// Construct a new `SeqDeserializer<I, E>`. new(iter: I) -> Self737 pub fn new(iter: I) -> Self { 738 SeqDeserializer { 739 iter: iter.fuse(), 740 count: 0, 741 marker: PhantomData, 742 } 743 } 744 } 745 746 impl<I, E> SeqDeserializer<I, E> 747 where 748 I: Iterator, 749 E: de::Error, 750 { 751 /// Check for remaining elements after passing a `SeqDeserializer` to 752 /// `Visitor::visit_seq`. end(self) -> Result<(), E>753 pub fn end(self) -> Result<(), E> { 754 let remaining = self.iter.count(); 755 if remaining == 0 { 756 Ok(()) 757 } else { 758 // First argument is the number of elements in the data, second 759 // argument is the number of elements expected by the Deserialize. 760 Err(de::Error::invalid_length( 761 self.count + remaining, 762 &ExpectedInSeq(self.count), 763 )) 764 } 765 } 766 } 767 768 impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E> 769 where 770 I: Iterator<Item = T>, 771 T: IntoDeserializer<'de, E>, 772 E: de::Error, 773 { 774 type Error = E; 775 deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,776 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 777 where 778 V: de::Visitor<'de>, 779 { 780 let v = try!(visitor.visit_seq(&mut self)); 781 try!(self.end()); 782 Ok(v) 783 } 784 785 forward_to_deserialize_any! { 786 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 787 bytes byte_buf option unit unit_struct newtype_struct seq tuple 788 tuple_struct map struct enum identifier ignored_any 789 } 790 } 791 792 impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> 793 where 794 I: Iterator<Item = T>, 795 T: IntoDeserializer<'de, E>, 796 E: de::Error, 797 { 798 type Error = E; 799 next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> where V: de::DeserializeSeed<'de>,800 fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> 801 where 802 V: de::DeserializeSeed<'de>, 803 { 804 match self.iter.next() { 805 Some(value) => { 806 self.count += 1; 807 seed.deserialize(value.into_deserializer()).map(Some) 808 } 809 None => Ok(None), 810 } 811 } 812 size_hint(&self) -> Option<usize>813 fn size_hint(&self) -> Option<usize> { 814 size_hint::from_bounds(&self.iter) 815 } 816 } 817 818 struct ExpectedInSeq(usize); 819 820 impl Expected for ExpectedInSeq { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result821 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 822 if self.0 == 1 { 823 write!(formatter, "1 element in sequence") 824 } else { 825 write!(formatter, "{} elements in sequence", self.0) 826 } 827 } 828 } 829 830 //////////////////////////////////////////////////////////////////////////////// 831 832 #[cfg(any(feature = "std", feature = "alloc"))] 833 impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> 834 where 835 T: IntoDeserializer<'de, E>, 836 E: de::Error, 837 { 838 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; 839 into_deserializer(self) -> Self::Deserializer840 fn into_deserializer(self) -> Self::Deserializer { 841 SeqDeserializer::new(self.into_iter()) 842 } 843 } 844 845 #[cfg(any(feature = "std", feature = "alloc"))] 846 impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> 847 where 848 T: IntoDeserializer<'de, E> + Eq + Ord, 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 #[cfg(feature = "std")] 859 impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> 860 where 861 T: IntoDeserializer<'de, E> + Eq + Hash, 862 S: BuildHasher, 863 E: de::Error, 864 { 865 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; 866 into_deserializer(self) -> Self::Deserializer867 fn into_deserializer(self) -> Self::Deserializer { 868 SeqDeserializer::new(self.into_iter()) 869 } 870 } 871 872 //////////////////////////////////////////////////////////////////////////////// 873 874 /// A deserializer holding a `SeqAccess`. 875 #[derive(Clone, Debug)] 876 pub struct SeqAccessDeserializer<A> { 877 seq: A, 878 } 879 880 impl<A> SeqAccessDeserializer<A> { 881 /// Construct a new `SeqAccessDeserializer<A>`. new(seq: A) -> Self882 pub fn new(seq: A) -> Self { 883 SeqAccessDeserializer { seq: seq } 884 } 885 } 886 887 impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> 888 where 889 A: de::SeqAccess<'de>, 890 { 891 type Error = A::Error; 892 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,893 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 894 where 895 V: de::Visitor<'de>, 896 { 897 visitor.visit_seq(self.seq) 898 } 899 900 forward_to_deserialize_any! { 901 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 902 bytes byte_buf option unit unit_struct newtype_struct seq tuple 903 tuple_struct map struct enum identifier ignored_any 904 } 905 } 906 907 //////////////////////////////////////////////////////////////////////////////// 908 909 /// A deserializer that iterates over a map. 910 pub struct MapDeserializer<'de, I, E> 911 where 912 I: Iterator, 913 I::Item: private::Pair, 914 { 915 iter: iter::Fuse<I>, 916 value: Option<Second<I::Item>>, 917 count: usize, 918 lifetime: PhantomData<&'de ()>, 919 error: PhantomData<E>, 920 } 921 922 impl<'de, I, E> MapDeserializer<'de, I, E> 923 where 924 I: Iterator, 925 I::Item: private::Pair, 926 { 927 /// Construct a new `MapDeserializer<I, E>`. new(iter: I) -> Self928 pub fn new(iter: I) -> Self { 929 MapDeserializer { 930 iter: iter.fuse(), 931 value: None, 932 count: 0, 933 lifetime: PhantomData, 934 error: PhantomData, 935 } 936 } 937 } 938 939 impl<'de, I, E> MapDeserializer<'de, I, E> 940 where 941 I: Iterator, 942 I::Item: private::Pair, 943 E: de::Error, 944 { 945 /// Check for remaining elements after passing a `MapDeserializer` to 946 /// `Visitor::visit_map`. end(self) -> Result<(), E>947 pub fn end(self) -> Result<(), E> { 948 let remaining = self.iter.count(); 949 if remaining == 0 { 950 Ok(()) 951 } else { 952 // First argument is the number of elements in the data, second 953 // argument is the number of elements expected by the Deserialize. 954 Err(de::Error::invalid_length( 955 self.count + remaining, 956 &ExpectedInMap(self.count), 957 )) 958 } 959 } 960 } 961 962 impl<'de, I, E> MapDeserializer<'de, I, E> 963 where 964 I: Iterator, 965 I::Item: private::Pair, 966 { next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)>967 fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> { 968 match self.iter.next() { 969 Some(kv) => { 970 self.count += 1; 971 Some(private::Pair::split(kv)) 972 } 973 None => None, 974 } 975 } 976 } 977 978 impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E> 979 where 980 I: Iterator, 981 I::Item: private::Pair, 982 First<I::Item>: IntoDeserializer<'de, E>, 983 Second<I::Item>: IntoDeserializer<'de, E>, 984 E: de::Error, 985 { 986 type Error = E; 987 deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,988 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 989 where 990 V: de::Visitor<'de>, 991 { 992 let value = try!(visitor.visit_map(&mut self)); 993 try!(self.end()); 994 Ok(value) 995 } 996 deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,997 fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> 998 where 999 V: de::Visitor<'de>, 1000 { 1001 let value = try!(visitor.visit_seq(&mut self)); 1002 try!(self.end()); 1003 Ok(value) 1004 } 1005 deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1006 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> 1007 where 1008 V: de::Visitor<'de>, 1009 { 1010 let _ = len; 1011 self.deserialize_seq(visitor) 1012 } 1013 1014 forward_to_deserialize_any! { 1015 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1016 bytes byte_buf option unit unit_struct newtype_struct tuple_struct map 1017 struct enum identifier ignored_any 1018 } 1019 } 1020 1021 impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E> 1022 where 1023 I: Iterator, 1024 I::Item: private::Pair, 1025 First<I::Item>: IntoDeserializer<'de, E>, 1026 Second<I::Item>: IntoDeserializer<'de, E>, 1027 E: de::Error, 1028 { 1029 type Error = E; 1030 next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1031 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1032 where 1033 T: de::DeserializeSeed<'de>, 1034 { 1035 match self.next_pair() { 1036 Some((key, value)) => { 1037 self.value = Some(value); 1038 seed.deserialize(key.into_deserializer()).map(Some) 1039 } 1040 None => Ok(None), 1041 } 1042 } 1043 next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1044 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> 1045 where 1046 T: de::DeserializeSeed<'de>, 1047 { 1048 let value = self.value.take(); 1049 // Panic because this indicates a bug in the program rather than an 1050 // expected failure. 1051 let value = value.expect("MapAccess::visit_value called before visit_key"); 1052 seed.deserialize(value.into_deserializer()) 1053 } 1054 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>,1055 fn next_entry_seed<TK, TV>( 1056 &mut self, 1057 kseed: TK, 1058 vseed: TV, 1059 ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> 1060 where 1061 TK: de::DeserializeSeed<'de>, 1062 TV: de::DeserializeSeed<'de>, 1063 { 1064 match self.next_pair() { 1065 Some((key, value)) => { 1066 let key = try!(kseed.deserialize(key.into_deserializer())); 1067 let value = try!(vseed.deserialize(value.into_deserializer())); 1068 Ok(Some((key, value))) 1069 } 1070 None => Ok(None), 1071 } 1072 } 1073 size_hint(&self) -> Option<usize>1074 fn size_hint(&self) -> Option<usize> { 1075 size_hint::from_bounds(&self.iter) 1076 } 1077 } 1078 1079 impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E> 1080 where 1081 I: Iterator, 1082 I::Item: private::Pair, 1083 First<I::Item>: IntoDeserializer<'de, E>, 1084 Second<I::Item>: IntoDeserializer<'de, E>, 1085 E: de::Error, 1086 { 1087 type Error = E; 1088 next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1089 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1090 where 1091 T: de::DeserializeSeed<'de>, 1092 { 1093 match self.next_pair() { 1094 Some((k, v)) => { 1095 let de = PairDeserializer(k, v, PhantomData); 1096 seed.deserialize(de).map(Some) 1097 } 1098 None => Ok(None), 1099 } 1100 } 1101 size_hint(&self) -> Option<usize>1102 fn size_hint(&self) -> Option<usize> { 1103 size_hint::from_bounds(&self.iter) 1104 } 1105 } 1106 1107 // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`. 1108 impl<'de, I, E> Clone for MapDeserializer<'de, I, E> 1109 where 1110 I: Iterator + Clone, 1111 I::Item: private::Pair, 1112 Second<I::Item>: Clone, 1113 { clone(&self) -> Self1114 fn clone(&self) -> Self { 1115 MapDeserializer { 1116 iter: self.iter.clone(), 1117 value: self.value.clone(), 1118 count: self.count, 1119 lifetime: self.lifetime, 1120 error: self.error, 1121 } 1122 } 1123 } 1124 1125 // Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`. 1126 impl<'de, I, E> Debug for MapDeserializer<'de, I, E> 1127 where 1128 I: Iterator + Debug, 1129 I::Item: private::Pair, 1130 Second<I::Item>: Debug, 1131 { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1132 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1133 formatter 1134 .debug_struct("MapDeserializer") 1135 .field("iter", &self.iter) 1136 .field("value", &self.value) 1137 .field("count", &self.count) 1138 .field("lifetime", &self.lifetime) 1139 .field("error", &self.error) 1140 .finish() 1141 } 1142 } 1143 1144 // Used in the `impl SeqAccess for MapDeserializer` to visit the map as a 1145 // sequence of pairs. 1146 struct PairDeserializer<A, B, E>(A, B, PhantomData<E>); 1147 1148 impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E> 1149 where 1150 A: IntoDeserializer<'de, E>, 1151 B: IntoDeserializer<'de, E>, 1152 E: de::Error, 1153 { 1154 type Error = E; 1155 1156 forward_to_deserialize_any! { 1157 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1158 bytes byte_buf option unit unit_struct newtype_struct tuple_struct map 1159 struct enum identifier ignored_any 1160 } 1161 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1162 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1163 where 1164 V: de::Visitor<'de>, 1165 { 1166 self.deserialize_seq(visitor) 1167 } 1168 deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1169 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1170 where 1171 V: de::Visitor<'de>, 1172 { 1173 let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData); 1174 let pair = try!(visitor.visit_seq(&mut pair_visitor)); 1175 if pair_visitor.1.is_none() { 1176 Ok(pair) 1177 } else { 1178 let remaining = pair_visitor.size_hint().unwrap(); 1179 // First argument is the number of elements in the data, second 1180 // argument is the number of elements expected by the Deserialize. 1181 Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining))) 1182 } 1183 } 1184 deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1185 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> 1186 where 1187 V: de::Visitor<'de>, 1188 { 1189 if len == 2 { 1190 self.deserialize_seq(visitor) 1191 } else { 1192 // First argument is the number of elements in the data, second 1193 // argument is the number of elements expected by the Deserialize. 1194 Err(de::Error::invalid_length(2, &ExpectedInSeq(len))) 1195 } 1196 } 1197 } 1198 1199 struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>); 1200 1201 impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> 1202 where 1203 A: IntoDeserializer<'de, E>, 1204 B: IntoDeserializer<'de, E>, 1205 E: de::Error, 1206 { 1207 type Error = E; 1208 next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: de::DeserializeSeed<'de>,1209 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> 1210 where 1211 T: de::DeserializeSeed<'de>, 1212 { 1213 if let Some(k) = self.0.take() { 1214 seed.deserialize(k.into_deserializer()).map(Some) 1215 } else if let Some(v) = self.1.take() { 1216 seed.deserialize(v.into_deserializer()).map(Some) 1217 } else { 1218 Ok(None) 1219 } 1220 } 1221 size_hint(&self) -> Option<usize>1222 fn size_hint(&self) -> Option<usize> { 1223 if self.0.is_some() { 1224 Some(2) 1225 } else if self.1.is_some() { 1226 Some(1) 1227 } else { 1228 Some(0) 1229 } 1230 } 1231 } 1232 1233 struct ExpectedInMap(usize); 1234 1235 impl Expected for ExpectedInMap { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1236 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1237 if self.0 == 1 { 1238 write!(formatter, "1 element in map") 1239 } else { 1240 write!(formatter, "{} elements in map", self.0) 1241 } 1242 } 1243 } 1244 1245 //////////////////////////////////////////////////////////////////////////////// 1246 1247 #[cfg(any(feature = "std", feature = "alloc"))] 1248 impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> 1249 where 1250 K: IntoDeserializer<'de, E> + Eq + Ord, 1251 V: IntoDeserializer<'de, E>, 1252 E: de::Error, 1253 { 1254 type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; 1255 into_deserializer(self) -> Self::Deserializer1256 fn into_deserializer(self) -> Self::Deserializer { 1257 MapDeserializer::new(self.into_iter()) 1258 } 1259 } 1260 1261 #[cfg(feature = "std")] 1262 impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S> 1263 where 1264 K: IntoDeserializer<'de, E> + Eq + Hash, 1265 V: IntoDeserializer<'de, E>, 1266 S: BuildHasher, 1267 E: de::Error, 1268 { 1269 type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; 1270 into_deserializer(self) -> Self::Deserializer1271 fn into_deserializer(self) -> Self::Deserializer { 1272 MapDeserializer::new(self.into_iter()) 1273 } 1274 } 1275 1276 //////////////////////////////////////////////////////////////////////////////// 1277 1278 /// A deserializer holding a `MapAccess`. 1279 #[derive(Clone, Debug)] 1280 pub struct MapAccessDeserializer<A> { 1281 map: A, 1282 } 1283 1284 impl<A> MapAccessDeserializer<A> { 1285 /// Construct a new `MapAccessDeserializer<A>`. new(map: A) -> Self1286 pub fn new(map: A) -> Self { 1287 MapAccessDeserializer { map: map } 1288 } 1289 } 1290 1291 impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> 1292 where 1293 A: de::MapAccess<'de>, 1294 { 1295 type Error = A::Error; 1296 deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1297 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 1298 where 1299 V: de::Visitor<'de>, 1300 { 1301 visitor.visit_map(self.map) 1302 } 1303 1304 forward_to_deserialize_any! { 1305 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 1306 bytes byte_buf option unit unit_struct newtype_struct seq tuple 1307 tuple_struct map struct enum identifier ignored_any 1308 } 1309 } 1310 1311 //////////////////////////////////////////////////////////////////////////////// 1312 1313 mod private { 1314 use lib::*; 1315 1316 use de::{self, Unexpected}; 1317 1318 #[derive(Clone, Debug)] 1319 pub struct UnitOnly<E> { 1320 marker: PhantomData<E>, 1321 } 1322 unit_only<T, E>(t: T) -> (T, UnitOnly<E>)1323 pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) { 1324 ( 1325 t, 1326 UnitOnly { 1327 marker: PhantomData, 1328 }, 1329 ) 1330 } 1331 1332 impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> 1333 where 1334 E: de::Error, 1335 { 1336 type Error = E; 1337 unit_variant(self) -> Result<(), Self::Error>1338 fn unit_variant(self) -> Result<(), Self::Error> { 1339 Ok(()) 1340 } 1341 newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,1342 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> 1343 where 1344 T: de::DeserializeSeed<'de>, 1345 { 1346 Err(de::Error::invalid_type( 1347 Unexpected::UnitVariant, 1348 &"newtype variant", 1349 )) 1350 } 1351 tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1352 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> 1353 where 1354 V: de::Visitor<'de>, 1355 { 1356 Err(de::Error::invalid_type( 1357 Unexpected::UnitVariant, 1358 &"tuple variant", 1359 )) 1360 } 1361 struct_variant<V>( self, _fields: &'static [&'static str], _visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,1362 fn struct_variant<V>( 1363 self, 1364 _fields: &'static [&'static str], 1365 _visitor: V, 1366 ) -> Result<V::Value, Self::Error> 1367 where 1368 V: de::Visitor<'de>, 1369 { 1370 Err(de::Error::invalid_type( 1371 Unexpected::UnitVariant, 1372 &"struct variant", 1373 )) 1374 } 1375 } 1376 1377 /// Avoid having to restate the generic types on `MapDeserializer`. The 1378 /// `Iterator::Item` contains enough information to figure out K and V. 1379 pub trait Pair { 1380 type First; 1381 type Second; split(self) -> (Self::First, Self::Second)1382 fn split(self) -> (Self::First, Self::Second); 1383 } 1384 1385 impl<A, B> Pair for (A, B) { 1386 type First = A; 1387 type Second = B; split(self) -> (A, B)1388 fn split(self) -> (A, B) { 1389 self 1390 } 1391 } 1392 1393 pub type First<T> = <T as Pair>::First; 1394 pub type Second<T> = <T as Pair>::Second; 1395 } 1396