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

erased_serde/
ser.rs
