rustolio_utils/bytes/encoding/
decode.rs

1//
2// SPDX-License-Identifier: MPL-2.0
3//
4// Copyright (c) 2026 Tobias Binnewies. All rights reserved.
5//
6// This Source Code Form is subject to the terms of the Mozilla Public
7// License, v. 2.0. If a copy of the MPL was not distributed with this
8// file, You can obtain one at http://mozilla.org/MPL/2.0/.
9//
10
11
12use crate::{bytes::Bytes, prelude::*};
13
14use super::{transmute_array, transmute_vec, type_eq};
15
16pub trait Decode: Sized {
17    fn decode(reader: &mut impl Decoder) -> crate::Result<Self>;
18
19    #[allow(async_fn_in_trait)] // Auto-Traits should not be specified as this leads to problems in web-code (where all types are `!Send`) and server code (where tokio::spawn needs all futures to be `Send`)
20    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self>;
21}
22
23pub trait Decoder: Unpin {
24    fn read_u8(&mut self) -> crate::Result<u8>;
25    fn read_exact(&mut self, buf: &mut [u8]) -> crate::Result<()>;
26}
27
28#[allow(async_fn_in_trait)]
29pub trait AsyncDecoder: Unpin {
30    async fn read_u8(&mut self) -> crate::Result<u8>;
31    async fn read_exact(&mut self, buf: &mut [u8]) -> crate::Result<()>;
32}
33
34// ---- Impls
35
36impl Decode for Bytes {
37    #[async_impl]
38    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
39        let v = Vec::<u8>::decode_async(reader).await?;
40        Ok(Bytes::from_owner(v))
41    }
42}
43
44impl<T> Decode for Vec<T>
45where
46    T: Decode,
47{
48    #[async_impl]
49    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
50        let len = usize::decode_async(reader).await?;
51
52        if type_eq::<T, u8>() {
53            let mut v = vec![0; len];
54            reader.read_exact(&mut v).await?;
55            return Ok(unsafe { transmute_vec(v) });
56        }
57
58        let mut v = Vec::with_capacity(len);
59        for _ in 0..len {
60            v.push(T::decode_async(reader).await?);
61        }
62        Ok(v)
63    }
64}
65
66impl<T, const N: usize> Decode for [T; N]
67where
68    T: Decode,
69{
70    #[async_impl]
71    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
72        use std::mem::MaybeUninit;
73
74        if type_eq::<T, u8>() {
75            let mut arr = [0; N];
76            reader.read_exact(&mut arr).await?;
77            return Ok(unsafe { transmute_array(arr) });
78        }
79
80        let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
81
82        for i in 0..N {
83            let value = T::decode_async(reader).await?;
84            arr[i].write(value);
85        }
86        // SAFETY: We have initialized all N elements above
87        Ok(unsafe { arr.map(|x| x.assume_init()) })
88    }
89}
90
91macro_rules! gen_nums {
92    ($($ty:ident),*) => {
93        $(
94            impl Decode for $ty {
95                #[async_impl]
96                async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
97                    let mut buf = [0u8; std::mem::size_of::<$ty>()];
98                    reader.read_exact(&mut buf).await?;
99                    Ok($ty::from_ne_bytes(buf))
100                }
101            }
102        )*
103    };
104}
105
106// Optimise for bytes
107impl Decode for u8 {
108    #[async_impl]
109    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
110        reader.read_u8().await
111    }
112}
113impl Decode for i8 {
114    #[async_impl]
115    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
116        Ok(reader.read_u8().await? as i8)
117    }
118}
119impl Decode for bool {
120    #[async_impl]
121    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
122        Ok(reader.read_u8().await? != 0)
123    }
124}
125
126// Standadize across platforms (8bytes vs 4bytes) -> always use 8 bytes
127impl Decode for usize {
128    #[async_impl]
129    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
130        let u = u64::decode_async(reader).await? as usize;
131        Ok(u)
132    }
133}
134impl Decode for isize {
135    #[async_impl]
136    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
137        Ok(i64::decode_async(reader).await? as isize)
138    }
139}
140
141gen_nums!(u16, u32, u64, u128);
142gen_nums!(i16, i32, i64, i128);
143gen_nums!(f32, f64);
144
145impl Decode for String {
146    #[async_impl]
147    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
148        let b = Vec::<u8>::decode_async(reader).await?;
149        String::from_utf8(b).context("Invalid data")
150    }
151}
152
153impl<T> Decode for std::marker::PhantomData<T> {
154    #[async_impl]
155    async fn decode_async(_: &mut impl AsyncDecoder) -> crate::Result<Self> {
156        Ok(std::marker::PhantomData)
157    }
158}
159
160impl<K, V> Decode for std::collections::HashMap<K, V>
161where
162    K: Decode + Eq + std::hash::Hash,
163    V: Decode,
164{
165    #[async_impl]
166    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
167        let len = usize::decode_async(reader).await?;
168
169        let mut m = std::collections::HashMap::with_capacity(len);
170        for _ in 0..len {
171            let k = K::decode_async(reader).await?;
172            let v = V::decode_async(reader).await?;
173            m.insert(k, v);
174        }
175        Ok(m)
176    }
177}
178
179impl<K> Decode for std::collections::HashSet<K>
180where
181    K: Decode + Eq + std::hash::Hash,
182{
183    #[async_impl]
184    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
185        let len = usize::decode_async(reader).await?;
186
187        let mut m = std::collections::HashSet::with_capacity(len);
188        for _ in 0..len {
189            m.insert(K::decode_async(reader).await?);
190        }
191        Ok(m)
192    }
193}
194
195impl<K, V> Decode for std::collections::BTreeMap<K, V>
196where
197    K: Decode + Ord,
198    V: Decode,
199{
200    #[async_impl]
201    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
202        let v = Vec::decode_async(reader).await?;
203        Ok(std::collections::BTreeMap::from_iter(v))
204    }
205}
206
207impl<K> Decode for std::collections::BTreeSet<K>
208where
209    K: Decode + Ord,
210{
211    #[async_impl]
212    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
213        let v = Vec::decode_async(reader).await?;
214        Ok(std::collections::BTreeSet::from_iter(v))
215    }
216}
217
218impl<T> Decode for std::collections::VecDeque<T>
219where
220    T: Decode,
221{
222    #[async_impl]
223    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
224        let v = Vec::decode_async(reader).await?;
225        Ok(v.into())
226    }
227}
228
229impl<T> Decode for std::collections::LinkedList<T>
230where
231    T: Decode,
232{
233    #[async_impl]
234    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
235        let len = usize::decode_async(reader).await?;
236
237        let mut l = std::collections::LinkedList::new();
238        for _ in 0..len {
239            l.push_back(T::decode_async(reader).await?);
240        }
241        Ok(l)
242    }
243}
244
245impl<T> Decode for std::collections::BinaryHeap<T>
246where
247    T: Decode + Ord,
248{
249    #[async_impl]
250    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
251        let v = Vec::decode_async(reader).await?;
252        Ok(v.into())
253    }
254}
255
256impl<T> Decode for Box<T>
257where
258    T: Decode,
259{
260    #[async_impl]
261    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
262        let t = T::decode_async(reader).await?;
263        Ok(Box::new(t))
264    }
265}
266
267impl<T> Decode for Box<[T]>
268where
269    T: Decode,
270{
271    #[async_impl]
272    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
273        let t = <Vec<T>>::decode_async(reader).await?;
274        Ok(t.into_boxed_slice())
275    }
276}
277
278impl<T, E> Decode for std::result::Result<T, E>
279where
280    T: Decode,
281    E: Decode,
282{
283    #[async_impl]
284    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
285        let variant_index = reader.read_u8().await?;
286        let r = match variant_index {
287            0 => Ok(T::decode_async(reader).await?),
288            1 => Err(E::decode_async(reader).await?),
289            _ => {
290                return Err(crate::Error::new(format!(
291                    "Invalid variant index: {}",
292                    variant_index
293                )))
294            }
295        };
296        Ok(r)
297    }
298}
299
300impl<T> Decode for Option<T>
301where
302    T: Decode,
303{
304    #[async_impl]
305    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
306        let variant_index = reader.read_u8().await?;
307        let r = match variant_index {
308            0 => None,
309            1 => Some(T::decode_async(reader).await?),
310            _ => {
311                return Err(crate::Error::new(format!(
312                    "Invalid variant index: {}",
313                    variant_index
314                )))
315            }
316        };
317        Ok(r)
318    }
319}
320
321impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
322where
323    T0: Decode,
324    T1: Decode,
325    T2: Decode,
326    T3: Decode,
327    T4: Decode,
328    T5: Decode,
329    T6: Decode,
330    T7: Decode,
331    T8: Decode,
332    T9: Decode,
333{
334    #[async_impl]
335    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
336        let t0 = T0::decode_async(reader).await?;
337        let t1 = T1::decode_async(reader).await?;
338        let t2 = T2::decode_async(reader).await?;
339        let t3 = T3::decode_async(reader).await?;
340        let t4 = T4::decode_async(reader).await?;
341        let t5 = T5::decode_async(reader).await?;
342        let t6 = T6::decode_async(reader).await?;
343        let t7 = T7::decode_async(reader).await?;
344        let t8 = T8::decode_async(reader).await?;
345        let t9 = T9::decode_async(reader).await?;
346        Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
347    }
348}
349
350impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
351where
352    T0: Decode,
353    T1: Decode,
354    T2: Decode,
355    T3: Decode,
356    T4: Decode,
357    T5: Decode,
358    T6: Decode,
359    T7: Decode,
360    T8: Decode,
361{
362    #[async_impl]
363    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
364        let t0 = T0::decode_async(reader).await?;
365        let t1 = T1::decode_async(reader).await?;
366        let t2 = T2::decode_async(reader).await?;
367        let t3 = T3::decode_async(reader).await?;
368        let t4 = T4::decode_async(reader).await?;
369        let t5 = T5::decode_async(reader).await?;
370        let t6 = T6::decode_async(reader).await?;
371        let t7 = T7::decode_async(reader).await?;
372        let t8 = T8::decode_async(reader).await?;
373        Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8))
374    }
375}
376
377impl<T0, T1, T2, T3, T4, T5, T6, T7> Decode for (T0, T1, T2, T3, T4, T5, T6, T7)
378where
379    T0: Decode,
380    T1: Decode,
381    T2: Decode,
382    T3: Decode,
383    T4: Decode,
384    T5: Decode,
385    T6: Decode,
386    T7: Decode,
387{
388    #[async_impl]
389    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
390        let t0 = T0::decode_async(reader).await?;
391        let t1 = T1::decode_async(reader).await?;
392        let t2 = T2::decode_async(reader).await?;
393        let t3 = T3::decode_async(reader).await?;
394        let t4 = T4::decode_async(reader).await?;
395        let t5 = T5::decode_async(reader).await?;
396        let t6 = T6::decode_async(reader).await?;
397        let t7 = T7::decode_async(reader).await?;
398        Ok((t0, t1, t2, t3, t4, t5, t6, t7))
399    }
400}
401
402impl<T0, T1, T2, T3, T4, T5, T6> Decode for (T0, T1, T2, T3, T4, T5, T6)
403where
404    T0: Decode,
405    T1: Decode,
406    T2: Decode,
407    T3: Decode,
408    T4: Decode,
409    T5: Decode,
410    T6: Decode,
411{
412    #[async_impl]
413    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
414        let t0 = T0::decode_async(reader).await?;
415        let t1 = T1::decode_async(reader).await?;
416        let t2 = T2::decode_async(reader).await?;
417        let t3 = T3::decode_async(reader).await?;
418        let t4 = T4::decode_async(reader).await?;
419        let t5 = T5::decode_async(reader).await?;
420        let t6 = T6::decode_async(reader).await?;
421        Ok((t0, t1, t2, t3, t4, t5, t6))
422    }
423}
424
425impl<T0, T1, T2, T3, T4, T5> Decode for (T0, T1, T2, T3, T4, T5)
426where
427    T0: Decode,
428    T1: Decode,
429    T2: Decode,
430    T3: Decode,
431    T4: Decode,
432    T5: Decode,
433{
434    #[async_impl]
435    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
436        let t0 = T0::decode_async(reader).await?;
437        let t1 = T1::decode_async(reader).await?;
438        let t2 = T2::decode_async(reader).await?;
439        let t3 = T3::decode_async(reader).await?;
440        let t4 = T4::decode_async(reader).await?;
441        let t5 = T5::decode_async(reader).await?;
442        Ok((t0, t1, t2, t3, t4, t5))
443    }
444}
445
446impl<T0, T1, T2, T3, T4> Decode for (T0, T1, T2, T3, T4)
447where
448    T0: Decode,
449    T1: Decode,
450    T2: Decode,
451    T3: Decode,
452    T4: Decode,
453{
454    #[async_impl]
455    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
456        let t0 = T0::decode_async(reader).await?;
457        let t1 = T1::decode_async(reader).await?;
458        let t2 = T2::decode_async(reader).await?;
459        let t3 = T3::decode_async(reader).await?;
460        let t4 = T4::decode_async(reader).await?;
461        Ok((t0, t1, t2, t3, t4))
462    }
463}
464
465impl<T0, T1, T2, T3> Decode for (T0, T1, T2, T3)
466where
467    T0: Decode,
468    T1: Decode,
469    T2: Decode,
470    T3: Decode,
471{
472    #[async_impl]
473    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
474        let t0 = T0::decode_async(reader).await?;
475        let t1 = T1::decode_async(reader).await?;
476        let t2 = T2::decode_async(reader).await?;
477        let t3 = T3::decode_async(reader).await?;
478        Ok((t0, t1, t2, t3))
479    }
480}
481
482impl<T0, T1, T2> Decode for (T0, T1, T2)
483where
484    T0: Decode,
485    T1: Decode,
486    T2: Decode,
487{
488    #[async_impl]
489    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
490        let t0 = T0::decode_async(reader).await?;
491        let t1 = T1::decode_async(reader).await?;
492        let t2 = T2::decode_async(reader).await?;
493        Ok((t0, t1, t2))
494    }
495}
496
497impl<T0, T1> Decode for (T0, T1)
498where
499    T0: Decode,
500    T1: Decode,
501{
502    #[async_impl]
503    async fn decode_async(reader: &mut impl AsyncDecoder) -> crate::Result<Self> {
504        let t0 = T0::decode_async(reader).await?;
505        let t1 = T1::decode_async(reader).await?;
506        Ok((t0, t1))
507    }
508}
509
510impl Decode for () {
511    #[async_impl]
512    async fn decode_async(_: &mut impl AsyncDecoder) -> crate::Result<Self> {
513        Ok(())
514    }
515}
rustolio_utils/bytes/encoding/decode.rs

rustolio_utils/bytes/encoding/
decode.rs
