aldrin_core/
value_deserializer.rs

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

aldrin_core/
value_deserializer.rs
