/rust/registry/src/index.crates.io-1949cf8c6b5b557f/bincode-2.0.1/src/enc/impls.rs

Source
use super::{write::Writer, Encode, Encoder};
use crate::{
    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
    error::EncodeError,
};
use core::cmp::Reverse;
use core::{
    cell::{Cell, RefCell},
    marker::PhantomData,
    num::{
        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
    },
    ops::{Bound, Range, RangeInclusive},
    time::Duration,
};

impl Encode for () {
    fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
        Ok(())
    }
}

impl<T> Encode for PhantomData<T> {
    fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
        Ok(())
    }
}

impl Encode for bool {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        u8::from(*self).encode(encoder)
    }
}

impl Encode for u8 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.writer().write(&[*self])
    }
}

impl Encode for NonZeroU8 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for u16 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroU16 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for u32 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroU32 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for u64 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroU64 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for u128 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroU128 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for usize {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
                Endianness::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroUsize {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for i8 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.writer().write(&[*self as u8])
    }
}

impl Encode for NonZeroI8 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for i16 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroI16 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for i32 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroI32 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for i64 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroI64 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for i128 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
                Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroI128 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for isize {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::INT_ENCODING {
            IntEncoding::Variable => {
                crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
            }
            IntEncoding::Fixed => match E::C::ENDIAN {
                Endianness::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
                Endianness::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
            },
        }
    }
}

impl Encode for NonZeroIsize {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.get().encode(encoder)
    }
}

impl Encode for f32 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::ENDIAN {
            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
        }
    }
}

impl Encode for f64 {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match E::C::ENDIAN {
            Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
            Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
        }
    }
}

impl<T: Encode> Encode for Wrapping<T> {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.0.encode(encoder)
    }
}

impl<T: Encode> Encode for Reverse<T> {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.0.encode(encoder)
    }
}

impl Encode for char {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encode_utf8(encoder.writer(), *self)
    }
}

impl<T> Encode for [T]
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        super::encode_slice_len(encoder, self.len())?;

        if unty::type_equal::<T, u8>() {
            // Safety: T = u8
            let t: &[u8] = unsafe { core::mem::transmute(self) };
            encoder.writer().write(t)?;
            return Ok(());
        }

        for item in self {
            item.encode(encoder)?;
        }
        Ok(())
    }
}

const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;

fn encode_utf8(writer: &mut impl Writer, c: char) -> Result<(), EncodeError> {
    let code = c as u32;

    if code < MAX_ONE_B {
        writer.write(&[c as u8])
    } else if code < MAX_TWO_B {
        let mut buf = [0u8; 2];
        buf[0] = ((code >> 6) & 0x1F) as u8 | TAG_TWO_B;
        buf[1] = (code & 0x3F) as u8 | TAG_CONT;
        writer.write(&buf)
    } else if code < MAX_THREE_B {
        let mut buf = [0u8; 3];
        buf[0] = ((code >> 12) & 0x0F) as u8 | TAG_THREE_B;
        buf[1] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
        buf[2] = (code & 0x3F) as u8 | TAG_CONT;
        writer.write(&buf)
    } else {
        let mut buf = [0u8; 4];
        buf[0] = ((code >> 18) & 0x07) as u8 | TAG_FOUR_B;
        buf[1] = ((code >> 12) & 0x3F) as u8 | TAG_CONT;
        buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        writer.write(&buf)
    }
}

impl Encode for str {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.as_bytes().encode(encoder)
    }
}

impl<T, const N: usize> Encode for [T; N]
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        if unty::type_equal::<T, u8>() {
            // Safety: this is &[u8; N]
            let array_slice: &[u8] =
                unsafe { core::slice::from_raw_parts(self.as_ptr().cast(), N) };
            encoder.writer().write(array_slice)
        } else {
            for item in self.iter() {
                item.encode(encoder)?;
            }
            Ok(())
        }
    }
}

impl<T> Encode for Option<T>
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        super::encode_option_variant(encoder, self)?;
        if let Some(val) = self {
            val.encode(encoder)?;
        }
        Ok(())
    }
}

impl<T, U> Encode for Result<T, U>
where
    T: Encode,
    U: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match self {
            Ok(val) => {
                0u32.encode(encoder)?;
                val.encode(encoder)
            }
            Err(err) => {
                1u32.encode(encoder)?;
                err.encode(encoder)
            }
        }
    }
}

impl<T> Encode for Cell<T>
where
    T: Encode + Copy,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        T::encode(&self.get(), encoder)
    }
}

impl<T> Encode for RefCell<T>
where
    T: Encode + ?Sized,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        let borrow_guard = self
            .try_borrow()
            .map_err(|e| EncodeError::RefCellAlreadyBorrowed {
                inner: e,
                type_name: core::any::type_name::<RefCell<T>>(),
            })?;
        T::encode(&borrow_guard, encoder)
    }
}

impl Encode for Duration {
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.as_secs().encode(encoder)?;
        self.subsec_nanos().encode(encoder)?;
        Ok(())
    }
}

impl<T> Encode for Range<T>
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.start.encode(encoder)?;
        self.end.encode(encoder)?;
        Ok(())
    }
}

impl<T> Encode for RangeInclusive<T>
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.start().encode(encoder)?;
        self.end().encode(encoder)?;
        Ok(())
    }
}

impl<T> Encode for Bound<T>
where
    T: Encode,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        match self {
            Self::Unbounded => {
                0u32.encode(encoder)?;
            }
            Self::Included(val) => {
                1u32.encode(encoder)?;
                val.encode(encoder)?;
            }
            Self::Excluded(val) => {
                2u32.encode(encoder)?;
                val.encode(encoder)?;
            }
        }
        Ok(())
    }
}

impl<T> Encode for &T
where
    T: Encode + ?Sized,
{
    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
        T::encode(self, encoder)
    }
}

Coverage Report

Created: 2026-11-03 08:22

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