bincode/enc/
impls.rs

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

bincode/enc/
impls.rs
