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;
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: ?Sized> Configure for T {}
90 
91 impl<T: ?Sized> Serialize for Readable<T>
92 where
93     T: 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 impl<T: ?Sized> Serialize for Compact<T>
104 where
105     T: Serialize,
106 {
107     #[inline]
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,108     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
109     where
110         S: Serializer,
111     {
112         self.0.serialize(Compact(serializer))
113     }
114 }
115 impl<'de, T> Deserialize<'de> for Readable<T>
116 where
117     T: Deserialize<'de>,
118 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,119     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
120     where
121         D: Deserializer<'de>,
122     {
123         T::deserialize(Readable(deserializer)).map(Readable)
124     }
125 }
126 impl<'de, T> Deserialize<'de> for Compact<T>
127 where
128     T: Deserialize<'de>,
129 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,130     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
131     where
132         D: Deserializer<'de>,
133     {
134         T::deserialize(Compact(deserializer)).map(Compact)
135     }
136 }
137 
138 impl<'de, T> DeserializeSeed<'de> for Readable<T>
139 where
140     T: DeserializeSeed<'de>,
141 {
142     type Value = T::Value;
143 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,144     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
145     where
146         D: Deserializer<'de>,
147     {
148         self.0.deserialize(Readable(deserializer))
149     }
150 }
151 impl<'de, T> DeserializeSeed<'de> for Compact<T>
152 where
153     T: DeserializeSeed<'de>,
154 {
155     type Value = T::Value;
156 
deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,157     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
158     where
159         D: Deserializer<'de>,
160     {
161         self.0.deserialize(Compact(deserializer))
162     }
163 }
164 
165 macro_rules! forward_method {
166     ($name: ident (self $(, $arg: ident : $arg_type: ty)* ) -> $return_type: ty) => {
167         fn $name (self $(, $arg : $arg_type)* ) -> $return_type {
168             (self.0).$name( $($arg),* )
169         }
170     };
171 }
172 
173 macro_rules! forward_serialize_methods {
174     ( $( $name: ident $arg_type: ty ),* ) => {
175         $(
176             forward_method!($name(self, v : $arg_type) -> Result<Self::Ok, Self::Error>);
177         )*
178     };
179 }
180 
181 macro_rules! impl_serializer {
182     ($wrapper:ident, $is_human_readable:expr) => {
183         impl<S> Serializer for $wrapper<S>
184         where
185             S: Serializer,
186         {
187             type Ok = S::Ok;
188             type Error = S::Error;
189 
190             type SerializeSeq = $wrapper<S::SerializeSeq>;
191             type SerializeTuple = $wrapper<S::SerializeTuple>;
192             type SerializeTupleStruct = $wrapper<S::SerializeTupleStruct>;
193             type SerializeTupleVariant = $wrapper<S::SerializeTupleVariant>;
194             type SerializeMap = $wrapper<S::SerializeMap>;
195             type SerializeStruct = $wrapper<S::SerializeStruct>;
196             type SerializeStructVariant = $wrapper<S::SerializeStructVariant>;
197 
198             fn is_human_readable(&self) -> bool {
199                 $is_human_readable
200             }
201 
202             forward_serialize_methods! {
203                 serialize_bool bool,
204                 serialize_i8 i8,
205                 serialize_i16 i16,
206                 serialize_i32 i32,
207                 serialize_i64 i64,
208                 serialize_u8 u8,
209                 serialize_u16 u16,
210                 serialize_u32 u32,
211                 serialize_u64 u64,
212                 serialize_f32 f32,
213                 serialize_f64 f64,
214                 serialize_char char,
215                 serialize_str &str,
216                 serialize_bytes &[u8],
217                 serialize_unit_struct &'static str
218 
219             }
220 
221             fn serialize_unit(self) -> Result<S::Ok, S::Error> {
222                 self.0.serialize_unit()
223             }
224 
225             fn serialize_unit_variant(
226                 self,
227                 name: &'static str,
228                 variant_index: u32,
229                 variant: &'static str,
230             ) -> Result<S::Ok, S::Error> {
231                 self.0.serialize_unit_variant(name, variant_index, variant)
232             }
233 
234             fn serialize_newtype_struct<T: ?Sized>(
235                 self,
236                 name: &'static str,
237                 value: &T,
238             ) -> Result<S::Ok, S::Error>
239             where
240                 T: Serialize,
241             {
242                 self.0.serialize_newtype_struct(name, &$wrapper(value))
243             }
244 
245             fn serialize_newtype_variant<T: ?Sized>(
246                 self,
247                 name: &'static str,
248                 variant_index: u32,
249                 variant: &'static str,
250                 value: &T,
251             ) -> Result<S::Ok, S::Error>
252             where
253                 T: Serialize,
254             {
255                 self.0
256                     .serialize_newtype_variant(name, variant_index, variant, &$wrapper(value))
257             }
258 
259             fn serialize_none(self) -> Result<S::Ok, Self::Error> {
260                 self.0.serialize_none()
261             }
262 
263             fn serialize_some<T: ?Sized>(self, value: &T) -> Result<S::Ok, Self::Error>
264             where
265                 T: Serialize,
266             {
267                 self.0.serialize_some(&$wrapper(value))
268             }
269 
270             fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
271                 self.0.serialize_seq(len).map($wrapper)
272             }
273 
274             fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
275                 self.0.serialize_tuple(len).map($wrapper)
276             }
277 
278             fn serialize_tuple_struct(
279                 self,
280                 name: &'static str,
281                 len: usize,
282             ) -> Result<Self::SerializeTupleStruct, Self::Error> {
283                 self.0.serialize_tuple_struct(name, len).map($wrapper)
284             }
285 
286             fn serialize_tuple_variant(
287                 self,
288                 name: &'static str,
289                 variant_index: u32,
290                 variant: &'static str,
291                 len: usize,
292             ) -> Result<Self::SerializeTupleVariant, Self::Error> {
293                 self.0
294                     .serialize_tuple_variant(name, variant_index, variant, len)
295                     .map($wrapper)
296             }
297 
298             fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
299                 self.0.serialize_map(len).map($wrapper)
300             }
301 
302             fn serialize_struct(
303                 self,
304                 name: &'static str,
305                 len: usize,
306             ) -> Result<Self::SerializeStruct, Self::Error> {
307                 self.0.serialize_struct(name, len).map($wrapper)
308             }
309 
310             fn serialize_struct_variant(
311                 self,
312                 name: &'static str,
313                 variant_index: u32,
314                 variant: &'static str,
315                 len: usize,
316             ) -> Result<Self::SerializeStructVariant, Self::Error> {
317                 self.0
318                     .serialize_struct_variant(name, variant_index, variant, len)
319                     .map($wrapper)
320             }
321         }
322 
323         impl<S> SerializeSeq for $wrapper<S>
324         where
325             S: SerializeSeq,
326         {
327             type Ok = S::Ok;
328             type Error = S::Error;
329             fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
330             where
331                 T: Serialize,
332             {
333                 self.0.serialize_element(&$wrapper(value))
334             }
335             fn end(self) -> Result<S::Ok, S::Error> {
336                 self.0.end()
337             }
338         }
339 
340         impl<S> SerializeTuple for $wrapper<S>
341         where
342             S: SerializeTuple,
343         {
344             type Ok = S::Ok;
345             type Error = S::Error;
346             fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
347             where
348                 T: Serialize,
349             {
350                 self.0.serialize_element(&$wrapper(value))
351             }
352             fn end(self) -> Result<S::Ok, S::Error> {
353                 self.0.end()
354             }
355         }
356 
357         impl<S> SerializeTupleStruct for $wrapper<S>
358         where
359             S: SerializeTupleStruct,
360         {
361             type Ok = S::Ok;
362             type Error = S::Error;
363             fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
364             where
365                 T: Serialize,
366             {
367                 self.0.serialize_field(&$wrapper(value))
368             }
369             fn end(self) -> Result<S::Ok, S::Error> {
370                 self.0.end()
371             }
372         }
373 
374         impl<S> SerializeTupleVariant for $wrapper<S>
375         where
376             S: SerializeTupleVariant,
377         {
378             type Ok = S::Ok;
379             type Error = S::Error;
380             fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
381             where
382                 T: Serialize,
383             {
384                 self.0.serialize_field(&$wrapper(value))
385             }
386             fn end(self) -> Result<S::Ok, S::Error> {
387                 self.0.end()
388             }
389         }
390 
391         impl<S> SerializeMap for $wrapper<S>
392         where
393             S: SerializeMap,
394         {
395             type Ok = S::Ok;
396             type Error = S::Error;
397             fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), S::Error>
398             where
399                 T: Serialize,
400             {
401                 self.0.serialize_key(&$wrapper(key))
402             }
403             fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
404             where
405                 T: Serialize,
406             {
407                 self.0.serialize_value(&$wrapper(value))
408             }
409             fn serialize_entry<K: ?Sized, V: ?Sized>(
410                 &mut self,
411                 key: &K,
412                 value: &V,
413             ) -> Result<(), S::Error>
414             where
415                 K: Serialize,
416                 V: Serialize,
417             {
418                 self.0.serialize_entry(key, &$wrapper(value))
419             }
420             fn end(self) -> Result<S::Ok, S::Error> {
421                 self.0.end()
422             }
423         }
424 
425         impl<S> SerializeStruct for $wrapper<S>
426         where
427             S: SerializeStruct,
428         {
429             type Ok = S::Ok;
430             type Error = S::Error;
431             fn serialize_field<T: ?Sized>(
432                 &mut self,
433                 name: &'static str,
434                 field: &T,
435             ) -> Result<(), S::Error>
436             where
437                 T: Serialize,
438             {
439                 self.0.serialize_field(name, &$wrapper(field))
440             }
441             fn end(self) -> Result<S::Ok, S::Error> {
442                 self.0.end()
443             }
444         }
445 
446         impl<S> SerializeStructVariant for $wrapper<S>
447         where
448             S: SerializeStructVariant,
449         {
450             type Ok = S::Ok;
451             type Error = S::Error;
452             fn serialize_field<T: ?Sized>(
453                 &mut self,
454                 name: &'static str,
455                 field: &T,
456             ) -> Result<(), S::Error>
457             where
458                 T: Serialize,
459             {
460                 self.0.serialize_field(name, &$wrapper(field))
461             }
462             fn end(self) -> Result<S::Ok, S::Error> {
463                 self.0.end()
464             }
465         }
466     };
467 }
468 
469 impl_serializer!(Readable, true);
470 impl_serializer!(Compact, false);
471 
472 macro_rules! forward_deserialize_methods {
473     ( $wrapper : ident ( $( $name: ident ),* ) ) => {
474         $(
475             fn $name<V>(self, visitor: V) -> Result<V::Value, D::Error>
476             where
477                 V: Visitor<'de>,
478             {
479                 (self.0).$name($wrapper(visitor))
480             }
481         )*
482     };
483 }
484 
485 macro_rules! impl_deserializer {
486     ($wrapper:ident, $is_human_readable:expr) => {
487         impl<'de, D> Deserializer<'de> for $wrapper<D>
488         where
489             D: Deserializer<'de>,
490         {
491             type Error = D::Error;
492 
493             forward_deserialize_methods! {
494                 $wrapper (
495                     deserialize_any,
496                     deserialize_bool,
497                     deserialize_u8,
498                     deserialize_u16,
499                     deserialize_u32,
500                     deserialize_u64,
501                     deserialize_i8,
502                     deserialize_i16,
503                     deserialize_i32,
504                     deserialize_i64,
505                     deserialize_f32,
506                     deserialize_f64,
507                     deserialize_char,
508                     deserialize_str,
509                     deserialize_string,
510                     deserialize_bytes,
511                     deserialize_byte_buf,
512                     deserialize_option,
513                     deserialize_unit,
514                     deserialize_seq,
515                     deserialize_map,
516                     deserialize_identifier,
517                     deserialize_ignored_any
518                 )
519             }
520 
521             fn deserialize_unit_struct<V>(
522                 self,
523                 name: &'static str,
524                 visitor: V,
525             ) -> Result<V::Value, D::Error>
526             where
527                 V: Visitor<'de>,
528             {
529                 self.0.deserialize_unit_struct(name, $wrapper(visitor))
530             }
531             fn deserialize_newtype_struct<V>(
532                 self,
533                 name: &'static str,
534                 visitor: V,
535             ) -> Result<V::Value, D::Error>
536             where
537                 V: Visitor<'de>,
538             {
539                 self.0.deserialize_newtype_struct(name, $wrapper(visitor))
540             }
541             fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
542             where
543                 V: Visitor<'de>,
544             {
545                 self.0.deserialize_tuple(len, $wrapper(visitor))
546             }
547             fn deserialize_tuple_struct<V>(
548                 self,
549                 name: &'static str,
550                 len: usize,
551                 visitor: V,
552             ) -> Result<V::Value, D::Error>
553             where
554                 V: Visitor<'de>,
555             {
556                 self.0
557                     .deserialize_tuple_struct(name, len, $wrapper(visitor))
558             }
559             fn deserialize_struct<V>(
560                 self,
561                 name: &'static str,
562                 fields: &'static [&'static str],
563                 visitor: V,
564             ) -> Result<V::Value, D::Error>
565             where
566                 V: Visitor<'de>,
567             {
568                 self.0.deserialize_struct(name, fields, $wrapper(visitor))
569             }
570             fn deserialize_enum<V>(
571                 self,
572                 name: &'static str,
573                 variants: &'static [&'static str],
574                 visitor: V,
575             ) -> Result<V::Value, D::Error>
576             where
577                 V: Visitor<'de>,
578             {
579                 self.0.deserialize_enum(name, variants, $wrapper(visitor))
580             }
581 
582             fn is_human_readable(&self) -> bool {
583                 $is_human_readable
584             }
585         }
586 
587         impl<'de, D> Visitor<'de> for $wrapper<D>
588         where
589             D: Visitor<'de>,
590         {
591             type Value = D::Value;
592             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
593                 self.0.expecting(formatter)
594             }
595             fn visit_bool<E>(self, v: bool) -> Result<D::Value, E>
596             where
597                 E: Error,
598             {
599                 self.0.visit_bool(v)
600             }
601             fn visit_i8<E>(self, v: i8) -> Result<D::Value, E>
602             where
603                 E: Error,
604             {
605                 self.0.visit_i8(v)
606             }
607             fn visit_i16<E>(self, v: i16) -> Result<D::Value, E>
608             where
609                 E: Error,
610             {
611                 self.0.visit_i16(v)
612             }
613             fn visit_i32<E>(self, v: i32) -> Result<D::Value, E>
614             where
615                 E: Error,
616             {
617                 self.0.visit_i32(v)
618             }
619             fn visit_i64<E>(self, v: i64) -> Result<D::Value, E>
620             where
621                 E: Error,
622             {
623                 self.0.visit_i64(v)
624             }
625             fn visit_u8<E>(self, v: u8) -> Result<D::Value, E>
626             where
627                 E: Error,
628             {
629                 self.0.visit_u8(v)
630             }
631             fn visit_u16<E>(self, v: u16) -> Result<D::Value, E>
632             where
633                 E: Error,
634             {
635                 self.0.visit_u16(v)
636             }
637             fn visit_u32<E>(self, v: u32) -> Result<D::Value, E>
638             where
639                 E: Error,
640             {
641                 self.0.visit_u32(v)
642             }
643             fn visit_u64<E>(self, v: u64) -> Result<D::Value, E>
644             where
645                 E: Error,
646             {
647                 self.0.visit_u64(v)
648             }
649             fn visit_f32<E>(self, v: f32) -> Result<D::Value, E>
650             where
651                 E: Error,
652             {
653                 self.0.visit_f32(v)
654             }
655             fn visit_f64<E>(self, v: f64) -> Result<D::Value, E>
656             where
657                 E: Error,
658             {
659                 self.0.visit_f64(v)
660             }
661             fn visit_char<E>(self, v: char) -> Result<D::Value, E>
662             where
663                 E: Error,
664             {
665                 self.0.visit_char(v)
666             }
667             fn visit_str<E>(self, v: &str) -> Result<D::Value, E>
668             where
669                 E: Error,
670             {
671                 self.0.visit_str(v)
672             }
673             fn visit_borrowed_str<E>(self, v: &'de str) -> Result<D::Value, E>
674             where
675                 E: Error,
676             {
677                 self.0.visit_borrowed_str(v)
678             }
679             fn visit_string<E>(self, v: String) -> Result<D::Value, E>
680             where
681                 E: Error,
682             {
683                 self.0.visit_string(v)
684             }
685             fn visit_bytes<E>(self, v: &[u8]) -> Result<D::Value, E>
686             where
687                 E: Error,
688             {
689                 self.0.visit_bytes(v)
690             }
691             fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<D::Value, E>
692             where
693                 E: Error,
694             {
695                 self.0.visit_borrowed_bytes(v)
696             }
697             fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<D::Value, E>
698             where
699                 E: Error,
700             {
701                 self.0.visit_byte_buf(v)
702             }
703             fn visit_none<E>(self) -> Result<D::Value, E>
704             where
705                 E: Error,
706             {
707                 self.0.visit_none()
708             }
709             fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
710             where
711                 D2: Deserializer<'de>,
712             {
713                 self.0.visit_some($wrapper(deserializer))
714             }
715             fn visit_unit<E>(self) -> Result<D::Value, E>
716             where
717                 E: Error,
718             {
719                 self.0.visit_unit()
720             }
721             fn visit_newtype_struct<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
722             where
723                 D2: Deserializer<'de>,
724             {
725                 self.0.visit_newtype_struct($wrapper(deserializer))
726             }
727             fn visit_seq<V>(self, seq: V) -> Result<D::Value, V::Error>
728             where
729                 V: SeqAccess<'de>,
730             {
731                 self.0.visit_seq($wrapper(seq))
732             }
733             fn visit_map<V>(self, map: V) -> Result<D::Value, V::Error>
734             where
735                 V: MapAccess<'de>,
736             {
737                 self.0.visit_map($wrapper(map))
738             }
739             fn visit_enum<V>(self, data: V) -> Result<D::Value, V::Error>
740             where
741                 V: EnumAccess<'de>,
742             {
743                 self.0.visit_enum($wrapper(data))
744             }
745         }
746 
747         impl<'de, D> SeqAccess<'de> for $wrapper<D>
748         where
749             D: SeqAccess<'de>,
750         {
751             type Error = D::Error;
752             fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, D::Error>
753             where
754                 T: DeserializeSeed<'de>,
755             {
756                 self.0.next_element_seed($wrapper(seed))
757             }
758             fn size_hint(&self) -> Option<usize> {
759                 self.0.size_hint()
760             }
761         }
762 
763         impl<'de, D> MapAccess<'de> for $wrapper<D>
764         where
765             D: MapAccess<'de>,
766         {
767             type Error = D::Error;
768             fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error>
769             where
770                 K: DeserializeSeed<'de>,
771             {
772                 self.0.next_key_seed($wrapper(seed))
773             }
774             fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error>
775             where
776                 V: DeserializeSeed<'de>,
777             {
778                 self.0.next_value_seed($wrapper(seed))
779             }
780             fn next_entry_seed<K, V>(
781                 &mut self,
782                 kseed: K,
783                 vseed: V,
784             ) -> Result<Option<(K::Value, V::Value)>, D::Error>
785             where
786                 K: DeserializeSeed<'de>,
787                 V: DeserializeSeed<'de>,
788             {
789                 self.0.next_entry_seed($wrapper(kseed), $wrapper(vseed))
790             }
791             fn size_hint(&self) -> Option<usize> {
792                 self.0.size_hint()
793             }
794         }
795 
796         impl<'de, D> EnumAccess<'de> for $wrapper<D>
797         where
798             D: EnumAccess<'de>,
799         {
800             type Error = D::Error;
801             type Variant = $wrapper<D::Variant>;
802             fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
803             where
804                 V: DeserializeSeed<'de>,
805             {
806                 self.0
807                     .variant_seed($wrapper(seed))
808                     .map(|(value, variant)| (value, $wrapper(variant)))
809             }
810         }
811 
812         impl<'de, D> VariantAccess<'de> for $wrapper<D>
813         where
814             D: VariantAccess<'de>,
815         {
816             type Error = D::Error;
817             fn unit_variant(self) -> Result<(), D::Error> {
818                 self.0.unit_variant()
819             }
820             fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error>
821             where
822                 T: DeserializeSeed<'de>,
823             {
824                 self.0.newtype_variant_seed($wrapper(seed))
825             }
826             fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
827             where
828                 V: Visitor<'de>,
829             {
830                 self.0.tuple_variant(len, $wrapper(visitor))
831             }
832             fn struct_variant<V>(
833                 self,
834                 fields: &'static [&'static str],
835                 visitor: V,
836             ) -> Result<V::Value, D::Error>
837             where
838                 V: Visitor<'de>,
839             {
840                 self.0.struct_variant(fields, $wrapper(visitor))
841             }
842         }
843     };
844 }
845 
846 impl_deserializer!(Readable, true);
847 impl_deserializer!(Compact, false);
848