scuffle_bytes_util/zero_copy/
serde.rs

1//! Types for binary deserialization and serialization.
2
3use std::io;
4use std::ops::Deref;
5
6use byteorder::ReadBytesExt;
7
8use super::ZeroCopyReader;
9use crate::{BytesCow, StringCow};
10
11/// A trait that should be implemented by types that can contain other deserializable types.
12pub trait Container {
13    /// The type of items in the container.
14    type Item;
15    /// Adds an item to the container.
16    fn add(&mut self, item: Self::Item);
17}
18
19impl<T> Container for Vec<T> {
20    type Item = T;
21
22    fn add(&mut self, item: Self::Item) {
23        self.push(item);
24    }
25}
26
27// TODO: This doesn't really make sense but it works
28impl<T> Container for Option<T> {
29    type Item = T;
30
31    fn add(&mut self, item: Self::Item) {
32        *self = Some(item);
33    }
34}
35
36/// A trait for deserializing types from a zero-copy reader.
37pub trait Deserialize<'a>: Sized {
38    /// Deserialize a value from the given zero-copy reader.
39    fn deserialize<R>(reader: R) -> io::Result<Self>
40    where
41        R: ZeroCopyReader<'a>;
42}
43
44/// A trait for deserializing types from a zero-copy reader with a seed.
45pub trait DeserializeSeed<'a, S>: Sized {
46    /// Deserialize a value from the given zero-copy reader using the provided seed.
47    fn deserialize_seed<R>(reader: R, seed: S) -> io::Result<Self>
48    where
49        R: ZeroCopyReader<'a>;
50}
51
52/// A trait for serializing types to a writer.
53pub trait Serialize {
54    /// Serialize the value into the given writer.
55    fn serialize<W>(&self, writer: W) -> io::Result<()>
56    where
57        W: std::io::Write;
58}
59
60macro_rules! impl_serialize {
61    ($($t:ty),+) => {
62        $(
63            impl Serialize for $t {
64                fn serialize<W>(&self, mut writer: W) -> io::Result<()>
65                where
66                    W: std::io::Write,
67                {
68                    writer.write_all(&self.to_be_bytes())
69                }
70            }
71        )+
72    };
73}
74
75impl_serialize!(f32, f64, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128);
76
77impl<'a> Deserialize<'a> for f32 {
78    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
79        reader.as_std().read_f32::<byteorder::BigEndian>()
80    }
81}
82
83impl<'a> Deserialize<'a> for f64 {
84    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
85        reader.as_std().read_f64::<byteorder::BigEndian>()
86    }
87}
88
89impl<'a> Deserialize<'a> for i8 {
90    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
91        reader.as_std().read_i8()
92    }
93}
94
95impl<'a> Deserialize<'a> for i16 {
96    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
97        reader.as_std().read_i16::<byteorder::BigEndian>()
98    }
99}
100
101impl<'a> Deserialize<'a> for i32 {
102    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
103        reader.as_std().read_i32::<byteorder::BigEndian>()
104    }
105}
106
107impl<'a> Deserialize<'a> for i64 {
108    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
109        reader.as_std().read_i64::<byteorder::BigEndian>()
110    }
111}
112
113impl<'a> Deserialize<'a> for i128 {
114    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
115        reader.as_std().read_i128::<byteorder::BigEndian>()
116    }
117}
118
119impl<'a> Deserialize<'a> for u8 {
120    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
121        reader.as_std().read_u8()
122    }
123}
124
125impl<'a> Deserialize<'a> for u16 {
126    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
127        reader.as_std().read_u16::<byteorder::BigEndian>()
128    }
129}
130
131impl<'a> Deserialize<'a> for u32 {
132    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
133        reader.as_std().read_u32::<byteorder::BigEndian>()
134    }
135}
136
137impl<'a> Deserialize<'a> for u64 {
138    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
139        reader.as_std().read_u64::<byteorder::BigEndian>()
140    }
141}
142
143impl<'a> Deserialize<'a> for u128 {
144    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
145        reader.as_std().read_u128::<byteorder::BigEndian>()
146    }
147}
148
149impl<'a, T, const LEN: usize> Deserialize<'a> for [T; LEN]
150where
151    T: Deserialize<'a> + Default + Copy,
152{
153    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
154        let mut buf = [T::default(); LEN];
155
156        for t in &mut buf {
157            *t = T::deserialize(&mut reader)?;
158        }
159
160        Ok(buf)
161    }
162}
163
164impl<T, const LEN: usize> Serialize for [T; LEN]
165where
166    T: Serialize,
167{
168    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
169    where
170        W: std::io::Write,
171    {
172        for t in self {
173            t.serialize(&mut writer)?;
174        }
175
176        Ok(())
177    }
178}
179
180impl<'a> Deserialize<'a> for BytesCow<'a> {
181    fn deserialize<R>(mut reader: R) -> io::Result<Self>
182    where
183        R: ZeroCopyReader<'a>,
184    {
185        reader.try_read_to_end()
186    }
187}
188
189impl Serialize for BytesCow<'_> {
190    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
191    where
192        W: std::io::Write,
193    {
194        writer.write_all(self.as_bytes())
195    }
196}
197
198impl<'a> Deserialize<'a> for StringCow<'a> {
199    fn deserialize<R>(mut reader: R) -> io::Result<Self>
200    where
201        R: ZeroCopyReader<'a>,
202    {
203        let bytes = reader.try_read_to_end()?;
204        Self::try_from(bytes).map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Invalid UTF-8"))
205    }
206}
207
208impl Serialize for StringCow<'_> {
209    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
210    where
211        W: std::io::Write,
212    {
213        writer.write_all(self.as_str().as_bytes())
214    }
215}
216
217/// A 24-bit signed integer in big-endian byte order.
218#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
219pub struct I24Be(pub i32);
220
221impl<'a> Deserialize<'a> for I24Be {
222    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
223        reader.as_std().read_i24::<byteorder::BigEndian>().map(I24Be)
224    }
225}
226
227impl Serialize for I24Be {
228    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
229    where
230        W: std::io::Write,
231    {
232        writer.write_all(&self.0.to_be_bytes()[1..])
233    }
234}
235
236impl From<I24Be> for i32 {
237    fn from(value: I24Be) -> Self {
238        value.0
239    }
240}
241
242impl Deref for I24Be {
243    type Target = i32;
244
245    fn deref(&self) -> &Self::Target {
246        &self.0
247    }
248}
249
250/// A 48-bit signed integer in big-endian byte order.
251#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
252pub struct I48Be(pub i64);
253
254impl<'a> Deserialize<'a> for I48Be {
255    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
256        reader.as_std().read_i48::<byteorder::BigEndian>().map(I48Be)
257    }
258}
259
260impl Serialize for I48Be {
261    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
262    where
263        W: std::io::Write,
264    {
265        writer.write_all(&self.0.to_be_bytes()[2..])
266    }
267}
268
269impl From<I48Be> for i64 {
270    fn from(value: I48Be) -> Self {
271        value.0
272    }
273}
274
275impl Deref for I48Be {
276    type Target = i64;
277
278    fn deref(&self) -> &Self::Target {
279        &self.0
280    }
281}
282
283/// A 24-bit unsigned integer in big-endian byte order.
284#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
285pub struct U24Be(pub u32);
286
287impl<'a> Deserialize<'a> for U24Be {
288    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
289        reader.as_std().read_u24::<byteorder::BigEndian>().map(U24Be)
290    }
291}
292
293impl Serialize for U24Be {
294    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
295    where
296        W: std::io::Write,
297    {
298        writer.write_all(&self.0.to_be_bytes()[1..])
299    }
300}
301
302impl From<U24Be> for u32 {
303    fn from(value: U24Be) -> Self {
304        value.0
305    }
306}
307
308impl Deref for U24Be {
309    type Target = u32;
310
311    fn deref(&self) -> &Self::Target {
312        &self.0
313    }
314}
315
316/// A 48-bit unsigned integer in big-endian byte order.
317#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
318pub struct U48Be(pub u64);
319
320impl<'a> Deserialize<'a> for U48Be {
321    fn deserialize<R: ZeroCopyReader<'a>>(mut reader: R) -> io::Result<Self> {
322        reader.as_std().read_u48::<byteorder::BigEndian>().map(U48Be)
323    }
324}
325
326impl Serialize for U48Be {
327    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
328    where
329        W: std::io::Write,
330    {
331        writer.write_all(&self.0.to_be_bytes()[2..])
332    }
333}
334
335impl From<U48Be> for u64 {
336    fn from(value: U48Be) -> Self {
337        value.0
338    }
339}
340
341impl Deref for U48Be {
342    type Target = u64;
343
344    fn deref(&self) -> &Self::Target {
345        &self.0
346    }
347}
scuffle_bytes_util/zero_copy/serde.rs

scuffle_bytes_util/zero_copy/
serde.rs
