erased_serde/
ser.rs

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

erased_serde/
ser.rs
