erased_serde/
de.rs

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

erased_serde/
de.rs
