aldrin_core/deserializer/
map.rs

1use super::Deserializer;
2use crate::buf_ext::ValueBufExt;
3use crate::tags::{KeyTag, KeyTagImpl, Tag};
4use crate::{Deserialize, DeserializeError, DeserializeKey, ValueKind};
5use std::marker::PhantomData;
6use std::{fmt, iter};
7
8#[derive(Debug)]
9pub enum MapDeserializer<'a, 'b, K> {
10    V1(Map1Deserializer<'a, 'b, K>),
11    V2(Map2Deserializer<'a, 'b, K>),
12}
13
14impl<'a, 'b, K: KeyTag> MapDeserializer<'a, 'b, K> {
15    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
16        let kind = buf.try_get_discriminant_u8::<ValueKind>()?;
17
18        if kind == K::Impl::VALUE_KIND_MAP1 {
19            Map1Deserializer::new_without_value_kind(buf, depth).map(Self::V1)
20        } else if kind == K::Impl::VALUE_KIND_MAP2 {
21            Map2Deserializer::new_without_value_kind(buf, depth).map(Self::V2)
22        } else {
23            Err(DeserializeError::UnexpectedValue)
24        }
25    }
26
27    pub fn deserialize<L: DeserializeKey<K>>(
28        &mut self,
29    ) -> Result<Option<MapElementDeserializer<'_, 'b, L>>, DeserializeError> {
30        match self {
31            Self::V1(deserializer) => deserializer.deserialize(),
32            Self::V2(deserializer) => deserializer.deserialize(),
33        }
34    }
35
36    pub fn deserialize_element<L, T, U>(&mut self) -> Result<Option<(L, U)>, DeserializeError>
37    where
38        L: DeserializeKey<K>,
39        T: Tag,
40        U: Deserialize<T>,
41    {
42        match self {
43            Self::V1(deserializer) => deserializer.deserialize_element(),
44            Self::V2(deserializer) => deserializer.deserialize_element(),
45        }
46    }
47
48    pub fn deserialize_extend<L, T, U, V>(self, map: &mut V) -> Result<(), DeserializeError>
49    where
50        L: DeserializeKey<K>,
51        T: Tag,
52        U: Deserialize<T>,
53        V: Extend<(L, U)>,
54    {
55        match self {
56            Self::V1(deserializer) => deserializer.deserialize_extend(map),
57            Self::V2(deserializer) => deserializer.deserialize_extend(map),
58        }
59    }
60
61    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
62        match self {
63            Self::V1(deserializer) => deserializer.skip_element(),
64            Self::V2(deserializer) => deserializer.skip_element(),
65        }
66    }
67
68    pub fn skip(self) -> Result<(), DeserializeError> {
69        match self {
70            Self::V1(deserializer) => deserializer.skip(),
71            Self::V2(deserializer) => deserializer.skip(),
72        }
73    }
74
75    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
76        match self {
77            Self::V1(deserializer) => deserializer.finish(t),
78            Self::V2(deserializer) => deserializer.finish(t),
79        }
80    }
81
82    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
83    where
84        F: FnOnce() -> Result<T, DeserializeError>,
85    {
86        match self {
87            Self::V1(deserializer) => deserializer.finish_with(f),
88            Self::V2(deserializer) => deserializer.finish_with(f),
89        }
90    }
91
92    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
93        match self {
94            Self::V1(deserializer) => deserializer.skip_and_finish(t),
95            Self::V2(deserializer) => deserializer.skip_and_finish(t),
96        }
97    }
98
99    pub fn skip_and_finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
100    where
101        F: FnOnce() -> Result<T, DeserializeError>,
102    {
103        match self {
104            Self::V1(deserializer) => deserializer.skip_and_finish_with(f),
105            Self::V2(deserializer) => deserializer.skip_and_finish_with(f),
106        }
107    }
108}
109
110pub struct Map1Deserializer<'a, 'b, K> {
111    buf: &'a mut &'b [u8],
112    len: u32,
113    depth: u8,
114    _key: PhantomData<K>,
115}
116
117impl<'a, 'b, K: KeyTag> Map1Deserializer<'a, 'b, K> {
118    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
119        buf.ensure_discriminant_u8(K::Impl::VALUE_KIND_MAP1)?;
120        Self::new_without_value_kind(buf, depth)
121    }
122
123    pub(super) fn new_without_value_kind(
124        buf: &'a mut &'b [u8],
125        depth: u8,
126    ) -> Result<Self, DeserializeError> {
127        let len = buf.try_get_varint_u32_le()?;
128
129        Ok(Self {
130            buf,
131            len,
132            depth,
133            _key: PhantomData,
134        })
135    }
136
137    pub fn len(&self) -> usize {
138        self.len as usize
139    }
140
141    pub fn is_empty(&self) -> bool {
142        self.len == 0
143    }
144
145    pub fn deserialize<L: DeserializeKey<K>>(
146        &mut self,
147    ) -> Result<Option<MapElementDeserializer<'_, 'b, L>>, DeserializeError> {
148        if self.is_empty() {
149            Ok(None)
150        } else {
151            self.len -= 1;
152            MapElementDeserializer::new(self.buf, self.depth).map(Some)
153        }
154    }
155
156    pub fn deserialize_element<L, T, U>(&mut self) -> Result<Option<(L, U)>, DeserializeError>
157    where
158        L: DeserializeKey<K>,
159        T: Tag,
160        U: Deserialize<T>,
161    {
162        match self.deserialize()? {
163            Some(elem) => elem.deserialize().map(Some),
164            None => Ok(None),
165        }
166    }
167
168    pub fn deserialize_extend<L, T, U, V>(mut self, map: &mut V) -> Result<(), DeserializeError>
169    where
170        L: DeserializeKey<K>,
171        T: Tag,
172        U: Deserialize<T>,
173        V: Extend<(L, U)>,
174    {
175        while let Some(kv) = self.deserialize_element()? {
176            map.extend(iter::once(kv));
177        }
178
179        Ok(())
180    }
181
182    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
183        if self.is_empty() {
184            Ok(())
185        } else {
186            self.len -= 1;
187            K::Impl::skip(self.buf)?;
188            Deserializer::new(self.buf, self.depth)?.skip()
189        }
190    }
191
192    pub fn skip(mut self) -> Result<(), DeserializeError> {
193        while !self.is_empty() {
194            self.skip_element()?;
195        }
196
197        Ok(())
198    }
199
200    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
201        self.finish_with(|| Ok(t))
202    }
203
204    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
205    where
206        F: FnOnce() -> Result<T, DeserializeError>,
207    {
208        if self.is_empty() {
209            f()
210        } else {
211            Err(DeserializeError::MoreElementsRemain)
212        }
213    }
214
215    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
216        self.skip_and_finish_with(|| Ok(t))
217    }
218
219    pub fn skip_and_finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
220    where
221        F: FnOnce() -> Result<T, DeserializeError>,
222    {
223        self.skip()?;
224        f()
225    }
226}
227
228impl<K> fmt::Debug for Map1Deserializer<'_, '_, K> {
229    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
230        let mut f = f.debug_struct("MapDeserializer");
231
232        f.field("buf", &self.buf);
233        f.field("len", &self.len);
234        f.field("depth", &self.depth);
235
236        f.finish()
237    }
238}
239
240pub struct Map2Deserializer<'a, 'b, K> {
241    buf: &'a mut &'b [u8],
242    empty: bool,
243    depth: u8,
244    _key: PhantomData<K>,
245}
246
247impl<'a, 'b, K: KeyTag> Map2Deserializer<'a, 'b, K> {
248    pub(super) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
249        buf.ensure_discriminant_u8(K::Impl::VALUE_KIND_MAP2)?;
250        Self::new_without_value_kind(buf, depth)
251    }
252
253    pub(super) fn new_without_value_kind(
254        buf: &'a mut &'b [u8],
255        depth: u8,
256    ) -> Result<Self, DeserializeError> {
257        Ok(Self {
258            buf,
259            empty: false,
260            depth,
261            _key: PhantomData,
262        })
263    }
264
265    pub fn deserialize<L: DeserializeKey<K>>(
266        &mut self,
267    ) -> Result<Option<MapElementDeserializer<'_, 'b, L>>, DeserializeError> {
268        if self.empty {
269            Ok(None)
270        } else {
271            match self.buf.try_get_discriminant_u8()? {
272                ValueKind::None => {
273                    self.empty = true;
274                    Ok(None)
275                }
276
277                ValueKind::Some => MapElementDeserializer::new(self.buf, self.depth).map(Some),
278                _ => Err(DeserializeError::InvalidSerialization),
279            }
280        }
281    }
282
283    pub fn deserialize_element<L, T, U>(&mut self) -> Result<Option<(L, U)>, DeserializeError>
284    where
285        L: DeserializeKey<K>,
286        T: Tag,
287        U: Deserialize<T>,
288    {
289        match self.deserialize()? {
290            Some(elem) => elem.deserialize().map(Some),
291            None => Ok(None),
292        }
293    }
294
295    pub fn deserialize_extend<L, T, U, V>(mut self, map: &mut V) -> Result<(), DeserializeError>
296    where
297        L: DeserializeKey<K>,
298        T: Tag,
299        U: Deserialize<T>,
300        V: Extend<(L, U)>,
301    {
302        while let Some(kv) = self.deserialize_element()? {
303            map.extend(iter::once(kv));
304        }
305
306        Ok(())
307    }
308
309    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
310        if !self.empty {
311            match self.buf.try_get_discriminant_u8()? {
312                ValueKind::None => self.empty = true,
313
314                ValueKind::Some => {
315                    K::Impl::skip(self.buf)?;
316                    Deserializer::new(self.buf, self.depth)?.skip()?;
317                }
318
319                _ => return Err(DeserializeError::InvalidSerialization),
320            }
321        }
322
323        Ok(())
324    }
325
326    pub fn skip(mut self) -> Result<(), DeserializeError> {
327        while !self.empty {
328            self.skip_element()?;
329        }
330
331        Ok(())
332    }
333
334    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
335        self.finish_with(|| Ok(t))
336    }
337
338    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
339    where
340        F: FnOnce() -> Result<T, DeserializeError>,
341    {
342        if self.empty {
343            f()
344        } else {
345            match self.buf.try_get_discriminant_u8()? {
346                ValueKind::None => f(),
347                ValueKind::Some => Err(DeserializeError::MoreElementsRemain),
348                _ => Err(DeserializeError::InvalidSerialization),
349            }
350        }
351    }
352
353    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
354        self.skip_and_finish_with(|| Ok(t))
355    }
356
357    pub fn skip_and_finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
358    where
359        F: FnOnce() -> Result<T, DeserializeError>,
360    {
361        self.skip()?;
362        f()
363    }
364}
365
366impl<K> fmt::Debug for Map2Deserializer<'_, '_, K> {
367    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
368        let mut f = f.debug_struct("MapDeserializer");
369
370        f.field("buf", &self.buf);
371        f.field("empty", &self.empty);
372        f.field("depth", &self.depth);
373
374        f.finish()
375    }
376}
377
378#[derive(Debug)]
379pub struct MapElementDeserializer<'a, 'b, L> {
380    buf: &'a mut &'b [u8],
381    key: L,
382    depth: u8,
383}
384
385impl<'a, 'b, L> MapElementDeserializer<'a, 'b, L> {
386    fn new<K>(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError>
387    where
388        K: KeyTag,
389        L: DeserializeKey<K>,
390    {
391        let key = K::Impl::deserialize_key(buf).and_then(L::try_from_key)?;
392        Ok(Self { buf, key, depth })
393    }
394
395    pub fn key(&self) -> &L {
396        &self.key
397    }
398
399    pub fn deserialize<T: Tag, U: Deserialize<T>>(self) -> Result<(L, U), DeserializeError> {
400        let deserializer = Deserializer::new(self.buf, self.depth)?;
401        let value = deserializer.deserialize()?;
402        Ok((self.key, value))
403    }
404
405    pub fn skip(self) -> Result<(), DeserializeError> {
406        Deserializer::new(self.buf, self.depth)?.skip()
407    }
408}
aldrin_core/deserializer/map.rs

aldrin_core/deserializer/
map.rs
