aldrin_core/
value_serializer.rs

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

aldrin_core/
value_serializer.rs
