serde_beve/
ser.rs

1mod map;
2mod seq;
3
4pub use map::MapSerializer;
5pub use seq::SeqSerializer;
6
7use crate::{Value, error::Error, headers::*};
8use std::io::Write;
9
10pub struct Serializer<W: Write> {
11    writer: W,
12    write: bool,
13}
14
15impl<W: Write> Serializer<W> {
16    pub fn new(writer: W) -> Self {
17        Self {
18            writer,
19            write: true,
20        }
21    }
22
23    fn serialize_num_array<T: Copy, const N: usize>(
24        &mut self,
25        v: &[T],
26        f: fn(T) -> [u8; N],
27    ) -> Result<(), Error> {
28        self.serialize_size(v.len())?;
29        let bytes = v.iter().flat_map(|v| f(*v)).collect::<Vec<_>>();
30        self.writer.write_all(&bytes)?;
31        Ok(())
32    }
33
34    fn serialize_size(&mut self, mut size: usize) -> Result<(), Error> {
35        if size >= 2_usize.pow(62) {
36            return Err(Error::TooLong);
37        }
38
39        size <<= 2;
40
41        if size < 2_usize.pow(6) {
42            self.writer.write_all(&[size as u8])?;
43        } else if size < 2_usize.pow(14) {
44            self.writer.write_all(&(size as u16 | 1).to_le_bytes())?;
45        } else if size < 2_usize.pow(30) {
46            self.writer.write_all(&(size as u32 | 2).to_le_bytes())?;
47        } else {
48            self.writer.write_all(&(size as u64 | 3).to_le_bytes())?;
49        }
50
51        Ok(())
52    }
53
54    fn serialize_str_value(&mut self, value: &[u8]) -> Result<(), Error> {
55        self.serialize_size(value.len())?;
56        self.writer.write_all(value)?;
57        Ok(())
58    }
59
60    fn serialize_value(&mut self, value: &Value) -> Result<(), Error> {
61        self.writer.write_all(&[value.header()])?;
62        match value {
63            Value::Null | Value::True | Value::False => {}
64
65            Value::I8(v) => self.writer.write_all(&v.to_le_bytes())?,
66            Value::I16(v) => self.writer.write_all(&v.to_le_bytes())?,
67            Value::I32(v) => self.writer.write_all(&v.to_le_bytes())?,
68            Value::I64(v) => self.writer.write_all(&v.to_le_bytes())?,
69            Value::I128(v) => self.writer.write_all(&v.to_le_bytes())?,
70
71            Value::U8(v) => self.writer.write_all(&[*v])?,
72            Value::U16(v) => self.writer.write_all(&v.to_le_bytes())?,
73            Value::U32(v) => self.writer.write_all(&v.to_le_bytes())?,
74            Value::U64(v) => self.writer.write_all(&v.to_le_bytes())?,
75            Value::U128(v) => self.writer.write_all(&v.to_le_bytes())?,
76
77            Value::F32(v) => self.writer.write_all(&v.to_le_bytes())?,
78            Value::F64(v) => self.writer.write_all(&v.to_le_bytes())?,
79
80            Value::String(v) => self.serialize_str_value(v)?,
81
82            Value::StringObject(v) => {
83                self.serialize_size(v.len())?;
84                for (k, v) in v {
85                    self.serialize_str_value(k)?;
86                    self.serialize_value(v)?;
87                }
88            }
89
90            Value::I8Object(v) => {
91                self.serialize_size(v.len())?;
92                for (k, v) in v {
93                    self.serialize_value(&Value::I8(*k))?;
94                    self.serialize_value(v)?;
95                }
96            }
97            Value::I16Object(v) => {
98                self.serialize_size(v.len())?;
99                for (k, v) in v {
100                    self.serialize_value(&Value::I16(*k))?;
101                    self.serialize_value(v)?;
102                }
103            }
104            Value::I32Object(v) => {
105                self.serialize_size(v.len())?;
106                for (k, v) in v {
107                    self.serialize_value(&Value::I32(*k))?;
108                    self.serialize_value(v)?;
109                }
110            }
111            Value::I64Object(v) => {
112                self.serialize_size(v.len())?;
113                for (k, v) in v {
114                    self.serialize_value(&Value::I64(*k))?;
115                    self.serialize_value(v)?;
116                }
117            }
118            Value::I128Object(v) => {
119                self.serialize_size(v.len())?;
120                for (k, v) in v {
121                    self.serialize_value(&Value::I128(*k))?;
122                    self.serialize_value(v)?;
123                }
124            }
125
126            Value::U8Object(v) => {
127                self.serialize_size(v.len())?;
128                for (k, v) in v {
129                    self.serialize_value(&Value::U8(*k))?;
130                    self.serialize_value(v)?;
131                }
132            }
133            Value::U16Object(v) => {
134                self.serialize_size(v.len())?;
135                for (k, v) in v {
136                    self.serialize_value(&Value::U16(*k))?;
137                    self.serialize_value(v)?;
138                }
139            }
140            Value::U32Object(v) => {
141                self.serialize_size(v.len())?;
142                for (k, v) in v {
143                    self.serialize_value(&Value::U32(*k))?;
144                    self.serialize_value(v)?;
145                }
146            }
147            Value::U64Object(v) => {
148                self.serialize_size(v.len())?;
149                for (k, v) in v {
150                    self.serialize_value(&Value::U64(*k))?;
151                    self.serialize_value(v)?;
152                }
153            }
154            Value::U128Object(v) => {
155                self.serialize_size(v.len())?;
156                for (k, v) in v {
157                    self.serialize_value(&Value::U128(*k))?;
158                    self.serialize_value(v)?;
159                }
160            }
161
162            Value::F32Array(v) => {
163                self.serialize_num_array(v, f32::to_le_bytes)?;
164            }
165            Value::F64Array(v) => {
166                self.serialize_num_array(v, f64::to_le_bytes)?;
167            }
168
169            Value::I8Array(v) => {
170                self.serialize_num_array(v, i8::to_le_bytes)?;
171            }
172            Value::I16Array(v) => {
173                self.serialize_num_array(v, i16::to_le_bytes)?;
174            }
175            Value::I32Array(v) => {
176                self.serialize_num_array(v, i32::to_le_bytes)?;
177            }
178            Value::I64Array(v) => {
179                self.serialize_num_array(v, i64::to_le_bytes)?;
180            }
181            Value::I128Array(v) => {
182                self.serialize_num_array(v, i128::to_le_bytes)?;
183            }
184
185            Value::U8Array(v) => {
186                self.serialize_num_array(v, u8::to_le_bytes)?;
187            }
188            Value::U16Array(v) => {
189                self.serialize_num_array(v, u16::to_le_bytes)?;
190            }
191            Value::U32Array(v) => {
192                self.serialize_num_array(v, u32::to_le_bytes)?;
193            }
194            Value::U64Array(v) => {
195                self.serialize_num_array(v, u64::to_le_bytes)?;
196            }
197            Value::U128Array(v) => {
198                self.serialize_num_array(v, u128::to_le_bytes)?;
199            }
200
201            Value::BoolArray(len, v) => {
202                self.serialize_size(*len)?;
203                self.writer.write_all(v)?;
204            }
205            Value::StringArray(v) => {
206                self.serialize_size(v.len())?;
207                for s in v {
208                    self.serialize_str_value(s)?;
209                }
210            }
211            Value::GenericArray(v) => {
212                self.serialize_size(v.len())?;
213                for v in v {
214                    self.serialize_value(v)?;
215                }
216            }
217
218            Value::Tag(tag, v) => {
219                self.serialize_size(*tag)?;
220                self.serialize_value(v)?;
221            }
222
223            // Never serialized
224            Value::F128
225            | Value::F128Array
226            | Value::Reserved
227            | Value::Complex(..)
228            | Value::Matrix { .. }
229            | Value::BF16 { .. }
230            | Value::F16 { .. }
231            | Value::BF16Array { .. }
232            | Value::F16Array { .. }
233            | Value::Delimiter => unreachable!(),
234        }
235
236        Ok(())
237    }
238}
239
240macro_rules! serialize_primitive {
241    ($fn:ident, $ty:ty, $variant:ident) => {
242        fn $fn(self, v: $ty) -> Result<Self::Ok, Self::Error> {
243            let out = Value::$variant(v);
244            if self.write {
245                self.serialize_value(&out)?;
246            }
247            Ok(out)
248        }
249    };
250}
251
252impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
253    type Ok = Value;
254    type Error = Error;
255
256    type SerializeSeq = SeqSerializer<'a, W>;
257    type SerializeTuple = SeqSerializer<'a, W>;
258    type SerializeTupleStruct = SeqSerializer<'a, W>;
259    type SerializeTupleVariant = SeqSerializer<'a, W>;
260    type SerializeMap = MapSerializer<'a, W>;
261    type SerializeStruct = MapSerializer<'a, W>;
262    type SerializeStructVariant = MapSerializer<'a, W>;
263
264    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
265        let out = v.into();
266        if self.write {
267            self.serialize_value(&out)?;
268        }
269        Ok(out)
270    }
271
272    serialize_primitive!(serialize_i8, i8, I8);
273    serialize_primitive!(serialize_i16, i16, I16);
274    serialize_primitive!(serialize_i32, i32, I32);
275    serialize_primitive!(serialize_i64, i64, I64);
276    serialize_primitive!(serialize_i128, i128, I128);
277    serialize_primitive!(serialize_u8, u8, U8);
278    serialize_primitive!(serialize_u16, u16, U16);
279    serialize_primitive!(serialize_u32, u32, U32);
280    serialize_primitive!(serialize_u64, u64, U64);
281    serialize_primitive!(serialize_u128, u128, U128);
282    serialize_primitive!(serialize_f32, f32, F32);
283    serialize_primitive!(serialize_f64, f64, F64);
284
285    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
286        self.serialize_str(&v.to_string())
287    }
288
289    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
290        let out = Value::String(v.as_bytes().to_vec());
291        if self.write {
292            self.serialize_value(&out)?;
293        }
294        Ok(out)
295    }
296
297    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
298        // TODO: avoid copying?
299        let out = Value::U8Array(v.to_vec());
300        if self.write {
301            self.serialize_value(&out)?;
302        }
303        Ok(out)
304    }
305
306    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
307        self.serialize_unit()
308    }
309
310    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
311    where
312        T: ?Sized + serde::Serialize,
313    {
314        value.serialize(self)
315    }
316
317    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
318        if self.write {
319            self.serialize_value(&Value::Null)?;
320        }
321        Ok(Value::Null)
322    }
323
324    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
325        self.serialize_unit()
326    }
327
328    fn serialize_unit_variant(
329        self,
330        _name: &'static str,
331        variant_index: u32,
332        _variant: &'static str,
333    ) -> Result<Self::Ok, Self::Error> {
334        let out = Value::Tag(variant_index as usize, Box::new(Value::Null));
335        if self.write {
336            self.serialize_value(&out)?;
337        }
338        Ok(out)
339    }
340
341    fn serialize_newtype_struct<T>(
342        self,
343        _name: &'static str,
344        value: &T,
345    ) -> Result<Self::Ok, Self::Error>
346    where
347        T: ?Sized + serde::Serialize,
348    {
349        value.serialize(self)
350    }
351
352    fn serialize_newtype_variant<T>(
353        self,
354        _name: &'static str,
355        variant_index: u32,
356        _variant: &'static str,
357        value: &T,
358    ) -> Result<Self::Ok, Self::Error>
359    where
360        T: ?Sized + serde::Serialize,
361    {
362        let out = Value::Tag(
363            variant_index as usize,
364            Box::new(value.serialize(&mut *self)?),
365        );
366        if self.write {
367            self.serialize_value(&out)?;
368        }
369        Ok(out)
370    }
371
372    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
373        Ok(SeqSerializer::new(self))
374    }
375
376    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
377        self.serialize_seq(Some(len))
378    }
379
380    fn serialize_tuple_struct(
381        self,
382        _name: &'static str,
383        len: usize,
384    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
385        self.serialize_seq(Some(len))
386    }
387
388    fn serialize_tuple_variant(
389        self,
390        _name: &'static str,
391        variant_index: u32,
392        _variant: &'static str,
393        len: usize,
394    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
395        if self.write {
396            self.writer.write_all(&[TAG])?;
397            self.serialize_size(variant_index as usize)?;
398        }
399        self.serialize_seq(Some(len))
400    }
401
402    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
403        Ok(MapSerializer::new(self, None))
404    }
405
406    fn serialize_struct(
407        self,
408        _name: &'static str,
409        _len: usize,
410    ) -> Result<Self::SerializeStruct, Self::Error> {
411        Ok(MapSerializer::new(self, Some(ObjectKind::String)))
412    }
413
414    fn serialize_struct_variant(
415        self,
416        _name: &'static str,
417        variant_index: u32,
418        _variant: &'static str,
419        len: usize,
420    ) -> Result<Self::SerializeStructVariant, Self::Error> {
421        if self.write {
422            self.writer.write_all(&[TAG])?;
423            self.serialize_size(variant_index as usize)?;
424        }
425        self.serialize_struct("", len)
426    }
427}
428
429/// Serializes the `value` into the `writer`.
430///
431/// The returned value is the intermediate value that was serialized. It can be ignored.
432pub fn to_writer(writer: impl Write, value: &impl serde::Serialize) -> Result<Value, Error> {
433    let mut serializer = Serializer::new(writer);
434    value.serialize(&mut serializer)
435}
436
437/// Serializes the `value` into a `Vec<u8>`.
438pub fn to_bytes(value: &impl serde::Serialize) -> Result<Vec<u8>, Error> {
439    let mut writer = Vec::new();
440    to_writer(&mut writer, value)?;
441    Ok(writer)
442}
serde_beve/ser.rs

serde_beve/
ser.rs
