serde_jam/
ser.rs

1//! serde-jam serialization implementation
2
3use crate::{Error, Result, Vec, compact::vlen};
4use serde::ser;
5
6/// Serializer for serde-jam
7#[derive(Default)]
8pub struct Serializer {
9    /// Output buffer
10    pub output: Vec<u8>,
11}
12
13impl ser::Serializer for &mut Serializer {
14    type Ok = ();
15    type Error = Error;
16
17    type SerializeSeq = Self;
18    type SerializeTuple = Self;
19    type SerializeTupleStruct = Self;
20    type SerializeTupleVariant = Self;
21    type SerializeMap = Self;
22    type SerializeStruct = Self;
23    type SerializeStructVariant = Self;
24
25    fn serialize_bool(self, v: bool) -> Result<()> {
26        if v {
27            self.output.push(1);
28        } else {
29            self.output.push(0);
30        }
31        Ok(())
32    }
33
34    fn serialize_i8(self, v: i8) -> Result<()> {
35        self.output.extend_from_slice(&[v as u8]);
36        Ok(())
37    }
38
39    fn serialize_u8(self, v: u8) -> Result<()> {
40        self.output.push(v);
41        Ok(())
42    }
43
44    fn serialize_i16(self, v: i16) -> Result<()> {
45        self.output.extend_from_slice(&v.to_le_bytes());
46        Ok(())
47    }
48
49    fn serialize_u16(self, v: u16) -> Result<()> {
50        self.output.extend_from_slice(&v.to_le_bytes());
51        Ok(())
52    }
53
54    fn serialize_i32(self, v: i32) -> Result<()> {
55        self.output.extend_from_slice(&v.to_le_bytes());
56        Ok(())
57    }
58
59    fn serialize_u32(self, v: u32) -> Result<()> {
60        self.output.extend_from_slice(&v.to_le_bytes());
61        Ok(())
62    }
63
64    fn serialize_i64(self, v: i64) -> Result<()> {
65        self.output.extend_from_slice(&v.to_le_bytes());
66        Ok(())
67    }
68
69    fn serialize_u64(self, v: u64) -> Result<()> {
70        self.output.extend_from_slice(&v.to_le_bytes());
71        Ok(())
72    }
73
74    fn serialize_f32(self, v: f32) -> Result<()> {
75        self.output.extend_from_slice(&v.to_le_bytes());
76        Ok(())
77    }
78
79    fn serialize_f64(self, v: f64) -> Result<()> {
80        self.output.extend_from_slice(&v.to_le_bytes());
81        Ok(())
82    }
83
84    fn serialize_str(self, v: &str) -> Result<()> {
85        // Strings need compact length prefix for proper encoding
86        let length = vlen::encode(v.len() as u64);
87        self.output.extend_from_slice(&length);
88        self.output.extend_from_slice(v.as_bytes());
89        Ok(())
90    }
91
92    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
93        self.output.extend_from_slice(v);
94        Ok(())
95    }
96
97    fn serialize_char(self, v: char) -> Result<()> {
98        self.output.push(v as u8);
99        Ok(())
100    }
101
102    fn serialize_none(self) -> Result<()> {
103        self.output.push(0);
104        Ok(())
105    }
106
107    fn serialize_some<T>(self, value: &T) -> Result<()>
108    where
109        T: ser::Serialize + ?Sized,
110    {
111        self.output.push(1);
112        value.serialize(self)
113    }
114
115    fn serialize_unit(self) -> Result<()> {
116        Err(anyhow::anyhow!("Unit not supported").into())
117    }
118
119    fn serialize_unit_variant(
120        self,
121        _name: &'static str,
122        variant_index: u32,
123        _variant: &'static str,
124    ) -> Result<()> {
125        if variant_index > 0xff {
126            return Err(anyhow::anyhow!("Variant index too large").into());
127        }
128        self.serialize_u8(variant_index as u8)
129    }
130
131    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
132    where
133        T: ser::Serialize + ?Sized,
134    {
135        Err(anyhow::anyhow!("Newtype struct not supported").into())
136    }
137
138    fn collect_map<K, V, I>(self, iter: I) -> Result<()>
139    where
140        K: ser::Serialize,
141        V: ser::Serialize,
142        I: IntoIterator<Item = (K, V)>,
143    {
144        let iter = iter.into_iter();
145        let len = iter.size_hint().0;
146        let length = vlen::encode(len as u64);
147        self.output.extend_from_slice(&length);
148
149        for (key, value) in iter {
150            key.serialize(&mut *self)?;
151            value.serialize(&mut *self)?;
152        }
153        Ok(())
154    }
155
156    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
157        if let Some(len) = len {
158            let length = vlen::encode(len as u64);
159            self.output.extend_from_slice(&length);
160        }
161        Ok(self)
162    }
163
164    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
165        Ok(self)
166    }
167
168    fn serialize_tuple_struct(
169        self,
170        _name: &'static str,
171        _len: usize,
172    ) -> Result<Self::SerializeTupleStruct> {
173        Err(anyhow::anyhow!("Tuple struct not supported").into())
174    }
175
176    fn serialize_tuple_variant(
177        self,
178        _name: &'static str,
179        variant_index: u32,
180        _variant: &'static str,
181        _len: usize,
182    ) -> Result<Self::SerializeTupleVariant> {
183        if variant_index > 0xff {
184            return Err(anyhow::anyhow!("Variant index too large").into());
185        }
186        self.serialize_u8(variant_index as u8)?;
187        Ok(self)
188    }
189
190    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
191        if let Some(len) = len {
192            let length = vlen::encode(len as u64);
193            self.output.extend_from_slice(&length);
194        }
195        Ok(self)
196    }
197
198    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
199        Ok(self)
200    }
201
202    fn serialize_struct_variant(
203        self,
204        _name: &'static str,
205        variant_index: u32,
206        _variant: &'static str,
207        _len: usize,
208    ) -> Result<Self::SerializeStructVariant> {
209        if variant_index > 0xff {
210            return Err(anyhow::anyhow!("Variant index too large").into());
211        }
212        self.serialize_u8(variant_index as u8)?;
213        Ok(self)
214    }
215
216    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
217        self.serialize_unit()
218    }
219
220    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
221        self,
222        _name: &'static str,
223        _variant_index: u32,
224        _variant: &'static str,
225        value: &T,
226    ) -> Result<()> {
227        if _variant_index > 0xff {
228            return Err(anyhow::anyhow!("Variant index too large").into());
229        }
230        self.serialize_u8(_variant_index as u8)?;
231        value.serialize(self)
232    }
233
234    fn collect_str<T>(self, _value: &T) -> Result<()>
235    where
236        T: ?Sized + core::fmt::Display,
237    {
238        Err(anyhow::anyhow!("Str not supported").into())
239    }
240
241    fn serialize_i128(self, v: i128) -> Result<()> {
242        self.output.extend_from_slice(&v.to_le_bytes());
243        Ok(())
244    }
245
246    fn serialize_u128(self, v: u128) -> Result<()> {
247        self.output.extend_from_slice(&v.to_le_bytes());
248        Ok(())
249    }
250
251    fn is_human_readable(&self) -> bool {
252        false
253    }
254}
255
256impl ser::SerializeSeq for &mut Serializer {
257    type Ok = ();
258    type Error = Error;
259
260    // Serialize a single element of the sequence.
261    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
262    where
263        T: ?Sized + ser::Serialize,
264    {
265        value.serialize(&mut **self)?;
266        Ok(())
267    }
268
269    // Close the sequence.
270    fn end(self) -> Result<()> {
271        Ok(())
272    }
273}
274
275impl ser::SerializeTuple for &mut Serializer {
276    type Ok = ();
277    type Error = Error;
278
279    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
280    where
281        T: ?Sized + ser::Serialize,
282    {
283        value.serialize(&mut **self)?;
284        Ok(())
285    }
286
287    fn end(self) -> Result<()> {
288        Ok(())
289    }
290}
291
292impl ser::SerializeTupleStruct for &mut Serializer {
293    type Ok = ();
294    type Error = Error;
295
296    fn serialize_field<T>(&mut self, _value: &T) -> Result<()>
297    where
298        T: ?Sized + ser::Serialize,
299    {
300        Err(anyhow::anyhow!("Tuple struct not supported").into())
301    }
302
303    fn end(self) -> Result<()> {
304        Ok(())
305    }
306}
307
308impl ser::SerializeTupleVariant for &mut Serializer {
309    type Ok = ();
310    type Error = Error;
311
312    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
313    where
314        T: ?Sized + ser::Serialize,
315    {
316        value.serialize(&mut **self)
317    }
318
319    fn end(self) -> Result<()> {
320        Ok(())
321    }
322}
323
324impl ser::SerializeMap for &mut Serializer {
325    type Ok = ();
326    type Error = Error;
327
328    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
329    where
330        T: ?Sized + ser::Serialize,
331    {
332        key.serialize(&mut **self)
333    }
334
335    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
336    where
337        T: ?Sized + ser::Serialize,
338    {
339        value.serialize(&mut **self)
340    }
341
342    fn end(self) -> Result<()> {
343        Ok(())
344    }
345}
346
347impl ser::SerializeStruct for &mut Serializer {
348    type Ok = ();
349    type Error = Error;
350
351    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
352    where
353        T: ?Sized + ser::Serialize,
354    {
355        value.serialize(&mut **self)?;
356        Ok(())
357    }
358
359    fn end(self) -> Result<()> {
360        Ok(())
361    }
362}
363
364impl ser::SerializeStructVariant for &mut Serializer {
365    type Ok = ();
366    type Error = Error;
367
368    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
369    where
370        T: ?Sized + ser::Serialize,
371    {
372        value.serialize(&mut **self)
373    }
374
375    fn end(self) -> Result<()> {
376        Ok(())
377    }
378}
serde_jam/ser.rs

serde_jam/
ser.rs
