erased_serde/
de.rs

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

erased_serde/
de.rs
