aldrin_core/
value_deserializer.rs

1use crate::buf_ext::ValueBufExt;
2use crate::deserialize_key::DeserializeKey;
3use crate::error::DeserializeError;
4use crate::ids::{
5    ChannelCookie, ObjectCookie, ObjectId, ObjectUuid, ServiceCookie, ServiceId, ServiceUuid,
6};
7use crate::serialized_value::SerializedValueSlice;
8use crate::value::ValueKind;
9use crate::MAX_VALUE_DEPTH;
10use bytes::Buf;
11use std::iter;
12use std::marker::PhantomData;
13use uuid::Uuid;
14
15pub trait Deserialize: Sized {
16    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError>;
17}
18
19#[derive(Debug)]
20pub struct Deserializer<'a, 'b> {
21    buf: &'a mut &'b [u8],
22    depth: u8,
23}
24
25impl<'a, 'b> Deserializer<'a, 'b> {
26    pub(crate) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
27        let mut this = Self { buf, depth };
28        this.increment_depth()?;
29        Ok(this)
30    }
31
32    fn increment_depth(&mut self) -> Result<(), DeserializeError> {
33        self.depth += 1;
34        if self.depth <= MAX_VALUE_DEPTH {
35            Ok(())
36        } else {
37            Err(DeserializeError::TooDeeplyNested)
38        }
39    }
40
41    #[allow(clippy::len_without_is_empty)]
42    pub fn len(&self) -> Result<usize, DeserializeError> {
43        let mut buf = *self.buf;
44        Deserializer::new(&mut buf, self.depth - 1)?.skip()?;
45
46        // Determine the length by computing how far `skip()` has advanced `buf` compared to the
47        // original buffer `*self.buf`.
48        Ok(buf.as_ptr() as usize - (*self.buf).as_ptr() as usize)
49    }
50
51    pub fn split_off_serialized_value(self) -> Result<&'b SerializedValueSlice, DeserializeError> {
52        let len = self.len()?;
53        let res = SerializedValueSlice::new(&self.buf[..len]);
54        self.buf.advance(len);
55        Ok(res)
56    }
57
58    pub fn peek_value_kind(&self) -> Result<ValueKind, DeserializeError> {
59        self.buf.try_peek_discriminant_u8()
60    }
61
62    pub fn skip(self) -> Result<(), DeserializeError> {
63        match self.buf.try_get_discriminant_u8()? {
64            ValueKind::None => Ok(()),
65            ValueKind::Some => self.skip(),
66            ValueKind::Bool | ValueKind::U8 | ValueKind::I8 => self.buf.try_skip(1),
67            ValueKind::U16 => self.buf.try_skip_varint_le::<2>(),
68            ValueKind::I16 => self.buf.try_skip_varint_le::<2>(),
69            ValueKind::U32 => self.buf.try_skip_varint_le::<4>(),
70            ValueKind::I32 => self.buf.try_skip_varint_le::<4>(),
71            ValueKind::U64 => self.buf.try_skip_varint_le::<8>(),
72            ValueKind::I64 => self.buf.try_skip_varint_le::<8>(),
73            ValueKind::F32 => self.buf.try_skip(4),
74            ValueKind::F64 => self.buf.try_skip(8),
75            ValueKind::String => {
76                let len = self.buf.try_get_varint_u32_le()? as usize;
77                self.buf.try_skip(len)
78            }
79            ValueKind::Uuid | ValueKind::Sender | ValueKind::Receiver => self.buf.try_skip(16),
80            ValueKind::ObjectId => self.buf.try_skip(32),
81            ValueKind::ServiceId => self.buf.try_skip(64),
82            ValueKind::Vec => VecDeserializer::new_without_value_kind(self.buf, self.depth)?.skip(),
83            ValueKind::Bytes => BytesDeserializer::new_without_value_kind(self.buf)?.skip_all(),
84            ValueKind::U8Map => {
85                MapDeserializer::<u8>::new_without_value_kind(self.buf, self.depth)?.skip()
86            }
87            ValueKind::I8Map => {
88                MapDeserializer::<i8>::new_without_value_kind(self.buf, self.depth)?.skip()
89            }
90            ValueKind::U16Map => {
91                MapDeserializer::<u16>::new_without_value_kind(self.buf, self.depth)?.skip()
92            }
93            ValueKind::I16Map => {
94                MapDeserializer::<i16>::new_without_value_kind(self.buf, self.depth)?.skip()
95            }
96            ValueKind::U32Map => {
97                MapDeserializer::<u32>::new_without_value_kind(self.buf, self.depth)?.skip()
98            }
99            ValueKind::I32Map => {
100                MapDeserializer::<i32>::new_without_value_kind(self.buf, self.depth)?.skip()
101            }
102            ValueKind::U64Map => {
103                MapDeserializer::<u64>::new_without_value_kind(self.buf, self.depth)?.skip()
104            }
105            ValueKind::I64Map => {
106                MapDeserializer::<i64>::new_without_value_kind(self.buf, self.depth)?.skip()
107            }
108            ValueKind::StringMap => {
109                MapDeserializer::<String>::new_without_value_kind(self.buf, self.depth)?.skip()
110            }
111            ValueKind::UuidMap => {
112                MapDeserializer::<Uuid>::new_without_value_kind(self.buf, self.depth)?.skip()
113            }
114            ValueKind::U8Set => SetDeserializer::<u8>::new_without_value_kind(self.buf)?.skip(),
115            ValueKind::I8Set => SetDeserializer::<i8>::new_without_value_kind(self.buf)?.skip(),
116            ValueKind::U16Set => SetDeserializer::<u16>::new_without_value_kind(self.buf)?.skip(),
117            ValueKind::I16Set => SetDeserializer::<i16>::new_without_value_kind(self.buf)?.skip(),
118            ValueKind::U32Set => SetDeserializer::<u32>::new_without_value_kind(self.buf)?.skip(),
119            ValueKind::I32Set => SetDeserializer::<i32>::new_without_value_kind(self.buf)?.skip(),
120            ValueKind::U64Set => SetDeserializer::<u64>::new_without_value_kind(self.buf)?.skip(),
121            ValueKind::I64Set => SetDeserializer::<i64>::new_without_value_kind(self.buf)?.skip(),
122            ValueKind::StringSet => {
123                SetDeserializer::<String>::new_without_value_kind(self.buf)?.skip()
124            }
125            ValueKind::UuidSet => SetDeserializer::<Uuid>::new_without_value_kind(self.buf)?.skip(),
126            ValueKind::Struct => {
127                StructDeserializer::new_without_value_kind(self.buf, self.depth)?.skip()
128            }
129            ValueKind::Enum => {
130                EnumDeserializer::new_without_value_kind(self.buf, self.depth)?.skip()
131            }
132        }
133    }
134
135    pub fn deserialize_none(self) -> Result<(), DeserializeError> {
136        self.buf.ensure_discriminant_u8(ValueKind::None)
137    }
138
139    pub fn deserialize_some<T: Deserialize>(mut self) -> Result<T, DeserializeError> {
140        self.increment_depth()?;
141        self.buf.ensure_discriminant_u8(ValueKind::Some)?;
142        T::deserialize(self)
143    }
144
145    pub fn deserialize_option<T: Deserialize>(mut self) -> Result<Option<T>, DeserializeError> {
146        self.increment_depth()?;
147        match self.buf.try_get_discriminant_u8()? {
148            ValueKind::Some => T::deserialize(self).map(Some),
149            ValueKind::None => Ok(None),
150            _ => Err(DeserializeError::UnexpectedValue),
151        }
152    }
153
154    pub fn deserialize_bool(self) -> Result<bool, DeserializeError> {
155        self.buf.ensure_discriminant_u8(ValueKind::Bool)?;
156        self.buf.try_get_u8().map(|v| v != 0)
157    }
158
159    pub fn deserialize_u8(self) -> Result<u8, DeserializeError> {
160        self.buf.ensure_discriminant_u8(ValueKind::U8)?;
161        self.buf.try_get_u8()
162    }
163
164    pub fn deserialize_i8(self) -> Result<i8, DeserializeError> {
165        self.buf.ensure_discriminant_u8(ValueKind::I8)?;
166        self.buf.try_get_i8()
167    }
168
169    pub fn deserialize_u16(self) -> Result<u16, DeserializeError> {
170        self.buf.ensure_discriminant_u8(ValueKind::U16)?;
171        self.buf.try_get_varint_u16_le()
172    }
173
174    pub fn deserialize_i16(self) -> Result<i16, DeserializeError> {
175        self.buf.ensure_discriminant_u8(ValueKind::I16)?;
176        self.buf.try_get_varint_i16_le()
177    }
178
179    pub fn deserialize_u32(self) -> Result<u32, DeserializeError> {
180        self.buf.ensure_discriminant_u8(ValueKind::U32)?;
181        self.buf.try_get_varint_u32_le()
182    }
183
184    pub fn deserialize_i32(self) -> Result<i32, DeserializeError> {
185        self.buf.ensure_discriminant_u8(ValueKind::I32)?;
186        self.buf.try_get_varint_i32_le()
187    }
188
189    pub fn deserialize_u64(self) -> Result<u64, DeserializeError> {
190        self.buf.ensure_discriminant_u8(ValueKind::U64)?;
191        self.buf.try_get_varint_u64_le()
192    }
193
194    pub fn deserialize_i64(self) -> Result<i64, DeserializeError> {
195        self.buf.ensure_discriminant_u8(ValueKind::I64)?;
196        self.buf.try_get_varint_i64_le()
197    }
198
199    pub fn deserialize_f32(self) -> Result<f32, DeserializeError> {
200        self.buf.ensure_discriminant_u8(ValueKind::F32)?;
201        self.buf.try_get_u32_le().map(f32::from_bits)
202    }
203
204    pub fn deserialize_f64(self) -> Result<f64, DeserializeError> {
205        self.buf.ensure_discriminant_u8(ValueKind::F64)?;
206        self.buf.try_get_u64_le().map(f64::from_bits)
207    }
208
209    pub fn deserialize_string(self) -> Result<String, DeserializeError> {
210        self.buf.ensure_discriminant_u8(ValueKind::String)?;
211        let len = self.buf.try_get_varint_u32_le()? as usize;
212        let bytes = self.buf.try_copy_to_bytes(len)?.into();
213        String::from_utf8(bytes).map_err(|_| DeserializeError::InvalidSerialization)
214    }
215
216    pub fn deserialize_uuid(self) -> Result<Uuid, DeserializeError> {
217        self.buf.ensure_discriminant_u8(ValueKind::Uuid)?;
218        let mut bytes = uuid::Bytes::default();
219        self.buf.try_copy_to_slice(&mut bytes)?;
220        Ok(Uuid::from_bytes(bytes))
221    }
222
223    pub fn deserialize_object_id(self) -> Result<ObjectId, DeserializeError> {
224        self.buf.ensure_discriminant_u8(ValueKind::ObjectId)?;
225        let mut bytes = uuid::Bytes::default();
226
227        self.buf.try_copy_to_slice(&mut bytes)?;
228        let uuid = ObjectUuid(Uuid::from_bytes(bytes));
229
230        self.buf.try_copy_to_slice(&mut bytes)?;
231        let cookie = ObjectCookie(Uuid::from_bytes(bytes));
232
233        Ok(ObjectId::new(uuid, cookie))
234    }
235
236    pub fn deserialize_service_id(self) -> Result<ServiceId, DeserializeError> {
237        self.buf.ensure_discriminant_u8(ValueKind::ServiceId)?;
238        let mut bytes = uuid::Bytes::default();
239
240        self.buf.try_copy_to_slice(&mut bytes)?;
241        let object_uuid = ObjectUuid(Uuid::from_bytes(bytes));
242
243        self.buf.try_copy_to_slice(&mut bytes)?;
244        let object_cookie = ObjectCookie(Uuid::from_bytes(bytes));
245
246        self.buf.try_copy_to_slice(&mut bytes)?;
247        let service_uuid = ServiceUuid(Uuid::from_bytes(bytes));
248
249        self.buf.try_copy_to_slice(&mut bytes)?;
250        let service_cookie = ServiceCookie(Uuid::from_bytes(bytes));
251
252        Ok(ServiceId::new(
253            ObjectId::new(object_uuid, object_cookie),
254            service_uuid,
255            service_cookie,
256        ))
257    }
258
259    pub fn deserialize_vec(self) -> Result<VecDeserializer<'a, 'b>, DeserializeError> {
260        VecDeserializer::new(self.buf, self.depth)
261    }
262
263    pub fn deserialize_vec_extend<V, T>(self, vec: &mut V) -> Result<(), DeserializeError>
264    where
265        V: Extend<T>,
266        T: Deserialize,
267    {
268        self.deserialize_vec()?.deserialize_extend(vec)
269    }
270
271    pub fn deserialize_vec_extend_new<V, T>(self) -> Result<V, DeserializeError>
272    where
273        V: Extend<T> + Default,
274        T: Deserialize,
275    {
276        let mut vec = V::default();
277        self.deserialize_vec()?.deserialize_extend(&mut vec)?;
278        Ok(vec)
279    }
280
281    pub fn deserialize_bytes(self) -> Result<BytesDeserializer<'a, 'b>, DeserializeError> {
282        BytesDeserializer::new(self.buf)
283    }
284
285    pub fn deserialize_bytes_to_vec(self) -> Result<Vec<u8>, DeserializeError> {
286        BytesDeserializer::new(self.buf)?.deserialize_all_to_vec()
287    }
288
289    pub fn deserialize_map<K: DeserializeKey>(
290        self,
291    ) -> Result<MapDeserializer<'a, 'b, K>, DeserializeError> {
292        MapDeserializer::new(self.buf, self.depth)
293    }
294
295    pub fn deserialize_map_extend<T, K, V>(self, map: &mut T) -> Result<(), DeserializeError>
296    where
297        T: Extend<(K, V)>,
298        K: DeserializeKey,
299        V: Deserialize,
300    {
301        MapDeserializer::new(self.buf, self.depth)?.deserialize_extend(map)
302    }
303
304    pub fn deserialize_map_extend_new<T, K, V>(self) -> Result<T, DeserializeError>
305    where
306        T: Extend<(K, V)> + Default,
307        K: DeserializeKey,
308        V: Deserialize,
309    {
310        let mut map = T::default();
311        MapDeserializer::new(self.buf, self.depth)?.deserialize_extend(&mut map)?;
312        Ok(map)
313    }
314
315    pub fn deserialize_set<T: DeserializeKey>(
316        self,
317    ) -> Result<SetDeserializer<'a, 'b, T>, DeserializeError> {
318        SetDeserializer::new(self.buf)
319    }
320
321    pub fn deserialize_set_extend<T, S>(self, set: &mut S) -> Result<(), DeserializeError>
322    where
323        S: Extend<T>,
324        T: DeserializeKey,
325    {
326        SetDeserializer::new(self.buf)?.deserialize_extend(set)
327    }
328
329    pub fn deserialize_set_extend_new<T, S>(self) -> Result<S, DeserializeError>
330    where
331        S: Extend<T> + Default,
332        T: DeserializeKey,
333    {
334        let mut set = S::default();
335        SetDeserializer::new(self.buf)?.deserialize_extend(&mut set)?;
336        Ok(set)
337    }
338
339    pub fn deserialize_struct(self) -> Result<StructDeserializer<'a, 'b>, DeserializeError> {
340        StructDeserializer::new(self.buf, self.depth)
341    }
342
343    pub fn deserialize_enum(self) -> Result<EnumDeserializer<'a, 'b>, DeserializeError> {
344        EnumDeserializer::new(self.buf, self.depth)
345    }
346
347    pub fn deserialize_sender(self) -> Result<ChannelCookie, DeserializeError> {
348        self.buf.ensure_discriminant_u8(ValueKind::Sender)?;
349        let mut bytes = uuid::Bytes::default();
350        self.buf.try_copy_to_slice(&mut bytes)?;
351        Ok(ChannelCookie(Uuid::from_bytes(bytes)))
352    }
353
354    pub fn deserialize_receiver(self) -> Result<ChannelCookie, DeserializeError> {
355        self.buf.ensure_discriminant_u8(ValueKind::Receiver)?;
356        let mut bytes = uuid::Bytes::default();
357        self.buf.try_copy_to_slice(&mut bytes)?;
358        Ok(ChannelCookie(Uuid::from_bytes(bytes)))
359    }
360}
361
362#[derive(Debug)]
363pub struct VecDeserializer<'a, 'b> {
364    buf: &'a mut &'b [u8],
365    num_elems: u32,
366    depth: u8,
367}
368
369impl<'a, 'b> VecDeserializer<'a, 'b> {
370    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
371        buf.ensure_discriminant_u8(ValueKind::Vec)?;
372        Self::new_without_value_kind(buf, depth)
373    }
374
375    fn new_without_value_kind(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
376        let num_elems = buf.try_get_varint_u32_le()?;
377        Ok(Self {
378            buf,
379            num_elems,
380            depth,
381        })
382    }
383
384    pub fn remaining_elements(&self) -> usize {
385        self.num_elems as usize
386    }
387
388    pub fn has_more_elements(&self) -> bool {
389        self.num_elems > 0
390    }
391
392    pub fn deserialize_element<T>(&mut self) -> Result<T, DeserializeError>
393    where
394        T: Deserialize,
395    {
396        if self.has_more_elements() {
397            self.num_elems -= 1;
398            T::deserialize(Deserializer::new(self.buf, self.depth)?)
399        } else {
400            Err(DeserializeError::NoMoreElements)
401        }
402    }
403
404    pub fn deserialize_extend<V, T>(mut self, vec: &mut V) -> Result<(), DeserializeError>
405    where
406        V: Extend<T>,
407        T: Deserialize,
408    {
409        while self.has_more_elements() {
410            let elem = self.deserialize_element()?;
411            vec.extend(iter::once(elem));
412        }
413
414        Ok(())
415    }
416
417    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
418        if self.num_elems > 0 {
419            self.num_elems -= 1;
420            Deserializer::new(self.buf, self.depth)?.skip()
421        } else {
422            Err(DeserializeError::NoMoreElements)
423        }
424    }
425
426    pub fn skip(mut self) -> Result<(), DeserializeError> {
427        while self.has_more_elements() {
428            self.skip_element()?;
429        }
430
431        Ok(())
432    }
433}
434
435#[derive(Debug)]
436pub struct BytesDeserializer<'a, 'b> {
437    buf: &'a mut &'b [u8],
438    len: u32,
439}
440
441impl<'a, 'b> BytesDeserializer<'a, 'b> {
442    fn new(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
443        buf.ensure_discriminant_u8(ValueKind::Bytes)?;
444        Self::new_without_value_kind(buf)
445    }
446
447    fn new_without_value_kind(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
448        let len = buf.try_get_varint_u32_le()?;
449        Ok(Self { buf, len })
450    }
451
452    pub fn len(&self) -> usize {
453        self.len as usize
454    }
455
456    pub fn is_empty(&self) -> bool {
457        self.len == 0
458    }
459
460    pub fn deserialize(&mut self, dst: &mut [u8]) -> Result<(), DeserializeError> {
461        if dst.len() <= self.len as usize {
462            self.buf.try_copy_to_slice(dst)?;
463            self.len -= dst.len() as u32;
464            Ok(())
465        } else {
466            Err(DeserializeError::NoMoreElements)
467        }
468    }
469
470    pub fn deserialize_to_vec(&mut self, len: usize) -> Result<Vec<u8>, DeserializeError> {
471        if self.len as usize >= len {
472            let bytes = self.buf.try_copy_to_bytes(self.len as usize)?;
473            self.len -= len as u32;
474            Ok(Vec::from(bytes))
475        } else {
476            Err(DeserializeError::NoMoreElements)
477        }
478    }
479
480    pub fn deserialize_all_to_vec(mut self) -> Result<Vec<u8>, DeserializeError> {
481        self.deserialize_to_vec(self.len as usize)
482    }
483
484    pub fn skip(&mut self, len: usize) -> Result<(), DeserializeError> {
485        if self.len as usize >= len {
486            self.buf.try_skip(len)?;
487            self.len -= len as u32;
488            Ok(())
489        } else {
490            Err(DeserializeError::NoMoreElements)
491        }
492    }
493
494    pub fn skip_all(mut self) -> Result<(), DeserializeError> {
495        self.skip(self.len as usize)
496    }
497}
498
499#[derive(Debug)]
500pub struct MapDeserializer<'a, 'b, K: DeserializeKey> {
501    buf: &'a mut &'b [u8],
502    num_elems: u32,
503    depth: u8,
504    _key: PhantomData<K>,
505}
506
507impl<'a, 'b, K: DeserializeKey> MapDeserializer<'a, 'b, K> {
508    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
509        K::deserialize_map_value_kind(buf)?;
510        Self::new_without_value_kind(buf, depth)
511    }
512
513    fn new_without_value_kind(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
514        let num_elems = buf.try_get_varint_u32_le()?;
515
516        Ok(Self {
517            buf,
518            num_elems,
519            depth,
520            _key: PhantomData,
521        })
522    }
523
524    pub fn remaining_elements(&self) -> usize {
525        self.num_elems as usize
526    }
527
528    pub fn has_more_elements(&self) -> bool {
529        self.num_elems > 0
530    }
531
532    pub fn deserialize_element(
533        &mut self,
534    ) -> Result<ElementDeserializer<'_, 'b, K>, DeserializeError> {
535        if self.has_more_elements() {
536            self.num_elems -= 1;
537            ElementDeserializer::new(self.buf, self.depth)
538        } else {
539            Err(DeserializeError::NoMoreElements)
540        }
541    }
542
543    pub fn deserialize_extend<T, V>(mut self, map: &mut T) -> Result<(), DeserializeError>
544    where
545        T: Extend<(K, V)>,
546        V: Deserialize,
547    {
548        while self.has_more_elements() {
549            let kv = self.deserialize_element()?.deserialize()?;
550            map.extend(iter::once(kv));
551        }
552
553        Ok(())
554    }
555
556    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
557        if self.has_more_elements() {
558            self.num_elems -= 1;
559            K::skip(self.buf)?;
560            Deserializer::new(self.buf, self.depth)?.skip()
561        } else {
562            Err(DeserializeError::NoMoreElements)
563        }
564    }
565
566    pub fn skip(mut self) -> Result<(), DeserializeError> {
567        while self.has_more_elements() {
568            self.skip_element()?;
569        }
570
571        Ok(())
572    }
573}
574
575#[derive(Debug)]
576pub struct ElementDeserializer<'a, 'b, K: DeserializeKey> {
577    buf: &'a mut &'b [u8],
578    key: K,
579    depth: u8,
580}
581
582impl<'a, 'b, K: DeserializeKey> ElementDeserializer<'a, 'b, K> {
583    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
584        let key = K::deserialize_key(buf)?;
585        Ok(Self { buf, key, depth })
586    }
587
588    pub fn key(&self) -> &K {
589        &self.key
590    }
591
592    pub fn deserialize<T: Deserialize>(self) -> Result<(K, T), DeserializeError> {
593        let value = T::deserialize(Deserializer::new(self.buf, self.depth)?)?;
594        Ok((self.key, value))
595    }
596
597    pub fn skip(self) -> Result<(), DeserializeError> {
598        Deserializer::new(self.buf, self.depth)?.skip()
599    }
600}
601
602#[derive(Debug)]
603pub struct SetDeserializer<'a, 'b, T: DeserializeKey> {
604    buf: &'a mut &'b [u8],
605    num_elems: u32,
606    _key: PhantomData<T>,
607}
608
609impl<'a, 'b, T: DeserializeKey> SetDeserializer<'a, 'b, T> {
610    fn new(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
611        T::deserialize_set_value_kind(buf)?;
612        Self::new_without_value_kind(buf)
613    }
614
615    fn new_without_value_kind(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
616        let num_elems = buf.try_get_varint_u32_le()?;
617
618        Ok(Self {
619            buf,
620            num_elems,
621            _key: PhantomData,
622        })
623    }
624
625    pub fn remaining_elements(&self) -> usize {
626        self.num_elems as usize
627    }
628
629    pub fn has_more_elements(&self) -> bool {
630        self.num_elems > 0
631    }
632
633    pub fn deserialize_element(&mut self) -> Result<T, DeserializeError> {
634        if self.has_more_elements() {
635            self.num_elems -= 1;
636            T::deserialize_key(self.buf)
637        } else {
638            Err(DeserializeError::NoMoreElements)
639        }
640    }
641
642    pub fn deserialize_extend<S>(mut self, set: &mut S) -> Result<(), DeserializeError>
643    where
644        S: Extend<T>,
645    {
646        while self.has_more_elements() {
647            let kv = self.deserialize_element()?;
648            set.extend(iter::once(kv));
649        }
650
651        Ok(())
652    }
653
654    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
655        if self.num_elems > 0 {
656            self.num_elems -= 1;
657            T::skip(self.buf)
658        } else {
659            Err(DeserializeError::NoMoreElements)
660        }
661    }
662
663    pub fn skip(mut self) -> Result<(), DeserializeError> {
664        while self.has_more_elements() {
665            self.skip_element()?;
666        }
667
668        Ok(())
669    }
670}
671
672#[derive(Debug)]
673pub struct StructDeserializer<'a, 'b> {
674    buf: &'a mut &'b [u8],
675    num_fields: u32,
676    depth: u8,
677}
678
679impl<'a, 'b> StructDeserializer<'a, 'b> {
680    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
681        buf.ensure_discriminant_u8(ValueKind::Struct)?;
682        Self::new_without_value_kind(buf, depth)
683    }
684
685    fn new_without_value_kind(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
686        let num_fields = buf.try_get_varint_u32_le()?;
687        Ok(Self {
688            buf,
689            num_fields,
690            depth,
691        })
692    }
693
694    pub fn remaining_fields(&self) -> usize {
695        self.num_fields as usize
696    }
697
698    pub fn has_more_fields(&self) -> bool {
699        self.num_fields > 0
700    }
701
702    pub fn deserialize_field(&mut self) -> Result<FieldDeserializer<'_, 'b>, DeserializeError> {
703        if self.has_more_fields() {
704            self.num_fields -= 1;
705            FieldDeserializer::new(self.buf, self.depth)
706        } else {
707            Err(DeserializeError::NoMoreElements)
708        }
709    }
710
711    pub fn skip(mut self) -> Result<(), DeserializeError> {
712        while self.has_more_fields() {
713            self.deserialize_field()?.skip()?;
714        }
715
716        Ok(())
717    }
718}
719
720#[derive(Debug)]
721pub struct FieldDeserializer<'a, 'b> {
722    buf: &'a mut &'b [u8],
723    id: u32,
724    depth: u8,
725}
726
727impl<'a, 'b> FieldDeserializer<'a, 'b> {
728    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
729        let id = buf.try_get_varint_u32_le()?;
730        Ok(Self { buf, id, depth })
731    }
732
733    pub fn id(&self) -> u32 {
734        self.id
735    }
736
737    pub fn deserialize<T: Deserialize>(self) -> Result<T, DeserializeError> {
738        T::deserialize(Deserializer::new(self.buf, self.depth)?)
739    }
740
741    pub fn skip(self) -> Result<(), DeserializeError> {
742        Deserializer::new(self.buf, self.depth)?.skip()
743    }
744}
745
746#[derive(Debug)]
747pub struct EnumDeserializer<'a, 'b> {
748    buf: &'a mut &'b [u8],
749    variant: u32,
750    depth: u8,
751}
752
753impl<'a, 'b> EnumDeserializer<'a, 'b> {
754    fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
755        buf.ensure_discriminant_u8(ValueKind::Enum)?;
756        Self::new_without_value_kind(buf, depth)
757    }
758
759    fn new_without_value_kind(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
760        let variant = buf.try_get_varint_u32_le()?;
761        Ok(Self {
762            buf,
763            variant,
764            depth,
765        })
766    }
767
768    pub fn variant(&self) -> u32 {
769        self.variant
770    }
771
772    pub fn deserialize<T: Deserialize>(self) -> Result<T, DeserializeError> {
773        T::deserialize(Deserializer::new(self.buf, self.depth)?)
774    }
775
776    pub fn skip(self) -> Result<(), DeserializeError> {
777        Deserializer::new(self.buf, self.depth)?.skip()
778    }
779}
aldrin_core/value_deserializer.rs

aldrin_core/
value_deserializer.rs
