erased_serde/
de.rs

1use crate::any::Any;
2use crate::error::{erase_de as erase, unerase_de as unerase, Error};
3use crate::map::{OptionExt, ResultExt};
4use crate::sealed::deserializer::Sealed;
5use alloc::boxed::Box;
6#[cfg(feature = "alloc")]
7use alloc::string::String;
8#[cfg(feature = "alloc")]
9use alloc::vec::Vec;
10use core::fmt;
11
12/// Deserialize a value of type `T` from the given trait object.
13///
14/// ```rust
15/// use erased_serde::Deserializer;
16/// use std::collections::BTreeMap as Map;
17///
18/// fn main() {
19///     static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#;
20///     static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66];
21///
22///     // Construct some deserializers.
23///     let json = &mut serde_json::Deserializer::from_slice(JSON);
24///     let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR);
25///
26///     // The values in this map are boxed trait objects, which is not possible
27///     // with the normal serde::Deserializer because of object safety.
28///     let mut formats: Map<&str, Box<dyn Deserializer>> = Map::new();
29///     formats.insert("json", Box::new(<dyn Deserializer>::erase(json)));
30///     formats.insert("cbor", Box::new(<dyn Deserializer>::erase(cbor)));
31///
32///     // Pick a Deserializer out of the formats map.
33///     let format = formats.get_mut("json").unwrap();
34///
35///     let data: Map<String, usize> = erased_serde::deserialize(format).unwrap();
36///
37///     println!("{}", data["A"] + data["B"]);
38/// }
39/// ```
40pub fn deserialize<'de, T>(deserializer: &mut dyn Deserializer<'de>) -> Result<T, Error>
41where
42    T: serde::Deserialize<'de>,
43{
44    serde::Deserialize::deserialize(deserializer)
45}
46
47// TRAITS //////////////////////////////////////////////////////////////////////
48
49pub trait DeserializeSeed<'de> {
50    fn erased_deserialize_seed(
51        &mut self,
52        deserializer: &mut dyn Deserializer<'de>,
53    ) -> Result<Out, Error>;
54}
55
56/// An object-safe equivalent of Serde's `Deserializer` trait.
57///
58/// Any implementation of Serde's `Deserializer` can be converted to a
59/// `&dyn erased_serde::Deserializer` or `Box<dyn erased_serde::Deserializer>`
60/// trait object using `erased_serde::Deserializer::erase`.
61///
62/// ```rust
63/// use erased_serde::Deserializer;
64/// use std::collections::BTreeMap as Map;
65///
66/// fn main() {
67///     static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#;
68///     static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66];
69///
70///     // Construct some deserializers.
71///     let json = &mut serde_json::Deserializer::from_slice(JSON);
72///     let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR);
73///
74///     // The values in this map are boxed trait objects, which is not possible
75///     // with the normal serde::Deserializer because of object safety.
76///     let mut formats: Map<&str, Box<dyn Deserializer>> = Map::new();
77///     formats.insert("json", Box::new(<dyn Deserializer>::erase(json)));
78///     formats.insert("cbor", Box::new(<dyn Deserializer>::erase(cbor)));
79///
80///     // Pick a Deserializer out of the formats map.
81///     let format = formats.get_mut("json").unwrap();
82///
83///     let data: Map<String, usize> = erased_serde::deserialize(format).unwrap();
84///
85///     println!("{}", data["A"] + data["B"]);
86/// }
87/// ```
88///
89/// This trait is sealed and can only be implemented via a
90/// `serde::Deserializer<'de>` impl.
91pub trait Deserializer<'de>: Sealed {
92    fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
93    fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
94    fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
95    fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
96    fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
97    fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
98    fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
99    fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
100    fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
101    fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
102    fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
103    fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
104    fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
105    fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
106    fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
107    fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
108    fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
109    fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
110    fn erased_deserialize_byte_buf(&mut self, visitor: &mut dyn Visitor<'de>)
111        -> Result<Out, Error>;
112    fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
113    fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
114    fn erased_deserialize_unit_struct(
115        &mut self,
116        name: &'static str,
117        visitor: &mut dyn Visitor<'de>,
118    ) -> Result<Out, Error>;
119    fn erased_deserialize_newtype_struct(
120        &mut self,
121        name: &'static str,
122        visitor: &mut dyn Visitor<'de>,
123    ) -> Result<Out, Error>;
124    fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
125    fn erased_deserialize_tuple(
126        &mut self,
127        len: usize,
128        visitor: &mut dyn Visitor<'de>,
129    ) -> Result<Out, Error>;
130    fn erased_deserialize_tuple_struct(
131        &mut self,
132        name: &'static str,
133        len: usize,
134        visitor: &mut dyn Visitor<'de>,
135    ) -> Result<Out, Error>;
136    fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>;
137    fn erased_deserialize_struct(
138        &mut self,
139        name: &'static str,
140        fields: &'static [&'static str],
141        visitor: &mut dyn Visitor<'de>,
142    ) -> Result<Out, Error>;
143    fn erased_deserialize_identifier(
144        &mut self,
145        visitor: &mut dyn Visitor<'de>,
146    ) -> Result<Out, Error>;
147    fn erased_deserialize_enum(
148        &mut self,
149        name: &'static str,
150        variants: &'static [&'static str],
151        visitor: &mut dyn Visitor<'de>,
152    ) -> Result<Out, Error>;
153    fn erased_deserialize_ignored_any(
154        &mut self,
155        visitor: &mut dyn Visitor<'de>,
156    ) -> Result<Out, Error>;
157    fn erased_is_human_readable(&self) -> bool;
158}
159
160pub trait Visitor<'de> {
161    fn erased_expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
162    fn erased_visit_bool(&mut self, v: bool) -> Result<Out, Error>;
163    fn erased_visit_i8(&mut self, v: i8) -> Result<Out, Error>;
164    fn erased_visit_i16(&mut self, v: i16) -> Result<Out, Error>;
165    fn erased_visit_i32(&mut self, v: i32) -> Result<Out, Error>;
166    fn erased_visit_i64(&mut self, v: i64) -> Result<Out, Error>;
167    fn erased_visit_i128(&mut self, v: i128) -> Result<Out, Error>;
168    fn erased_visit_u8(&mut self, v: u8) -> Result<Out, Error>;
169    fn erased_visit_u16(&mut self, v: u16) -> Result<Out, Error>;
170    fn erased_visit_u32(&mut self, v: u32) -> Result<Out, Error>;
171    fn erased_visit_u64(&mut self, v: u64) -> Result<Out, Error>;
172    fn erased_visit_u128(&mut self, v: u128) -> Result<Out, Error>;
173    fn erased_visit_f32(&mut self, v: f32) -> Result<Out, Error>;
174    fn erased_visit_f64(&mut self, v: f64) -> Result<Out, Error>;
175    fn erased_visit_char(&mut self, v: char) -> Result<Out, Error>;
176    fn erased_visit_str(&mut self, v: &str) -> Result<Out, Error>;
177    fn erased_visit_borrowed_str(&mut self, v: &'de str) -> Result<Out, Error>;
178    #[cfg(feature = "alloc")]
179    fn erased_visit_string(&mut self, v: String) -> Result<Out, Error>;
180    fn erased_visit_bytes(&mut self, v: &[u8]) -> Result<Out, Error>;
181    fn erased_visit_borrowed_bytes(&mut self, v: &'de [u8]) -> Result<Out, Error>;
182    #[cfg(feature = "alloc")]
183    fn erased_visit_byte_buf(&mut self, v: Vec<u8>) -> Result<Out, Error>;
184    fn erased_visit_none(&mut self) -> Result<Out, Error>;
185    fn erased_visit_some(&mut self, deserializer: &mut dyn Deserializer<'de>)
186        -> Result<Out, Error>;
187    fn erased_visit_unit(&mut self) -> Result<Out, Error>;
188    fn erased_visit_newtype_struct(
189        &mut self,
190        deserializer: &mut dyn Deserializer<'de>,
191    ) -> Result<Out, Error>;
192    fn erased_visit_seq(&mut self, seq: &mut dyn SeqAccess<'de>) -> Result<Out, Error>;
193    fn erased_visit_map(&mut self, map: &mut dyn MapAccess<'de>) -> Result<Out, Error>;
194    fn erased_visit_enum(&mut self, data: &mut dyn EnumAccess<'de>) -> Result<Out, Error>;
195}
196
197pub trait SeqAccess<'de> {
198    fn erased_next_element(
199        &mut self,
200        seed: &mut dyn DeserializeSeed<'de>,
201    ) -> Result<Option<Out>, Error>;
202    fn erased_size_hint(&self) -> Option<usize>;
203}
204
205pub trait MapAccess<'de> {
206    fn erased_next_key(
207        &mut self,
208        seed: &mut dyn DeserializeSeed<'de>,
209    ) -> Result<Option<Out>, Error>;
210    fn erased_next_value(&mut self, seed: &mut dyn DeserializeSeed<'de>) -> Result<Out, Error>;
211    fn erased_next_entry(
212        &mut self,
213        key: &mut dyn DeserializeSeed<'de>,
214        value: &mut dyn DeserializeSeed<'de>,
215    ) -> Result<Option<(Out, Out)>, Error>;
216    fn erased_size_hint(&self) -> Option<usize>;
217}
218
219pub trait EnumAccess<'de> {
220    fn erased_variant_seed(
221        &mut self,
222        seed: &mut dyn DeserializeSeed<'de>,
223    ) -> Result<(Out, Variant<'de>), Error>;
224}
225
226impl<'de> dyn Deserializer<'de> {
227    /// Convert any Serde `Deserializer` to a trait object.
228    ///
229    /// ```rust
230    /// use erased_serde::Deserializer;
231    /// use std::collections::BTreeMap as Map;
232    ///
233    /// fn main() {
234    ///     static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#;
235    ///     static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66];
236    ///
237    ///     // Construct some deserializers.
238    ///     let json = &mut serde_json::Deserializer::from_slice(JSON);
239    ///     let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR);
240    ///
241    ///     // The values in this map are boxed trait objects, which is not possible
242    ///     // with the normal serde::Deserializer because of object safety.
243    ///     let mut formats: Map<&str, Box<dyn Deserializer>> = Map::new();
244    ///     formats.insert("json", Box::new(<dyn Deserializer>::erase(json)));
245    ///     formats.insert("cbor", Box::new(<dyn Deserializer>::erase(cbor)));
246    ///
247    ///     // Pick a Deserializer out of the formats map.
248    ///     let format = formats.get_mut("json").unwrap();
249    ///
250    ///     let data: Map<String, usize> = erased_serde::deserialize(format).unwrap();
251    ///
252    ///     println!("{}", data["A"] + data["B"]);
253    /// }
254    /// ```
255    pub fn erase<D>(deserializer: D) -> impl Deserializer<'de>
256    where
257        D: serde::Deserializer<'de>,
258    {
259        erase::Deserializer::new(deserializer)
260    }
261}
262
263// OUT /////////////////////////////////////////////////////////////////////////
264
265pub struct Out(Any);
266
267impl Out {
268    unsafe fn new<T>(t: T) -> Self {
269        Out(unsafe { Any::new(t) })
270    }
271
272    unsafe fn take<T>(self) -> T {
273        unsafe { self.0.take() }
274    }
275}
276
277// IMPL ERASED SERDE FOR SERDE /////////////////////////////////////////////////
278
279mod erase {
280    pub struct DeserializeSeed<D> {
281        state: Option<D>,
282    }
283
284    impl<D> DeserializeSeed<D> {
285        pub(crate) fn new(seed: D) -> Self {
286            DeserializeSeed { state: Some(seed) }
287        }
288
289        pub(crate) fn take(&mut self) -> D {
290            self.state.take().unwrap()
291        }
292    }
293
294    pub struct Deserializer<D> {
295        state: Option<D>,
296    }
297
298    impl<D> Deserializer<D> {
299        pub(crate) fn new(deserializer: D) -> Self {
300            Deserializer {
301                state: Some(deserializer),
302            }
303        }
304
305        pub(crate) fn take(&mut self) -> D {
306            self.state.take().unwrap()
307        }
308
309        pub(crate) fn as_ref(&self) -> &D {
310            self.state.as_ref().unwrap()
311        }
312    }
313
314    pub struct Visitor<D> {
315        state: Option<D>,
316    }
317
318    impl<D> Visitor<D> {
319        pub(crate) fn new(visitor: D) -> Self {
320            Visitor {
321                state: Some(visitor),
322            }
323        }
324
325        pub(crate) fn take(&mut self) -> D {
326            self.state.take().unwrap()
327        }
328
329        pub(crate) fn as_ref(&self) -> &D {
330            self.state.as_ref().unwrap()
331        }
332    }
333
334    pub struct SeqAccess<D> {
335        state: D,
336    }
337
338    impl<D> SeqAccess<D> {
339        pub(crate) fn new(seq_access: D) -> Self {
340            SeqAccess { state: seq_access }
341        }
342
343        pub(crate) fn as_ref(&self) -> &D {
344            &self.state
345        }
346
347        pub(crate) fn as_mut(&mut self) -> &mut D {
348            &mut self.state
349        }
350    }
351
352    pub struct MapAccess<D> {
353        state: D,
354    }
355
356    impl<D> MapAccess<D> {
357        pub(crate) fn new(map_access: D) -> Self {
358            MapAccess { state: map_access }
359        }
360
361        pub(crate) fn as_ref(&self) -> &D {
362            &self.state
363        }
364
365        pub(crate) fn as_mut(&mut self) -> &mut D {
366            &mut self.state
367        }
368    }
369
370    pub struct EnumAccess<D> {
371        state: Option<D>,
372    }
373
374    impl<D> EnumAccess<D> {
375        pub(crate) fn new(enum_access: D) -> Self {
376            EnumAccess {
377                state: Some(enum_access),
378            }
379        }
380
381        pub(crate) fn take(&mut self) -> D {
382            self.state.take().unwrap()
383        }
384    }
385}
386
387impl<'de, T> DeserializeSeed<'de> for erase::DeserializeSeed<T>
388where
389    T: serde::de::DeserializeSeed<'de>,
390{
391    fn erased_deserialize_seed(
392        &mut self,
393        deserializer: &mut dyn Deserializer<'de>,
394    ) -> Result<Out, Error> {
395        unsafe { self.take().deserialize(deserializer).unsafe_map(Out::new) }
396    }
397}
398
399impl<'de, T> Deserializer<'de> for erase::Deserializer<T>
400where
401    T: serde::Deserializer<'de>,
402{
403    fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
404        self.take().deserialize_any(visitor).map_err(erase)
405    }
406
407    fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
408        self.take().deserialize_bool(visitor).map_err(erase)
409    }
410
411    fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
412        self.take().deserialize_i8(visitor).map_err(erase)
413    }
414
415    fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
416        self.take().deserialize_i16(visitor).map_err(erase)
417    }
418
419    fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
420        self.take().deserialize_i32(visitor).map_err(erase)
421    }
422
423    fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
424        self.take().deserialize_i64(visitor).map_err(erase)
425    }
426
427    fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
428        self.take().deserialize_i128(visitor).map_err(erase)
429    }
430
431    fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
432        self.take().deserialize_u8(visitor).map_err(erase)
433    }
434
435    fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
436        self.take().deserialize_u16(visitor).map_err(erase)
437    }
438
439    fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
440        self.take().deserialize_u32(visitor).map_err(erase)
441    }
442
443    fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
444        self.take().deserialize_u64(visitor).map_err(erase)
445    }
446
447    fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
448        self.take().deserialize_u128(visitor).map_err(erase)
449    }
450
451    fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
452        self.take().deserialize_f32(visitor).map_err(erase)
453    }
454
455    fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
456        self.take().deserialize_f64(visitor).map_err(erase)
457    }
458
459    fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
460        self.take().deserialize_char(visitor).map_err(erase)
461    }
462
463    fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
464        self.take().deserialize_str(visitor).map_err(erase)
465    }
466
467    fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
468        self.take().deserialize_string(visitor).map_err(erase)
469    }
470
471    fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
472        self.take().deserialize_bytes(visitor).map_err(erase)
473    }
474
475    fn erased_deserialize_byte_buf(
476        &mut self,
477        visitor: &mut dyn Visitor<'de>,
478    ) -> Result<Out, Error> {
479        self.take().deserialize_byte_buf(visitor).map_err(erase)
480    }
481
482    fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
483        self.take().deserialize_option(visitor).map_err(erase)
484    }
485
486    fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
487        self.take().deserialize_unit(visitor).map_err(erase)
488    }
489
490    fn erased_deserialize_unit_struct(
491        &mut self,
492        name: &'static str,
493        visitor: &mut dyn Visitor<'de>,
494    ) -> Result<Out, Error> {
495        self.take()
496            .deserialize_unit_struct(name, visitor)
497            .map_err(erase)
498    }
499
500    fn erased_deserialize_newtype_struct(
501        &mut self,
502        name: &'static str,
503        visitor: &mut dyn Visitor<'de>,
504    ) -> Result<Out, Error> {
505        self.take()
506            .deserialize_newtype_struct(name, visitor)
507            .map_err(erase)
508    }
509
510    fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
511        self.take().deserialize_seq(visitor).map_err(erase)
512    }
513
514    fn erased_deserialize_tuple(
515        &mut self,
516        len: usize,
517        visitor: &mut dyn Visitor<'de>,
518    ) -> Result<Out, Error> {
519        self.take().deserialize_tuple(len, visitor).map_err(erase)
520    }
521
522    fn erased_deserialize_tuple_struct(
523        &mut self,
524        name: &'static str,
525        len: usize,
526        visitor: &mut dyn Visitor<'de>,
527    ) -> Result<Out, Error> {
528        self.take()
529            .deserialize_tuple_struct(name, len, visitor)
530            .map_err(erase)
531    }
532
533    fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
534        self.take().deserialize_map(visitor).map_err(erase)
535    }
536
537    fn erased_deserialize_struct(
538        &mut self,
539        name: &'static str,
540        fields: &'static [&'static str],
541        visitor: &mut dyn Visitor<'de>,
542    ) -> Result<Out, Error> {
543        self.take()
544            .deserialize_struct(name, fields, visitor)
545            .map_err(erase)
546    }
547
548    fn erased_deserialize_identifier(
549        &mut self,
550        visitor: &mut dyn Visitor<'de>,
551    ) -> Result<Out, Error> {
552        self.take().deserialize_identifier(visitor).map_err(erase)
553    }
554
555    fn erased_deserialize_enum(
556        &mut self,
557        name: &'static str,
558        variants: &'static [&'static str],
559        visitor: &mut dyn Visitor<'de>,
560    ) -> Result<Out, Error> {
561        self.take()
562            .deserialize_enum(name, variants, visitor)
563            .map_err(erase)
564    }
565
566    fn erased_deserialize_ignored_any(
567        &mut self,
568        visitor: &mut dyn Visitor<'de>,
569    ) -> Result<Out, Error> {
570        self.take().deserialize_ignored_any(visitor).map_err(erase)
571    }
572
573    fn erased_is_human_readable(&self) -> bool {
574        self.as_ref().is_human_readable()
575    }
576}
577
578impl<'de, T> Sealed for erase::Deserializer<T> where T: serde::Deserializer<'de> {}
579
580impl<'de, T> Visitor<'de> for erase::Visitor<T>
581where
582    T: serde::de::Visitor<'de>,
583{
584    fn erased_expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
585        self.as_ref().expecting(formatter)
586    }
587
588    fn erased_visit_bool(&mut self, v: bool) -> Result<Out, Error> {
589        unsafe { self.take().visit_bool(v).unsafe_map(Out::new) }
590    }
591
592    fn erased_visit_i8(&mut self, v: i8) -> Result<Out, Error> {
593        unsafe { self.take().visit_i8(v).unsafe_map(Out::new) }
594    }
595
596    fn erased_visit_i16(&mut self, v: i16) -> Result<Out, Error> {
597        unsafe { self.take().visit_i16(v).unsafe_map(Out::new) }
598    }
599
600    fn erased_visit_i32(&mut self, v: i32) -> Result<Out, Error> {
601        unsafe { self.take().visit_i32(v).unsafe_map(Out::new) }
602    }
603
604    fn erased_visit_i64(&mut self, v: i64) -> Result<Out, Error> {
605        unsafe { self.take().visit_i64(v).unsafe_map(Out::new) }
606    }
607
608    fn erased_visit_i128(&mut self, v: i128) -> Result<Out, Error> {
609        unsafe { self.take().visit_i128(v).unsafe_map(Out::new) }
610    }
611
612    fn erased_visit_u8(&mut self, v: u8) -> Result<Out, Error> {
613        unsafe { self.take().visit_u8(v).unsafe_map(Out::new) }
614    }
615
616    fn erased_visit_u16(&mut self, v: u16) -> Result<Out, Error> {
617        unsafe { self.take().visit_u16(v).unsafe_map(Out::new) }
618    }
619
620    fn erased_visit_u32(&mut self, v: u32) -> Result<Out, Error> {
621        unsafe { self.take().visit_u32(v).unsafe_map(Out::new) }
622    }
623
624    fn erased_visit_u64(&mut self, v: u64) -> Result<Out, Error> {
625        unsafe { self.take().visit_u64(v).unsafe_map(Out::new) }
626    }
627
628    fn erased_visit_u128(&mut self, v: u128) -> Result<Out, Error> {
629        unsafe { self.take().visit_u128(v).unsafe_map(Out::new) }
630    }
631
632    fn erased_visit_f32(&mut self, v: f32) -> Result<Out, Error> {
633        unsafe { self.take().visit_f32(v).unsafe_map(Out::new) }
634    }
635
636    fn erased_visit_f64(&mut self, v: f64) -> Result<Out, Error> {
637        unsafe { self.take().visit_f64(v).unsafe_map(Out::new) }
638    }
639
640    fn erased_visit_char(&mut self, v: char) -> Result<Out, Error> {
641        unsafe { self.take().visit_char(v).unsafe_map(Out::new) }
642    }
643
644    fn erased_visit_str(&mut self, v: &str) -> Result<Out, Error> {
645        unsafe { self.take().visit_str(v).unsafe_map(Out::new) }
646    }
647
648    fn erased_visit_borrowed_str(&mut self, v: &'de str) -> Result<Out, Error> {
649        unsafe { self.take().visit_borrowed_str(v).unsafe_map(Out::new) }
650    }
651
652    #[cfg(feature = "alloc")]
653    fn erased_visit_string(&mut self, v: String) -> Result<Out, Error> {
654        unsafe { self.take().visit_string(v).unsafe_map(Out::new) }
655    }
656
657    fn erased_visit_bytes(&mut self, v: &[u8]) -> Result<Out, Error> {
658        unsafe { self.take().visit_bytes(v).unsafe_map(Out::new) }
659    }
660
661    fn erased_visit_borrowed_bytes(&mut self, v: &'de [u8]) -> Result<Out, Error> {
662        unsafe { self.take().visit_borrowed_bytes(v).unsafe_map(Out::new) }
663    }
664
665    #[cfg(feature = "alloc")]
666    fn erased_visit_byte_buf(&mut self, v: Vec<u8>) -> Result<Out, Error> {
667        unsafe { self.take().visit_byte_buf(v).unsafe_map(Out::new) }
668    }
669
670    fn erased_visit_none(&mut self) -> Result<Out, Error> {
671        unsafe { self.take().visit_none().unsafe_map(Out::new) }
672    }
673
674    fn erased_visit_some(
675        &mut self,
676        deserializer: &mut dyn Deserializer<'de>,
677    ) -> Result<Out, Error> {
678        unsafe { self.take().visit_some(deserializer).unsafe_map(Out::new) }
679    }
680
681    fn erased_visit_unit(&mut self) -> Result<Out, Error> {
682        unsafe { self.take().visit_unit().unsafe_map(Out::new) }
683    }
684
685    fn erased_visit_newtype_struct(
686        &mut self,
687        deserializer: &mut dyn Deserializer<'de>,
688    ) -> Result<Out, Error> {
689        unsafe {
690            self.take()
691                .visit_newtype_struct(deserializer)
692                .unsafe_map(Out::new)
693        }
694    }
695
696    fn erased_visit_seq(&mut self, seq: &mut dyn SeqAccess<'de>) -> Result<Out, Error> {
697        unsafe { self.take().visit_seq(seq).unsafe_map(Out::new) }
698    }
699
700    fn erased_visit_map(&mut self, map: &mut dyn MapAccess<'de>) -> Result<Out, Error> {
701        unsafe { self.take().visit_map(map).unsafe_map(Out::new) }
702    }
703
704    fn erased_visit_enum(&mut self, data: &mut dyn EnumAccess<'de>) -> Result<Out, Error> {
705        unsafe { self.take().visit_enum(data).unsafe_map(Out::new) }
706    }
707}
708
709impl<'de, T> SeqAccess<'de> for erase::SeqAccess<T>
710where
711    T: serde::de::SeqAccess<'de>,
712{
713    fn erased_next_element(
714        &mut self,
715        seed: &mut dyn DeserializeSeed<'de>,
716    ) -> Result<Option<Out>, Error> {
717        self.as_mut().next_element_seed(seed).map_err(erase)
718    }
719
720    fn erased_size_hint(&self) -> Option<usize> {
721        self.as_ref().size_hint()
722    }
723}
724
725impl<'de, T> MapAccess<'de> for erase::MapAccess<T>
726where
727    T: serde::de::MapAccess<'de>,
728{
729    fn erased_next_key(
730        &mut self,
731        seed: &mut dyn DeserializeSeed<'de>,
732    ) -> Result<Option<Out>, Error> {
733        self.as_mut().next_key_seed(seed).map_err(erase)
734    }
735
736    fn erased_next_value(&mut self, seed: &mut dyn DeserializeSeed<'de>) -> Result<Out, Error> {
737        self.as_mut().next_value_seed(seed).map_err(erase)
738    }
739
740    fn erased_next_entry(
741        &mut self,
742        kseed: &mut dyn DeserializeSeed<'de>,
743        vseed: &mut dyn DeserializeSeed<'de>,
744    ) -> Result<Option<(Out, Out)>, Error> {
745        self.as_mut().next_entry_seed(kseed, vseed).map_err(erase)
746    }
747
748    fn erased_size_hint(&self) -> Option<usize> {
749        self.as_ref().size_hint()
750    }
751}
752
753impl<'de, T> EnumAccess<'de> for erase::EnumAccess<T>
754where
755    T: serde::de::EnumAccess<'de>,
756{
757    fn erased_variant_seed(
758        &mut self,
759        seed: &mut dyn DeserializeSeed<'de>,
760    ) -> Result<(Out, Variant<'de>), Error> {
761        self.take()
762            .variant_seed(seed)
763            .map(|(out, variant)| {
764                use serde::de::VariantAccess;
765                let erased = Variant {
766                    data: unsafe { Any::new(variant) },
767                    unit_variant: {
768                        unsafe fn unit_variant<'de, T>(a: Any) -> Result<(), Error>
769                        where
770                            T: serde::de::EnumAccess<'de>,
771                        {
772                            unsafe { a.take::<T::Variant>().unit_variant().map_err(erase) }
773                        }
774                        unit_variant::<T>
775                    },
776                    visit_newtype: {
777                        unsafe fn visit_newtype<'de, T>(
778                            a: Any,
779                            seed: &mut dyn DeserializeSeed<'de>,
780                        ) -> Result<Out, Error>
781                        where
782                            T: serde::de::EnumAccess<'de>,
783                        {
784                            unsafe {
785                                a.take::<T::Variant>()
786                                    .newtype_variant_seed(seed)
787                                    .map_err(erase)
788                            }
789                        }
790                        visit_newtype::<T>
791                    },
792                    tuple_variant: {
793                        unsafe fn tuple_variant<'de, T>(
794                            a: Any,
795                            len: usize,
796                            visitor: &mut dyn Visitor<'de>,
797                        ) -> Result<Out, Error>
798                        where
799                            T: serde::de::EnumAccess<'de>,
800                        {
801                            unsafe {
802                                a.take::<T::Variant>()
803                                    .tuple_variant(len, visitor)
804                                    .map_err(erase)
805                            }
806                        }
807                        tuple_variant::<T>
808                    },
809                    struct_variant: {
810                        unsafe fn struct_variant<'de, T>(
811                            a: Any,
812                            fields: &'static [&'static str],
813                            visitor: &mut dyn Visitor<'de>,
814                        ) -> Result<Out, Error>
815                        where
816                            T: serde::de::EnumAccess<'de>,
817                        {
818                            unsafe {
819                                a.take::<T::Variant>()
820                                    .struct_variant(fields, visitor)
821                                    .map_err(erase)
822                            }
823                        }
824                        struct_variant::<T>
825                    },
826                };
827                (out, erased)
828            })
829            .map_err(erase)
830    }
831}
832
833// IMPL SERDE FOR ERASED SERDE /////////////////////////////////////////////////
834
835impl<'de> serde::de::DeserializeSeed<'de> for &mut (dyn DeserializeSeed<'de> + '_) {
836    type Value = Out;
837    fn deserialize<D>(self, deserializer: D) -> Result<Out, D::Error>
838    where
839        D: serde::Deserializer<'de>,
840    {
841        let mut erased = erase::Deserializer::new(deserializer);
842        self.erased_deserialize_seed(&mut erased).map_err(unerase)
843    }
844}
845
846macro_rules! impl_deserializer_for_trait_object {
847    ({$($mut:tt)*} $ty:ty) => {
848        impl<'de> serde::Deserializer<'de> for $ty {
849            type Error = Error;
850
851            fn deserialize_any<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
852            where
853                V: serde::de::Visitor<'de>,
854            {
855                let mut erased = erase::Visitor::new(visitor);
856                unsafe { self.erased_deserialize_any(&mut erased).unsafe_map(Out::take) }
857            }
858
859            fn deserialize_bool<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
860            where
861                V: serde::de::Visitor<'de>,
862            {
863                let mut erased = erase::Visitor::new(visitor);
864                unsafe { self.erased_deserialize_bool(&mut erased).unsafe_map(Out::take) }
865            }
866
867            fn deserialize_i8<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
868            where
869                V: serde::de::Visitor<'de>,
870            {
871                let mut erased = erase::Visitor::new(visitor);
872                unsafe { self.erased_deserialize_i8(&mut erased).unsafe_map(Out::take) }
873            }
874
875            fn deserialize_i16<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
876            where
877                V: serde::de::Visitor<'de>,
878            {
879                let mut erased = erase::Visitor::new(visitor);
880                unsafe { self.erased_deserialize_i16(&mut erased).unsafe_map(Out::take) }
881            }
882
883            fn deserialize_i32<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
884            where
885                V: serde::de::Visitor<'de>,
886            {
887                let mut erased = erase::Visitor::new(visitor);
888                unsafe { self.erased_deserialize_i32(&mut erased).unsafe_map(Out::take) }
889            }
890
891            fn deserialize_i64<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
892            where
893                V: serde::de::Visitor<'de>,
894            {
895                let mut erased = erase::Visitor::new(visitor);
896                unsafe { self.erased_deserialize_i64(&mut erased).unsafe_map(Out::take) }
897            }
898
899            fn deserialize_i128<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
900            where
901                V: serde::de::Visitor<'de>,
902            {
903                let mut erased = erase::Visitor::new(visitor);
904                unsafe { self.erased_deserialize_i128(&mut erased).unsafe_map(Out::take) }
905            }
906
907            fn deserialize_u8<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
908            where
909                V: serde::de::Visitor<'de>,
910            {
911                let mut erased = erase::Visitor::new(visitor);
912                unsafe { self.erased_deserialize_u8(&mut erased).unsafe_map(Out::take) }
913            }
914
915            fn deserialize_u16<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
916            where
917                V: serde::de::Visitor<'de>,
918            {
919                let mut erased = erase::Visitor::new(visitor);
920                unsafe { self.erased_deserialize_u16(&mut erased).unsafe_map(Out::take) }
921            }
922
923            fn deserialize_u32<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
924            where
925                V: serde::de::Visitor<'de>,
926            {
927                let mut erased = erase::Visitor::new(visitor);
928                unsafe { self.erased_deserialize_u32(&mut erased).unsafe_map(Out::take) }
929            }
930
931            fn deserialize_u64<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
932            where
933                V: serde::de::Visitor<'de>,
934            {
935                let mut erased = erase::Visitor::new(visitor);
936                unsafe { self.erased_deserialize_u64(&mut erased).unsafe_map(Out::take) }
937            }
938
939            fn deserialize_u128<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
940            where
941                V: serde::de::Visitor<'de>,
942            {
943                let mut erased = erase::Visitor::new(visitor);
944                unsafe { self.erased_deserialize_u128(&mut erased).unsafe_map(Out::take) }
945            }
946
947            fn deserialize_f32<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
948            where
949                V: serde::de::Visitor<'de>,
950            {
951                let mut erased = erase::Visitor::new(visitor);
952                unsafe { self.erased_deserialize_f32(&mut erased).unsafe_map(Out::take) }
953            }
954
955            fn deserialize_f64<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
956            where
957                V: serde::de::Visitor<'de>,
958            {
959                let mut erased = erase::Visitor::new(visitor);
960                unsafe { self.erased_deserialize_f64(&mut erased).unsafe_map(Out::take) }
961            }
962
963            fn deserialize_char<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
964            where
965                V: serde::de::Visitor<'de>,
966            {
967                let mut erased = erase::Visitor::new(visitor);
968                unsafe { self.erased_deserialize_char(&mut erased).unsafe_map(Out::take) }
969            }
970
971            fn deserialize_str<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
972            where
973                V: serde::de::Visitor<'de>,
974            {
975                let mut erased = erase::Visitor::new(visitor);
976                unsafe { self.erased_deserialize_str(&mut erased).unsafe_map(Out::take) }
977            }
978
979            fn deserialize_string<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
980            where
981                V: serde::de::Visitor<'de>,
982            {
983                let mut erased = erase::Visitor::new(visitor);
984                unsafe { self.erased_deserialize_string(&mut erased).unsafe_map(Out::take) }
985            }
986
987            fn deserialize_bytes<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
988            where
989                V: serde::de::Visitor<'de>,
990            {
991                let mut erased = erase::Visitor::new(visitor);
992                unsafe { self.erased_deserialize_bytes(&mut erased).unsafe_map(Out::take) }
993            }
994
995            fn deserialize_byte_buf<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
996            where
997                V: serde::de::Visitor<'de>,
998            {
999                let mut erased = erase::Visitor::new(visitor);
1000                unsafe { self.erased_deserialize_byte_buf(&mut erased).unsafe_map(Out::take) }
1001            }
1002
1003            fn deserialize_option<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1004            where
1005                V: serde::de::Visitor<'de>,
1006            {
1007                let mut erased = erase::Visitor::new(visitor);
1008                unsafe { self.erased_deserialize_option(&mut erased).unsafe_map(Out::take) }
1009            }
1010
1011            fn deserialize_unit<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1012            where
1013                V: serde::de::Visitor<'de>,
1014            {
1015                let mut erased = erase::Visitor::new(visitor);
1016                unsafe { self.erased_deserialize_unit(&mut erased).unsafe_map(Out::take) }
1017            }
1018
1019            fn deserialize_unit_struct<V>($($mut)* self, name: &'static str, visitor: V) -> Result<V::Value, Error>
1020            where
1021                V: serde::de::Visitor<'de>,
1022            {
1023                let mut erased = erase::Visitor::new(visitor);
1024                unsafe { self.erased_deserialize_unit_struct(name, &mut erased).unsafe_map(Out::take) }
1025            }
1026
1027            fn deserialize_newtype_struct<V>($($mut)* self, name: &'static str, visitor: V) -> Result<V::Value, Error>
1028            where
1029                V: serde::de::Visitor<'de>,
1030            {
1031                let mut erased = erase::Visitor::new(visitor);
1032                unsafe { self.erased_deserialize_newtype_struct(name, &mut erased).unsafe_map(Out::take) }
1033            }
1034
1035            fn deserialize_seq<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1036            where
1037                V: serde::de::Visitor<'de>,
1038            {
1039                let mut erased = erase::Visitor::new(visitor);
1040                unsafe { self.erased_deserialize_seq(&mut erased).unsafe_map(Out::take) }
1041            }
1042
1043            fn deserialize_tuple<V>($($mut)* self, len: usize, visitor: V) -> Result<V::Value, Error>
1044            where
1045                V: serde::de::Visitor<'de>,
1046            {
1047                let mut erased = erase::Visitor::new(visitor);
1048                unsafe { self.erased_deserialize_tuple(len, &mut erased).unsafe_map(Out::take) }
1049            }
1050
1051            fn deserialize_tuple_struct<V>($($mut)* self, name: &'static str, len: usize, visitor: V) -> Result<V::Value, Error>
1052            where
1053                V: serde::de::Visitor<'de>,
1054            {
1055                let mut erased = erase::Visitor::new(visitor);
1056                unsafe { self.erased_deserialize_tuple_struct(name, len, &mut erased).unsafe_map(Out::take) }
1057            }
1058
1059            fn deserialize_map<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1060            where
1061                V: serde::de::Visitor<'de>,
1062            {
1063                let mut erased = erase::Visitor::new(visitor);
1064                unsafe { self.erased_deserialize_map(&mut erased).unsafe_map(Out::take) }
1065            }
1066
1067            fn deserialize_struct<V>($($mut)* self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
1068            where
1069                V: serde::de::Visitor<'de>,
1070            {
1071                let mut erased = erase::Visitor::new(visitor);
1072                unsafe { self.erased_deserialize_struct(name, fields, &mut erased).unsafe_map(Out::take) }
1073            }
1074
1075            fn deserialize_identifier<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1076            where
1077                V: serde::de::Visitor<'de>,
1078            {
1079                let mut erased = erase::Visitor::new(visitor);
1080                unsafe { self.erased_deserialize_identifier(&mut erased).unsafe_map(Out::take) }
1081            }
1082
1083            fn deserialize_enum<V>($($mut)* self, name: &'static str, variants: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
1084            where
1085                V: serde::de::Visitor<'de>,
1086            {
1087                let mut erased = erase::Visitor::new(visitor);
1088                unsafe { self.erased_deserialize_enum(name, variants, &mut erased).unsafe_map(Out::take) }
1089            }
1090
1091            fn deserialize_ignored_any<V>($($mut)* self, visitor: V) -> Result<V::Value, Error>
1092            where
1093                V: serde::de::Visitor<'de>,
1094            {
1095                let mut erased = erase::Visitor::new(visitor);
1096                unsafe { self.erased_deserialize_ignored_any(&mut erased).unsafe_map(Out::take) }
1097            }
1098
1099            fn is_human_readable(&self) -> bool {
1100                self.erased_is_human_readable()
1101            }
1102        }
1103    };
1104}
1105
1106impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + '_));
1107impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Send + '_));
1108impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Sync + '_));
1109impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Send + Sync + '_));
1110impl_deserializer_for_trait_object!({mut} Box<dyn Deserializer<'de> + '_>);
1111impl_deserializer_for_trait_object!({mut} Box<dyn Deserializer<'de> + Send + '_>);
1112impl_deserializer_for_trait_object!({mut} Box<dyn Deserializer<'de> + Sync + '_>);
1113impl_deserializer_for_trait_object!({mut} Box<dyn Deserializer<'de> + Send + Sync + '_>);
1114
1115impl<'de> serde::de::Visitor<'de> for &mut (dyn Visitor<'de> + '_) {
1116    type Value = Out;
1117
1118    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1119        (**self).erased_expecting(formatter)
1120    }
1121
1122    fn visit_bool<E>(self, v: bool) -> Result<Out, E>
1123    where
1124        E: serde::de::Error,
1125    {
1126        self.erased_visit_bool(v).map_err(unerase)
1127    }
1128
1129    fn visit_i8<E>(self, v: i8) -> Result<Out, E>
1130    where
1131        E: serde::de::Error,
1132    {
1133        self.erased_visit_i8(v).map_err(unerase)
1134    }
1135
1136    fn visit_i16<E>(self, v: i16) -> Result<Out, E>
1137    where
1138        E: serde::de::Error,
1139    {
1140        self.erased_visit_i16(v).map_err(unerase)
1141    }
1142
1143    fn visit_i32<E>(self, v: i32) -> Result<Out, E>
1144    where
1145        E: serde::de::Error,
1146    {
1147        self.erased_visit_i32(v).map_err(unerase)
1148    }
1149
1150    fn visit_i64<E>(self, v: i64) -> Result<Out, E>
1151    where
1152        E: serde::de::Error,
1153    {
1154        self.erased_visit_i64(v).map_err(unerase)
1155    }
1156
1157    fn visit_i128<E>(self, v: i128) -> Result<Out, E>
1158    where
1159        E: serde::de::Error,
1160    {
1161        self.erased_visit_i128(v).map_err(unerase)
1162    }
1163
1164    fn visit_u8<E>(self, v: u8) -> Result<Out, E>
1165    where
1166        E: serde::de::Error,
1167    {
1168        self.erased_visit_u8(v).map_err(unerase)
1169    }
1170
1171    fn visit_u16<E>(self, v: u16) -> Result<Out, E>
1172    where
1173        E: serde::de::Error,
1174    {
1175        self.erased_visit_u16(v).map_err(unerase)
1176    }
1177
1178    fn visit_u32<E>(self, v: u32) -> Result<Out, E>
1179    where
1180        E: serde::de::Error,
1181    {
1182        self.erased_visit_u32(v).map_err(unerase)
1183    }
1184
1185    fn visit_u64<E>(self, v: u64) -> Result<Out, E>
1186    where
1187        E: serde::de::Error,
1188    {
1189        self.erased_visit_u64(v).map_err(unerase)
1190    }
1191
1192    fn visit_u128<E>(self, v: u128) -> Result<Out, E>
1193    where
1194        E: serde::de::Error,
1195    {
1196        self.erased_visit_u128(v).map_err(unerase)
1197    }
1198
1199    fn visit_f32<E>(self, v: f32) -> Result<Out, E>
1200    where
1201        E: serde::de::Error,
1202    {
1203        self.erased_visit_f32(v).map_err(unerase)
1204    }
1205
1206    fn visit_f64<E>(self, v: f64) -> Result<Out, E>
1207    where
1208        E: serde::de::Error,
1209    {
1210        self.erased_visit_f64(v).map_err(unerase)
1211    }
1212
1213    fn visit_char<E>(self, v: char) -> Result<Out, E>
1214    where
1215        E: serde::de::Error,
1216    {
1217        self.erased_visit_char(v).map_err(unerase)
1218    }
1219
1220    fn visit_str<E>(self, v: &str) -> Result<Out, E>
1221    where
1222        E: serde::de::Error,
1223    {
1224        self.erased_visit_str(v).map_err(unerase)
1225    }
1226
1227    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Out, E>
1228    where
1229        E: serde::de::Error,
1230    {
1231        self.erased_visit_borrowed_str(v).map_err(unerase)
1232    }
1233
1234    #[cfg(feature = "alloc")]
1235    fn visit_string<E>(self, v: String) -> Result<Out, E>
1236    where
1237        E: serde::de::Error,
1238    {
1239        self.erased_visit_string(v).map_err(unerase)
1240    }
1241
1242    fn visit_bytes<E>(self, v: &[u8]) -> Result<Out, E>
1243    where
1244        E: serde::de::Error,
1245    {
1246        self.erased_visit_bytes(v).map_err(unerase)
1247    }
1248
1249    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Out, E>
1250    where
1251        E: serde::de::Error,
1252    {
1253        self.erased_visit_borrowed_bytes(v).map_err(unerase)
1254    }
1255
1256    #[cfg(feature = "alloc")]
1257    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Out, E>
1258    where
1259        E: serde::de::Error,
1260    {
1261        self.erased_visit_byte_buf(v).map_err(unerase)
1262    }
1263
1264    fn visit_none<E>(self) -> Result<Out, E>
1265    where
1266        E: serde::de::Error,
1267    {
1268        self.erased_visit_none().map_err(unerase)
1269    }
1270
1271    fn visit_some<D>(self, deserializer: D) -> Result<Out, D::Error>
1272    where
1273        D: serde::Deserializer<'de>,
1274    {
1275        let mut erased = erase::Deserializer::new(deserializer);
1276        self.erased_visit_some(&mut erased).map_err(unerase)
1277    }
1278
1279    fn visit_unit<E>(self) -> Result<Out, E>
1280    where
1281        E: serde::de::Error,
1282    {
1283        self.erased_visit_unit().map_err(unerase)
1284    }
1285
1286    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Out, D::Error>
1287    where
1288        D: serde::Deserializer<'de>,
1289    {
1290        let mut erased = erase::Deserializer::new(deserializer);
1291        self.erased_visit_newtype_struct(&mut erased)
1292            .map_err(unerase)
1293    }
1294
1295    fn visit_seq<V>(self, seq: V) -> Result<Out, V::Error>
1296    where
1297        V: serde::de::SeqAccess<'de>,
1298    {
1299        let mut erased = erase::SeqAccess::new(seq);
1300        self.erased_visit_seq(&mut erased).map_err(unerase)
1301    }
1302
1303    fn visit_map<V>(self, map: V) -> Result<Out, V::Error>
1304    where
1305        V: serde::de::MapAccess<'de>,
1306    {
1307        let mut erased = erase::MapAccess::new(map);
1308        self.erased_visit_map(&mut erased).map_err(unerase)
1309    }
1310
1311    fn visit_enum<V>(self, data: V) -> Result<Out, V::Error>
1312    where
1313        V: serde::de::EnumAccess<'de>,
1314    {
1315        let mut erased = erase::EnumAccess::new(data);
1316        self.erased_visit_enum(&mut erased).map_err(unerase)
1317    }
1318}
1319
1320impl<'de> serde::de::SeqAccess<'de> for &mut (dyn SeqAccess<'de> + '_) {
1321    type Error = Error;
1322
1323    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1324    where
1325        T: serde::de::DeserializeSeed<'de>,
1326    {
1327        let mut seed = erase::DeserializeSeed::new(seed);
1328        unsafe {
1329            (**self)
1330                .erased_next_element(&mut seed)
1331                .map(|opt| opt.unsafe_map(Out::take))
1332        }
1333    }
1334
1335    fn size_hint(&self) -> Option<usize> {
1336        (**self).erased_size_hint()
1337    }
1338}
1339
1340impl<'de> serde::de::MapAccess<'de> for &mut (dyn MapAccess<'de> + '_) {
1341    type Error = Error;
1342
1343    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1344    where
1345        K: serde::de::DeserializeSeed<'de>,
1346    {
1347        let mut erased = erase::DeserializeSeed::new(seed);
1348        unsafe {
1349            (**self)
1350                .erased_next_key(&mut erased)
1351                .map(|opt| opt.unsafe_map(Out::take))
1352        }
1353    }
1354
1355    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1356    where
1357        V: serde::de::DeserializeSeed<'de>,
1358    {
1359        let mut erased = erase::DeserializeSeed::new(seed);
1360        unsafe {
1361            (**self)
1362                .erased_next_value(&mut erased)
1363                .unsafe_map(Out::take)
1364        }
1365    }
1366
1367    fn size_hint(&self) -> Option<usize> {
1368        (**self).erased_size_hint()
1369    }
1370}
1371
1372impl<'de> serde::de::EnumAccess<'de> for &mut (dyn EnumAccess<'de> + '_) {
1373    type Error = Error;
1374    type Variant = Variant<'de>;
1375
1376    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1377    where
1378        V: serde::de::DeserializeSeed<'de>,
1379    {
1380        let mut erased = erase::DeserializeSeed::new(seed);
1381        match self.erased_variant_seed(&mut erased) {
1382            Ok((out, variant)) => Ok((unsafe { out.take() }, variant)),
1383            Err(err) => Err(err),
1384        }
1385    }
1386}
1387
1388pub struct Variant<'de> {
1389    data: Any,
1390    unit_variant: unsafe fn(Any) -> Result<(), Error>,
1391    visit_newtype: unsafe fn(Any, seed: &mut dyn DeserializeSeed<'de>) -> Result<Out, Error>,
1392    tuple_variant: unsafe fn(Any, len: usize, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error>,
1393    struct_variant: unsafe fn(
1394        Any,
1395        fields: &'static [&'static str],
1396        visitor: &mut dyn Visitor<'de>,
1397    ) -> Result<Out, Error>,
1398}
1399
1400impl<'de> serde::de::VariantAccess<'de> for Variant<'de> {
1401    type Error = Error;
1402
1403    fn unit_variant(self) -> Result<(), Error> {
1404        unsafe { (self.unit_variant)(self.data) }
1405    }
1406
1407    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1408    where
1409        T: serde::de::DeserializeSeed<'de>,
1410    {
1411        let mut erased = erase::DeserializeSeed::new(seed);
1412        unsafe { (self.visit_newtype)(self.data, &mut erased).unsafe_map(Out::take) }
1413    }
1414
1415    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
1416    where
1417        V: serde::de::Visitor<'de>,
1418    {
1419        let mut erased = erase::Visitor::new(visitor);
1420        unsafe { (self.tuple_variant)(self.data, len, &mut erased).unsafe_map(Out::take) }
1421    }
1422
1423    fn struct_variant<V>(
1424        self,
1425        fields: &'static [&'static str],
1426        visitor: V,
1427    ) -> Result<V::Value, Error>
1428    where
1429        V: serde::de::Visitor<'de>,
1430    {
1431        let mut erased = erase::Visitor::new(visitor);
1432        unsafe { (self.struct_variant)(self.data, fields, &mut erased).unsafe_map(Out::take) }
1433    }
1434}
1435
1436// IMPL ERASED SERDE FOR ERASED SERDE //////////////////////////////////////////
1437
1438macro_rules! deref_erased_deserializer {
1439    (<'de $(, $T:ident)*> Deserializer<'de> for $ty:ty $(where $($where:tt)*)?) => {
1440        impl<'de $(, $T)*> Deserializer<'de> for $ty $(where $($where)*)? {
1441            fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1442                (**self).erased_deserialize_any(visitor)
1443            }
1444
1445            fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1446                (**self).erased_deserialize_bool(visitor)
1447            }
1448
1449            fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1450                (**self).erased_deserialize_i8(visitor)
1451            }
1452
1453            fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1454                (**self).erased_deserialize_i16(visitor)
1455            }
1456
1457            fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1458                (**self).erased_deserialize_i32(visitor)
1459            }
1460
1461            fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1462                (**self).erased_deserialize_i64(visitor)
1463            }
1464
1465            fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1466                (**self).erased_deserialize_i128(visitor)
1467            }
1468
1469            fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1470                (**self).erased_deserialize_u8(visitor)
1471            }
1472
1473            fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1474                (**self).erased_deserialize_u16(visitor)
1475            }
1476
1477            fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1478                (**self).erased_deserialize_u32(visitor)
1479            }
1480
1481            fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1482                (**self).erased_deserialize_u64(visitor)
1483            }
1484
1485            fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1486                (**self).erased_deserialize_u128(visitor)
1487            }
1488
1489            fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1490                (**self).erased_deserialize_f32(visitor)
1491            }
1492
1493            fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1494                (**self).erased_deserialize_f64(visitor)
1495            }
1496
1497            fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1498                (**self).erased_deserialize_char(visitor)
1499            }
1500
1501            fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1502                (**self).erased_deserialize_str(visitor)
1503            }
1504
1505            fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1506                (**self).erased_deserialize_string(visitor)
1507            }
1508
1509            fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1510                (**self).erased_deserialize_bytes(visitor)
1511            }
1512
1513            fn erased_deserialize_byte_buf(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1514                (**self).erased_deserialize_byte_buf(visitor)
1515            }
1516
1517            fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1518                (**self).erased_deserialize_option(visitor)
1519            }
1520
1521            fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1522                (**self).erased_deserialize_unit(visitor)
1523            }
1524
1525            fn erased_deserialize_unit_struct(&mut self, name: &'static str, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1526                (**self).erased_deserialize_unit_struct(name, visitor)
1527            }
1528
1529            fn erased_deserialize_newtype_struct(&mut self, name: &'static str, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1530                (**self).erased_deserialize_newtype_struct(name, visitor)
1531            }
1532
1533            fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1534                (**self).erased_deserialize_seq(visitor)
1535            }
1536
1537            fn erased_deserialize_tuple(&mut self, len: usize, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1538                (**self).erased_deserialize_tuple(len, visitor)
1539            }
1540
1541            fn erased_deserialize_tuple_struct(&mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1542                (**self).erased_deserialize_tuple_struct(name, len, visitor)
1543            }
1544
1545            fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1546                (**self).erased_deserialize_map(visitor)
1547            }
1548
1549            fn erased_deserialize_struct(&mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1550                (**self).erased_deserialize_struct(name, fields, visitor)
1551            }
1552
1553            fn erased_deserialize_identifier(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1554                (**self).erased_deserialize_identifier(visitor)
1555            }
1556
1557            fn erased_deserialize_enum(&mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1558                (**self).erased_deserialize_enum(name, variants, visitor)
1559            }
1560
1561            fn erased_deserialize_ignored_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result<Out, Error> {
1562                (**self).erased_deserialize_ignored_any(visitor)
1563            }
1564
1565            fn erased_is_human_readable(&self) -> bool {
1566                (**self).erased_is_human_readable()
1567            }
1568        }
1569
1570        impl<'de $(, $T)*> Sealed for $ty $(where $($where)*)? {}
1571    };
1572}
1573
1574deref_erased_deserializer!(<'de, T> Deserializer<'de> for &mut T where T: ?Sized + Deserializer<'de>);
1575deref_erased_deserializer!(<'de, T> Deserializer<'de> for Box<T> where T: ?Sized + Deserializer<'de>);
1576
1577// TEST ////////////////////////////////////////////////////////////////////////
1578
1579#[cfg(test)]
1580mod tests {
1581    use super::*;
1582    use alloc::borrow::ToOwned;
1583    use core::fmt::Debug;
1584    use serde_derive::Deserialize;
1585
1586    fn test_json<'de, T>(json: &'de [u8])
1587    where
1588        T: serde::Deserialize<'de> + PartialEq + Debug,
1589    {
1590        let expected: T = serde_json::from_slice(json).unwrap();
1591
1592        // test borrowed trait object
1593        {
1594            let mut de = serde_json::Deserializer::from_slice(json);
1595            let de: &mut dyn Deserializer = &mut <dyn Deserializer>::erase(&mut de);
1596            assert_eq!(expected, deserialize::<T>(de).unwrap());
1597        }
1598
1599        // test boxed trait object
1600        {
1601            let mut de = serde_json::Deserializer::from_slice(json);
1602            let mut de: Box<dyn Deserializer> = Box::new(<dyn Deserializer>::erase(&mut de));
1603            assert_eq!(expected, deserialize::<T>(&mut de).unwrap());
1604        }
1605    }
1606
1607    #[test]
1608    fn test_value() {
1609        test_json::<serde_json::Value>(br#"["a", 1, [true], {"a": 1}]"#);
1610    }
1611
1612    #[test]
1613    fn test_struct() {
1614        #[derive(Deserialize, PartialEq, Debug)]
1615        struct S {
1616            f: usize,
1617        }
1618
1619        test_json::<S>(br#"{"f":256}"#);
1620    }
1621
1622    #[test]
1623    fn test_enum() {
1624        #[derive(Deserialize, PartialEq, Debug)]
1625        enum E {
1626            Unit,
1627            Newtype(bool),
1628            Tuple(bool, bool),
1629            Struct { t: bool, f: bool },
1630        }
1631
1632        test_json::<E>(br#""Unit""#);
1633        test_json::<E>(br#"{"Newtype":true}"#);
1634        test_json::<E>(br#"{"Tuple":[true,false]}"#);
1635        test_json::<E>(br#"{"Struct":{"t":true,"f":false}}"#);
1636    }
1637
1638    #[test]
1639    fn test_borrowed() {
1640        let bytes = br#""borrowed""#.to_owned();
1641        test_json::<&str>(&bytes);
1642    }
1643
1644    #[test]
1645    fn assert_deserializer() {
1646        fn assert<'de, T: serde::Deserializer<'de>>() {}
1647
1648        assert::<&mut dyn Deserializer>();
1649        assert::<&mut (dyn Deserializer + Send)>();
1650        assert::<&mut (dyn Deserializer + Sync)>();
1651        assert::<&mut (dyn Deserializer + Send + Sync)>();
1652        assert::<&mut (dyn Deserializer + Sync + Send)>();
1653
1654        assert::<Box<dyn Deserializer>>();
1655        assert::<Box<dyn Deserializer + Send>>();
1656        assert::<Box<dyn Deserializer + Sync>>();
1657        assert::<Box<dyn Deserializer + Send + Sync>>();
1658        assert::<Box<dyn Deserializer + Sync + Send>>();
1659    }
1660}
erased_serde/de.rs

erased_serde/
de.rs
