aldrin_core/deserializer/
struct_.rs

1use super::Deserializer;
2use crate::buf_ext::ValueBufExt;
3use crate::tags::Tag;
4use crate::{Deserialize, DeserializeError, UnknownFields, ValueKind};
5
6#[derive(Debug)]
7pub enum StructDeserializer<'a, 'b> {
8    V1(Struct1Deserializer<'a, 'b>),
9    V2(Struct2Deserializer<'a, 'b>),
10}
11
12impl<'a, 'b> StructDeserializer<'a, 'b> {
13    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
14        match buf.try_get_discriminant_u8()? {
15            ValueKind::Struct1 => {
16                Struct1Deserializer::new_without_value_kind(buf, depth).map(Self::V1)
17            }
18
19            ValueKind::Struct2 => {
20                Struct2Deserializer::new_without_value_kind(buf, depth).map(Self::V2)
21            }
22
23            _ => Err(DeserializeError::UnexpectedValue),
24        }
25    }
26
27    pub fn deserialize(&mut self) -> Result<Option<FieldDeserializer<'_, 'b>>, DeserializeError> {
28        match self {
29            Self::V1(deserializer) => deserializer.deserialize(),
30            Self::V2(deserializer) => deserializer.deserialize(),
31        }
32    }
33
34    pub fn deserialize_specific_field<T: Tag, U: Deserialize<T>>(
35        &mut self,
36        id: impl Into<u32>,
37    ) -> Result<U, DeserializeError> {
38        match self {
39            Self::V1(deserializer) => deserializer.deserialize_specific_field(id),
40            Self::V2(deserializer) => deserializer.deserialize_specific_field(id),
41        }
42    }
43
44    pub fn skip(self) -> Result<(), DeserializeError> {
45        match self {
46            Self::V1(deserializer) => deserializer.skip(),
47            Self::V2(deserializer) => deserializer.skip(),
48        }
49    }
50
51    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
52        match self {
53            Self::V1(deserializer) => deserializer.finish(t),
54            Self::V2(deserializer) => deserializer.finish(t),
55        }
56    }
57
58    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
59    where
60        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
61    {
62        match self {
63            Self::V1(deserializer) => deserializer.finish_with(f),
64            Self::V2(deserializer) => deserializer.finish_with(f),
65        }
66    }
67
68    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
69        match self {
70            Self::V1(deserializer) => deserializer.skip_and_finish(t),
71            Self::V2(deserializer) => deserializer.skip_and_finish(t),
72        }
73    }
74
75    pub fn skip_and_finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
76    where
77        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
78    {
79        match self {
80            Self::V1(deserializer) => deserializer.skip_and_finish_with(f),
81            Self::V2(deserializer) => deserializer.skip_and_finish_with(f),
82        }
83    }
84}
85
86#[derive(Debug)]
87pub struct Struct1Deserializer<'a, 'b> {
88    buf: &'a mut &'b [u8],
89    len: u32,
90    depth: u8,
91    unknown_fields: UnknownFields,
92}
93
94impl<'a, 'b> Struct1Deserializer<'a, 'b> {
95    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
96        buf.ensure_discriminant_u8(ValueKind::Struct1)?;
97        Self::new_without_value_kind(buf, depth)
98    }
99
100    pub(super) fn new_without_value_kind(
101        buf: &'a mut &'b [u8],
102        depth: u8,
103    ) -> Result<Self, DeserializeError> {
104        let len = buf.try_get_varint_u32_le()?;
105
106        Ok(Self {
107            buf,
108            len,
109            depth,
110            unknown_fields: UnknownFields::new(),
111        })
112    }
113
114    pub fn len(&self) -> usize {
115        self.len as usize
116    }
117
118    pub fn is_empty(&self) -> bool {
119        self.len == 0
120    }
121
122    pub fn deserialize(&mut self) -> Result<Option<FieldDeserializer<'_, 'b>>, DeserializeError> {
123        if self.is_empty() {
124            Ok(None)
125        } else {
126            self.len -= 1;
127            FieldDeserializer::new(self.buf, self.depth, &mut self.unknown_fields).map(Some)
128        }
129    }
130
131    pub fn deserialize_specific_field<T: Tag, U: Deserialize<T>>(
132        &mut self,
133        id: impl Into<u32>,
134    ) -> Result<U, DeserializeError> {
135        let field = self
136            .deserialize()?
137            .ok_or(DeserializeError::InvalidSerialization)?;
138
139        if field.id() == id.into() {
140            field.deserialize()
141        } else {
142            Err(DeserializeError::InvalidSerialization)
143        }
144    }
145
146    pub fn skip(mut self) -> Result<(), DeserializeError> {
147        while let Some(field) = self.deserialize()? {
148            field.skip()?;
149        }
150
151        Ok(())
152    }
153
154    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
155        self.finish_with(|_| Ok(t))
156    }
157
158    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
159    where
160        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
161    {
162        if self.is_empty() {
163            f(self.unknown_fields)
164        } else {
165            Err(DeserializeError::MoreElementsRemain)
166        }
167    }
168
169    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
170        self.skip_and_finish_with(|_| Ok(t))
171    }
172
173    pub fn skip_and_finish_with<T, F>(mut self, f: F) -> Result<T, DeserializeError>
174    where
175        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
176    {
177        while let Some(field) = self.deserialize()? {
178            field.skip()?;
179        }
180
181        f(self.unknown_fields)
182    }
183}
184
185#[derive(Debug)]
186pub struct Struct2Deserializer<'a, 'b> {
187    buf: &'a mut &'b [u8],
188    empty: bool,
189    depth: u8,
190    unknown_fields: UnknownFields,
191}
192
193impl<'a, 'b> Struct2Deserializer<'a, 'b> {
194    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
195        buf.ensure_discriminant_u8(ValueKind::Struct2)?;
196        Self::new_without_value_kind(buf, depth)
197    }
198
199    pub(super) fn new_without_value_kind(
200        buf: &'a mut &'b [u8],
201        depth: u8,
202    ) -> Result<Self, DeserializeError> {
203        Ok(Self {
204            buf,
205            empty: false,
206            depth,
207            unknown_fields: UnknownFields::new(),
208        })
209    }
210
211    pub fn deserialize(&mut self) -> Result<Option<FieldDeserializer<'_, 'b>>, DeserializeError> {
212        if self.empty {
213            Ok(None)
214        } else {
215            match self.buf.try_get_discriminant_u8()? {
216                ValueKind::None => {
217                    self.empty = true;
218                    Ok(None)
219                }
220
221                ValueKind::Some => {
222                    FieldDeserializer::new(self.buf, self.depth, &mut self.unknown_fields).map(Some)
223                }
224
225                _ => Err(DeserializeError::InvalidSerialization),
226            }
227        }
228    }
229
230    pub fn deserialize_specific_field<T: Tag, U: Deserialize<T>>(
231        &mut self,
232        id: impl Into<u32>,
233    ) -> Result<U, DeserializeError> {
234        let field = self
235            .deserialize()?
236            .ok_or(DeserializeError::InvalidSerialization)?;
237
238        if field.id() == id.into() {
239            field.deserialize()
240        } else {
241            Err(DeserializeError::InvalidSerialization)
242        }
243    }
244
245    pub fn skip(mut self) -> Result<(), DeserializeError> {
246        while let Some(field) = self.deserialize()? {
247            field.skip()?;
248        }
249
250        Ok(())
251    }
252
253    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
254        self.finish_with(|_| Ok(t))
255    }
256
257    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
258    where
259        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
260    {
261        if self.empty {
262            f(self.unknown_fields)
263        } else {
264            match self.buf.try_get_discriminant_u8()? {
265                ValueKind::None => f(self.unknown_fields),
266                ValueKind::Some => Err(DeserializeError::MoreElementsRemain),
267                _ => Err(DeserializeError::InvalidSerialization),
268            }
269        }
270    }
271
272    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
273        self.skip_and_finish_with(|_| Ok(t))
274    }
275
276    pub fn skip_and_finish_with<T, F>(mut self, f: F) -> Result<T, DeserializeError>
277    where
278        F: FnOnce(UnknownFields) -> Result<T, DeserializeError>,
279    {
280        while let Some(field) = self.deserialize()? {
281            field.skip()?;
282        }
283
284        f(self.unknown_fields)
285    }
286}
287
288#[derive(Debug)]
289pub struct FieldDeserializer<'a, 'b> {
290    buf: &'a mut &'b [u8],
291    id: u32,
292    depth: u8,
293    unknown_fields: &'a mut UnknownFields,
294}
295
296impl<'a, 'b> FieldDeserializer<'a, 'b> {
297    fn new(
298        buf: &'a mut &'b [u8],
299        depth: u8,
300        unknown_fields: &'a mut UnknownFields,
301    ) -> Result<Self, DeserializeError> {
302        let id = buf.try_get_varint_u32_le()?;
303
304        Ok(Self {
305            buf,
306            id,
307            depth,
308            unknown_fields,
309        })
310    }
311
312    pub fn id(&self) -> u32 {
313        self.id
314    }
315
316    pub fn try_id<T: TryFrom<u32>>(&self) -> Result<T, DeserializeError> {
317        self.id
318            .try_into()
319            .map_err(|_| DeserializeError::InvalidSerialization)
320    }
321
322    pub fn deserialize<T: Tag, U: Deserialize<T>>(self) -> Result<U, DeserializeError> {
323        Deserializer::new(self.buf, self.depth)?.deserialize()
324    }
325
326    pub fn skip(self) -> Result<(), DeserializeError> {
327        Deserializer::new(self.buf, self.depth)?.skip()
328    }
329
330    pub fn add_to_unknown_fields(self) -> Result<(), DeserializeError> {
331        let deserializer = Deserializer::new(self.buf, self.depth)?;
332        let value = deserializer.deserialize()?;
333        self.unknown_fields.insert(self.id, value);
334        Ok(())
335    }
336}
aldrin_core/deserializer/struct_.rs

aldrin_core/deserializer/
struct_.rs
