1 use serde::de::{ 2 Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, 3 VariantAccess, Visitor, 4 }; 5 use serde::ser::{ 6 Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple, 7 SerializeTupleStruct, SerializeTupleVariant, Serializer, 8 }; 9 use std::fmt::{self, Display}; 10 11 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] 12 pub struct Readable<T: ?Sized>(T); 13 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] 14 pub struct Compact<T: ?Sized>(T); 15 16 /// Trait to determine whether a value is represented in human-readable or 17 /// compact form. 18 /// 19 /// ``` 20 /// use serde::{Deserialize, Deserializer, Serialize, Serializer}; 21 /// use serde_test::{assert_tokens, Configure, Token}; 22 /// 23 /// #[derive(Debug, PartialEq)] 24 /// struct Example(u8, u8); 25 /// 26 /// impl Serialize for Example { 27 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 28 /// where 29 /// S: Serializer, 30 /// { 31 /// if serializer.is_human_readable() { 32 /// format!("{}.{}", self.0, self.1).serialize(serializer) 33 /// } else { 34 /// (self.0, self.1).serialize(serializer) 35 /// } 36 /// } 37 /// } 38 /// 39 /// impl<'de> Deserialize<'de> for Example { 40 /// fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 41 /// where 42 /// D: Deserializer<'de>, 43 /// { 44 /// use serde::de::Error; 45 /// if deserializer.is_human_readable() { 46 /// let s = String::deserialize(deserializer)?; 47 /// let parts: Vec<_> = s.split('.').collect(); 48 /// Ok(Example( 49 /// parts[0].parse().map_err(D::Error::custom)?, 50 /// parts[1].parse().map_err(D::Error::custom)?, 51 /// )) 52 /// } else { 53 /// let (x, y) = Deserialize::deserialize(deserializer)?; 54 /// Ok(Example(x, y)) 55 /// } 56 /// } 57 /// } 58 /// 59 /// fn main() { 60 /// assert_tokens( 61 /// &Example(1, 0).compact(), 62 /// &[ 63 /// Token::Tuple { len: 2 }, 64 /// Token::U8(1), 65 /// Token::U8(0), 66 /// Token::TupleEnd, 67 /// ], 68 /// ); 69 /// assert_tokens(&Example(1, 0).readable(), &[Token::Str("1.0")]); 70 /// } 71 /// ``` 72 pub trait Configure { 73 /// Marks `self` as using `is_human_readable == true` readable(self) -> Readable<Self> where Self: Sized,74 fn readable(self) -> Readable<Self> 75 where 76 Self: Sized, 77 { 78 Readable(self) 79 } 80 /// Marks `self` as using `is_human_readable == false` compact(self) -> Compact<Self> where Self: Sized,81 fn compact(self) -> Compact<Self> 82 where 83 Self: Sized, 84 { 85 Compact(self) 86 } 87 } 88 89 impl<T> Configure for T where T: ?Sized {} 90 91 impl<T> Serialize for Readable<T> 92 where 93 T: ?Sized + Serialize, 94 { 95 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,96 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 97 where 98 S: Serializer, 99 { 100 self.0.serialize(Readable(serializer)) 101 } 102 } 103 104 impl<T> Serialize for Compact<T> 105 where 106 T: ?Sized + Serialize, 107 { 108 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,109 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 110 where 111 S: Serializer, 112 { 113 self.0.serialize(Compact(serializer)) 114 } 115 } 116 117 impl<'de, T> Deserialize<'de> for Readable<T> 118 where 119 T: Deserialize<'de>, 120 { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,121 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 122 where 123 D: Deserializer<'de>, 124 { 125 T::deserialize(Readable(deserializer)).map(Readable) 126 } 127 deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>,128 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> 129 where 130 D: Deserializer<'de>, 131 { 132 T::deserialize_in_place(Readable(deserializer), &mut place.0) 133 } 134 } 135 136 impl<'de, T> Deserialize<'de> for Compact<T> 137 where 138 T: Deserialize<'de>, 139 { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,140 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 141 where 142 D: Deserializer<'de>, 143 { 144 T::deserialize(Compact(deserializer)).map(Compact) 145 } 146 deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>,147 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error> 148 where 149 D: Deserializer<'de>, 150 { 151 T::deserialize_in_place(Compact(deserializer), &mut place.0) 152 } 153 } 154 155 impl<'de, T> DeserializeSeed<'de> for Readable<T> 156 where 157 T: DeserializeSeed<'de>, 158 { 159 type Value = T::Value; 160 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,161 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 162 where 163 D: Deserializer<'de>, 164 { 165 self.0.deserialize(Readable(deserializer)) 166 } 167 } 168 169 impl<'de, T> DeserializeSeed<'de> for Compact<T> 170 where 171 T: DeserializeSeed<'de>, 172 { 173 type Value = T::Value; 174 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,175 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 176 where 177 D: Deserializer<'de>, 178 { 179 self.0.deserialize(Compact(deserializer)) 180 } 181 } 182 183 macro_rules! forward_method { 184 ($name: ident (self $(, $arg: ident : $arg_type: ty)* ) -> $return_type: ty) => { 185 fn $name (self $(, $arg : $arg_type)* ) -> $return_type { 186 (self.0).$name( $($arg),* ) 187 } 188 }; 189 } 190 191 macro_rules! forward_serialize_methods { 192 ( $( $name: ident $arg_type: ty ),* ) => { 193 $( 194 forward_method!($name(self, v : $arg_type) -> Result<Self::Ok, Self::Error>); 195 )* 196 }; 197 } 198 199 macro_rules! impl_serializer { 200 ($wrapper:ident, $is_human_readable:expr) => { 201 impl<S> Serializer for $wrapper<S> 202 where 203 S: Serializer, 204 { 205 type Ok = S::Ok; 206 type Error = S::Error; 207 208 type SerializeSeq = $wrapper<S::SerializeSeq>; 209 type SerializeTuple = $wrapper<S::SerializeTuple>; 210 type SerializeTupleStruct = $wrapper<S::SerializeTupleStruct>; 211 type SerializeTupleVariant = $wrapper<S::SerializeTupleVariant>; 212 type SerializeMap = $wrapper<S::SerializeMap>; 213 type SerializeStruct = $wrapper<S::SerializeStruct>; 214 type SerializeStructVariant = $wrapper<S::SerializeStructVariant>; 215 216 fn is_human_readable(&self) -> bool { 217 $is_human_readable 218 } 219 220 forward_serialize_methods! { 221 serialize_bool bool, 222 serialize_i8 i8, 223 serialize_i16 i16, 224 serialize_i32 i32, 225 serialize_i64 i64, 226 serialize_i128 i128, 227 serialize_u8 u8, 228 serialize_u16 u16, 229 serialize_u32 u32, 230 serialize_u64 u64, 231 serialize_u128 u128, 232 serialize_f32 f32, 233 serialize_f64 f64, 234 serialize_char char, 235 serialize_str &str, 236 serialize_bytes &[u8], 237 serialize_unit_struct &'static str 238 } 239 240 fn serialize_unit(self) -> Result<S::Ok, S::Error> { 241 self.0.serialize_unit() 242 } 243 244 fn serialize_unit_variant( 245 self, 246 name: &'static str, 247 variant_index: u32, 248 variant: &'static str, 249 ) -> Result<S::Ok, S::Error> { 250 self.0.serialize_unit_variant(name, variant_index, variant) 251 } 252 253 fn serialize_newtype_struct<T>( 254 self, 255 name: &'static str, 256 value: &T, 257 ) -> Result<S::Ok, S::Error> 258 where 259 T: ?Sized + Serialize, 260 { 261 self.0.serialize_newtype_struct(name, &$wrapper(value)) 262 } 263 264 fn serialize_newtype_variant<T>( 265 self, 266 name: &'static str, 267 variant_index: u32, 268 variant: &'static str, 269 value: &T, 270 ) -> Result<S::Ok, S::Error> 271 where 272 T: ?Sized + Serialize, 273 { 274 self.0 275 .serialize_newtype_variant(name, variant_index, variant, &$wrapper(value)) 276 } 277 278 fn serialize_none(self) -> Result<S::Ok, Self::Error> { 279 self.0.serialize_none() 280 } 281 282 fn serialize_some<T>(self, value: &T) -> Result<S::Ok, Self::Error> 283 where 284 T: ?Sized + Serialize, 285 { 286 self.0.serialize_some(&$wrapper(value)) 287 } 288 289 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { 290 self.0.serialize_seq(len).map($wrapper) 291 } 292 293 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> { 294 self.0.serialize_tuple(len).map($wrapper) 295 } 296 297 fn serialize_tuple_struct( 298 self, 299 name: &'static str, 300 len: usize, 301 ) -> Result<Self::SerializeTupleStruct, Self::Error> { 302 self.0.serialize_tuple_struct(name, len).map($wrapper) 303 } 304 305 fn serialize_tuple_variant( 306 self, 307 name: &'static str, 308 variant_index: u32, 309 variant: &'static str, 310 len: usize, 311 ) -> Result<Self::SerializeTupleVariant, Self::Error> { 312 self.0 313 .serialize_tuple_variant(name, variant_index, variant, len) 314 .map($wrapper) 315 } 316 317 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { 318 self.0.serialize_map(len).map($wrapper) 319 } 320 321 fn serialize_struct( 322 self, 323 name: &'static str, 324 len: usize, 325 ) -> Result<Self::SerializeStruct, Self::Error> { 326 self.0.serialize_struct(name, len).map($wrapper) 327 } 328 329 fn serialize_struct_variant( 330 self, 331 name: &'static str, 332 variant_index: u32, 333 variant: &'static str, 334 len: usize, 335 ) -> Result<Self::SerializeStructVariant, Self::Error> { 336 self.0 337 .serialize_struct_variant(name, variant_index, variant, len) 338 .map($wrapper) 339 } 340 341 fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> 342 where 343 I: IntoIterator, 344 <I as IntoIterator>::Item: Serialize, 345 { 346 self.0 347 .collect_seq(iter.into_iter().map(|item| $wrapper(item))) 348 } 349 350 fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> 351 where 352 K: Serialize, 353 V: Serialize, 354 I: IntoIterator<Item = (K, V)>, 355 { 356 self.0.collect_map( 357 iter.into_iter() 358 .map(|(key, value)| ($wrapper(key), $wrapper(value))), 359 ) 360 } 361 362 fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> 363 where 364 T: ?Sized + Display, 365 { 366 self.0.collect_str(value) 367 } 368 } 369 370 impl<S> SerializeSeq for $wrapper<S> 371 where 372 S: SerializeSeq, 373 { 374 type Ok = S::Ok; 375 type Error = S::Error; 376 377 fn serialize_element<T>(&mut self, value: &T) -> Result<(), S::Error> 378 where 379 T: ?Sized + Serialize, 380 { 381 self.0.serialize_element(&$wrapper(value)) 382 } 383 384 fn end(self) -> Result<S::Ok, S::Error> { 385 self.0.end() 386 } 387 } 388 389 impl<S> SerializeTuple for $wrapper<S> 390 where 391 S: SerializeTuple, 392 { 393 type Ok = S::Ok; 394 type Error = S::Error; 395 396 fn serialize_element<T>(&mut self, value: &T) -> Result<(), S::Error> 397 where 398 T: ?Sized + Serialize, 399 { 400 self.0.serialize_element(&$wrapper(value)) 401 } 402 403 fn end(self) -> Result<S::Ok, S::Error> { 404 self.0.end() 405 } 406 } 407 408 impl<S> SerializeTupleStruct for $wrapper<S> 409 where 410 S: SerializeTupleStruct, 411 { 412 type Ok = S::Ok; 413 type Error = S::Error; 414 415 fn serialize_field<T>(&mut self, value: &T) -> Result<(), S::Error> 416 where 417 T: ?Sized + Serialize, 418 { 419 self.0.serialize_field(&$wrapper(value)) 420 } 421 422 fn end(self) -> Result<S::Ok, S::Error> { 423 self.0.end() 424 } 425 } 426 427 impl<S> SerializeTupleVariant for $wrapper<S> 428 where 429 S: SerializeTupleVariant, 430 { 431 type Ok = S::Ok; 432 type Error = S::Error; 433 434 fn serialize_field<T>(&mut self, value: &T) -> Result<(), S::Error> 435 where 436 T: ?Sized + Serialize, 437 { 438 self.0.serialize_field(&$wrapper(value)) 439 } 440 441 fn end(self) -> Result<S::Ok, S::Error> { 442 self.0.end() 443 } 444 } 445 446 impl<S> SerializeMap for $wrapper<S> 447 where 448 S: SerializeMap, 449 { 450 type Ok = S::Ok; 451 type Error = S::Error; 452 453 fn serialize_key<T>(&mut self, key: &T) -> Result<(), S::Error> 454 where 455 T: ?Sized + Serialize, 456 { 457 self.0.serialize_key(&$wrapper(key)) 458 } 459 460 fn serialize_value<T>(&mut self, value: &T) -> Result<(), S::Error> 461 where 462 T: ?Sized + Serialize, 463 { 464 self.0.serialize_value(&$wrapper(value)) 465 } 466 467 fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), S::Error> 468 where 469 K: ?Sized + Serialize, 470 V: ?Sized + Serialize, 471 { 472 self.0.serialize_entry(&$wrapper(key), &$wrapper(value)) 473 } 474 475 fn end(self) -> Result<S::Ok, S::Error> { 476 self.0.end() 477 } 478 } 479 480 impl<S> SerializeStruct for $wrapper<S> 481 where 482 S: SerializeStruct, 483 { 484 type Ok = S::Ok; 485 type Error = S::Error; 486 487 fn serialize_field<T>(&mut self, name: &'static str, field: &T) -> Result<(), S::Error> 488 where 489 T: ?Sized + Serialize, 490 { 491 self.0.serialize_field(name, &$wrapper(field)) 492 } 493 494 fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { 495 self.0.skip_field(key) 496 } 497 498 fn end(self) -> Result<S::Ok, S::Error> { 499 self.0.end() 500 } 501 } 502 503 impl<S> SerializeStructVariant for $wrapper<S> 504 where 505 S: SerializeStructVariant, 506 { 507 type Ok = S::Ok; 508 type Error = S::Error; 509 510 fn serialize_field<T>(&mut self, name: &'static str, field: &T) -> Result<(), S::Error> 511 where 512 T: ?Sized + Serialize, 513 { 514 self.0.serialize_field(name, &$wrapper(field)) 515 } 516 517 fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { 518 self.0.skip_field(key) 519 } 520 521 fn end(self) -> Result<S::Ok, S::Error> { 522 self.0.end() 523 } 524 } 525 }; 526 } 527 528 impl_serializer!(Readable, true); 529 impl_serializer!(Compact, false); 530 531 macro_rules! forward_deserialize_methods { 532 ( $wrapper : ident ( $( $name: ident ),* ) ) => { 533 $( 534 fn $name<V>(self, visitor: V) -> Result<V::Value, D::Error> 535 where 536 V: Visitor<'de>, 537 { 538 (self.0).$name($wrapper(visitor)) 539 } 540 )* 541 }; 542 } 543 544 macro_rules! impl_deserializer { 545 ($wrapper:ident, $is_human_readable:expr) => { 546 impl<'de, D> Deserializer<'de> for $wrapper<D> 547 where 548 D: Deserializer<'de>, 549 { 550 type Error = D::Error; 551 552 forward_deserialize_methods! { 553 $wrapper ( 554 deserialize_any, 555 deserialize_bool, 556 deserialize_u8, 557 deserialize_u16, 558 deserialize_u32, 559 deserialize_u64, 560 deserialize_u128, 561 deserialize_i8, 562 deserialize_i16, 563 deserialize_i32, 564 deserialize_i64, 565 deserialize_i128, 566 deserialize_f32, 567 deserialize_f64, 568 deserialize_char, 569 deserialize_str, 570 deserialize_string, 571 deserialize_bytes, 572 deserialize_byte_buf, 573 deserialize_option, 574 deserialize_unit, 575 deserialize_seq, 576 deserialize_map, 577 deserialize_identifier, 578 deserialize_ignored_any 579 ) 580 } 581 582 fn deserialize_unit_struct<V>( 583 self, 584 name: &'static str, 585 visitor: V, 586 ) -> Result<V::Value, D::Error> 587 where 588 V: Visitor<'de>, 589 { 590 self.0.deserialize_unit_struct(name, $wrapper(visitor)) 591 } 592 593 fn deserialize_newtype_struct<V>( 594 self, 595 name: &'static str, 596 visitor: V, 597 ) -> Result<V::Value, D::Error> 598 where 599 V: Visitor<'de>, 600 { 601 self.0.deserialize_newtype_struct(name, $wrapper(visitor)) 602 } 603 604 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error> 605 where 606 V: Visitor<'de>, 607 { 608 self.0.deserialize_tuple(len, $wrapper(visitor)) 609 } 610 611 fn deserialize_tuple_struct<V>( 612 self, 613 name: &'static str, 614 len: usize, 615 visitor: V, 616 ) -> Result<V::Value, D::Error> 617 where 618 V: Visitor<'de>, 619 { 620 self.0 621 .deserialize_tuple_struct(name, len, $wrapper(visitor)) 622 } 623 624 fn deserialize_struct<V>( 625 self, 626 name: &'static str, 627 fields: &'static [&'static str], 628 visitor: V, 629 ) -> Result<V::Value, D::Error> 630 where 631 V: Visitor<'de>, 632 { 633 self.0.deserialize_struct(name, fields, $wrapper(visitor)) 634 } 635 636 fn deserialize_enum<V>( 637 self, 638 name: &'static str, 639 variants: &'static [&'static str], 640 visitor: V, 641 ) -> Result<V::Value, D::Error> 642 where 643 V: Visitor<'de>, 644 { 645 self.0.deserialize_enum(name, variants, $wrapper(visitor)) 646 } 647 648 fn is_human_readable(&self) -> bool { 649 $is_human_readable 650 } 651 } 652 653 impl<'de, D> Visitor<'de> for $wrapper<D> 654 where 655 D: Visitor<'de>, 656 { 657 type Value = D::Value; 658 659 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 660 self.0.expecting(formatter) 661 } 662 663 fn visit_bool<E>(self, v: bool) -> Result<D::Value, E> 664 where 665 E: Error, 666 { 667 self.0.visit_bool(v) 668 } 669 670 fn visit_i8<E>(self, v: i8) -> Result<D::Value, E> 671 where 672 E: Error, 673 { 674 self.0.visit_i8(v) 675 } 676 677 fn visit_i16<E>(self, v: i16) -> Result<D::Value, E> 678 where 679 E: Error, 680 { 681 self.0.visit_i16(v) 682 } 683 684 fn visit_i32<E>(self, v: i32) -> Result<D::Value, E> 685 where 686 E: Error, 687 { 688 self.0.visit_i32(v) 689 } 690 691 fn visit_i64<E>(self, v: i64) -> Result<D::Value, E> 692 where 693 E: Error, 694 { 695 self.0.visit_i64(v) 696 } 697 698 fn visit_i128<E>(self, v: i128) -> Result<D::Value, E> 699 where 700 E: Error, 701 { 702 self.0.visit_i128(v) 703 } 704 705 fn visit_u8<E>(self, v: u8) -> Result<D::Value, E> 706 where 707 E: Error, 708 { 709 self.0.visit_u8(v) 710 } 711 712 fn visit_u16<E>(self, v: u16) -> Result<D::Value, E> 713 where 714 E: Error, 715 { 716 self.0.visit_u16(v) 717 } 718 719 fn visit_u32<E>(self, v: u32) -> Result<D::Value, E> 720 where 721 E: Error, 722 { 723 self.0.visit_u32(v) 724 } 725 726 fn visit_u64<E>(self, v: u64) -> Result<D::Value, E> 727 where 728 E: Error, 729 { 730 self.0.visit_u64(v) 731 } 732 733 fn visit_u128<E>(self, v: u128) -> Result<D::Value, E> 734 where 735 E: Error, 736 { 737 self.0.visit_u128(v) 738 } 739 740 fn visit_f32<E>(self, v: f32) -> Result<D::Value, E> 741 where 742 E: Error, 743 { 744 self.0.visit_f32(v) 745 } 746 747 fn visit_f64<E>(self, v: f64) -> Result<D::Value, E> 748 where 749 E: Error, 750 { 751 self.0.visit_f64(v) 752 } 753 754 fn visit_char<E>(self, v: char) -> Result<D::Value, E> 755 where 756 E: Error, 757 { 758 self.0.visit_char(v) 759 } 760 761 fn visit_str<E>(self, v: &str) -> Result<D::Value, E> 762 where 763 E: Error, 764 { 765 self.0.visit_str(v) 766 } 767 768 fn visit_borrowed_str<E>(self, v: &'de str) -> Result<D::Value, E> 769 where 770 E: Error, 771 { 772 self.0.visit_borrowed_str(v) 773 } 774 775 fn visit_string<E>(self, v: String) -> Result<D::Value, E> 776 where 777 E: Error, 778 { 779 self.0.visit_string(v) 780 } 781 782 fn visit_bytes<E>(self, v: &[u8]) -> Result<D::Value, E> 783 where 784 E: Error, 785 { 786 self.0.visit_bytes(v) 787 } 788 789 fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<D::Value, E> 790 where 791 E: Error, 792 { 793 self.0.visit_borrowed_bytes(v) 794 } 795 796 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<D::Value, E> 797 where 798 E: Error, 799 { 800 self.0.visit_byte_buf(v) 801 } 802 803 fn visit_none<E>(self) -> Result<D::Value, E> 804 where 805 E: Error, 806 { 807 self.0.visit_none() 808 } 809 810 fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error> 811 where 812 D2: Deserializer<'de>, 813 { 814 self.0.visit_some($wrapper(deserializer)) 815 } 816 817 fn visit_unit<E>(self) -> Result<D::Value, E> 818 where 819 E: Error, 820 { 821 self.0.visit_unit() 822 } 823 824 fn visit_newtype_struct<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error> 825 where 826 D2: Deserializer<'de>, 827 { 828 self.0.visit_newtype_struct($wrapper(deserializer)) 829 } 830 831 fn visit_seq<V>(self, seq: V) -> Result<D::Value, V::Error> 832 where 833 V: SeqAccess<'de>, 834 { 835 self.0.visit_seq($wrapper(seq)) 836 } 837 838 fn visit_map<V>(self, map: V) -> Result<D::Value, V::Error> 839 where 840 V: MapAccess<'de>, 841 { 842 self.0.visit_map($wrapper(map)) 843 } 844 845 fn visit_enum<V>(self, data: V) -> Result<D::Value, V::Error> 846 where 847 V: EnumAccess<'de>, 848 { 849 self.0.visit_enum($wrapper(data)) 850 } 851 } 852 853 impl<'de, D> SeqAccess<'de> for $wrapper<D> 854 where 855 D: SeqAccess<'de>, 856 { 857 type Error = D::Error; 858 859 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, D::Error> 860 where 861 T: DeserializeSeed<'de>, 862 { 863 self.0.next_element_seed($wrapper(seed)) 864 } 865 866 fn size_hint(&self) -> Option<usize> { 867 self.0.size_hint() 868 } 869 } 870 871 impl<'de, D> MapAccess<'de> for $wrapper<D> 872 where 873 D: MapAccess<'de>, 874 { 875 type Error = D::Error; 876 877 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error> 878 where 879 K: DeserializeSeed<'de>, 880 { 881 self.0.next_key_seed($wrapper(seed)) 882 } 883 884 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error> 885 where 886 V: DeserializeSeed<'de>, 887 { 888 self.0.next_value_seed($wrapper(seed)) 889 } 890 891 fn next_entry_seed<K, V>( 892 &mut self, 893 kseed: K, 894 vseed: V, 895 ) -> Result<Option<(K::Value, V::Value)>, D::Error> 896 where 897 K: DeserializeSeed<'de>, 898 V: DeserializeSeed<'de>, 899 { 900 self.0.next_entry_seed($wrapper(kseed), $wrapper(vseed)) 901 } 902 903 fn size_hint(&self) -> Option<usize> { 904 self.0.size_hint() 905 } 906 } 907 908 impl<'de, D> EnumAccess<'de> for $wrapper<D> 909 where 910 D: EnumAccess<'de>, 911 { 912 type Error = D::Error; 913 type Variant = $wrapper<D::Variant>; 914 915 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> 916 where 917 V: DeserializeSeed<'de>, 918 { 919 self.0 920 .variant_seed($wrapper(seed)) 921 .map(|(value, variant)| (value, $wrapper(variant))) 922 } 923 } 924 925 impl<'de, D> VariantAccess<'de> for $wrapper<D> 926 where 927 D: VariantAccess<'de>, 928 { 929 type Error = D::Error; 930 931 fn unit_variant(self) -> Result<(), D::Error> { 932 self.0.unit_variant() 933 } 934 935 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error> 936 where 937 T: DeserializeSeed<'de>, 938 { 939 self.0.newtype_variant_seed($wrapper(seed)) 940 } 941 942 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error> 943 where 944 V: Visitor<'de>, 945 { 946 self.0.tuple_variant(len, $wrapper(visitor)) 947 } 948 949 fn struct_variant<V>( 950 self, 951 fields: &'static [&'static str], 952 visitor: V, 953 ) -> Result<V::Value, D::Error> 954 where 955 V: Visitor<'de>, 956 { 957 self.0.struct_variant(fields, $wrapper(visitor)) 958 } 959 } 960 }; 961 } 962 963 impl_deserializer!(Readable, true); 964 impl_deserializer!(Compact, false); 965