aldrin_core/deserializer/
vec.rs

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

aldrin_core/deserializer/
vec.rs
