aldrin_core/deserializer/
bytes.rs

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

aldrin_core/deserializer/
bytes.rs
