bincode_next/features/serde/
ser.rs

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

bincode_next/features/serde/
ser.rs
