serde_util/
maybe.rs

1use std::fmt::Formatter;
2
3use serde::Deserialize;
4use serde::Deserializer;
5use serde::de::DeserializeSeed;
6use serde::de::EnumAccess;
7use serde::de::MapAccess;
8use serde::de::SeqAccess;
9use serde::de::VariantAccess;
10use serde::de::Visitor;
11
12/// Something that may be of the kind of `T`.
13///
14/// If a value doesn't have the kind of `T`, this will *discard* the value and
15/// provide an `MayBe::IsNot`. Nevertheless, if the value does have the kind of
16/// `T` but cannot be deserialized by `T`, this will also fail to deserialize,
17/// making this wrapper "shallow".
18///
19/// For example, `struct`s have the same kind as a JSON object, `{}`, If the
20/// contents of said JSON object don't match what the `struct` is expecting,
21/// like if the `struct Foo { bar: u32 }` is being matched, as `MayBe<Foo>`,
22/// against `{"bar": ""}`, then that is an error. However, matching the same
23/// `MayBe<Foo>` against a JSON array, `[]` would not lead to an error, but
24/// to an `MayBe::IsNot`.
25///
26/// Can only be used with self-describing formats, like JSON.
27#[derive(Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
28pub enum MayBe<T> {
29    Is(T),
30    IsNot,
31}
32
33// FIXME decide on Default
34// This enum is analogous to Result, *not* Option.
35//
36//impl<T> Default for MayBe<T> {
37//    fn default() -> Self {
38//        MayBe::IsNot
39//    }
40//}
41//impl<T: Default> Default for MayBe<T> {
42//    fn default() -> Self {
43//        MayBe::Is(T::default())
44//    }
45//}
46
47impl<T> MayBe<T> {
48    /// Returns whether the `MayBe` contains a `T`.
49    pub fn is(&self) -> bool {
50        matches!(self, MayBe::Is(_))
51    }
52
53    /// Returns whether the `MayBe` does not contain a `T`.
54    pub fn is_not(&self) -> bool {
55        !self.is()
56    }
57
58    /// Converts this `MayBe<T>` into an `Option<T>`.
59    pub fn into_opt(self) -> Option<T> {
60        self.into()
61    }
62
63    /// Converts this `&MayBe<T>` into an `Option<&T>`.
64    pub fn as_opt(&self) -> Option<&T> {
65        match self {
66            MayBe::Is(t) => Some(t),
67            MayBe::IsNot => None,
68        }
69    }
70
71    /// Converts this `&mut MayBe<T>` into an `Option<&mut T>`.
72    pub fn as_mut_opt(&mut self) -> Option<&mut T> {
73        match self {
74            MayBe::Is(t) => Some(t),
75            MayBe::IsNot => None,
76        }
77    }
78}
79
80impl<T: Clone> Clone for MayBe<T> {
81    fn clone(&self) -> Self {
82        match self {
83            MayBe::Is(t) => MayBe::Is(t.clone()),
84            MayBe::IsNot => MayBe::IsNot,
85        }
86    }
87
88    fn clone_from(&mut self, source: &Self) {
89        match (self, source) {
90            (MayBe::Is(a), MayBe::Is(b)) => a.clone_from(b),
91            (MayBe::IsNot, MayBe::IsNot) => (),
92            (a, b) => *a = b.clone(),
93        }
94    }
95}
96
97impl<T> From<MayBe<T>> for Option<T> {
98    fn from(thing: MayBe<T>) -> Option<T> {
99        match thing {
100            MayBe::Is(t) => Some(t),
101            MayBe::IsNot => None,
102        }
103    }
104}
105
106impl<T> From<Option<T>> for MayBe<T> {
107    fn from(thing: Option<T>) -> MayBe<T> {
108        match thing {
109            Some(t) => MayBe::Is(t),
110            None => MayBe::IsNot,
111        }
112    }
113}
114
115impl<T> From<T> for MayBe<T> {
116    fn from(thing: T) -> MayBe<T> {
117        MayBe::Is(thing)
118    }
119}
120
121// actual deserialize
122
123struct MayBeDer<'a, D>(&'a mut bool, D);
124
125struct MayBeVis<'a, V>(&'a mut bool, V);
126
127// acts as Deserializer, MapAccess, SeqAccess and EnumAccess, depending on T.
128struct DeepDer<'a, T>(&'a mut bool, T);
129
130#[derive(Deserialize)]
131#[serde(untagged)]
132enum MayBeHelper<T> {
133    #[serde(deserialize_with="may_be")]
134    #[serde(bound = "T: Deserialize<'de>")]
135    Value(MayBe<T>),
136}
137
138fn may_be<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
139    d: D,
140) -> Result<MayBe<T>, D::Error> {
141    let mut depth: bool = false;
142    match T::deserialize(MayBeDer(&mut depth, d)) {
143        Ok(t) => Ok(MayBe::Is(t)),
144        Err(_) if !depth => Ok(MayBe::IsNot),
145        Err(e) => Err(e),
146    }
147}
148
149impl<'de, T: Deserialize<'de>> Deserialize<'de> for MayBe<T> {
150    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
151        MayBeHelper::<T>::deserialize(d).map(|MayBeHelper::Value(v): _| v)
152    }
153}
154
155impl<'a, 'de: 'a, V: Visitor<'de>> Visitor<'de> for MayBeVis<'a, V> {
156    type Value = V::Value;
157
158    fn expecting(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
159        let MayBeVis(_depth, inner) = self;
160        inner.expecting(formatter)
161    }
162
163    fn visit_bool<E: serde::de::Error>(
164        self,
165        v: bool,
166    ) -> Result<Self::Value, E> {
167        let MayBeVis(_depth, inner) = self;
168        inner.visit_bool(v)
169    }
170
171    fn visit_i8<E: serde::de::Error>(
172        self,
173        v: i8,
174    ) -> Result<Self::Value, E> {
175        let MayBeVis(_depth, inner) = self;
176        inner.visit_i8(v)
177    }
178
179    fn visit_i16<E: serde::de::Error>(
180        self,
181        v: i16,
182    ) -> Result<Self::Value, E> {
183        let MayBeVis(_depth, inner) = self;
184        inner.visit_i16(v)
185    }
186
187    fn visit_i32<E: serde::de::Error>(
188        self,
189        v: i32,
190    ) -> Result<Self::Value, E> {
191        let MayBeVis(_depth, inner) = self;
192        inner.visit_i32(v)
193    }
194
195    fn visit_i64<E: serde::de::Error>(
196        self,
197        v: i64,
198    ) -> Result<Self::Value, E> {
199        let MayBeVis(_depth, inner) = self;
200        inner.visit_i64(v)
201    }
202
203    fn visit_i128<E: serde::de::Error>(
204        self,
205        v: i128,
206    ) -> Result<Self::Value, E> {
207        let MayBeVis(_depth, inner) = self;
208        inner.visit_i128(v)
209    }
210
211    fn visit_u8<E: serde::de::Error>(
212        self,
213        v: u8,
214    ) -> Result<Self::Value, E> {
215        let MayBeVis(_depth, inner) = self;
216        inner.visit_u8(v)
217    }
218
219    fn visit_u16<E: serde::de::Error>(
220        self,
221        v: u16,
222    ) -> Result<Self::Value, E> {
223        let MayBeVis(_depth, inner) = self;
224        inner.visit_u16(v)
225    }
226
227    fn visit_u32<E: serde::de::Error>(
228        self,
229        v: u32,
230    ) -> Result<Self::Value, E> {
231        let MayBeVis(_depth, inner) = self;
232        inner.visit_u32(v)
233    }
234
235    fn visit_u64<E: serde::de::Error>(
236        self,
237        v: u64,
238    ) -> Result<Self::Value, E> {
239        let MayBeVis(_depth, inner) = self;
240        inner.visit_u64(v)
241    }
242
243    fn visit_u128<E: serde::de::Error>(
244        self,
245        v: u128,
246    ) -> Result<Self::Value, E> {
247        let MayBeVis(_depth, inner) = self;
248        inner.visit_u128(v)
249    }
250
251    fn visit_f32<E: serde::de::Error>(
252        self,
253        v: f32,
254    ) -> Result<Self::Value, E> {
255        let MayBeVis(_depth, inner) = self;
256        inner.visit_f32(v)
257    }
258
259    fn visit_f64<E: serde::de::Error>(
260        self,
261        v: f64,
262    ) -> Result<Self::Value, E> {
263        let MayBeVis(_depth, inner) = self;
264        inner.visit_f64(v)
265    }
266
267    fn visit_char<E: serde::de::Error>(
268        self,
269        v: char,
270    ) -> Result<Self::Value, E> {
271        let MayBeVis(_depth, inner) = self;
272        inner.visit_char(v)
273    }
274
275    fn visit_str<E: serde::de::Error>(
276        self,
277        v: &str,
278    ) -> Result<Self::Value, E> {
279        let MayBeVis(_depth, inner) = self;
280        inner.visit_str(v)
281    }
282
283    fn visit_borrowed_str<E: serde::de::Error>(
284        self,
285        v: &'de str,
286    ) -> Result<Self::Value, E> {
287        let MayBeVis(_depth, inner) = self;
288        inner.visit_borrowed_str(v)
289    }
290
291    fn visit_string<E: serde::de::Error>(
292        self,
293        v: String,
294    ) -> Result<Self::Value, E> {
295        let MayBeVis(_depth, inner) = self;
296        inner.visit_string(v)
297    }
298
299    fn visit_bytes<E: serde::de::Error>(
300        self,
301        v: &[u8],
302    ) -> Result<Self::Value, E> {
303        let MayBeVis(_depth, inner) = self;
304        inner.visit_bytes(v)
305    }
306
307    fn visit_borrowed_bytes<E: serde::de::Error>(
308        self,
309        v: &'de [u8],
310    ) -> Result<Self::Value, E> {
311        let MayBeVis(_depth, inner) = self;
312        inner.visit_borrowed_bytes(v)
313    }
314
315    fn visit_byte_buf<E: serde::de::Error>(
316        self,
317        v: Vec<u8>,
318    ) -> Result<Self::Value, E> {
319        let MayBeVis(_depth, inner) = self;
320        inner.visit_byte_buf(v)
321    }
322
323    fn visit_none<E: serde::de::Error>(
324        self,
325    ) -> Result<Self::Value, E> {
326        let MayBeVis(_depth, inner) = self;
327        inner.visit_none()
328    }
329
330    fn visit_some<D: Deserializer<'de>>(
331        self,
332        deserializer: D,
333    ) -> Result<Self::Value, D::Error> {
334        let MayBeVis(depth, inner) = self;
335        inner.visit_some(DeepDer(depth, deserializer))
336    }
337
338    fn visit_unit<E: serde::de::Error>(
339        self,
340    ) -> Result<Self::Value, E> {
341        let MayBeVis(_depth, inner) = self;
342        inner.visit_unit()
343    }
344
345    fn visit_newtype_struct<D: Deserializer<'de>>(
346        self,
347        deserializer: D,
348    ) -> Result<Self::Value, D::Error> {
349        let MayBeVis(depth, inner) = self;
350        inner.visit_newtype_struct(DeepDer(depth, deserializer))
351    }
352
353    fn visit_seq<A: SeqAccess<'de>>(
354        self,
355        seq: A,
356    ) -> Result<Self::Value, A::Error> {
357        let MayBeVis(depth, inner) = self;
358        inner.visit_seq(DeepDer(depth, seq))
359    }
360
361    fn visit_map<A: MapAccess<'de>>(
362        self,
363        map: A,
364    ) -> Result<Self::Value, A::Error> {
365        let MayBeVis(depth, inner) = self;
366        inner.visit_map(DeepDer(depth, map))
367    }
368
369    fn visit_enum<A: EnumAccess<'de>>(
370        self,
371        data: A,
372    ) -> Result<Self::Value, A::Error> {
373        let MayBeVis(depth, inner) = self;
374        inner.visit_enum(DeepDer(depth, data))
375    }
376}
377
378impl<'a, 'de: 'a, D: Deserializer<'de>> Deserializer<'de> for MayBeDer<'a, D> {
379    type Error = D::Error;
380
381    fn deserialize_any<V: Visitor<'de>>(
382        self,
383        visitor: V,
384    ) -> Result<V::Value, Self::Error> {
385        let MayBeDer(depth, inner) = self;
386        inner.deserialize_any(MayBeVis(depth, visitor))
387    }
388
389    fn deserialize_bool<V: Visitor<'de>>(
390        self,
391        visitor: V,
392    ) -> Result<V::Value, Self::Error> {
393        let MayBeDer(depth, inner) = self;
394        inner.deserialize_bool(MayBeVis(depth, visitor))
395    }
396
397    fn deserialize_i8<V: Visitor<'de>>(
398        self,
399        visitor: V,
400    ) -> Result<V::Value, Self::Error> {
401        let MayBeDer(depth, inner) = self;
402        inner.deserialize_i8(MayBeVis(depth, visitor))
403    }
404
405    fn deserialize_i16<V: Visitor<'de>>(
406        self,
407        visitor: V,
408    ) -> Result<V::Value, Self::Error> {
409        let MayBeDer(depth, inner) = self;
410        inner.deserialize_i16(MayBeVis(depth, visitor))
411    }
412
413    fn deserialize_i32<V: Visitor<'de>>(
414        self,
415        visitor: V,
416    ) -> Result<V::Value, Self::Error> {
417        let MayBeDer(depth, inner) = self;
418        inner.deserialize_i32(MayBeVis(depth, visitor))
419    }
420
421    fn deserialize_i64<V: Visitor<'de>>(
422        self,
423        visitor: V,
424    ) -> Result<V::Value, Self::Error> {
425        let MayBeDer(depth, inner) = self;
426        inner.deserialize_i64(MayBeVis(depth, visitor))
427    }
428
429    fn deserialize_u8<V: Visitor<'de>>(
430        self,
431        visitor: V,
432    ) -> Result<V::Value, Self::Error> {
433        let MayBeDer(depth, inner) = self;
434        inner.deserialize_u8(MayBeVis(depth, visitor))
435    }
436
437    fn deserialize_u16<V: Visitor<'de>>(
438        self,
439        visitor: V,
440    ) -> Result<V::Value, Self::Error> {
441        let MayBeDer(depth, inner) = self;
442        inner.deserialize_u16(MayBeVis(depth, visitor))
443    }
444
445    fn deserialize_u32<V: Visitor<'de>>(
446        self,
447        visitor: V,
448    ) -> Result<V::Value, Self::Error> {
449        let MayBeDer(depth, inner) = self;
450        inner.deserialize_u32(MayBeVis(depth, visitor))
451    }
452
453    fn deserialize_u64<V: Visitor<'de>>(
454        self,
455        visitor: V,
456    ) -> Result<V::Value, Self::Error> {
457        let MayBeDer(depth, inner) = self;
458        inner.deserialize_u64(MayBeVis(depth, visitor))
459    }
460
461    fn deserialize_f32<V: Visitor<'de>>(
462        self,
463        visitor: V,
464    ) -> Result<V::Value, Self::Error> {
465        let MayBeDer(depth, inner) = self;
466        inner.deserialize_f32(MayBeVis(depth, visitor))
467    }
468
469    fn deserialize_f64<V: Visitor<'de>>(
470        self,
471        visitor: V,
472    ) -> Result<V::Value, Self::Error> {
473        let MayBeDer(depth, inner) = self;
474        inner.deserialize_f64(MayBeVis(depth, visitor))
475    }
476
477    fn deserialize_char<V: Visitor<'de>>(
478        self,
479        visitor: V,
480    ) -> Result<V::Value, Self::Error> {
481        let MayBeDer(depth, inner) = self;
482        inner.deserialize_char(MayBeVis(depth, visitor))
483    }
484
485    fn deserialize_str<V: Visitor<'de>>(
486        self,
487        visitor: V,
488    ) -> Result<V::Value, Self::Error> {
489        let MayBeDer(depth, inner) = self;
490        inner.deserialize_str(MayBeVis(depth, visitor))
491    }
492
493    fn deserialize_string<V: Visitor<'de>>(
494        self,
495        visitor: V,
496    ) -> Result<V::Value, Self::Error> {
497        let MayBeDer(depth, inner) = self;
498        inner.deserialize_string(MayBeVis(depth, visitor))
499    }
500
501    fn deserialize_bytes<V: Visitor<'de>>(
502        self,
503        visitor: V,
504    ) -> Result<V::Value, Self::Error> {
505        let MayBeDer(depth, inner) = self;
506        inner.deserialize_bytes(MayBeVis(depth, visitor))
507    }
508
509    fn deserialize_byte_buf<V: Visitor<'de>>(
510        self,
511        visitor: V,
512    ) -> Result<V::Value, Self::Error> {
513        let MayBeDer(depth, inner) = self;
514        inner.deserialize_byte_buf(MayBeVis(depth, visitor))
515    }
516
517    fn deserialize_option<V: Visitor<'de>>(
518        self,
519        visitor: V,
520    ) -> Result<V::Value, Self::Error> {
521        let MayBeDer(depth, inner) = self;
522        inner.deserialize_option(MayBeVis(depth, visitor))
523    }
524
525    fn deserialize_unit<V: Visitor<'de>>(
526        self,
527        visitor: V,
528    ) -> Result<V::Value, Self::Error> {
529        let MayBeDer(depth, inner) = self;
530        inner.deserialize_unit(MayBeVis(depth, visitor))
531    }
532
533    fn deserialize_unit_struct<V: Visitor<'de>>(
534        self, 
535        name: &'static str, 
536        visitor: V,
537    ) -> Result<V::Value, Self::Error> {
538        let MayBeDer(depth, inner) = self;
539        inner.deserialize_unit_struct(name, MayBeVis(depth, visitor))
540    }
541
542    fn deserialize_newtype_struct<V: Visitor<'de>>(
543        self, 
544        name: &'static str, 
545        visitor: V,
546    ) -> Result<V::Value, Self::Error> {
547        let MayBeDer(depth, inner) = self;
548        inner.deserialize_newtype_struct(name, MayBeVis(depth, visitor))
549    }
550
551    fn deserialize_seq<V: Visitor<'de>>(
552        self,
553        visitor: V,
554    ) -> Result<V::Value, Self::Error> {
555        let MayBeDer(depth, inner) = self;
556        inner.deserialize_seq(MayBeVis(depth, visitor))
557    }
558
559    fn deserialize_tuple<V: Visitor<'de>>(
560        self, 
561        len: usize, 
562        visitor: V,
563    ) -> Result<V::Value, Self::Error> {
564        let MayBeDer(depth, inner) = self;
565        inner.deserialize_tuple(len, MayBeVis(depth, visitor))
566    }
567
568    fn deserialize_tuple_struct<V: Visitor<'de>>(
569        self, 
570        name: &'static str, 
571        len: usize, 
572        visitor: V,
573    ) -> Result<V::Value, Self::Error> {
574        let MayBeDer(depth, inner) = self;
575        inner.deserialize_tuple_struct(name, len, MayBeVis(depth, visitor))
576    }
577
578    fn deserialize_map<V: Visitor<'de>>(
579        self,
580        visitor: V,
581    ) -> Result<V::Value, Self::Error> {
582        let MayBeDer(depth, inner) = self;
583        inner.deserialize_map(MayBeVis(depth, visitor))
584    }
585
586    fn deserialize_struct<V: Visitor<'de>>(
587        self, 
588        name: &'static str, 
589        fields: &'static [&'static str], 
590        visitor: V,
591    ) -> Result<V::Value, Self::Error> {
592        let MayBeDer(depth, inner) = self;
593        inner.deserialize_struct(name, fields, MayBeVis(depth, visitor))
594    }
595
596    fn deserialize_enum<V: Visitor<'de>>(
597        self, 
598        name: &'static str, 
599        variants: &'static [&'static str], 
600        visitor: V,
601    ) -> Result<V::Value, Self::Error> {
602        let MayBeDer(depth, inner) = self;
603        inner.deserialize_enum(name, variants, MayBeVis(depth, visitor))
604    }
605
606    fn deserialize_identifier<V: Visitor<'de>>(
607        self, 
608        visitor: V,
609    ) -> Result<V::Value, Self::Error> {
610        let MayBeDer(depth, inner) = self;
611        inner.deserialize_identifier(MayBeVis(depth, visitor))
612    }
613
614    fn deserialize_ignored_any<V: Visitor<'de>>(
615        self, 
616        visitor: V,
617    ) -> Result<V::Value, Self::Error> {
618        let MayBeDer(depth, inner) = self;
619        inner.deserialize_ignored_any(MayBeVis(depth, visitor))
620    }
621
622    fn deserialize_i128<V: Visitor<'de>>(
623        self,
624        visitor: V,
625    ) -> Result<V::Value, Self::Error> {
626        let MayBeDer(depth, inner) = self;
627        inner.deserialize_i128(MayBeVis(depth, visitor))
628    }
629
630    fn deserialize_u128<V: Visitor<'de>>(
631        self,
632        visitor: V,
633    ) -> Result<V::Value, Self::Error> {
634        let MayBeDer(depth, inner) = self;
635        inner.deserialize_u128(MayBeVis(depth, visitor))
636    }
637
638    fn is_human_readable(&self) -> bool {
639        let MayBeDer(_depth, inner) = self;
640        inner.is_human_readable()
641    }
642}
643
644impl<'a, 'de: 'a, A: VariantAccess<'de>> VariantAccess<'de> for DeepDer<'a, A> {
645    type Error = A::Error;
646
647    fn unit_variant(self) -> Result<(), Self::Error> {
648        let DeepDer(depth, inner) = self;
649        *depth = true;
650        inner.unit_variant()
651    }
652
653    fn newtype_variant_seed<T: DeserializeSeed<'de>>(
654        self,
655        seed: T,
656    ) -> Result<T::Value, Self::Error> {
657        let DeepDer(depth, inner) = self;
658        *depth = true;
659        inner.newtype_variant_seed(seed)
660    }
661
662    fn tuple_variant<V: Visitor<'de>>(
663        self, 
664        len: usize, 
665        visitor: V,
666    ) -> Result<V::Value, Self::Error> {
667        let DeepDer(depth, inner) = self;
668        *depth = true;
669        inner.tuple_variant(len, visitor)
670    }
671
672    fn struct_variant<V: Visitor<'de>>(
673        self, 
674        fields: &'static [&'static str], 
675        visitor: V
676    ) -> Result<V::Value, Self::Error> {
677        let DeepDer(depth, inner) = self;
678        *depth = true;
679        inner.struct_variant(fields, visitor)
680    }
681
682    fn newtype_variant<T: Deserialize<'de>>(
683        self,
684    ) -> Result<T, Self::Error> {
685        let DeepDer(depth, inner) = self;
686        *depth = true;
687        inner.newtype_variant()
688    }
689}
690
691impl<'a, 'de: 'a, A: EnumAccess<'de>> EnumAccess<'de> for DeepDer<'a, A> {
692    type Error = A::Error;
693
694    type Variant = DeepDer<'a, A::Variant>;
695
696    fn variant_seed<V: DeserializeSeed<'de>>(
697        self, 
698        seed: V,
699    ) -> Result<(V::Value, Self::Variant), Self::Error> {
700        let DeepDer(depth, inner) = self;
701        *depth = true;
702        inner.variant_seed(seed).map(move |(a, b)| {
703            (a, DeepDer(depth, b))
704        })
705    }
706
707    fn variant<V: Deserialize<'de>>(
708        self,
709    ) -> Result<(V, Self::Variant), Self::Error> {
710        let DeepDer(depth, inner) = self;
711        *depth = true;
712        inner.variant().map(move |(a, b)| {
713            (a, DeepDer(depth, b))
714        })
715    }
716}
717
718impl<'a, 'de: 'a, A: SeqAccess<'de>> SeqAccess<'de> for DeepDer<'a, A> {
719    type Error = A::Error;
720
721    fn next_element_seed<T: DeserializeSeed<'de>>(
722        &mut self, 
723        seed: T,
724    ) -> Result<Option<T::Value>, Self::Error> {
725        let DeepDer(ref mut depth, inner) = self;
726        **depth = true;
727        inner.next_element_seed(seed)
728    }
729
730    fn next_element<T: Deserialize<'de>>(
731        &mut self, 
732    ) -> Result<Option<T>, Self::Error> {
733        let DeepDer(ref mut depth, inner) = self;
734        **depth = true;
735        inner.next_element()
736    }
737
738    fn size_hint(&self) -> Option<usize> {
739        let DeepDer(_depth, inner) = self;
740        inner.size_hint()
741    }
742}
743
744impl<'a, 'de: 'a, A: MapAccess<'de>> MapAccess<'de> for DeepDer<'a, A> {
745    type Error = A::Error;
746
747    fn next_key_seed<K: DeserializeSeed<'de>>(
748        &mut self, 
749        seed: K,
750    ) -> Result<Option<K::Value>, Self::Error> {
751        let DeepDer(ref mut depth, inner) = self;
752        **depth = true;
753        inner.next_key_seed(seed)
754    }
755
756    fn next_value_seed<V: DeserializeSeed<'de>>(
757        &mut self,
758        seed: V,
759    ) -> Result<V::Value, Self::Error> {
760        let DeepDer(ref mut depth, inner) = self;
761        **depth = true;
762        inner.next_value_seed(seed)
763    }
764
765    fn next_entry_seed<K: DeserializeSeed<'de>, V: DeserializeSeed<'de>>(
766        &mut self, 
767        kseed: K, 
768        vseed: V,
769    ) -> Result<Option<(K::Value, V::Value)>, Self::Error> {
770        let DeepDer(ref mut depth, inner) = self;
771        **depth = true;
772        inner.next_entry_seed(kseed, vseed)
773    }
774
775    fn next_key<K: Deserialize<'de>>(
776        &mut self,
777    ) -> Result<Option<K>, Self::Error> {
778        let DeepDer(ref mut depth, inner) = self;
779        **depth = true;
780        inner.next_key()
781    }
782
783    fn next_value<V: Deserialize<'de>>(
784        &mut self,
785    ) -> Result<V, Self::Error> {
786        let DeepDer(ref mut depth, inner) = self;
787        **depth = true;
788        inner.next_value()
789    }
790
791    fn next_entry<K: Deserialize<'de>, V: Deserialize<'de>>(
792        &mut self,
793    ) -> Result<Option<(K, V)>, Self::Error> {
794        let DeepDer(ref mut depth, inner) = self;
795        **depth = true;
796        inner.next_entry()
797    }
798
799    fn size_hint(&self) -> Option<usize> {
800        let DeepDer(_depth, inner) = self;
801        inner.size_hint()
802    }
803}
804
805impl<'a, 'de: 'a, D: Deserializer<'de>> Deserializer<'de> for DeepDer<'a, D> {
806    type Error = D::Error;
807
808    fn deserialize_any<V: Visitor<'de>>(
809        self,
810        visitor: V,
811    ) -> Result<V::Value, Self::Error> {
812        let DeepDer(depth, inner) = self;
813        *depth = true;
814        inner.deserialize_any(visitor)
815    }
816
817    fn deserialize_bool<V: Visitor<'de>>(
818        self,
819        visitor: V,
820    ) -> Result<V::Value, Self::Error> {
821        let DeepDer(depth, inner) = self;
822        *depth = true;
823        inner.deserialize_bool(visitor)
824    }
825
826    fn deserialize_i8<V: Visitor<'de>>(
827        self,
828        visitor: V,
829    ) -> Result<V::Value, Self::Error> {
830        let DeepDer(depth, inner) = self;
831        *depth = true;
832        inner.deserialize_i8(visitor)
833    }
834
835    fn deserialize_i16<V: Visitor<'de>>(
836        self,
837        visitor: V,
838    ) -> Result<V::Value, Self::Error> {
839        let DeepDer(depth, inner) = self;
840        *depth = true;
841        inner.deserialize_i16(visitor)
842    }
843
844    fn deserialize_i32<V: Visitor<'de>>(
845        self,
846        visitor: V,
847    ) -> Result<V::Value, Self::Error> {
848        let DeepDer(depth, inner) = self;
849        *depth = true;
850        inner.deserialize_i32(visitor)
851    }
852
853    fn deserialize_i64<V: Visitor<'de>>(
854        self,
855        visitor: V,
856    ) -> Result<V::Value, Self::Error> {
857        let DeepDer(depth, inner) = self;
858        *depth = true;
859        inner.deserialize_i64(visitor)
860    }
861
862    fn deserialize_u8<V: Visitor<'de>>(
863        self,
864        visitor: V,
865    ) -> Result<V::Value, Self::Error> {
866        let DeepDer(depth, inner) = self;
867        *depth = true;
868        inner.deserialize_u8(visitor)
869    }
870
871    fn deserialize_u16<V: Visitor<'de>>(
872        self,
873        visitor: V,
874    ) -> Result<V::Value, Self::Error> {
875        let DeepDer(depth, inner) = self;
876        *depth = true;
877        inner.deserialize_u16(visitor)
878    }
879
880    fn deserialize_u32<V: Visitor<'de>>(
881        self,
882        visitor: V,
883    ) -> Result<V::Value, Self::Error> {
884        let DeepDer(depth, inner) = self;
885        *depth = true;
886        inner.deserialize_u32(visitor)
887    }
888
889    fn deserialize_u64<V: Visitor<'de>>(
890        self,
891        visitor: V,
892    ) -> Result<V::Value, Self::Error> {
893        let DeepDer(depth, inner) = self;
894        *depth = true;
895        inner.deserialize_u64(visitor)
896    }
897
898    fn deserialize_f32<V: Visitor<'de>>(
899        self,
900        visitor: V,
901    ) -> Result<V::Value, Self::Error> {
902        let DeepDer(depth, inner) = self;
903        *depth = true;
904        inner.deserialize_f32(visitor)
905    }
906
907    fn deserialize_f64<V: Visitor<'de>>(
908        self,
909        visitor: V,
910    ) -> Result<V::Value, Self::Error> {
911        let DeepDer(depth, inner) = self;
912        *depth = true;
913        inner.deserialize_f64(visitor)
914    }
915
916    fn deserialize_char<V: Visitor<'de>>(
917        self,
918        visitor: V,
919    ) -> Result<V::Value, Self::Error> {
920        let DeepDer(depth, inner) = self;
921        *depth = true;
922        inner.deserialize_char(visitor)
923    }
924
925    fn deserialize_str<V: Visitor<'de>>(
926        self,
927        visitor: V,
928    ) -> Result<V::Value, Self::Error> {
929        let DeepDer(depth, inner) = self;
930        *depth = true;
931        inner.deserialize_str(visitor)
932    }
933
934    fn deserialize_string<V: Visitor<'de>>(
935        self,
936        visitor: V,
937    ) -> Result<V::Value, Self::Error> {
938        let DeepDer(depth, inner) = self;
939        *depth = true;
940        inner.deserialize_string(visitor)
941    }
942
943    fn deserialize_bytes<V: Visitor<'de>>(
944        self,
945        visitor: V,
946    ) -> Result<V::Value, Self::Error> {
947        let DeepDer(depth, inner) = self;
948        *depth = true;
949        inner.deserialize_bytes(visitor)
950    }
951
952    fn deserialize_byte_buf<V: Visitor<'de>>(
953        self,
954        visitor: V,
955    ) -> Result<V::Value, Self::Error> {
956        let DeepDer(depth, inner) = self;
957        *depth = true;
958        inner.deserialize_byte_buf(visitor)
959    }
960
961    fn deserialize_option<V: Visitor<'de>>(
962        self,
963        visitor: V,
964    ) -> Result<V::Value, Self::Error> {
965        let DeepDer(depth, inner) = self;
966        *depth = true;
967        inner.deserialize_option(visitor)
968    }
969
970    fn deserialize_unit<V: Visitor<'de>>(
971        self,
972        visitor: V,
973    ) -> Result<V::Value, Self::Error> {
974        let DeepDer(depth, inner) = self;
975        *depth = true;
976        inner.deserialize_unit(visitor)
977    }
978
979    fn deserialize_unit_struct<V: Visitor<'de>>(
980        self, 
981        name: &'static str, 
982        visitor: V,
983    ) -> Result<V::Value, Self::Error> {
984        let DeepDer(depth, inner) = self;
985        *depth = true;
986        inner.deserialize_unit_struct(name, visitor)
987    }
988
989    fn deserialize_newtype_struct<V: Visitor<'de>>(
990        self, 
991        name: &'static str, 
992        visitor: V,
993    ) -> Result<V::Value, Self::Error> {
994        let DeepDer(depth, inner) = self;
995        *depth = true;
996        inner.deserialize_newtype_struct(name, visitor)
997    }
998
999    fn deserialize_seq<V: Visitor<'de>>(
1000        self,
1001        visitor: V,
1002    ) -> Result<V::Value, Self::Error> {
1003        let DeepDer(depth, inner) = self;
1004        *depth = true;
1005        inner.deserialize_seq(visitor)
1006    }
1007
1008    fn deserialize_tuple<V: Visitor<'de>>(
1009        self, 
1010        len: usize, 
1011        visitor: V,
1012    ) -> Result<V::Value, Self::Error> {
1013        let DeepDer(depth, inner) = self;
1014        *depth = true;
1015        inner.deserialize_tuple(len, visitor)
1016    }
1017
1018    fn deserialize_tuple_struct<V: Visitor<'de>>(
1019        self, 
1020        name: &'static str, 
1021        len: usize, 
1022        visitor: V,
1023    ) -> Result<V::Value, Self::Error> {
1024        let DeepDer(depth, inner) = self;
1025        *depth = true;
1026        inner.deserialize_tuple_struct(name, len, visitor)
1027    }
1028
1029    fn deserialize_map<V: Visitor<'de>>(
1030        self,
1031        visitor: V,
1032    ) -> Result<V::Value, Self::Error> {
1033        let DeepDer(depth, inner) = self;
1034        *depth = true;
1035        inner.deserialize_map(visitor)
1036    }
1037
1038    fn deserialize_struct<V: Visitor<'de>>(
1039        self, 
1040        name: &'static str, 
1041        fields: &'static [&'static str], 
1042        visitor: V,
1043    ) -> Result<V::Value, Self::Error> {
1044        let DeepDer(depth, inner) = self;
1045        *depth = true;
1046        inner.deserialize_struct(name, fields, visitor)
1047    }
1048
1049    fn deserialize_enum<V: Visitor<'de>>(
1050        self, 
1051        name: &'static str, 
1052        variants: &'static [&'static str], 
1053        visitor: V,
1054    ) -> Result<V::Value, Self::Error> {
1055        let DeepDer(depth, inner) = self;
1056        *depth = true;
1057        inner.deserialize_enum(name, variants, visitor)
1058    }
1059
1060    fn deserialize_identifier<V: Visitor<'de>>(
1061        self, 
1062        visitor: V,
1063    ) -> Result<V::Value, Self::Error> {
1064        let DeepDer(depth, inner) = self;
1065        *depth = true;
1066        inner.deserialize_identifier(visitor)
1067    }
1068
1069    fn deserialize_ignored_any<V: Visitor<'de>>(
1070        self, 
1071        visitor: V,
1072    ) -> Result<V::Value, Self::Error> {
1073        let DeepDer(depth, inner) = self;
1074        *depth = true;
1075        inner.deserialize_ignored_any(visitor)
1076    }
1077
1078    fn deserialize_i128<V: Visitor<'de>>(
1079        self,
1080        visitor: V,
1081    ) -> Result<V::Value, Self::Error> {
1082        let DeepDer(depth, inner) = self;
1083        *depth = true;
1084        inner.deserialize_i128(visitor)
1085    }
1086
1087    fn deserialize_u128<V: Visitor<'de>>(
1088        self,
1089        visitor: V,
1090    ) -> Result<V::Value, Self::Error> {
1091        let DeepDer(depth, inner) = self;
1092        *depth = true;
1093        inner.deserialize_u128(visitor)
1094    }
1095
1096    fn is_human_readable(&self) -> bool {
1097        let DeepDer(_depth, inner) = self;
1098        inner.is_human_readable()
1099    }
1100}
serde_util/maybe.rs

serde_util/
maybe.rs
