aldrin_core/deserializer/
set.rs

1use crate::buf_ext::ValueBufExt;
2use crate::tags::{KeyTag, KeyTagImpl};
3use crate::{DeserializeError, DeserializeKey, ValueKind};
4use std::marker::PhantomData;
5use std::{fmt, iter};
6
7#[derive(Debug)]
8pub enum SetDeserializer<'a, 'b, K> {
9    V1(Set1Deserializer<'a, 'b, K>),
10    V2(Set2Deserializer<'a, 'b, K>),
11}
12
13impl<'a, 'b, K: KeyTag> SetDeserializer<'a, 'b, K> {
14    pub(super) fn new(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
15        let kind = buf.try_get_discriminant_u8::<ValueKind>()?;
16
17        if kind == K::Impl::VALUE_KIND_SET1 {
18            Set1Deserializer::new_without_value_kind(buf).map(Self::V1)
19        } else if kind == K::Impl::VALUE_KIND_SET2 {
20            Set2Deserializer::new_without_value_kind(buf).map(Self::V2)
21        } else {
22            Err(DeserializeError::UnexpectedValue)
23        }
24    }
25
26    pub fn deserialize<T: DeserializeKey<K>>(&mut self) -> Result<Option<T>, DeserializeError> {
27        match self {
28            Self::V1(deserializer) => deserializer.deserialize(),
29            Self::V2(deserializer) => deserializer.deserialize(),
30        }
31    }
32
33    pub fn deserialize_extend<T, U>(self, set: &mut U) -> Result<(), DeserializeError>
34    where
35        T: DeserializeKey<K>,
36        U: Extend<T>,
37    {
38        match self {
39            Self::V1(deserializer) => deserializer.deserialize_extend(set),
40            Self::V2(deserializer) => deserializer.deserialize_extend(set),
41        }
42    }
43
44    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
45        match self {
46            Self::V1(deserializer) => deserializer.skip_element(),
47            Self::V2(deserializer) => deserializer.skip_element(),
48        }
49    }
50
51    pub fn skip(self) -> Result<(), DeserializeError> {
52        match self {
53            Self::V1(deserializer) => deserializer.skip(),
54            Self::V2(deserializer) => deserializer.skip(),
55        }
56    }
57
58    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
59        match self {
60            Self::V1(deserializer) => deserializer.finish(t),
61            Self::V2(deserializer) => deserializer.finish(t),
62        }
63    }
64
65    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
66    where
67        F: FnOnce() -> Result<T, DeserializeError>,
68    {
69        match self {
70            Self::V1(deserializer) => deserializer.finish_with(f),
71            Self::V2(deserializer) => deserializer.finish_with(f),
72        }
73    }
74
75    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
76        match self {
77            Self::V1(deserializer) => deserializer.skip_and_finish(t),
78            Self::V2(deserializer) => deserializer.skip_and_finish(t),
79        }
80    }
81
82    pub fn skip_and_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.skip_and_finish_with(f),
88            Self::V2(deserializer) => deserializer.skip_and_finish_with(f),
89        }
90    }
91}
92
93pub struct Set1Deserializer<'a, 'b, K> {
94    buf: &'a mut &'b [u8],
95    len: u32,
96    _key: PhantomData<K>,
97}
98
99impl<'a, 'b, K: KeyTag> Set1Deserializer<'a, 'b, K> {
100    pub(super) fn new(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
101        buf.ensure_discriminant_u8(K::Impl::VALUE_KIND_SET1)?;
102        Self::new_without_value_kind(buf)
103    }
104
105    pub(super) fn new_without_value_kind(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
106        let len = buf.try_get_varint_u32_le()?;
107
108        Ok(Self {
109            buf,
110            len,
111            _key: PhantomData,
112        })
113    }
114
115    pub fn len(&self) -> usize {
116        self.len as usize
117    }
118
119    pub fn is_empty(&self) -> bool {
120        self.len == 0
121    }
122
123    pub fn deserialize<T: DeserializeKey<K>>(&mut self) -> Result<Option<T>, DeserializeError> {
124        if self.is_empty() {
125            Ok(None)
126        } else {
127            self.len -= 1;
128
129            K::Impl::deserialize_key(self.buf)
130                .and_then(T::try_from_key)
131                .map(Some)
132        }
133    }
134
135    pub fn deserialize_extend<T, U>(mut self, set: &mut U) -> Result<(), DeserializeError>
136    where
137        T: DeserializeKey<K>,
138        U: Extend<T>,
139    {
140        while let Some(elem) = self.deserialize()? {
141            set.extend(iter::once(elem));
142        }
143
144        Ok(())
145    }
146
147    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
148        if self.is_empty() {
149            Ok(())
150        } else {
151            self.len -= 1;
152            K::Impl::skip(self.buf)
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
192impl<K> fmt::Debug for Set1Deserializer<'_, '_, K> {
193    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
194        let mut f = f.debug_struct("Set1Deserializer");
195
196        f.field("buf", &self.buf);
197        f.field("len", &self.len);
198
199        f.finish()
200    }
201}
202
203pub struct Set2Deserializer<'a, 'b, K> {
204    buf: &'a mut &'b [u8],
205    empty: bool,
206    _key: PhantomData<K>,
207}
208
209impl<'a, 'b, K: KeyTag> Set2Deserializer<'a, 'b, K> {
210    pub(super) fn new(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
211        buf.ensure_discriminant_u8(K::Impl::VALUE_KIND_SET2)?;
212        Self::new_without_value_kind(buf)
213    }
214
215    pub(super) fn new_without_value_kind(buf: &'a mut &'b [u8]) -> Result<Self, DeserializeError> {
216        Ok(Self {
217            buf,
218            empty: false,
219            _key: PhantomData,
220        })
221    }
222
223    pub fn deserialize<T: DeserializeKey<K>>(&mut self) -> Result<Option<T>, DeserializeError> {
224        if self.empty {
225            Ok(None)
226        } else {
227            match self.buf.try_get_discriminant_u8()? {
228                ValueKind::None => {
229                    self.empty = true;
230                    Ok(None)
231                }
232
233                ValueKind::Some => K::Impl::deserialize_key(self.buf)
234                    .and_then(T::try_from_key)
235                    .map(Some),
236
237                _ => Err(DeserializeError::InvalidSerialization),
238            }
239        }
240    }
241
242    pub fn deserialize_extend<T, U>(mut self, set: &mut U) -> Result<(), DeserializeError>
243    where
244        T: DeserializeKey<K>,
245        U: Extend<T>,
246    {
247        while let Some(elem) = self.deserialize()? {
248            set.extend(iter::once(elem));
249        }
250
251        Ok(())
252    }
253
254    pub fn skip_element(&mut self) -> Result<(), DeserializeError> {
255        if !self.empty {
256            match self.buf.try_get_discriminant_u8()? {
257                ValueKind::None => self.empty = true,
258                ValueKind::Some => K::Impl::skip(self.buf)?,
259                _ => return Err(DeserializeError::InvalidSerialization),
260            }
261        }
262
263        Ok(())
264    }
265
266    pub fn skip(mut self) -> Result<(), DeserializeError> {
267        while !self.empty {
268            self.skip_element()?;
269        }
270
271        Ok(())
272    }
273
274    pub fn finish<T>(self, t: T) -> Result<T, DeserializeError> {
275        self.finish_with(|| Ok(t))
276    }
277
278    pub fn finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
279    where
280        F: FnOnce() -> Result<T, DeserializeError>,
281    {
282        if self.empty {
283            f()
284        } else {
285            match self.buf.try_get_discriminant_u8()? {
286                ValueKind::None => f(),
287                ValueKind::Some => Err(DeserializeError::MoreElementsRemain),
288                _ => Err(DeserializeError::InvalidSerialization),
289            }
290        }
291    }
292
293    pub fn skip_and_finish<T>(self, t: T) -> Result<T, DeserializeError> {
294        self.skip_and_finish_with(|| Ok(t))
295    }
296
297    pub fn skip_and_finish_with<T, F>(self, f: F) -> Result<T, DeserializeError>
298    where
299        F: FnOnce() -> Result<T, DeserializeError>,
300    {
301        self.skip()?;
302        f()
303    }
304}
305
306impl<K> fmt::Debug for Set2Deserializer<'_, '_, K> {
307    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
308        let mut f = f.debug_struct("Set2Deserializer");
309
310        f.field("buf", &self.buf);
311        f.field("empty", &self.empty);
312
313        f.finish()
314    }
315}
aldrin_core/deserializer/set.rs

aldrin_core/deserializer/
set.rs
