flowly_core/
codec.rs

1use arrayvec::ArrayVec;
2pub use bytes::TryGetError;
3use bytes::{Buf, BufMut, Bytes, BytesMut};
4
5pub trait Reader: Buf {
6    fn read_string(&mut self, len: usize) -> Result<String, TryGetError> {
7        let mut buf = BytesMut::with_capacity(len);
8        buf.put(Buf::take(self, len));
9
10        String::from_utf8(buf.into()).map_err(|_| TryGetError {
11            requested: 0,
12            available: 0,
13        })
14    }
15
16    fn read_array<const N: usize>(&mut self, len: usize) -> Result<ArrayVec<u8, N>, TryGetError> {
17        let mut arr = ArrayVec::new();
18        unsafe { arr.set_len(usize::min(N, len)) };
19        self.read_slice(&mut arr)?;
20
21        Ok(arr)
22    }
23
24    fn read_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError> {
25        self.try_copy_to_slice(dst)
26    }
27
28    fn read_bytes(&mut self, len: usize) -> Result<Bytes, TryGetError> {
29        let available = Self::remaining(self);
30        if available < len {
31            Err(TryGetError {
32                requested: len,
33                available,
34            })
35        } else {
36            Ok(self.copy_to_bytes(len))
37        }
38    }
39
40    fn read_bytes_prepend(&mut self, len: usize, prep: &[u8]) -> Result<Bytes, TryGetError> {
41        let available = Self::remaining(self);
42
43        if available < len {
44            Err(TryGetError {
45                requested: len,
46                available,
47            })
48        } else {
49            let mut ret = BytesMut::with_capacity(len + prep.len());
50            ret.put(prep);
51            ret.put(self.take(len));
52
53            Ok(ret.freeze())
54        }
55    }
56
57    #[inline]
58    fn read_u8(&mut self) -> Result<u8, TryGetError> {
59        self.try_get_u8()
60    }
61
62    #[inline]
63    fn read_i8(&mut self) -> Result<i8, TryGetError> {
64        self.try_get_i8()
65    }
66
67    #[inline]
68    fn read_u16(&mut self) -> Result<u16, TryGetError> {
69        self.try_get_u16()
70    }
71
72    #[inline]
73    fn read_i16(&mut self) -> Result<i16, TryGetError> {
74        self.try_get_i16()
75    }
76
77    #[inline]
78    fn read_u32(&mut self) -> Result<u32, TryGetError> {
79        self.try_get_u32()
80    }
81
82    #[inline]
83    fn read_i32(&mut self) -> Result<i32, TryGetError> {
84        self.try_get_i32()
85    }
86
87    #[inline]
88    fn read_u64(&mut self) -> Result<u64, TryGetError> {
89        self.try_get_u64()
90    }
91
92    #[inline]
93    fn read_i64(&mut self) -> Result<i64, TryGetError> {
94        self.try_get_i64()
95    }
96
97    #[inline]
98    fn read_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
99        self.try_get_uint(nbytes)
100    }
101
102    #[inline]
103    fn read_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
104        self.try_get_int(nbytes)
105    }
106
107    #[inline]
108    fn read_f32(&mut self) -> Result<f32, TryGetError> {
109        self.try_get_f32()
110    }
111
112    #[inline]
113    fn read_f64(&mut self) -> Result<f64, TryGetError> {
114        self.try_get_f64()
115    }
116
117    #[inline]
118    fn peek_u8(&mut self) -> Result<u8, TryGetError> {
119        self.chunk().read_u8()
120    }
121
122    #[inline]
123    fn read_i24(&mut self) -> Result<i32, TryGetError> {
124        Ok(self.read_int(3)? as i32)
125    }
126
127    #[inline]
128    fn read_u24(&mut self) -> Result<u32, TryGetError> {
129        Ok(self.read_uint(3)? as u32)
130    }
131
132    #[inline]
133    fn read_i48(&mut self) -> Result<i64, TryGetError> {
134        Ok(self.read_int(6)? as i64)
135    }
136
137    #[inline]
138    fn read_u48(&mut self) -> Result<u64, TryGetError> {
139        Ok(self.read_uint(6)? as u64)
140    }
141
142    #[inline]
143    fn read_remaining(&mut self) -> Bytes {
144        self.read_bytes(self.remaining()).unwrap()
145    }
146}
147
148impl<T: Buf> Reader for T {}
149
150pub trait ReaderExt: Sized + Reader {
151    #[inline]
152    fn read_u8p2<const A: u8, const B: u8>(&mut self) -> Result<(u8, u8), TryGetError> {
153        const {
154            assert! {A as usize + B as usize == 8};
155        }
156
157        let val = self.read_u8()?;
158        let mask = (((1u16 << A) - 1) << B) as u8;
159
160        Ok((val >> B, val & (!mask)))
161    }
162
163    #[inline]
164    fn read_u8p3<const A: u8, const B: u8, const C: u8>(
165        &mut self,
166    ) -> Result<(u8, u8, u8), TryGetError> {
167        const {
168            assert! {A as usize + B as usize + C as usize == 8};
169        }
170
171        let val = self.read_u8()?;
172        let b_mask = ((1u16 << B) - 1) as u8;
173        let c_mask = ((1u16 << C) - 1) as u8;
174
175        Ok(((val >> (B + C)), (val >> C) & b_mask, val & c_mask))
176    }
177
178    #[inline]
179    fn read_u8p4<const A: u8, const B: u8, const C: u8, const D: u8>(
180        &mut self,
181    ) -> Result<(u8, u8, u8, u8), TryGetError> {
182        const {
183            assert! {A as usize + B as usize + C as usize + D as usize == 8};
184        }
185
186        let val = self.read_u8()?;
187        let b_mask = ((1u16 << B) - 1) as u8;
188        let c_mask = ((1u16 << C) - 1) as u8;
189        let d_mask = ((1u16 << D) - 1) as u8;
190
191        Ok((
192            (val >> (B + C + D)),
193            (val >> (C + D)) & b_mask,
194            (val >> D) & c_mask,
195            val & d_mask,
196        ))
197    }
198
199    #[inline]
200    fn read_u16p2<const A: u8, const B: u8>(&mut self) -> Result<(u16, u16), TryGetError> {
201        const {
202            assert! {A as usize + B as usize == 16};
203        }
204
205        let val = self.read_u16()?;
206        let mask = (((1u32 << A) - 1) << B) as u16;
207
208        Ok((val >> B, val & (!mask)))
209    }
210
211    #[inline]
212    fn read_u16p3<const A: u8, const B: u8, const C: u8>(
213        &mut self,
214    ) -> Result<(u16, u16, u16), TryGetError> {
215        const {
216            assert! {A as usize + B as usize + C as usize == 16};
217        }
218
219        let val = self.read_u16()?;
220        let b_mask = ((1u32 << B) - 1) as u16;
221        let c_mask = ((1u32 << C) - 1) as u16;
222
223        Ok(((val >> (B + C)), (val >> C) & b_mask, val & c_mask))
224    }
225
226    #[inline]
227    fn read_u16p4<const A: u16, const B: u16, const C: u16, const D: u16>(
228        &mut self,
229    ) -> Result<(u16, u16, u16, u16), TryGetError> {
230        const {
231            assert! {A as usize + B as usize + C as usize + D as usize == 16};
232        }
233
234        let val = self.read_u16()?;
235        let b_mask = ((1u32 << B) - 1) as u16;
236        let c_mask = ((1u32 << C) - 1) as u16;
237        let d_mask = ((1u32 << D) - 1) as u16;
238
239        Ok((
240            (val >> (B + C + D)),
241            (val >> (C + D)) & b_mask,
242            (val >> D) & c_mask,
243            val & d_mask,
244        ))
245    }
246}
247
248impl<T: Reader> ReaderExt for T {}
249
250pub trait Writer: BufMut {
251    #[inline]
252    fn put_i24(&mut self, val: i32) {
253        self.put_int(val as i64, 3)
254    }
255
256    #[inline]
257    fn put_u24(&mut self, val: u32) {
258        self.put_uint(val as u64, 3)
259    }
260
261    #[inline]
262    fn put_i48(&mut self, val: i64) {
263        self.put_int(val, 6)
264    }
265
266    #[inline]
267    fn put_u48(&mut self, val: u64) {
268        self.put_uint(val, 6)
269    }
270
271    #[inline]
272    fn put_str(&mut self, string: &str) {
273        self.put_slice(string.as_bytes())
274    }
275}
276
277impl<T: BufMut> Writer for T {}
278
279pub trait WriterExt: Writer {
280    fn put_u8p2<const A: u8, const B: u8>(&mut self, a: u8, b: u8) {
281        let _ = b;
282        let _ = a;
283        const {
284            assert!(A + B == 8);
285        }
286
287        todo!()
288    }
289
290    fn put_u8p3<const A: u8, const B: u8, const C: u8>(&mut self, a: u8, b: u8, c: u8) {
291        let _ = c;
292        let _ = b;
293        let _ = a;
294        const {
295            assert!(A + B + C == 8);
296        }
297
298        todo!()
299    }
300
301    fn put_u8p4<const A: u8, const B: u8, const C: u8, const D: u8>(
302        &mut self,
303        a: u8,
304        b: u8,
305        c: u8,
306        d: u8,
307    ) {
308        let _ = d;
309        let _ = c;
310        let _ = b;
311        let _ = a;
312        const {
313            assert!(A + B + C + D == 8);
314        }
315
316        todo!()
317    }
318
319    fn put_u16p2<const A: u8, const B: u8>(&mut self, a: u16, b: u16) {
320        let _ = b;
321        let _ = a;
322        const {
323            assert!(A + B == 16);
324        }
325
326        todo!()
327    }
328
329    fn put_u16p3<const A: u8, const B: u8, const C: u8>(&mut self, a: u16, b: u16, c: u16) {
330        let _ = c;
331        let _ = b;
332        let _ = a;
333        const {
334            assert!(A + B + C == 16);
335        }
336
337        todo!()
338    }
339
340    fn put_u16p4<const A: u8, const B: u8, const C: u8, const D: u8>(
341        &mut self,
342        a: u16,
343        b: u16,
344        c: u16,
345        d: u16,
346    ) {
347        let _ = d;
348        let _ = c;
349        let _ = b;
350        let _ = a;
351        const {
352            assert!(A + B + C + D == 16);
353        }
354
355        todo!()
356    }
357}
358
359impl<T: Writer> WriterExt for T {}
360
361pub trait Decoder<T> {
362    type Error;
363
364    fn decode<R: Reader>(&mut self, reader: &mut R) -> Result<T, Self::Error>;
365}
366
367pub trait Encoder<T> {
368    type Error;
369
370    fn encode<W: Writer>(&mut self, item: &T, writer: &mut W) -> Result<(), Self::Error>;
371    fn size_hint() -> (usize, Option<usize>) {
372        (0, None)
373    }
374    fn estimate_size(&self, _: &T) -> usize {
375        Self::size_hint().0
376    }
377}
378
379#[derive(Debug, Default, Clone, Copy)]
380pub struct BytesDecoder;
381
382impl Decoder<Bytes> for BytesDecoder {
383    type Error = crate::Void;
384
385    fn decode<R: Reader>(&mut self, reader: &mut R) -> Result<Bytes, Self::Error> {
386        Ok(reader.read_bytes(reader.remaining()).unwrap())
387    }
388}