minicbor_serde/
ser.rs

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

minicbor_serde/
ser.rs
