erased_serde/
ser.rs

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

erased_serde/
ser.rs
