erased_serde/
de.rs

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

erased_serde/
de.rs
