aldrin_core/
serializer.rs

1mod bytes;
2mod map;
3mod set;
4mod struct_;
5mod vec;
6
7use crate::buf_ext::BufMutExt;
8use crate::tags::{self, KeyTag, Tag};
9use crate::{
10    AsUnknownFields, AsUnknownVariant, ChannelCookie, ObjectId, Serialize, SerializeError,
11    SerializeKey, SerializedValueSlice, ServiceId, ValueKind, MAX_VALUE_DEPTH,
12};
13use ::bytes::{BufMut, BytesMut};
14use uuid::Uuid;
15
16pub use self::bytes::{Bytes1Serializer, Bytes2Serializer};
17pub use map::{Map1Serializer, Map2Serializer};
18pub use set::{Set1Serializer, Set2Serializer};
19pub use struct_::{Struct1Serializer, Struct2Serializer};
20pub use vec::{Vec1Serializer, Vec2Serializer};
21
22#[derive(Debug)]
23pub struct Serializer<'a> {
24    buf: &'a mut BytesMut,
25    depth: u8,
26}
27
28impl<'a> Serializer<'a> {
29    pub(crate) fn new(buf: &'a mut BytesMut, depth: u8) -> Result<Self, SerializeError> {
30        let mut this = Self { buf, depth };
31        this.increment_depth()?;
32        Ok(this)
33    }
34
35    fn increment_depth(&mut self) -> Result<(), SerializeError> {
36        self.depth += 1;
37
38        if self.depth <= MAX_VALUE_DEPTH {
39            Ok(())
40        } else {
41            Err(SerializeError::TooDeeplyNested)
42        }
43    }
44
45    pub fn copy_from_serialized_value(
46        self,
47        value: &SerializedValueSlice,
48    ) -> Result<(), SerializeError> {
49        self.buf.extend_from_slice(value);
50        Ok(())
51    }
52
53    pub fn serialize<T: Tag>(self, value: impl Serialize<T>) -> Result<(), SerializeError> {
54        value.serialize(self)
55    }
56
57    pub fn serialize_none(self) -> Result<(), SerializeError> {
58        self.buf.put_discriminant_u8(ValueKind::None);
59        Ok(())
60    }
61
62    pub fn serialize_some<T: Tag>(
63        mut self,
64        value: impl Serialize<T>,
65    ) -> Result<(), SerializeError> {
66        self.increment_depth()?;
67        self.buf.put_discriminant_u8(ValueKind::Some);
68        self.serialize(value)
69    }
70
71    pub fn serialize_bool(self, value: bool) -> Result<(), SerializeError> {
72        self.buf.put_discriminant_u8(ValueKind::Bool);
73        self.buf.put_u8(value.into());
74        Ok(())
75    }
76
77    pub fn serialize_u8(self, value: u8) -> Result<(), SerializeError> {
78        self.buf.put_discriminant_u8(ValueKind::U8);
79        self.buf.put_u8(value);
80        Ok(())
81    }
82
83    pub fn serialize_i8(self, value: i8) -> Result<(), SerializeError> {
84        self.buf.put_discriminant_u8(ValueKind::I8);
85        self.buf.put_i8(value);
86        Ok(())
87    }
88
89    pub fn serialize_u16(self, value: u16) -> Result<(), SerializeError> {
90        self.buf.put_discriminant_u8(ValueKind::U16);
91        self.buf.put_varint_u16_le(value);
92        Ok(())
93    }
94
95    pub fn serialize_i16(self, value: i16) -> Result<(), SerializeError> {
96        self.buf.put_discriminant_u8(ValueKind::I16);
97        self.buf.put_varint_i16_le(value);
98        Ok(())
99    }
100
101    pub fn serialize_u32(self, value: u32) -> Result<(), SerializeError> {
102        self.buf.put_discriminant_u8(ValueKind::U32);
103        self.buf.put_varint_u32_le(value);
104        Ok(())
105    }
106
107    pub fn serialize_i32(self, value: i32) -> Result<(), SerializeError> {
108        self.buf.put_discriminant_u8(ValueKind::I32);
109        self.buf.put_varint_i32_le(value);
110        Ok(())
111    }
112
113    pub fn serialize_u64(self, value: u64) -> Result<(), SerializeError> {
114        self.buf.put_discriminant_u8(ValueKind::U64);
115        self.buf.put_varint_u64_le(value);
116        Ok(())
117    }
118
119    pub fn serialize_i64(self, value: i64) -> Result<(), SerializeError> {
120        self.buf.put_discriminant_u8(ValueKind::I64);
121        self.buf.put_varint_i64_le(value);
122        Ok(())
123    }
124
125    pub fn serialize_f32(self, value: f32) -> Result<(), SerializeError> {
126        self.buf.put_discriminant_u8(ValueKind::F32);
127        self.buf.put_u32_le(value.to_bits());
128        Ok(())
129    }
130
131    pub fn serialize_f64(self, value: f64) -> Result<(), SerializeError> {
132        self.buf.put_discriminant_u8(ValueKind::F64);
133        self.buf.put_u64_le(value.to_bits());
134        Ok(())
135    }
136
137    pub fn serialize_string(self, value: &str) -> Result<(), SerializeError> {
138        if value.len() <= u32::MAX as usize {
139            self.buf.put_discriminant_u8(ValueKind::String);
140            self.buf.put_varint_u32_le(value.len() as u32);
141            self.buf.put_slice(value.as_bytes());
142            Ok(())
143        } else {
144            Err(SerializeError::Overflow)
145        }
146    }
147
148    pub fn serialize_uuid(self, value: Uuid) -> Result<(), SerializeError> {
149        self.buf.put_discriminant_u8(ValueKind::Uuid);
150        self.buf.put_slice(value.as_bytes());
151        Ok(())
152    }
153
154    pub fn serialize_object_id(self, value: ObjectId) -> Result<(), SerializeError> {
155        self.buf.put_discriminant_u8(ValueKind::ObjectId);
156        self.buf.put_slice(value.uuid.0.as_bytes());
157        self.buf.put_slice(value.cookie.0.as_bytes());
158        Ok(())
159    }
160
161    pub fn serialize_service_id(self, value: ServiceId) -> Result<(), SerializeError> {
162        self.buf.put_discriminant_u8(ValueKind::ServiceId);
163        self.buf.put_slice(value.object_id.uuid.0.as_bytes());
164        self.buf.put_slice(value.object_id.cookie.0.as_bytes());
165        self.buf.put_slice(value.uuid.0.as_bytes());
166        self.buf.put_slice(value.cookie.0.as_bytes());
167        Ok(())
168    }
169
170    pub fn serialize_vec1(self, num_elems: usize) -> Result<Vec1Serializer<'a>, SerializeError> {
171        Vec1Serializer::new(self.buf, num_elems, self.depth)
172    }
173
174    pub fn serialize_vec1_iter<T, U>(self, vec: U) -> Result<(), SerializeError>
175    where
176        T: Tag,
177        U: IntoIterator,
178        U::IntoIter: ExactSizeIterator,
179        U::Item: Serialize<T>,
180    {
181        let vec = vec.into_iter();
182        let mut serializer = self.serialize_vec1(vec.len())?;
183
184        for elem in vec {
185            serializer.serialize(elem)?;
186        }
187
188        serializer.finish()
189    }
190
191    pub fn serialize_vec2(self) -> Result<Vec2Serializer<'a>, SerializeError> {
192        Vec2Serializer::new(self.buf, self.depth)
193    }
194
195    pub fn serialize_vec2_iter<T, U>(self, vec: U) -> Result<(), SerializeError>
196    where
197        T: Tag,
198        U: IntoIterator,
199        U::Item: Serialize<T>,
200    {
201        let mut serializer = self.serialize_vec2()?;
202
203        for elem in vec {
204            serializer.serialize(elem)?;
205        }
206
207        serializer.finish()
208    }
209
210    pub fn serialize_bytes1(
211        self,
212        num_elems: usize,
213    ) -> Result<Bytes1Serializer<'a>, SerializeError> {
214        Bytes1Serializer::new(self.buf, num_elems)
215    }
216
217    pub fn serialize_byte_slice1(self, bytes: &[u8]) -> Result<(), SerializeError> {
218        let mut serializer = self.serialize_bytes1(bytes.len())?;
219        serializer.serialize(bytes)?;
220        serializer.finish()
221    }
222
223    pub fn serialize_bytes2(self) -> Result<Bytes2Serializer<'a>, SerializeError> {
224        Bytes2Serializer::new(self.buf)
225    }
226
227    pub fn serialize_byte_slice2(self, bytes: &[u8]) -> Result<(), SerializeError> {
228        let mut serializer = self.serialize_bytes2()?;
229        serializer.serialize(bytes)?;
230        serializer.finish()
231    }
232
233    pub fn serialize_map1<K: KeyTag>(
234        self,
235        num_elems: usize,
236    ) -> Result<Map1Serializer<'a, K>, SerializeError> {
237        Map1Serializer::new(self.buf, num_elems, self.depth)
238    }
239
240    pub fn serialize_map1_iter<K, L, T, U, I>(self, map: I) -> Result<(), SerializeError>
241    where
242        K: KeyTag,
243        L: SerializeKey<K>,
244        T: Tag,
245        U: Serialize<T>,
246        I: IntoIterator<Item = (L, U)>,
247        I::IntoIter: ExactSizeIterator,
248    {
249        let map = map.into_iter();
250        let mut serializer = self.serialize_map1(map.len())?;
251
252        for (key, value) in map {
253            serializer.serialize(&key, value)?;
254        }
255
256        serializer.finish()
257    }
258
259    pub fn serialize_map2<K: KeyTag>(self) -> Result<Map2Serializer<'a, K>, SerializeError> {
260        Map2Serializer::new(self.buf, self.depth)
261    }
262
263    pub fn serialize_map2_iter<K, L, T, U, I>(self, map: I) -> Result<(), SerializeError>
264    where
265        K: KeyTag,
266        L: SerializeKey<K>,
267        T: Tag,
268        U: Serialize<T>,
269        I: IntoIterator<Item = (L, U)>,
270    {
271        let mut serializer = self.serialize_map2()?;
272
273        for (key, value) in map {
274            serializer.serialize(&key, value)?;
275        }
276
277        serializer.finish()
278    }
279
280    pub fn serialize_set1<K: KeyTag>(
281        self,
282        num_elems: usize,
283    ) -> Result<Set1Serializer<'a, K>, SerializeError> {
284        Set1Serializer::new(self.buf, num_elems)
285    }
286
287    pub fn serialize_set1_iter<K, T>(self, set: T) -> Result<(), SerializeError>
288    where
289        K: KeyTag,
290        T: IntoIterator,
291        T::IntoIter: ExactSizeIterator,
292        T::Item: SerializeKey<K>,
293    {
294        let set = set.into_iter();
295        let mut serializer = self.serialize_set1(set.len())?;
296
297        for value in set {
298            serializer.serialize(&value)?;
299        }
300
301        serializer.finish()
302    }
303
304    pub fn serialize_set2<K: KeyTag>(self) -> Result<Set2Serializer<'a, K>, SerializeError> {
305        Set2Serializer::new(self.buf)
306    }
307
308    pub fn serialize_set2_iter<K, T>(self, set: T) -> Result<(), SerializeError>
309    where
310        K: KeyTag,
311        T: IntoIterator,
312        T::Item: SerializeKey<K>,
313    {
314        let mut serializer = self.serialize_set2()?;
315
316        for value in set {
317            serializer.serialize(&value)?;
318        }
319
320        serializer.finish()
321    }
322
323    pub fn serialize_struct1(
324        self,
325        num_fields: usize,
326    ) -> Result<Struct1Serializer<'a>, SerializeError> {
327        Struct1Serializer::new(self.buf, num_fields, self.depth)
328    }
329
330    pub fn serialize_struct1_with_unknown_fields<T>(
331        self,
332        num_fields: usize,
333        unknown_fields: T,
334    ) -> Result<Struct1Serializer<'a>, SerializeError>
335    where
336        T: AsUnknownFields,
337        T::FieldsIter: ExactSizeIterator,
338    {
339        Struct1Serializer::with_unknown_fields(self.buf, num_fields, unknown_fields, self.depth)
340    }
341
342    pub fn serialize_struct2(self) -> Result<Struct2Serializer<'a>, SerializeError> {
343        Struct2Serializer::new(self.buf, self.depth)
344    }
345
346    pub fn serialize_struct2_with_unknown_fields(
347        self,
348        unknown_fields: impl AsUnknownFields,
349    ) -> Result<Struct2Serializer<'a>, SerializeError> {
350        Struct2Serializer::with_unknown_fields(self.buf, unknown_fields, self.depth)
351    }
352
353    pub fn serialize_enum<T: Tag>(
354        mut self,
355        id: impl Into<u32>,
356        value: impl Serialize<T>,
357    ) -> Result<(), SerializeError> {
358        self.increment_depth()?;
359        self.buf.put_discriminant_u8(ValueKind::Enum);
360        self.buf.put_varint_u32_le(id.into());
361        self.serialize(value)
362    }
363
364    pub fn serialize_unit_enum(self, id: impl Into<u32>) -> Result<(), SerializeError> {
365        self.serialize_enum::<tags::Unit>(id, ())
366    }
367
368    pub fn serialize_unknown_variant(
369        self,
370        variant: impl AsUnknownVariant,
371    ) -> Result<(), SerializeError> {
372        self.serialize_enum(variant.id(), variant.value())
373    }
374
375    pub fn serialize_sender(self, value: ChannelCookie) -> Result<(), SerializeError> {
376        self.buf.put_discriminant_u8(ValueKind::Sender);
377        self.buf.put_slice(value.0.as_bytes());
378        Ok(())
379    }
380
381    pub fn serialize_receiver(self, value: ChannelCookie) -> Result<(), SerializeError> {
382        self.buf.put_discriminant_u8(ValueKind::Receiver);
383        self.buf.put_slice(value.0.as_bytes());
384        Ok(())
385    }
386}
aldrin_core/serializer.rs

aldrin_core/
serializer.rs
