serde_wincode/
ser.rs

1//! Serializer
2
3use core::marker::PhantomData;
4
5use serde::Serialize;
6use thiserror::Error;
7use wincode::{SchemaWrite, error::WriteError, io::Writer};
8
9#[cfg(not(feature = "alloc"))]
10const CANNOT_COLLECT_STR: &str = "`serde::Serializer::collect_str` got called, but serde-wincode was unable to allocate memory";
11
12const SEQUENCE_MUST_HAVE_LENGTH: &str = "Serde provided serde-wincode with a sequence without a length, which is not supported in wincode";
13
14const SERDE_ERROR: &str = "serde error";
15
16#[derive(Debug, Error)]
17pub enum Error {
18    /// [`serde::Serializer::collect_str`] got called,
19    // but serde-wincode was unable to allocate memory.
20    #[cfg(not(feature = "alloc"))]
21    #[error("{CANNOT_COLLECT_STR}")]
22    CannotCollectStr,
23    #[cfg(feature = "alloc")]
24    #[error("{msg}")]
25    CustomSerde { msg: alloc::string::String },
26    #[cfg(not(feature = "alloc"))]
27    #[error("{SERDE_ERROR}")]
28    CustomSerde,
29    /// Serde provided serde-wincode with a sequence without a length,
30    // which is not supported in wincode.
31    #[error("{SEQUENCE_MUST_HAVE_LENGTH}")]
32    SequenceMustHaveLength,
33    #[error(transparent)]
34    Write(#[from] WriteError),
35}
36
37impl From<Error> for WriteError {
38    fn from(err: Error) -> Self {
39        match err {
40            #[cfg(not(feature = "alloc"))]
41            Error::CannotCollectStr => Self::Custom(CANNOT_COLLECT_STR),
42            #[cfg(feature = "alloc")]
43            Error::CustomSerde { msg: _ } => Self::Custom(SERDE_ERROR),
44            #[cfg(not(feature = "alloc"))]
45            Error::CustomSerde => Self::Custom(SERDE_ERROR),
46            Error::SequenceMustHaveLength => {
47                Self::Custom(SEQUENCE_MUST_HAVE_LENGTH)
48            }
49            Error::Write(err) => err,
50        }
51    }
52}
53
54impl serde::ser::Error for Error {
55    #[cfg(feature = "alloc")]
56    fn custom<T>(msg: T) -> Self
57    where
58        T: core::fmt::Display,
59    {
60        Self::CustomSerde {
61            msg: alloc::string::ToString::to_string(&msg),
62        }
63    }
64
65    #[cfg(not(feature = "alloc"))]
66    fn custom<T>(_msg: T) -> Self
67    where
68        T: core::fmt::Display,
69    {
70        Self::CustomSerde
71    }
72}
73
74pub struct Serializer<W, C = wincode::config::Configuration> {
75    inner: W,
76    marker: PhantomData<C>,
77}
78
79impl<W, C> Serializer<W, C> {
80    pub fn new(writer: W) -> Self {
81        Self {
82            inner: writer,
83            marker: PhantomData,
84        }
85    }
86
87    fn as_mut(&mut self) -> Serializer<&mut W, C> {
88        Serializer {
89            inner: &mut self.inner,
90            marker: self.marker,
91        }
92    }
93}
94
95macro_rules! impl_fn_serializer {
96    ($serialize_method:ident, $serialize_ty:ty) => {
97        fn $serialize_method(
98            self,
99            value: $serialize_ty,
100        ) -> Result<Self::Ok, Self::Error> {
101            <$serialize_ty as SchemaWrite<C>>::write(self.inner, &value)
102                .map_err(Self::Error::Write)
103        }
104    };
105}
106
107impl<W, C> serde::Serializer for Serializer<W, C>
108where
109    C: wincode::config::Config,
110    W: Writer,
111{
112    type Ok = ();
113    type Error = Error;
114
115    type SerializeSeq = Self;
116    type SerializeTuple = Self;
117    type SerializeTupleStruct = Self;
118    type SerializeTupleVariant = Self;
119    type SerializeMap = Self;
120    type SerializeStruct = Self;
121    type SerializeStructVariant = Self;
122
123    impl_fn_serializer!(serialize_bool, bool);
124    impl_fn_serializer!(serialize_i8, i8);
125    impl_fn_serializer!(serialize_i16, i16);
126    impl_fn_serializer!(serialize_i32, i32);
127    impl_fn_serializer!(serialize_i64, i64);
128    impl_fn_serializer!(serialize_u8, u8);
129    impl_fn_serializer!(serialize_u16, u16);
130    impl_fn_serializer!(serialize_u32, u32);
131    impl_fn_serializer!(serialize_u64, u64);
132    impl_fn_serializer!(serialize_f32, f32);
133    impl_fn_serializer!(serialize_f64, f64);
134    impl_fn_serializer!(serialize_char, char);
135    impl_fn_serializer!(serialize_str, &str);
136    impl_fn_serializer!(serialize_bytes, &[u8]);
137
138    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
139        <u8 as SchemaWrite<C>>::write(self.inner, &0u8)
140            .map_err(Self::Error::Write)
141    }
142
143    fn serialize_some<T>(mut self, value: &T) -> Result<Self::Ok, Self::Error>
144    where
145        T: Serialize + ?Sized,
146    {
147        <u8 as SchemaWrite<C>>::write(&mut self.inner, &1u8)?;
148        value.serialize(self)
149    }
150
151    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
152        Ok(())
153    }
154
155    fn serialize_unit_struct(
156        self,
157        _name: &'static str,
158    ) -> Result<Self::Ok, Self::Error> {
159        Ok(())
160    }
161
162    fn serialize_unit_variant(
163        self,
164        _name: &'static str,
165        variant_index: u32,
166        _variant: &'static str,
167    ) -> Result<Self::Ok, Self::Error> {
168        <u32 as SchemaWrite<C>>::write(self.inner, &variant_index)
169            .map_err(Self::Error::Write)
170    }
171
172    fn serialize_newtype_struct<T>(
173        self,
174        _name: &'static str,
175        value: &T,
176    ) -> Result<Self::Ok, Self::Error>
177    where
178        T: Serialize + ?Sized,
179    {
180        value.serialize(self)
181    }
182
183    fn serialize_newtype_variant<T>(
184        mut self,
185        _name: &'static str,
186        variant_index: u32,
187        _variant: &'static str,
188        value: &T,
189    ) -> Result<Self::Ok, Self::Error>
190    where
191        T: Serialize + ?Sized,
192    {
193        <u32 as SchemaWrite<C>>::write(&mut self.inner, &variant_index)?;
194        value.serialize(self)
195    }
196
197    fn serialize_seq(
198        mut self,
199        len: Option<usize>,
200    ) -> Result<Self::SerializeSeq, Self::Error> {
201        let len = len.ok_or(Self::Error::SequenceMustHaveLength)?;
202        <usize as SchemaWrite<C>>::write(&mut self.inner, &len)?;
203        Ok(self)
204    }
205
206    fn serialize_tuple(
207        self,
208        _: usize,
209    ) -> Result<Self::SerializeTuple, Self::Error> {
210        Ok(self)
211    }
212
213    fn serialize_tuple_struct(
214        self,
215        _name: &'static str,
216        _len: usize,
217    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
218        Ok(self)
219    }
220
221    fn serialize_tuple_variant(
222        mut self,
223        _name: &'static str,
224        variant_index: u32,
225        _variant: &'static str,
226        _len: usize,
227    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
228        <u32 as SchemaWrite<C>>::write(&mut self.inner, &variant_index)?;
229        Ok(self)
230    }
231
232    fn serialize_map(
233        mut self,
234        len: Option<usize>,
235    ) -> Result<Self::SerializeMap, Self::Error> {
236        let len = len.ok_or(Self::Error::SequenceMustHaveLength)?;
237        <usize as SchemaWrite<C>>::write(&mut self.inner, &len)?;
238        Ok(self)
239    }
240
241    fn serialize_struct(
242        self,
243        _name: &'static str,
244        _len: usize,
245    ) -> Result<Self::SerializeStruct, Self::Error> {
246        Ok(self)
247    }
248
249    fn serialize_struct_variant(
250        mut self,
251        _name: &'static str,
252        variant_index: u32,
253        _variant: &'static str,
254        _len: usize,
255    ) -> Result<Self::SerializeStructVariant, Self::Error> {
256        <u32 as SchemaWrite<C>>::write(&mut self.inner, &variant_index)?;
257        Ok(self)
258    }
259
260    #[cfg(not(feature = "alloc"))]
261    fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
262    where
263        T: core::fmt::Display + ?Sized,
264    {
265        Err(Self::Error::CannotCollectStr)
266    }
267
268    fn is_human_readable(&self) -> bool {
269        false
270    }
271}
272
273impl<W, C> serde::ser::SerializeSeq for Serializer<W, C>
274where
275    C: wincode::config::Config,
276    W: Writer,
277{
278    type Ok = ();
279    type Error = Error;
280
281    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
282    where
283        T: Serialize + ?Sized,
284    {
285        value.serialize(self.as_mut())
286    }
287
288    fn end(self) -> Result<Self::Ok, Self::Error> {
289        Ok(())
290    }
291}
292
293impl<W, C> serde::ser::SerializeTuple for Serializer<W, C>
294where
295    C: wincode::config::Config,
296    W: Writer,
297{
298    type Ok = ();
299    type Error = Error;
300
301    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
302    where
303        T: Serialize + ?Sized,
304    {
305        value.serialize(self.as_mut())
306    }
307
308    fn end(self) -> Result<Self::Ok, Self::Error> {
309        Ok(())
310    }
311}
312
313impl<W, C> serde::ser::SerializeTupleStruct for Serializer<W, C>
314where
315    C: wincode::config::Config,
316    W: Writer,
317{
318    type Ok = ();
319    type Error = Error;
320
321    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
322    where
323        T: Serialize + ?Sized,
324    {
325        value.serialize(self.as_mut())
326    }
327
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        Ok(())
330    }
331}
332
333impl<W, C> serde::ser::SerializeTupleVariant for Serializer<W, C>
334where
335    C: wincode::config::Config,
336    W: Writer,
337{
338    type Ok = ();
339    type Error = Error;
340
341    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
342    where
343        T: Serialize + ?Sized,
344    {
345        value.serialize(self.as_mut())
346    }
347
348    fn end(self) -> Result<Self::Ok, Self::Error> {
349        Ok(())
350    }
351}
352
353impl<W, C> serde::ser::SerializeMap for Serializer<W, C>
354where
355    C: wincode::config::Config,
356    W: Writer,
357{
358    type Ok = ();
359    type Error = Error;
360
361    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
362    where
363        T: Serialize + ?Sized,
364    {
365        key.serialize(self.as_mut())
366    }
367
368    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
369    where
370        T: Serialize + ?Sized,
371    {
372        value.serialize(self.as_mut())
373    }
374
375    fn end(self) -> Result<Self::Ok, Self::Error> {
376        Ok(())
377    }
378}
379
380impl<W, C> serde::ser::SerializeStruct for Serializer<W, C>
381where
382    C: wincode::config::Config,
383    W: Writer,
384{
385    type Ok = ();
386    type Error = Error;
387
388    fn serialize_field<T>(
389        &mut self,
390        _key: &'static str,
391        value: &T,
392    ) -> Result<(), Self::Error>
393    where
394        T: Serialize + ?Sized,
395    {
396        value.serialize(self.as_mut())
397    }
398
399    fn end(self) -> Result<Self::Ok, Self::Error> {
400        Ok(())
401    }
402}
403
404impl<W, C> serde::ser::SerializeStructVariant for Serializer<W, C>
405where
406    C: wincode::config::Config,
407    W: Writer,
408{
409    type Ok = ();
410    type Error = Error;
411
412    fn serialize_field<T>(
413        &mut self,
414        _key: &'static str,
415        value: &T,
416    ) -> Result<(), Self::Error>
417    where
418        T: Serialize + ?Sized,
419    {
420        value.serialize(self.as_mut())
421    }
422
423    fn end(self) -> Result<Self::Ok, Self::Error> {
424        Ok(())
425    }
426}
427
428const SIZE_OVERFLOW: &str = "Overflow when calculating serialized size";
429
430#[derive(Debug, Error)]
431pub enum SizeOfError {
432    #[error(transparent)]
433    Serialize(Error),
434    /// Overflow when calculating serialized size
435    #[error("{SIZE_OVERFLOW}")]
436    SizeOverflow,
437}
438
439impl<E> From<E> for SizeOfError
440where
441    Error: From<E>,
442{
443    fn from(err: E) -> Self {
444        Self::Serialize(err.into())
445    }
446}
447
448impl From<SizeOfError> for WriteError {
449    fn from(err: SizeOfError) -> Self {
450        match err {
451            SizeOfError::Serialize(err) => err.into(),
452            SizeOfError::SizeOverflow => Self::Custom(SIZE_OVERFLOW),
453        }
454    }
455}
456
457impl serde::ser::Error for SizeOfError {
458    fn custom<T>(msg: T) -> Self
459    where
460        T: core::fmt::Display,
461    {
462        Self::Serialize(Error::custom(msg))
463    }
464}
465
466/// Dummy serializer used to compute serialized size
467#[repr(transparent)]
468pub(crate) struct SizeOf<C> {
469    size: usize,
470    marker: PhantomData<C>,
471}
472
473impl<C> SizeOf<C> {
474    pub fn new() -> Self {
475        Self {
476            size: 0,
477            marker: PhantomData,
478        }
479    }
480
481    /// Returns the size in bytes that the serializer has already processed
482    pub fn serialized_size(&self) -> usize {
483        self.size
484    }
485
486    fn add_size(&mut self, size: usize) -> Result<(), SizeOfError> {
487        self.size = self
488            .size
489            .checked_add(size)
490            .ok_or(SizeOfError::SizeOverflow)?;
491        Ok(())
492    }
493}
494
495macro_rules! impl_fn_sizeof {
496    ($serialize_method:ident, $serialize_ty:ty) => {
497        fn $serialize_method(
498            mut self,
499            value: $serialize_ty,
500        ) -> Result<Self::Ok, Self::Error> {
501            let value_size =
502                <$serialize_ty as SchemaWrite<C>>::size_of(&value)?;
503            self.add_size(value_size)?;
504            Ok(self)
505        }
506    };
507}
508
509impl<C> serde::Serializer for SizeOf<C>
510where
511    C: wincode::config::Config,
512{
513    type Ok = Self;
514    type Error = SizeOfError;
515
516    type SerializeSeq = Self;
517    type SerializeTuple = Self;
518    type SerializeTupleStruct = Self;
519    type SerializeTupleVariant = Self;
520    type SerializeMap = Self;
521    type SerializeStruct = Self;
522    type SerializeStructVariant = Self;
523
524    impl_fn_sizeof!(serialize_bool, bool);
525    impl_fn_sizeof!(serialize_i8, i8);
526    impl_fn_sizeof!(serialize_i16, i16);
527    impl_fn_sizeof!(serialize_i32, i32);
528    impl_fn_sizeof!(serialize_i64, i64);
529    impl_fn_sizeof!(serialize_i128, i128);
530    impl_fn_sizeof!(serialize_u8, u8);
531    impl_fn_sizeof!(serialize_u16, u16);
532    impl_fn_sizeof!(serialize_u32, u32);
533    impl_fn_sizeof!(serialize_u64, u64);
534    impl_fn_sizeof!(serialize_u128, u128);
535    impl_fn_sizeof!(serialize_f32, f32);
536    impl_fn_sizeof!(serialize_f64, f64);
537    impl_fn_sizeof!(serialize_char, char);
538    impl_fn_sizeof!(serialize_str, &str);
539    impl_fn_sizeof!(serialize_bytes, &[u8]);
540
541    fn serialize_none(mut self) -> Result<Self::Ok, Self::Error> {
542        let discriminant_size = <u8 as SchemaWrite<C>>::size_of(&0u8)?;
543        self.add_size(discriminant_size)?;
544        Ok(self)
545    }
546
547    fn serialize_some<T>(mut self, value: &T) -> Result<Self::Ok, Self::Error>
548    where
549        T: Serialize + ?Sized,
550    {
551        let discriminant_size = <u8 as SchemaWrite<C>>::size_of(&1u8)?;
552        self.add_size(discriminant_size)?;
553        value.serialize(self)
554    }
555
556    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
557        Ok(self)
558    }
559
560    fn serialize_unit_struct(
561        self,
562        _name: &'static str,
563    ) -> Result<Self::Ok, Self::Error> {
564        Ok(self)
565    }
566
567    fn serialize_unit_variant(
568        mut self,
569        _name: &'static str,
570        variant_index: u32,
571        _variant: &'static str,
572    ) -> Result<Self::Ok, Self::Error> {
573        let variant_index_size =
574            <u32 as SchemaWrite<C>>::size_of(&variant_index)?;
575        self.add_size(variant_index_size)?;
576        Ok(self)
577    }
578
579    fn serialize_newtype_struct<T>(
580        self,
581        _name: &'static str,
582        value: &T,
583    ) -> Result<Self::Ok, Self::Error>
584    where
585        T: Serialize + ?Sized,
586    {
587        value.serialize(self)
588    }
589
590    fn serialize_newtype_variant<T>(
591        mut self,
592        _name: &'static str,
593        variant_index: u32,
594        _variant: &'static str,
595        value: &T,
596    ) -> Result<Self::Ok, Self::Error>
597    where
598        T: Serialize + ?Sized,
599    {
600        let variant_index_size =
601            <u32 as SchemaWrite<C>>::size_of(&variant_index)?;
602        self.add_size(variant_index_size)?;
603        value.serialize(self)
604    }
605
606    fn serialize_seq(
607        mut self,
608        len: Option<usize>,
609    ) -> Result<Self::SerializeSeq, Self::Error> {
610        let len = len.ok_or(Error::SequenceMustHaveLength)?;
611        let len_size = <usize as SchemaWrite<C>>::size_of(&len)?;
612        self.add_size(len_size)?;
613        Ok(self)
614    }
615
616    fn serialize_tuple(
617        self,
618        _: usize,
619    ) -> Result<Self::SerializeTuple, Self::Error> {
620        Ok(self)
621    }
622
623    fn serialize_tuple_struct(
624        self,
625        _name: &'static str,
626        _len: usize,
627    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
628        Ok(self)
629    }
630
631    fn serialize_tuple_variant(
632        mut self,
633        _name: &'static str,
634        variant_index: u32,
635        _variant: &'static str,
636        _len: usize,
637    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
638        let variant_index_size =
639            <u32 as SchemaWrite<C>>::size_of(&variant_index)?;
640        self.add_size(variant_index_size)?;
641        Ok(self)
642    }
643
644    fn serialize_map(
645        mut self,
646        len: Option<usize>,
647    ) -> Result<Self::SerializeMap, Self::Error> {
648        let len = len.ok_or(Error::SequenceMustHaveLength)?;
649        let len_size = <usize as SchemaWrite<C>>::size_of(&len)?;
650        self.add_size(len_size)?;
651        Ok(self)
652    }
653
654    fn serialize_struct(
655        self,
656        _name: &'static str,
657        _len: usize,
658    ) -> Result<Self::SerializeStruct, Self::Error> {
659        Ok(self)
660    }
661
662    fn serialize_struct_variant(
663        mut self,
664        _name: &'static str,
665        variant_index: u32,
666        _variant: &'static str,
667        _len: usize,
668    ) -> Result<Self::SerializeStructVariant, Self::Error> {
669        let variant_index_size =
670            <u32 as SchemaWrite<C>>::size_of(&variant_index)?;
671        self.add_size(variant_index_size)?;
672        Ok(self)
673    }
674
675    #[cfg(not(feature = "alloc"))]
676    fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
677    where
678        T: core::fmt::Display + ?Sized,
679    {
680        Err(Error::CannotCollectStr.into())
681    }
682
683    fn is_human_readable(&self) -> bool {
684        false
685    }
686}
687
688impl<C> serde::ser::SerializeSeq for SizeOf<C>
689where
690    C: wincode::config::Config,
691{
692    type Ok = Self;
693    type Error = SizeOfError;
694
695    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
696    where
697        T: Serialize + ?Sized,
698    {
699        let serializer = SizeOf {
700            size: self.size,
701            marker: self.marker,
702        };
703        *self = value.serialize(serializer)?;
704        Ok(())
705    }
706
707    fn end(self) -> Result<Self::Ok, Self::Error> {
708        Ok(self)
709    }
710}
711
712impl<C> serde::ser::SerializeTuple for SizeOf<C>
713where
714    C: wincode::config::Config,
715{
716    type Ok = Self;
717    type Error = SizeOfError;
718
719    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
720    where
721        T: Serialize + ?Sized,
722    {
723        let serializer = SizeOf {
724            size: self.size,
725            marker: self.marker,
726        };
727        *self = value.serialize(serializer)?;
728        Ok(())
729    }
730
731    fn end(self) -> Result<Self::Ok, Self::Error> {
732        Ok(self)
733    }
734}
735
736impl<C> serde::ser::SerializeTupleStruct for SizeOf<C>
737where
738    C: wincode::config::Config,
739{
740    type Ok = Self;
741    type Error = SizeOfError;
742
743    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
744    where
745        T: Serialize + ?Sized,
746    {
747        let serializer = SizeOf {
748            size: self.size,
749            marker: self.marker,
750        };
751        *self = value.serialize(serializer)?;
752        Ok(())
753    }
754
755    fn end(self) -> Result<Self::Ok, Self::Error> {
756        Ok(self)
757    }
758}
759
760impl<C> serde::ser::SerializeTupleVariant for SizeOf<C>
761where
762    C: wincode::config::Config,
763{
764    type Ok = Self;
765    type Error = SizeOfError;
766
767    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
768    where
769        T: Serialize + ?Sized,
770    {
771        let serializer = SizeOf {
772            size: self.size,
773            marker: self.marker,
774        };
775        *self = value.serialize(serializer)?;
776        Ok(())
777    }
778
779    fn end(self) -> Result<Self::Ok, Self::Error> {
780        Ok(self)
781    }
782}
783
784impl<C> serde::ser::SerializeMap for SizeOf<C>
785where
786    C: wincode::config::Config,
787{
788    type Ok = Self;
789    type Error = SizeOfError;
790
791    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
792    where
793        T: Serialize + ?Sized,
794    {
795        let serializer = SizeOf {
796            size: self.size,
797            marker: self.marker,
798        };
799        *self = key.serialize(serializer)?;
800        Ok(())
801    }
802
803    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
804    where
805        T: Serialize + ?Sized,
806    {
807        let serializer = SizeOf {
808            size: self.size,
809            marker: self.marker,
810        };
811        *self = value.serialize(serializer)?;
812        Ok(())
813    }
814
815    fn end(self) -> Result<Self::Ok, Self::Error> {
816        Ok(self)
817    }
818}
819
820impl<C> serde::ser::SerializeStruct for SizeOf<C>
821where
822    C: wincode::config::Config,
823{
824    type Ok = Self;
825    type Error = SizeOfError;
826
827    fn serialize_field<T>(
828        &mut self,
829        _key: &'static str,
830        value: &T,
831    ) -> Result<(), Self::Error>
832    where
833        T: Serialize + ?Sized,
834    {
835        let serializer = SizeOf {
836            size: self.size,
837            marker: self.marker,
838        };
839        *self = value.serialize(serializer)?;
840        Ok(())
841    }
842
843    fn end(self) -> Result<Self::Ok, Self::Error> {
844        Ok(self)
845    }
846}
847
848impl<C> serde::ser::SerializeStructVariant for SizeOf<C>
849where
850    C: wincode::config::Config,
851{
852    type Ok = Self;
853    type Error = SizeOfError;
854
855    fn serialize_field<T>(
856        &mut self,
857        _key: &'static str,
858        value: &T,
859    ) -> Result<(), Self::Error>
860    where
861        T: Serialize + ?Sized,
862    {
863        let serializer = SizeOf {
864            size: self.size,
865            marker: self.marker,
866        };
867        *self = value.serialize(serializer)?;
868        Ok(())
869    }
870
871    fn end(self) -> Result<Self::Ok, Self::Error> {
872        Ok(self)
873    }
874}
serde_wincode/ser.rs

serde_wincode/
ser.rs
