aldrin_core/
value_serializer.rs

1use crate::buf_ext::BufMutExt;
2use crate::error::SerializeError;
3use crate::ids::{ChannelCookie, ObjectId, ServiceId};
4use crate::serialize_key::SerializeKey;
5use crate::serialized_value::SerializedValueSlice;
6use crate::value::ValueKind;
7use crate::MAX_VALUE_DEPTH;
8use bytes::{BufMut, BytesMut};
9use std::fmt;
10use std::marker::PhantomData;
11use uuid::Uuid;
12
13pub trait Serialize {
14    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError>;
15}
16
17#[derive(Debug)]
18pub struct Serializer<'a> {
19    buf: &'a mut BytesMut,
20    depth: u8,
21}
22
23impl<'a> Serializer<'a> {
24    pub(crate) fn new(buf: &'a mut BytesMut, depth: u8) -> Result<Self, SerializeError> {
25        let mut this = Self { buf, depth };
26        this.increment_depth()?;
27        Ok(this)
28    }
29
30    fn increment_depth(&mut self) -> Result<(), SerializeError> {
31        self.depth += 1;
32        if self.depth <= MAX_VALUE_DEPTH {
33            Ok(())
34        } else {
35            Err(SerializeError::TooDeeplyNested)
36        }
37    }
38
39    pub fn copy_from_serialized_value(self, value: &SerializedValueSlice) {
40        self.buf.extend_from_slice(value);
41    }
42
43    pub fn serialize_none(self) {
44        self.buf.put_discriminant_u8(ValueKind::None);
45    }
46
47    pub fn serialize_some<T: Serialize + ?Sized>(
48        mut self,
49        value: &T,
50    ) -> Result<(), SerializeError> {
51        self.increment_depth()?;
52        self.buf.put_discriminant_u8(ValueKind::Some);
53        value.serialize(self)
54    }
55
56    pub fn serialize_bool(self, value: bool) {
57        self.buf.put_discriminant_u8(ValueKind::Bool);
58        self.buf.put_u8(value.into());
59    }
60
61    pub fn serialize_u8(self, value: u8) {
62        self.buf.put_discriminant_u8(ValueKind::U8);
63        self.buf.put_u8(value);
64    }
65
66    pub fn serialize_i8(self, value: i8) {
67        self.buf.put_discriminant_u8(ValueKind::I8);
68        self.buf.put_i8(value);
69    }
70
71    pub fn serialize_u16(self, value: u16) {
72        self.buf.put_discriminant_u8(ValueKind::U16);
73        self.buf.put_varint_u16_le(value);
74    }
75
76    pub fn serialize_i16(self, value: i16) {
77        self.buf.put_discriminant_u8(ValueKind::I16);
78        self.buf.put_varint_i16_le(value);
79    }
80
81    pub fn serialize_u32(self, value: u32) {
82        self.buf.put_discriminant_u8(ValueKind::U32);
83        self.buf.put_varint_u32_le(value);
84    }
85
86    pub fn serialize_i32(self, value: i32) {
87        self.buf.put_discriminant_u8(ValueKind::I32);
88        self.buf.put_varint_i32_le(value);
89    }
90
91    pub fn serialize_u64(self, value: u64) {
92        self.buf.put_discriminant_u8(ValueKind::U64);
93        self.buf.put_varint_u64_le(value);
94    }
95
96    pub fn serialize_i64(self, value: i64) {
97        self.buf.put_discriminant_u8(ValueKind::I64);
98        self.buf.put_varint_i64_le(value);
99    }
100
101    pub fn serialize_f32(self, value: f32) {
102        self.buf.put_discriminant_u8(ValueKind::F32);
103        self.buf.put_u32_le(value.to_bits());
104    }
105
106    pub fn serialize_f64(self, value: f64) {
107        self.buf.put_discriminant_u8(ValueKind::F64);
108        self.buf.put_u64_le(value.to_bits());
109    }
110
111    pub fn serialize_string(self, value: &str) -> Result<(), SerializeError> {
112        if value.len() <= u32::MAX as usize {
113            self.buf.put_discriminant_u8(ValueKind::String);
114            self.buf.put_varint_u32_le(value.len() as u32);
115            self.buf.put_slice(value.as_bytes());
116            Ok(())
117        } else {
118            Err(SerializeError::Overflow)
119        }
120    }
121
122    pub fn serialize_uuid(self, value: Uuid) {
123        self.buf.put_discriminant_u8(ValueKind::Uuid);
124        self.buf.put_slice(value.as_bytes());
125    }
126
127    pub fn serialize_object_id(self, value: ObjectId) {
128        self.buf.put_discriminant_u8(ValueKind::ObjectId);
129        self.buf.put_slice(value.uuid.0.as_bytes());
130        self.buf.put_slice(value.cookie.0.as_bytes());
131    }
132
133    pub fn serialize_service_id(self, value: ServiceId) {
134        self.buf.put_discriminant_u8(ValueKind::ServiceId);
135        self.buf.put_slice(value.object_id.uuid.0.as_bytes());
136        self.buf.put_slice(value.object_id.cookie.0.as_bytes());
137        self.buf.put_slice(value.uuid.0.as_bytes());
138        self.buf.put_slice(value.cookie.0.as_bytes());
139    }
140
141    pub fn serialize_vec(self, num_elems: usize) -> Result<VecSerializer<'a>, SerializeError> {
142        VecSerializer::new(self.buf, num_elems, self.depth)
143    }
144
145    pub fn serialize_vec_iter<T>(self, vec: T) -> Result<(), SerializeError>
146    where
147        T: IntoIterator,
148        T::Item: Serialize,
149        T::IntoIter: ExactSizeIterator,
150    {
151        let vec = vec.into_iter();
152        let mut serializer = self.serialize_vec(vec.len())?;
153
154        for elem in vec {
155            serializer.serialize_element(&elem)?;
156        }
157
158        serializer.finish()
159    }
160
161    pub fn serialize_bytes(self, num_elems: usize) -> Result<BytesSerializer<'a>, SerializeError> {
162        BytesSerializer::new(self.buf, num_elems)
163    }
164
165    pub fn serialize_byte_slice(self, bytes: &[u8]) -> Result<(), SerializeError> {
166        let mut serializer = self.serialize_bytes(bytes.len())?;
167        serializer.serialize(bytes)?;
168        serializer.finish()
169    }
170
171    pub fn serialize_map<K: SerializeKey + ?Sized>(
172        self,
173        num_elems: usize,
174    ) -> Result<MapSerializer<'a, K>, SerializeError> {
175        MapSerializer::new(self.buf, num_elems, self.depth)
176    }
177
178    pub fn serialize_map_iter<T, K, V>(self, map: T) -> Result<(), SerializeError>
179    where
180        T: IntoIterator<Item = (K, V)>,
181        T::IntoIter: ExactSizeIterator,
182        K: SerializeKey,
183        V: Serialize,
184    {
185        let map = map.into_iter();
186        let mut serializer = self.serialize_map(map.len())?;
187
188        for (key, value) in map {
189            serializer.serialize_element(&key, &value)?;
190        }
191
192        serializer.finish()
193    }
194
195    pub fn serialize_set<T: SerializeKey + ?Sized>(
196        self,
197        num_elems: usize,
198    ) -> Result<SetSerializer<'a, T>, SerializeError> {
199        SetSerializer::new(self.buf, num_elems)
200    }
201
202    pub fn serialize_set_iter<T>(self, set: T) -> Result<(), SerializeError>
203    where
204        T: IntoIterator,
205        T::Item: SerializeKey,
206        T::IntoIter: ExactSizeIterator,
207    {
208        let set = set.into_iter();
209        let mut serializer = self.serialize_set(set.len())?;
210
211        for value in set {
212            serializer.serialize_element(&value)?;
213        }
214
215        serializer.finish()
216    }
217
218    pub fn serialize_struct(
219        self,
220        num_fields: usize,
221    ) -> Result<StructSerializer<'a>, SerializeError> {
222        StructSerializer::new(self.buf, num_fields, self.depth)
223    }
224
225    pub fn serialize_enum<T: Serialize + ?Sized>(
226        mut self,
227        variant: u32,
228        value: &T,
229    ) -> Result<(), SerializeError> {
230        self.increment_depth()?;
231        self.buf.put_discriminant_u8(ValueKind::Enum);
232        self.buf.put_varint_u32_le(variant);
233        value.serialize(self)
234    }
235
236    pub fn serialize_sender(self, value: ChannelCookie) {
237        self.buf.put_discriminant_u8(ValueKind::Sender);
238        self.buf.put_slice(value.0.as_bytes());
239    }
240
241    pub fn serialize_receiver(self, value: ChannelCookie) {
242        self.buf.put_discriminant_u8(ValueKind::Receiver);
243        self.buf.put_slice(value.0.as_bytes());
244    }
245}
246
247#[derive(Debug)]
248pub struct VecSerializer<'a> {
249    buf: &'a mut BytesMut,
250    num_elems: u32,
251    depth: u8,
252}
253
254impl<'a> VecSerializer<'a> {
255    fn new(buf: &'a mut BytesMut, num_elems: usize, depth: u8) -> Result<Self, SerializeError> {
256        if num_elems <= u32::MAX as usize {
257            buf.put_discriminant_u8(ValueKind::Vec);
258            buf.put_varint_u32_le(num_elems as u32);
259            Ok(Self {
260                buf,
261                num_elems: num_elems as u32,
262                depth,
263            })
264        } else {
265            Err(SerializeError::Overflow)
266        }
267    }
268
269    pub fn remaining_elements(&self) -> usize {
270        self.num_elems as usize
271    }
272
273    pub fn requires_additional_elements(&self) -> bool {
274        self.num_elems > 0
275    }
276
277    pub fn serialize_element<T: Serialize + ?Sized>(
278        &mut self,
279        value: &T,
280    ) -> Result<&mut Self, SerializeError> {
281        if self.num_elems > 0 {
282            self.num_elems -= 1;
283            value.serialize(Serializer::new(self.buf, self.depth)?)?;
284            Ok(self)
285        } else {
286            Err(SerializeError::TooManyElements)
287        }
288    }
289
290    pub fn finish(self) -> Result<(), SerializeError> {
291        if self.num_elems == 0 {
292            Ok(())
293        } else {
294            Err(SerializeError::TooFewElements)
295        }
296    }
297}
298
299#[derive(Debug)]
300pub struct BytesSerializer<'a> {
301    buf: &'a mut BytesMut,
302    num_elems: u32,
303}
304
305impl<'a> BytesSerializer<'a> {
306    fn new(buf: &'a mut BytesMut, num_elems: usize) -> Result<Self, SerializeError> {
307        if num_elems <= u32::MAX as usize {
308            buf.put_discriminant_u8(ValueKind::Bytes);
309            buf.put_varint_u32_le(num_elems as u32);
310            Ok(Self {
311                buf,
312                num_elems: num_elems as u32,
313            })
314        } else {
315            Err(SerializeError::Overflow)
316        }
317    }
318
319    pub fn remaining_elements(&self) -> usize {
320        self.num_elems as usize
321    }
322
323    pub fn requires_additional_elements(&self) -> bool {
324        self.num_elems > 0
325    }
326
327    pub fn serialize(&mut self, bytes: &[u8]) -> Result<&mut Self, SerializeError> {
328        if self.num_elems as usize >= bytes.len() {
329            self.num_elems -= bytes.len() as u32;
330            self.buf.put_slice(bytes);
331            Ok(self)
332        } else {
333            Err(SerializeError::TooManyElements)
334        }
335    }
336
337    pub fn finish(self) -> Result<(), SerializeError> {
338        if self.num_elems == 0 {
339            Ok(())
340        } else {
341            Err(SerializeError::TooFewElements)
342        }
343    }
344}
345
346pub struct MapSerializer<'a, K: SerializeKey + ?Sized> {
347    buf: &'a mut BytesMut,
348    num_elems: u32,
349    depth: u8,
350    _key: PhantomData<K>,
351}
352
353impl<'a, K: SerializeKey + ?Sized> MapSerializer<'a, K> {
354    fn new(mut buf: &'a mut BytesMut, num_elems: usize, depth: u8) -> Result<Self, SerializeError> {
355        if num_elems <= u32::MAX as usize {
356            K::serialize_map_value_kind(&mut buf);
357            buf.put_varint_u32_le(num_elems as u32);
358
359            Ok(Self {
360                buf,
361                num_elems: num_elems as u32,
362                depth,
363                _key: PhantomData,
364            })
365        } else {
366            Err(SerializeError::Overflow)
367        }
368    }
369
370    pub fn remaining_elements(&self) -> usize {
371        self.num_elems as usize
372    }
373
374    pub fn requires_additional_elements(&self) -> bool {
375        self.num_elems > 0
376    }
377
378    pub fn serialize_element<T: Serialize + ?Sized>(
379        &mut self,
380        key: &K,
381        value: &T,
382    ) -> Result<&mut Self, SerializeError> {
383        if self.num_elems > 0 {
384            self.num_elems -= 1;
385            key.serialize_key(self.buf)?;
386            value.serialize(Serializer::new(self.buf, self.depth)?)?;
387            Ok(self)
388        } else {
389            Err(SerializeError::TooManyElements)
390        }
391    }
392
393    pub fn finish(self) -> Result<(), SerializeError> {
394        if self.num_elems == 0 {
395            Ok(())
396        } else {
397            Err(SerializeError::TooFewElements)
398        }
399    }
400}
401
402impl<'a, K: SerializeKey + ?Sized> fmt::Debug for MapSerializer<'a, K> {
403    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
404        let mut f = f.debug_struct("MapSerializer");
405
406        f.field("buf", &self.buf);
407        f.field("num_elems", &self.num_elems);
408
409        f.finish()
410    }
411}
412
413pub struct SetSerializer<'a, T: SerializeKey + ?Sized> {
414    buf: &'a mut BytesMut,
415    num_elems: u32,
416    _key: PhantomData<T>,
417}
418
419impl<'a, T: SerializeKey + ?Sized> SetSerializer<'a, T> {
420    fn new(mut buf: &'a mut BytesMut, num_elems: usize) -> Result<Self, SerializeError> {
421        if num_elems <= u32::MAX as usize {
422            T::serialize_set_value_kind(&mut buf);
423            buf.put_varint_u32_le(num_elems as u32);
424
425            Ok(Self {
426                buf,
427                num_elems: num_elems as u32,
428                _key: PhantomData,
429            })
430        } else {
431            Err(SerializeError::Overflow)
432        }
433    }
434
435    pub fn remaining_elements(&self) -> usize {
436        self.num_elems as usize
437    }
438
439    pub fn requires_additional_elements(&self) -> bool {
440        self.num_elems > 0
441    }
442
443    pub fn serialize_element(&mut self, value: &T) -> Result<&mut Self, SerializeError> {
444        if self.num_elems > 0 {
445            self.num_elems -= 1;
446            value.serialize_key(self.buf)?;
447            Ok(self)
448        } else {
449            Err(SerializeError::TooManyElements)
450        }
451    }
452
453    pub fn finish(self) -> Result<(), SerializeError> {
454        if self.num_elems == 0 {
455            Ok(())
456        } else {
457            Err(SerializeError::TooFewElements)
458        }
459    }
460}
461
462impl<'a, T: SerializeKey + ?Sized> fmt::Debug for SetSerializer<'a, T> {
463    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
464        let mut f = f.debug_struct("SetSerializer");
465
466        f.field("buf", &self.buf);
467        f.field("num_elems", &self.num_elems);
468
469        f.finish()
470    }
471}
472
473#[derive(Debug)]
474pub struct StructSerializer<'a> {
475    buf: &'a mut BytesMut,
476    num_fields: u32,
477    depth: u8,
478}
479
480impl<'a> StructSerializer<'a> {
481    fn new(buf: &'a mut BytesMut, num_fields: usize, depth: u8) -> Result<Self, SerializeError> {
482        if num_fields <= u32::MAX as usize {
483            buf.put_discriminant_u8(ValueKind::Struct);
484            buf.put_varint_u32_le(num_fields as u32);
485            Ok(Self {
486                buf,
487                num_fields: num_fields as u32,
488                depth,
489            })
490        } else {
491            Err(SerializeError::Overflow)
492        }
493    }
494
495    pub fn remaining_fields(&self) -> usize {
496        self.num_fields as usize
497    }
498
499    pub fn requires_additional_fields(&self) -> bool {
500        self.num_fields > 0
501    }
502
503    pub fn serialize_field<T: Serialize + ?Sized>(
504        &mut self,
505        id: u32,
506        value: &T,
507    ) -> Result<&mut Self, SerializeError> {
508        if self.num_fields > 0 {
509            self.num_fields -= 1;
510            self.buf.put_varint_u32_le(id);
511            value.serialize(Serializer::new(self.buf, self.depth)?)?;
512            Ok(self)
513        } else {
514            Err(SerializeError::TooManyElements)
515        }
516    }
517
518    pub fn finish(self) -> Result<(), SerializeError> {
519        if self.num_fields == 0 {
520            Ok(())
521        } else {
522            Err(SerializeError::TooFewElements)
523        }
524    }
525}
aldrin_core/value_serializer.rs

aldrin_core/
value_serializer.rs
