erased_serde/
ser.rs

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

erased_serde/
ser.rs
