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 self.read_int(6)
135 }
136
137 #[inline]
138 fn read_u48(&mut self) -> Result<u64, TryGetError> {
139 self.read_uint(6)
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}