bincode_next/features/serde/
ser.rs

1#![allow(deprecated)]
2use super::EncodeError as SerdeEncodeError;
3use crate::config::Config;
4use crate::enc::Encode;
5use crate::enc::Encoder;
6use crate::enc::write::Writer;
7use crate::error::EncodeError;
8#[cfg(feature = "alloc")]
9use alloc::vec::Vec;
10use serde::ser::Serialize;
11use serde::ser::SerializeMap;
12use serde::ser::SerializeSeq;
13use serde::ser::SerializeStruct;
14use serde::ser::SerializeStructVariant;
15use serde::ser::SerializeTuple;
16use serde::ser::SerializeTupleStruct;
17use serde::ser::SerializeTupleVariant;
18use serde::ser::Serializer;
19
20/// Encode the given value into the given slice. Returns the amount of bytes that have been written.
21///
22/// See the [config] module for more information on configurations.
23///
24/// [config]: ../config/index.html
25///
26/// # Errors
27///
28/// Returns an `EncodeError` if the encoding fails.
29#[cfg(feature = "alloc")]
30#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
31pub fn encode_to_vec<E, C>(
32    val: E,
33    config: C,
34) -> Result<Vec<u8>, EncodeError>
35where
36    E: Serialize,
37    C: Config,
38{
39    let mut encoder = crate::enc::EncoderImpl::new(crate::VecWriter::default(), config);
40    let serializer = SerdeEncoder { enc: &mut encoder };
41    val.serialize(serializer)?;
42    Ok(encoder.into_writer().collect())
43}
44
45/// Encode the given value into a custom [Writer].
46///
47/// See the [config] module for more information on configurations.
48///
49/// [config]: ../config/index.html
50///
51/// # Errors
52///
53/// Returns an `EncodeError` if the encoding fails.
54pub fn encode_into_slice<E, C>(
55    val: E,
56    dst: &mut [u8],
57    config: C,
58) -> Result<usize, EncodeError>
59where
60    E: Serialize,
61    C: Config,
62{
63    let mut encoder =
64        crate::enc::EncoderImpl::new(crate::enc::write::SliceWriter::new(dst), config);
65    let serializer = SerdeEncoder { enc: &mut encoder };
66    val.serialize(serializer)?;
67    Ok(encoder.into_writer().bytes_written())
68}
69
70/// # Errors
71///
72/// Returns an `EncodeError` if the encoding fails.
73pub fn encode_into_writer<E: Serialize, W: Writer, C: Config>(
74    val: E,
75    writer: W,
76    config: C,
77) -> Result<(), EncodeError> {
78    let mut encoder = crate::enc::EncoderImpl::<_, C>::new(writer, config);
79    let serializer = SerdeEncoder { enc: &mut encoder };
80    val.serialize(serializer)?;
81    Ok(())
82}
83
84/// # Errors
85///
86/// Returns an `EncodeError` if the encoding fails.
87#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
88#[cfg(feature = "std")]
89pub fn encode_into_std_write<E: Serialize, C: Config, W: std::io::Write>(
90    val: E,
91    dst: &mut W,
92    config: C,
93) -> Result<usize, EncodeError> {
94    let writer = crate::IoWriter::new(dst);
95    let mut encoder = crate::enc::EncoderImpl::<_, C>::new(writer, config);
96    let serializer = SerdeEncoder { enc: &mut encoder };
97    val.serialize(serializer)?;
98    Ok(encoder.into_writer().bytes_written())
99}
100
101pub(super) struct SerdeEncoder<'a, ENC: Encoder> {
102    pub(super) enc: &'a mut ENC,
103}
104
105impl<ENC> Serializer for SerdeEncoder<'_, ENC>
106where
107    ENC: Encoder,
108{
109    type Error = EncodeError;
110    type Ok = ();
111    type SerializeMap = Self;
112    type SerializeSeq = Self;
113    type SerializeStruct = Self;
114    type SerializeStructVariant = Self;
115    type SerializeTuple = Self;
116    type SerializeTupleStruct = Self;
117    type SerializeTupleVariant = Self;
118
119    serde::serde_if_integer128! {
120        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
121            v.encode(self.enc)
122        }
123    }
124
125    serde::serde_if_integer128! {
126        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
127            v.encode(self.enc)
128        }
129    }
130
131    fn serialize_bool(
132        self,
133        v: bool,
134    ) -> Result<Self::Ok, Self::Error> {
135        v.encode(self.enc)
136    }
137
138    fn serialize_i8(
139        self,
140        v: i8,
141    ) -> Result<Self::Ok, Self::Error> {
142        v.encode(self.enc)
143    }
144
145    fn serialize_i16(
146        self,
147        v: i16,
148    ) -> Result<Self::Ok, Self::Error> {
149        v.encode(self.enc)
150    }
151
152    fn serialize_i32(
153        self,
154        v: i32,
155    ) -> Result<Self::Ok, Self::Error> {
156        v.encode(self.enc)
157    }
158
159    fn serialize_i64(
160        self,
161        v: i64,
162    ) -> Result<Self::Ok, Self::Error> {
163        v.encode(self.enc)
164    }
165
166    fn serialize_u8(
167        self,
168        v: u8,
169    ) -> Result<Self::Ok, Self::Error> {
170        v.encode(self.enc)
171    }
172
173    fn serialize_u16(
174        self,
175        v: u16,
176    ) -> Result<Self::Ok, Self::Error> {
177        v.encode(self.enc)
178    }
179
180    fn serialize_u32(
181        self,
182        v: u32,
183    ) -> Result<Self::Ok, Self::Error> {
184        v.encode(self.enc)
185    }
186
187    fn serialize_u64(
188        self,
189        v: u64,
190    ) -> Result<Self::Ok, Self::Error> {
191        v.encode(self.enc)
192    }
193
194    fn serialize_f32(
195        self,
196        v: f32,
197    ) -> Result<Self::Ok, Self::Error> {
198        v.encode(self.enc)
199    }
200
201    fn serialize_f64(
202        self,
203        v: f64,
204    ) -> Result<Self::Ok, Self::Error> {
205        v.encode(self.enc)
206    }
207
208    fn serialize_char(
209        self,
210        v: char,
211    ) -> Result<Self::Ok, Self::Error> {
212        v.encode(self.enc)
213    }
214
215    fn serialize_str(
216        self,
217        v: &str,
218    ) -> Result<Self::Ok, Self::Error> {
219        v.encode(self.enc)
220    }
221
222    fn serialize_bytes(
223        self,
224        v: &[u8],
225    ) -> Result<Self::Ok, Self::Error> {
226        v.encode(self.enc)
227    }
228
229    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
230        0u8.encode(self.enc)
231    }
232
233    fn serialize_some<T>(
234        mut self,
235        value: &T,
236    ) -> Result<Self::Ok, Self::Error>
237    where
238        T: Serialize + ?Sized,
239    {
240        1u8.encode(&mut self.enc)?;
241        value.serialize(self)
242    }
243
244    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
245        Ok(())
246    }
247
248    fn serialize_unit_struct(
249        self,
250        _name: &'static str,
251    ) -> Result<Self::Ok, Self::Error> {
252        Ok(())
253    }
254
255    fn serialize_unit_variant(
256        self,
257        _name: &'static str,
258        variant_index: u32,
259        _variant: &'static str,
260    ) -> Result<Self::Ok, Self::Error> {
261        variant_index.encode(self.enc)
262    }
263
264    fn serialize_newtype_struct<T>(
265        self,
266        _name: &'static str,
267        value: &T,
268    ) -> Result<Self::Ok, Self::Error>
269    where
270        T: Serialize + ?Sized,
271    {
272        value.serialize(self)
273    }
274
275    fn serialize_newtype_variant<T>(
276        mut self,
277        _name: &'static str,
278        variant_index: u32,
279        _variant: &'static str,
280        value: &T,
281    ) -> Result<Self::Ok, Self::Error>
282    where
283        T: Serialize + ?Sized,
284    {
285        variant_index.encode(&mut self.enc)?;
286        value.serialize(self)
287    }
288
289    fn serialize_seq(
290        mut self,
291        len: Option<usize>,
292    ) -> Result<Self::SerializeSeq, Self::Error> {
293        let len = len.ok_or_else(|| SerdeEncodeError::SequenceMustHaveLength.into())?;
294        len.encode(&mut self.enc)?;
295        Ok(self)
296    }
297
298    fn serialize_tuple(
299        self,
300        _: usize,
301    ) -> Result<Self::SerializeTuple, Self::Error> {
302        Ok(self)
303    }
304
305    fn serialize_tuple_struct(
306        self,
307        _name: &'static str,
308        _len: usize,
309    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
310        Ok(self)
311    }
312
313    fn serialize_tuple_variant(
314        mut self,
315        _name: &'static str,
316        variant_index: u32,
317        _variant: &'static str,
318        _len: usize,
319    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
320        variant_index.encode(&mut self.enc)?;
321        Ok(self)
322    }
323
324    fn serialize_map(
325        mut self,
326        len: Option<usize>,
327    ) -> Result<Self::SerializeMap, Self::Error> {
328        let len = len.ok_or_else(|| SerdeEncodeError::SequenceMustHaveLength.into())?;
329        len.encode(&mut self.enc)?;
330        Ok(self)
331    }
332
333    fn serialize_struct(
334        self,
335        _name: &'static str,
336        _len: usize,
337    ) -> Result<Self::SerializeStruct, Self::Error> {
338        Ok(self)
339    }
340
341    fn serialize_struct_variant(
342        mut self,
343        _name: &'static str,
344        variant_index: u32,
345        _variant: &'static str,
346        _len: usize,
347    ) -> Result<Self::SerializeStructVariant, Self::Error> {
348        variant_index.encode(&mut self.enc)?;
349        Ok(self)
350    }
351
352    #[cfg(not(feature = "alloc"))]
353    fn collect_str<T>(
354        self,
355        _: &T,
356    ) -> Result<Self::Ok, Self::Error>
357    where
358        T: core::fmt::Display + ?Sized,
359    {
360        Err(SerdeEncodeError::CannotCollectStr.into())
361    }
362
363    fn is_human_readable(&self) -> bool {
364        false
365    }
366}
367
368type Compound<'a, ENC> = SerdeEncoder<'a, ENC>;
369
370impl<ENC: Encoder> SerializeSeq for Compound<'_, ENC> {
371    type Error = EncodeError;
372    type Ok = ();
373
374    fn serialize_element<T>(
375        &mut self,
376        value: &T,
377    ) -> Result<(), Self::Error>
378    where
379        T: Serialize + ?Sized,
380    {
381        value.serialize(SerdeEncoder { enc: self.enc })
382    }
383
384    fn end(self) -> Result<Self::Ok, Self::Error> {
385        Ok(())
386    }
387}
388
389impl<ENC: Encoder> SerializeTuple for Compound<'_, ENC> {
390    type Error = EncodeError;
391    type Ok = ();
392
393    fn serialize_element<T>(
394        &mut self,
395        value: &T,
396    ) -> Result<(), Self::Error>
397    where
398        T: Serialize + ?Sized,
399    {
400        value.serialize(SerdeEncoder { enc: self.enc })
401    }
402
403    fn end(self) -> Result<Self::Ok, Self::Error> {
404        Ok(())
405    }
406}
407
408impl<ENC: Encoder> SerializeTupleStruct for Compound<'_, ENC> {
409    type Error = EncodeError;
410    type Ok = ();
411
412    fn serialize_field<T>(
413        &mut self,
414        value: &T,
415    ) -> Result<(), Self::Error>
416    where
417        T: Serialize + ?Sized,
418    {
419        value.serialize(SerdeEncoder { enc: self.enc })
420    }
421
422    fn end(self) -> Result<Self::Ok, Self::Error> {
423        Ok(())
424    }
425}
426
427impl<ENC: Encoder> SerializeTupleVariant for Compound<'_, ENC> {
428    type Error = EncodeError;
429    type Ok = ();
430
431    fn serialize_field<T>(
432        &mut self,
433        value: &T,
434    ) -> Result<(), Self::Error>
435    where
436        T: Serialize + ?Sized,
437    {
438        value.serialize(SerdeEncoder { enc: self.enc })
439    }
440
441    fn end(self) -> Result<Self::Ok, Self::Error> {
442        Ok(())
443    }
444}
445
446impl<ENC: Encoder> SerializeMap for Compound<'_, ENC> {
447    type Error = EncodeError;
448    type Ok = ();
449
450    fn serialize_key<T>(
451        &mut self,
452        key: &T,
453    ) -> Result<(), Self::Error>
454    where
455        T: Serialize + ?Sized,
456    {
457        key.serialize(SerdeEncoder { enc: self.enc })
458    }
459
460    fn serialize_value<T>(
461        &mut self,
462        value: &T,
463    ) -> Result<(), Self::Error>
464    where
465        T: Serialize + ?Sized,
466    {
467        value.serialize(SerdeEncoder { enc: self.enc })
468    }
469
470    fn end(self) -> Result<Self::Ok, Self::Error> {
471        Ok(())
472    }
473}
474
475impl<ENC: Encoder> SerializeStruct for Compound<'_, ENC> {
476    type Error = EncodeError;
477    type Ok = ();
478
479    fn serialize_field<T>(
480        &mut self,
481        _key: &'static str,
482        value: &T,
483    ) -> Result<(), Self::Error>
484    where
485        T: Serialize + ?Sized,
486    {
487        value.serialize(SerdeEncoder { enc: self.enc })
488    }
489
490    fn end(self) -> Result<Self::Ok, Self::Error> {
491        Ok(())
492    }
493}
494
495impl<ENC: Encoder> SerializeStructVariant for Compound<'_, ENC> {
496    type Error = EncodeError;
497    type Ok = ();
498
499    fn serialize_field<T>(
500        &mut self,
501        _key: &'static str,
502        value: &T,
503    ) -> Result<(), Self::Error>
504    where
505        T: Serialize + ?Sized,
506    {
507        value.serialize(SerdeEncoder { enc: self.enc })
508    }
509
510    fn end(self) -> Result<Self::Ok, Self::Error> {
511        Ok(())
512    }
513}
bincode_next/features/serde/ser.rs

bincode_next/features/serde/
ser.rs
