bincode_next/enc/
impls.rs

1#![allow(unsafe_code)]
2use super::{write::Writer, Encode, Encoder};
3use crate::{
4    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
5    error::EncodeError,
6};
7use core::cmp::Reverse;
8use core::{
9    cell::{Cell, RefCell},
10    marker::PhantomData,
11    num::{
12        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
13        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
14    },
15    ops::{Bound, Range, RangeInclusive},
16    time::Duration,
17};
18
19impl Encode for () {
20    fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
21        Ok(())
22    }
23}
24
25impl<T> Encode for PhantomData<T> {
26    fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
27        Ok(())
28    }
29}
30
31impl Encode for bool {
32    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
33        u8::from(*self).encode(encoder)
34    }
35}
36
37impl Encode for u8 {
38    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
39        encoder.writer().write(&[*self])
40    }
41}
42
43impl Encode for NonZeroU8 {
44    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
45        self.get().encode(encoder)
46    }
47}
48
49impl Encode for u16 {
50    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
51        match E::C::INT_ENCODING {
52            IntEncoding::Variable => {
53                crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
54            }
55            IntEncoding::Fixed => match E::C::ENDIAN {
56                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
57                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
58            },
59        }
60    }
61}
62
63impl Encode for NonZeroU16 {
64    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
65        self.get().encode(encoder)
66    }
67}
68
69impl Encode for u32 {
70    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
71        match E::C::INT_ENCODING {
72            IntEncoding::Variable => {
73                crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
74            }
75            IntEncoding::Fixed => match E::C::ENDIAN {
76                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
77                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
78            },
79        }
80    }
81}
82
83impl Encode for NonZeroU32 {
84    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
85        self.get().encode(encoder)
86    }
87}
88
89impl Encode for u64 {
90    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
91        match E::C::INT_ENCODING {
92            IntEncoding::Variable => {
93                crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
94            }
95            IntEncoding::Fixed => match E::C::ENDIAN {
96                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
97                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
98            },
99        }
100    }
101}
102
103impl Encode for NonZeroU64 {
104    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
105        self.get().encode(encoder)
106    }
107}
108
109impl Encode for u128 {
110    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
111        match E::C::INT_ENCODING {
112            IntEncoding::Variable => {
113                crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
114            }
115            IntEncoding::Fixed => match E::C::ENDIAN {
116                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
117                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
118            },
119        }
120    }
121}
122
123impl Encode for NonZeroU128 {
124    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
125        self.get().encode(encoder)
126    }
127}
128
129impl Encode for usize {
130    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
131        match E::C::INT_ENCODING {
132            IntEncoding::Variable => {
133                crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
134            }
135            IntEncoding::Fixed => match E::C::ENDIAN {
136                Endianness::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
137                Endianness::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
138            },
139        }
140    }
141}
142
143impl Encode for NonZeroUsize {
144    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
145        self.get().encode(encoder)
146    }
147}
148
149impl Encode for i8 {
150    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
151        encoder.writer().write(&self.to_ne_bytes())
152    }
153}
154
155impl Encode for NonZeroI8 {
156    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
157        self.get().encode(encoder)
158    }
159}
160
161impl Encode for i16 {
162    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
163        match E::C::INT_ENCODING {
164            IntEncoding::Variable => {
165                crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
166            }
167            IntEncoding::Fixed => match E::C::ENDIAN {
168                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
169                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
170            },
171        }
172    }
173}
174
175impl Encode for NonZeroI16 {
176    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
177        self.get().encode(encoder)
178    }
179}
180
181impl Encode for i32 {
182    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
183        match E::C::INT_ENCODING {
184            IntEncoding::Variable => {
185                crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
186            }
187            IntEncoding::Fixed => match E::C::ENDIAN {
188                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
189                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
190            },
191        }
192    }
193}
194
195impl Encode for NonZeroI32 {
196    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
197        self.get().encode(encoder)
198    }
199}
200
201impl Encode for i64 {
202    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
203        match E::C::INT_ENCODING {
204            IntEncoding::Variable => {
205                crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
206            }
207            IntEncoding::Fixed => match E::C::ENDIAN {
208                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
209                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
210            },
211        }
212    }
213}
214
215impl Encode for NonZeroI64 {
216    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
217        self.get().encode(encoder)
218    }
219}
220
221impl Encode for i128 {
222    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
223        match E::C::INT_ENCODING {
224            IntEncoding::Variable => {
225                crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
226            }
227            IntEncoding::Fixed => match E::C::ENDIAN {
228                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
229                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
230            },
231        }
232    }
233}
234
235impl Encode for NonZeroI128 {
236    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
237        self.get().encode(encoder)
238    }
239}
240
241impl Encode for isize {
242    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
243        match E::C::INT_ENCODING {
244            IntEncoding::Variable => {
245                crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
246            }
247            IntEncoding::Fixed => match E::C::ENDIAN {
248                Endianness::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
249                Endianness::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
250            },
251        }
252    }
253}
254
255impl Encode for NonZeroIsize {
256    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
257        self.get().encode(encoder)
258    }
259}
260
261impl Encode for f32 {
262    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
263        match E::C::ENDIAN {
264            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
265            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
266        }
267    }
268}
269
270impl Encode for f64 {
271    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
272        match E::C::ENDIAN {
273            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
274            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
275        }
276    }
277}
278
279impl<T: Encode> Encode for Wrapping<T> {
280    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
281        self.0.encode(encoder)
282    }
283}
284
285impl<T: Encode> Encode for Reverse<T> {
286    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
287        self.0.encode(encoder)
288    }
289}
290
291impl Encode for char {
292    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
293        encode_utf8(encoder.writer(), *self)
294    }
295}
296
297impl<T> Encode for [T]
298where
299    T: Encode,
300{
301    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
302        super::encode_slice_len(encoder, self.len())?;
303
304        if unty::type_equal::<T, u8>() {
305            // Safety: T = u8
306            let t: &[u8] = unsafe { &*(core::ptr::from_ref::<[T]>(self) as *const [u8]) };
307            encoder.writer().write(t)?;
308            return Ok(());
309        }
310
311        for item in self {
312            item.encode(encoder)?;
313        }
314        Ok(())
315    }
316}
317
318const TAG_CONT: u8 = 0b1000_0000;
319const TAG_TWO_B: u8 = 0b1100_0000;
320const TAG_THREE_B: u8 = 0b1110_0000;
321const TAG_FOUR_B: u8 = 0b1111_0000;
322const MAX_ONE_B: u32 = 0x80;
323const MAX_TWO_B: u32 = 0x800;
324const MAX_THREE_B: u32 = 0x10000;
325
326fn encode_utf8(writer: &mut impl Writer, c: char) -> Result<(), EncodeError> {
327    let code = c as u32;
328
329    if code < MAX_ONE_B {
330        writer.write(&[c as u8])
331    } else if code < MAX_TWO_B {
332        let mut buf = [0u8; 2];
333        buf[0] = ((code >> 6) & 0x1F) as u8 | TAG_TWO_B;
334        buf[1] = (code & 0x3F) as u8 | TAG_CONT;
335        writer.write(&buf)
336    } else if code < MAX_THREE_B {
337        let mut buf = [0u8; 3];
338        buf[0] = ((code >> 12) & 0x0F) as u8 | TAG_THREE_B;
339        buf[1] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
340        buf[2] = (code & 0x3F) as u8 | TAG_CONT;
341        writer.write(&buf)
342    } else {
343        let mut buf = [0u8; 4];
344        buf[0] = ((code >> 18) & 0x07) as u8 | TAG_FOUR_B;
345        buf[1] = ((code >> 12) & 0x3F) as u8 | TAG_CONT;
346        buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
347        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
348        writer.write(&buf)
349    }
350}
351
352impl Encode for str {
353    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
354        self.as_bytes().encode(encoder)
355    }
356}
357
358impl<T, const N: usize> Encode for [T; N]
359where
360    T: Encode,
361{
362    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
363        if unty::type_equal::<T, u8>() {
364            // Safety: this is &[u8; N]
365            let array_slice: &[u8] =
366                unsafe { core::slice::from_raw_parts(self.as_ptr().cast(), N) };
367            encoder.writer().write(array_slice)
368        } else {
369            for item in self {
370                item.encode(encoder)?;
371            }
372            Ok(())
373        }
374    }
375}
376
377impl<T> Encode for Option<T>
378where
379    T: Encode,
380{
381    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
382        super::encode_option_variant(encoder, self.as_ref())?;
383        if let Some(val) = self {
384            val.encode(encoder)?;
385        }
386        Ok(())
387    }
388}
389
390impl<T, U> Encode for Result<T, U>
391where
392    T: Encode,
393    U: Encode,
394{
395    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
396        match self {
397            Ok(val) => {
398                0u32.encode(encoder)?;
399                val.encode(encoder)
400            }
401            Err(err) => {
402                1u32.encode(encoder)?;
403                err.encode(encoder)
404            }
405        }
406    }
407}
408
409impl<T> Encode for Cell<T>
410where
411    T: Encode + Copy,
412{
413    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
414        T::encode(&self.get(), encoder)
415    }
416}
417
418impl<T> Encode for RefCell<T>
419where
420    T: Encode + ?Sized,
421{
422    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
423        let borrow_guard = self
424            .try_borrow()
425            .map_err(|e| EncodeError::RefCellAlreadyBorrowed {
426                inner: e,
427                type_name: core::any::type_name::<Self>(),
428            })?;
429        T::encode(&borrow_guard, encoder)
430    }
431}
432
433impl Encode for Duration {
434    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
435        self.as_secs().encode(encoder)?;
436        self.subsec_nanos().encode(encoder)?;
437        Ok(())
438    }
439}
440
441impl<T> Encode for Range<T>
442where
443    T: Encode,
444{
445    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
446        self.start.encode(encoder)?;
447        self.end.encode(encoder)?;
448        Ok(())
449    }
450}
451
452impl<T> Encode for RangeInclusive<T>
453where
454    T: Encode,
455{
456    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
457        self.start().encode(encoder)?;
458        self.end().encode(encoder)?;
459        Ok(())
460    }
461}
462
463impl<T> Encode for Bound<T>
464where
465    T: Encode,
466{
467    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
468        match self {
469            Self::Unbounded => {
470                0u32.encode(encoder)?;
471            }
472            Self::Included(val) => {
473                1u32.encode(encoder)?;
474                val.encode(encoder)?;
475            }
476            Self::Excluded(val) => {
477                2u32.encode(encoder)?;
478                val.encode(encoder)?;
479            }
480        }
481        Ok(())
482    }
483}
484
485impl<T> Encode for &T
486where
487    T: Encode + ?Sized,
488{
489    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
490        T::encode(self, encoder)
491    }
492}
bincode_next/enc/impls.rs

bincode_next/enc/
impls.rs
