berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add getters for current configuration values (#681) 

This was inspired by suggestions provided in #598, thanks a lot to
@VictorKoenders.

Fixes #598.

Co-authored-by: Trangar <gpg@trangar.com>
This commit is contained in:
Sebastian Hahn 2023-12-11 09:57:32 +01:00 committed by GitHub
parent 7344ad0c85
commit b31bb67c59
7 changed files with 258 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/config.rs
View File

@ -173,11 +173,31 @@ impl<E, I, L> Configuration<E, I, L> {
pub trait Config: pub trait Config:
InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone
{ {
/// This configuration's Endianness
fn endianness(&self) -> Endianness;
/// This configuration's Integer Encoding
fn int_encoding(&self) -> IntEncoding;
/// This configuration's byte limit, or `None` if no limit is configured
fn limit(&self) -> Option<usize>;
} }
impl<T> Config for T where impl<T> Config for T
T: InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone where
T: InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone,
{ {
fn endianness(&self) -> Endianness {
<T as InternalEndianConfig>::ENDIAN
}
fn int_encoding(&self) -> IntEncoding {
<T as InternalIntEncodingConfig>::INT_ENCODING
}
fn limit(&self) -> Option<usize> {
<T as InternalLimitConfig>::LIMIT
}
} }
/// Encodes all integer types in big endian. /// Encodes all integer types in big endian.
@ -185,7 +205,7 @@ impl<T> Config for T where
pub struct BigEndian {} pub struct BigEndian {}
impl InternalEndianConfig for BigEndian { impl InternalEndianConfig for BigEndian {
const ENDIAN: Endian = Endian::Big; const ENDIAN: Endianness = Endianness::Big;
} }
/// Encodes all integer types in little endian. /// Encodes all integer types in little endian.
@ -193,7 +213,7 @@ impl InternalEndianConfig for BigEndian {
pub struct LittleEndian {} pub struct LittleEndian {}
impl InternalEndianConfig for LittleEndian { impl InternalEndianConfig for LittleEndian {
const ENDIAN: Endian = Endian::Little; const ENDIAN: Endianness = Endianness::Little;
} }
/// Use fixed-size integer encoding. /// Use fixed-size integer encoding.
@ -226,21 +246,35 @@ impl<const N: usize> InternalLimitConfig for Limit<N> {
const LIMIT: Option<usize> = Some(N); const LIMIT: Option<usize> = Some(N);
} }
/// Endianness of a `Configuration`.
#[derive(PartialEq, Eq)]
#[non_exhaustive]
pub enum Endianness {
/// Little Endian encoding, see `LittleEndian`.
Little,
/// Big Endian encoding, see `BigEndian`.
Big,
}
/// Integer Encoding of a `Configuration`.
#[derive(PartialEq, Eq)]
#[non_exhaustive]
pub enum IntEncoding {
/// Fixed Integer Encoding, see `Fixint`.
Fixed,
/// Variable Integer Encoding, see `Varint`.
Variable,
}
mod internal { mod internal {
use super::Configuration; use super::{Configuration, Endianness, IntEncoding};
pub trait InternalEndianConfig { pub trait InternalEndianConfig {
const ENDIAN: Endian; const ENDIAN: Endianness;
} }
impl<E: InternalEndianConfig, I, L> InternalEndianConfig for Configuration<E, I, L> { impl<E: InternalEndianConfig, I, L> InternalEndianConfig for Configuration<E, I, L> {
const ENDIAN: Endian = E::ENDIAN; const ENDIAN: Endianness = E::ENDIAN;
}
#[derive(PartialEq, Eq)]
pub enum Endian {
Little,
Big,
} }
pub trait InternalIntEncodingConfig { pub trait InternalIntEncodingConfig {
@ -251,12 +285,6 @@ mod internal {
const INT_ENCODING: IntEncoding = I::INT_ENCODING; const INT_ENCODING: IntEncoding = I::INT_ENCODING;
} }
#[derive(PartialEq, Eq)]
pub enum IntEncoding {
Fixed,
Variable,
}
pub trait InternalLimitConfig { pub trait InternalLimitConfig {
const LIMIT: Option<usize>; const LIMIT: Option<usize>;
} }

50
src/de/impls.rs
View File

@ -3,7 +3,7 @@ use super::{
BorrowDecode, BorrowDecoder, Decode, Decoder, BorrowDecode, BorrowDecoder, Decode, Decoder,
}; };
use crate::{ use crate::{
config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig}, config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
error::{DecodeError, IntegerType}, error::{DecodeError, IntegerType},
impl_borrow_decode, impl_borrow_decode,
}; };
@ -65,8 +65,8 @@ impl Decode for u16 {
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => u16::from_le_bytes(bytes), Endianness::Little => u16::from_le_bytes(bytes),
Endian::Big => u16::from_be_bytes(bytes), Endianness::Big => u16::from_be_bytes(bytes),
}) })
} }
} }
@ -94,8 +94,8 @@ impl Decode for u32 {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => u32::from_le_bytes(bytes), Endianness::Little => u32::from_le_bytes(bytes),
Endian::Big => u32::from_be_bytes(bytes), Endianness::Big => u32::from_be_bytes(bytes),
}) })
} }
} }
@ -123,8 +123,8 @@ impl Decode for u64 {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes), Endianness::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes), Endianness::Big => u64::from_be_bytes(bytes),
}) })
} }
} }
@ -152,8 +152,8 @@ impl Decode for u128 {
let mut bytes = [0u8; 16]; let mut bytes = [0u8; 16];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => u128::from_le_bytes(bytes), Endianness::Little => u128::from_le_bytes(bytes),
Endian::Big => u128::from_be_bytes(bytes), Endianness::Big => u128::from_be_bytes(bytes),
}) })
} }
} }
@ -182,8 +182,8 @@ impl Decode for usize {
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
let value = match D::C::ENDIAN { let value = match D::C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes), Endianness::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes), Endianness::Big => u64::from_be_bytes(bytes),
}; };
value value
@ -234,8 +234,8 @@ impl Decode for i16 {
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => i16::from_le_bytes(bytes), Endianness::Little => i16::from_le_bytes(bytes),
Endian::Big => i16::from_be_bytes(bytes), Endianness::Big => i16::from_be_bytes(bytes),
}) })
} }
} }
@ -263,8 +263,8 @@ impl Decode for i32 {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => i32::from_le_bytes(bytes), Endianness::Little => i32::from_le_bytes(bytes),
Endian::Big => i32::from_be_bytes(bytes), Endianness::Big => i32::from_be_bytes(bytes),
}) })
} }
} }
@ -292,8 +292,8 @@ impl Decode for i64 {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes), Endianness::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes), Endianness::Big => i64::from_be_bytes(bytes),
}) })
} }
} }
@ -321,8 +321,8 @@ impl Decode for i128 {
let mut bytes = [0u8; 16]; let mut bytes = [0u8; 16];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => i128::from_le_bytes(bytes), Endianness::Little => i128::from_le_bytes(bytes),
Endian::Big => i128::from_be_bytes(bytes), Endianness::Big => i128::from_be_bytes(bytes),
}) })
} }
} }
@ -350,8 +350,8 @@ impl Decode for isize {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes), Endianness::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes), Endianness::Big => i64::from_be_bytes(bytes),
} as isize) } as isize)
} }
} }
@ -374,8 +374,8 @@ impl Decode for f32 {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => f32::from_le_bytes(bytes), Endianness::Little => f32::from_le_bytes(bytes),
Endian::Big => f32::from_be_bytes(bytes), Endianness::Big => f32::from_be_bytes(bytes),
}) })
} }
} }
@ -387,8 +387,8 @@ impl Decode for f64 {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN { Ok(match D::C::ENDIAN {
Endian::Little => f64::from_le_bytes(bytes), Endianness::Little => f64::from_le_bytes(bytes),
Endian::Big => f64::from_be_bytes(bytes), Endianness::Big => f64::from_be_bytes(bytes),
}) })
} }
} }

50
src/enc/impls.rs
View File

@ -1,6 +1,6 @@
use super::{write::Writer, Encode, Encoder}; use super::{write::Writer, Encode, Encoder};
use crate::{ use crate::{
config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig}, config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
error::EncodeError, error::EncodeError,
}; };
use core::{ use core::{
@ -51,8 +51,8 @@ impl Encode for u16 {
crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -71,8 +71,8 @@ impl Encode for u32 {
crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -91,8 +91,8 @@ impl Encode for u64 {
crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -111,8 +111,8 @@ impl Encode for u128 {
crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -131,8 +131,8 @@ impl Encode for usize {
crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&(*self as u64).to_be_bytes()), Endianness::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
Endian::Little => encoder.writer().write(&(*self as u64).to_le_bytes()), Endianness::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
}, },
} }
} }
@ -163,8 +163,8 @@ impl Encode for i16 {
crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -183,8 +183,8 @@ impl Encode for i32 {
crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -203,8 +203,8 @@ impl Encode for i64 {
crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -223,8 +223,8 @@ impl Encode for i128 {
crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}, },
} }
} }
@ -243,8 +243,8 @@ impl Encode for isize {
crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
} }
IntEncoding::Fixed => match E::C::ENDIAN { IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&(*self as i64).to_be_bytes()), Endianness::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
Endian::Little => encoder.writer().write(&(*self as i64).to_le_bytes()), Endianness::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
}, },
} }
} }
@ -259,8 +259,8 @@ impl Encode for NonZeroIsize {
impl Encode for f32 { impl Encode for f32 {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN { match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
} }
} }
} }
@ -268,8 +268,8 @@ impl Encode for f32 {
impl Encode for f64 { impl Encode for f64 {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN { match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
} }
} }
} }

18
src/varint/decode_signed.rs
View File

@ -1,10 +1,10 @@
use crate::{ use crate::{
config::Endian, config::Endianness,
de::read::Reader, de::read::Reader,
error::{DecodeError, IntegerType}, error::{DecodeError, IntegerType},
}; };
pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endian) -> Result<i16, DecodeError> { pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endianness) -> Result<i16, DecodeError> {
let n = super::varint_decode_u16(read, endian) let n = super::varint_decode_u16(read, endian)
.map_err(DecodeError::change_integer_type_to_signed)?; .map_err(DecodeError::change_integer_type_to_signed)?;
Ok(if n % 2 == 0 { Ok(if n % 2 == 0 {
@ -21,7 +21,7 @@ pub fn varint_decode_i16<R: Reader>(read: &mut R, endian: Endian) -> Result<i16,
}) })
} }
pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endian) -> Result<i32, DecodeError> { pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endianness) -> Result<i32, DecodeError> {
let n = super::varint_decode_u32(read, endian) let n = super::varint_decode_u32(read, endian)
.map_err(DecodeError::change_integer_type_to_signed)?; .map_err(DecodeError::change_integer_type_to_signed)?;
Ok(if n % 2 == 0 { Ok(if n % 2 == 0 {
@ -38,7 +38,7 @@ pub fn varint_decode_i32<R: Reader>(read: &mut R, endian: Endian) -> Result<i32,
}) })
} }
pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endian) -> Result<i64, DecodeError> { pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endianness) -> Result<i64, DecodeError> {
let n = super::varint_decode_u64(read, endian) let n = super::varint_decode_u64(read, endian)
.map_err(DecodeError::change_integer_type_to_signed)?; .map_err(DecodeError::change_integer_type_to_signed)?;
Ok(if n % 2 == 0 { Ok(if n % 2 == 0 {
@ -55,7 +55,10 @@ pub fn varint_decode_i64<R: Reader>(read: &mut R, endian: Endian) -> Result<i64,
}) })
} }
pub fn varint_decode_i128<R: Reader>(read: &mut R, endian: Endian) -> Result<i128, DecodeError> { pub fn varint_decode_i128<R: Reader>(
read: &mut R,
endian: Endianness,
) -> Result<i128, DecodeError> {
let n = super::varint_decode_u128(read, endian) let n = super::varint_decode_u128(read, endian)
.map_err(DecodeError::change_integer_type_to_signed)?; .map_err(DecodeError::change_integer_type_to_signed)?;
Ok(if n % 2 == 0 { Ok(if n % 2 == 0 {
@ -72,7 +75,10 @@ pub fn varint_decode_i128<R: Reader>(read: &mut R, endian: Endian) -> Result<i12
}) })
} }
pub fn varint_decode_isize<R: Reader>(read: &mut R, endian: Endian) -> Result<isize, DecodeError> { pub fn varint_decode_isize<R: Reader>(
read: &mut R,
endian: Endianness,
) -> Result<isize, DecodeError> {
match varint_decode_i64(read, endian) { match varint_decode_i64(read, endian) {
Ok(val) => Ok(val as isize), Ok(val) => Ok(val as isize),
Err(DecodeError::InvalidIntegerType { found, .. }) => { Err(DecodeError::InvalidIntegerType { found, .. }) => {

156
src/varint/decode_unsigned.rs
View File

@ -2,14 +2,14 @@ use core::{convert::TryInto, u32};
use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE}; use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
use crate::{ use crate::{
config::Endian, config::Endianness,
de::read::Reader, de::read::Reader,
error::{DecodeError, IntegerType}, error::{DecodeError, IntegerType},
}; };
#[inline(never)] #[inline(never)]
#[cold] #[cold]
fn deserialize_varint_cold_u16<R>(read: &mut R, endian: Endian) -> Result<u16, DecodeError> fn deserialize_varint_cold_u16<R>(read: &mut R, endian: Endianness) -> Result<u16, DecodeError>
where where
R: Reader, R: Reader,
{ {
@ -21,8 +21,8 @@ where
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes), Endianness::Big => u16::from_be_bytes(bytes),
Endian::Little => u16::from_le_bytes(bytes), Endianness::Little => u16::from_le_bytes(bytes),
}) })
} }
U32_BYTE => invalid_varint_discriminant(IntegerType::U16, IntegerType::U32), U32_BYTE => invalid_varint_discriminant(IntegerType::U16, IntegerType::U32),
@ -34,7 +34,7 @@ where
#[inline(never)] #[inline(never)]
#[cold] #[cold]
fn deserialize_varint_cold_u32<R>(read: &mut R, endian: Endian) -> Result<u32, DecodeError> fn deserialize_varint_cold_u32<R>(read: &mut R, endian: Endianness) -> Result<u32, DecodeError>
where where
R: Reader, R: Reader,
{ {
@ -46,16 +46,16 @@ where
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u32, Endianness::Big => u16::from_be_bytes(bytes) as u32,
Endian::Little => u16::from_le_bytes(bytes) as u32, Endianness::Little => u16::from_le_bytes(bytes) as u32,
}) })
} }
U32_BYTE => { U32_BYTE => {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes), Endianness::Big => u32::from_be_bytes(bytes),
Endian::Little => u32::from_le_bytes(bytes), Endianness::Little => u32::from_le_bytes(bytes),
}) })
} }
U64_BYTE => invalid_varint_discriminant(IntegerType::U32, IntegerType::U64), U64_BYTE => invalid_varint_discriminant(IntegerType::U32, IntegerType::U64),
@ -66,7 +66,7 @@ where
#[inline(never)] #[inline(never)]
#[cold] #[cold]
fn deserialize_varint_cold_u64<R>(read: &mut R, endian: Endian) -> Result<u64, DecodeError> fn deserialize_varint_cold_u64<R>(read: &mut R, endian: Endianness) -> Result<u64, DecodeError>
where where
R: Reader, R: Reader,
{ {
@ -78,24 +78,24 @@ where
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u64, Endianness::Big => u16::from_be_bytes(bytes) as u64,
Endian::Little => u16::from_le_bytes(bytes) as u64, Endianness::Little => u16::from_le_bytes(bytes) as u64,
}) })
} }
U32_BYTE => { U32_BYTE => {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as u64, Endianness::Big => u32::from_be_bytes(bytes) as u64,
Endian::Little => u32::from_le_bytes(bytes) as u64, Endianness::Little => u32::from_le_bytes(bytes) as u64,
}) })
} }
U64_BYTE => { U64_BYTE => {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes), Endianness::Big => u64::from_be_bytes(bytes),
Endian::Little => u64::from_le_bytes(bytes), Endianness::Little => u64::from_le_bytes(bytes),
}) })
} }
U128_BYTE => invalid_varint_discriminant(IntegerType::U64, IntegerType::U128), U128_BYTE => invalid_varint_discriminant(IntegerType::U64, IntegerType::U128),
@ -105,7 +105,7 @@ where
#[inline(never)] #[inline(never)]
#[cold] #[cold]
fn deserialize_varint_cold_usize<R>(read: &mut R, endian: Endian) -> Result<usize, DecodeError> fn deserialize_varint_cold_usize<R>(read: &mut R, endian: Endianness) -> Result<usize, DecodeError>
where where
R: Reader, R: Reader,
{ {
@ -117,24 +117,24 @@ where
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as usize, Endianness::Big => u16::from_be_bytes(bytes) as usize,
Endian::Little => u16::from_le_bytes(bytes) as usize, Endianness::Little => u16::from_le_bytes(bytes) as usize,
}) })
} }
U32_BYTE => { U32_BYTE => {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as usize, Endianness::Big => u32::from_be_bytes(bytes) as usize,
Endian::Little => u32::from_le_bytes(bytes) as usize, Endianness::Little => u32::from_le_bytes(bytes) as usize,
}) })
} }
U64_BYTE => { U64_BYTE => {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes) as usize, Endianness::Big => u64::from_be_bytes(bytes) as usize,
Endian::Little => u64::from_le_bytes(bytes) as usize, Endianness::Little => u64::from_le_bytes(bytes) as usize,
}) })
} }
U128_BYTE => invalid_varint_discriminant(IntegerType::Usize, IntegerType::U128), U128_BYTE => invalid_varint_discriminant(IntegerType::Usize, IntegerType::U128),
@ -144,7 +144,7 @@ where
#[inline(never)] #[inline(never)]
#[cold] #[cold]
fn deserialize_varint_cold_u128<R>(read: &mut R, endian: Endian) -> Result<u128, DecodeError> fn deserialize_varint_cold_u128<R>(read: &mut R, endian: Endianness) -> Result<u128, DecodeError>
where where
R: Reader, R: Reader,
{ {
@ -156,32 +156,32 @@ where
let mut bytes = [0u8; 2]; let mut bytes = [0u8; 2];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u128, Endianness::Big => u16::from_be_bytes(bytes) as u128,
Endian::Little => u16::from_le_bytes(bytes) as u128, Endianness::Little => u16::from_le_bytes(bytes) as u128,
}) })
} }
U32_BYTE => { U32_BYTE => {
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as u128, Endianness::Big => u32::from_be_bytes(bytes) as u128,
Endian::Little => u32::from_le_bytes(bytes) as u128, Endianness::Little => u32::from_le_bytes(bytes) as u128,
}) })
} }
U64_BYTE => { U64_BYTE => {
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes) as u128, Endianness::Big => u64::from_be_bytes(bytes) as u128,
Endian::Little => u64::from_le_bytes(bytes) as u128, Endianness::Little => u64::from_le_bytes(bytes) as u128,
}) })
} }
U128_BYTE => { U128_BYTE => {
let mut bytes = [0u8; 16]; let mut bytes = [0u8; 16];
read.read(&mut bytes)?; read.read(&mut bytes)?;
Ok(match endian { Ok(match endian {
Endian::Big => u128::from_be_bytes(bytes), Endianness::Big => u128::from_be_bytes(bytes),
Endian::Little => u128::from_le_bytes(bytes), Endianness::Little => u128::from_le_bytes(bytes),
}) })
} }
_ => invalid_varint_discriminant(IntegerType::U128, IntegerType::Reserved), _ => invalid_varint_discriminant(IntegerType::U128, IntegerType::Reserved),
@ -197,15 +197,15 @@ fn invalid_varint_discriminant<T>(
Err(DecodeError::InvalidIntegerType { expected, found }) Err(DecodeError::InvalidIntegerType { expected, found })
} }
pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endian) -> Result<u16, DecodeError> { pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endianness) -> Result<u16, DecodeError> {
if let Some(bytes) = read.peek_read(3) { if let Some(bytes) = read.peek_read(3) {
let (discriminant, bytes) = bytes.split_at(1); let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] { let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u16, 1), byte @ 0..=SINGLE_BYTE_MAX => (byte as u16, 1),
U16_BYTE => { U16_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()), Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()), Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
}; };
(val, 3) (val, 3)
@ -223,23 +223,23 @@ pub fn varint_decode_u16<R: Reader>(read: &mut R, endian: Endian) -> Result<u16,
} }
} }
pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endian) -> Result<u32, DecodeError> { pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endianness) -> Result<u32, DecodeError> {
if let Some(bytes) = read.peek_read(5) { if let Some(bytes) = read.peek_read(5) {
let (discriminant, bytes) = bytes.split_at(1); let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] { let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u32, 1), byte @ 0..=SINGLE_BYTE_MAX => (byte as u32, 1),
U16_BYTE => { U16_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()), Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()), Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
}; };
(val as u32, 3) (val as u32, 3)
} }
U32_BYTE => { U32_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()), Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()), Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
}; };
(val, 5) (val, 5)
@ -256,31 +256,31 @@ pub fn varint_decode_u32<R: Reader>(read: &mut R, endian: Endian) -> Result<u32,
} }
} }
pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endian) -> Result<u64, DecodeError> { pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endianness) -> Result<u64, DecodeError> {
if let Some(bytes) = read.peek_read(9) { if let Some(bytes) = read.peek_read(9) {
let (discriminant, bytes) = bytes.split_at(1); let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] { let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u64, 1), byte @ 0..=SINGLE_BYTE_MAX => (byte as u64, 1),
U16_BYTE => { U16_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()), Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()), Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
}; };
(val as u64, 3) (val as u64, 3)
} }
U32_BYTE => { U32_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()), Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()), Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
}; };
(val as u64, 5) (val as u64, 5)
} }
U64_BYTE => { U64_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()), Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()), Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
}; };
(val, 9) (val, 9)
@ -296,31 +296,34 @@ pub fn varint_decode_u64<R: Reader>(read: &mut R, endian: Endian) -> Result<u64,
} }
} }
pub fn varint_decode_usize<R: Reader>(read: &mut R, endian: Endian) -> Result<usize, DecodeError> { pub fn varint_decode_usize<R: Reader>(
read: &mut R,
endian: Endianness,
) -> Result<usize, DecodeError> {
if let Some(bytes) = read.peek_read(9) { if let Some(bytes) = read.peek_read(9) {
let (discriminant, bytes) = bytes.split_at(1); let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] { let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as usize, 1), byte @ 0..=SINGLE_BYTE_MAX => (byte as usize, 1),
U16_BYTE => { U16_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()), Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()), Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
}; };
(val as usize, 3) (val as usize, 3)
} }
U32_BYTE => { U32_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()), Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()), Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
}; };
(val as usize, 5) (val as usize, 5)
} }
U64_BYTE => { U64_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()), Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()), Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
}; };
(val as usize, 9) (val as usize, 9)
@ -336,39 +339,42 @@ pub fn varint_decode_usize<R: Reader>(read: &mut R, endian: Endian) -> Result<us
} }
} }
pub fn varint_decode_u128<R: Reader>(read: &mut R, endian: Endian) -> Result<u128, DecodeError> { pub fn varint_decode_u128<R: Reader>(
read: &mut R,
endian: Endianness,
) -> Result<u128, DecodeError> {
if let Some(bytes) = read.peek_read(17) { if let Some(bytes) = read.peek_read(17) {
let (discriminant, bytes) = bytes.split_at(1); let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] { let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u128, 1), byte @ 0..=SINGLE_BYTE_MAX => (byte as u128, 1),
U16_BYTE => { U16_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()), Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()), Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
}; };
(val as u128, 3) (val as u128, 3)
} }
U32_BYTE => { U32_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()), Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()), Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
}; };
(val as u128, 5) (val as u128, 5)
} }
U64_BYTE => { U64_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()), Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()), Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
}; };
(val as u128, 9) (val as u128, 9)
} }
U128_BYTE => { U128_BYTE => {
let val = match endian { let val = match endian {
Endian::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()), Endianness::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()),
Endian::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()), Endianness::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()),
}; };
(val, 17) (val, 17)
@ -392,11 +398,11 @@ fn test_decode_u16() {
]; ];
for &(slice, expected_le, expected_be) in cases { for &(slice, expected_le, expected_be) in cases {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u16(&mut reader, Endian::Little).unwrap(); let found = varint_decode_u16(&mut reader, Endianness::Little).unwrap();
assert_eq!(expected_le, found); assert_eq!(expected_le, found);
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u16(&mut reader, Endian::Big).unwrap(); let found = varint_decode_u16(&mut reader, Endianness::Big).unwrap();
assert_eq!(expected_be, found); assert_eq!(expected_be, found);
} }
@ -428,7 +434,7 @@ fn test_decode_u16() {
for (slice, expected) in errors { for (slice, expected) in errors {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u16(&mut reader, Endian::Little).unwrap_err(); let found = varint_decode_u16(&mut reader, Endianness::Little).unwrap_err();
assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found)); assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
} }
} }
@ -443,11 +449,11 @@ fn test_decode_u32() {
]; ];
for &(slice, expected_le, expected_be) in cases { for &(slice, expected_le, expected_be) in cases {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u32(&mut reader, Endian::Little).unwrap(); let found = varint_decode_u32(&mut reader, Endianness::Little).unwrap();
assert_eq!(expected_le, found); assert_eq!(expected_le, found);
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u32(&mut reader, Endian::Big).unwrap(); let found = varint_decode_u32(&mut reader, Endianness::Big).unwrap();
assert_eq!(expected_be, found); assert_eq!(expected_be, found);
} }
@ -482,7 +488,7 @@ fn test_decode_u32() {
for (slice, expected) in errors { for (slice, expected) in errors {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u32(&mut reader, Endian::Little).unwrap_err(); let found = varint_decode_u32(&mut reader, Endianness::Little).unwrap_err();
assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found)); assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
} }
} }
@ -502,11 +508,11 @@ fn test_decode_u64() {
]; ];
for &(slice, expected_le, expected_be) in cases { for &(slice, expected_le, expected_be) in cases {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u64(&mut reader, Endian::Little).unwrap(); let found = varint_decode_u64(&mut reader, Endianness::Little).unwrap();
assert_eq!(expected_le, found); assert_eq!(expected_le, found);
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u64(&mut reader, Endian::Big).unwrap(); let found = varint_decode_u64(&mut reader, Endianness::Big).unwrap();
assert_eq!(expected_be, found); assert_eq!(expected_be, found);
} }
@ -560,7 +566,7 @@ fn test_decode_u64() {
for (slice, expected) in errors { for (slice, expected) in errors {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u64(&mut reader, Endian::Little).unwrap_err(); let found = varint_decode_u64(&mut reader, Endianness::Little).unwrap_err();
assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found)); assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
} }
} }
@ -585,11 +591,11 @@ fn test_decode_u128() {
]; ];
for &(slice, expected_le, expected_be) in cases { for &(slice, expected_le, expected_be) in cases {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u128(&mut reader, Endian::Little).unwrap(); let found = varint_decode_u128(&mut reader, Endianness::Little).unwrap();
assert_eq!(expected_le, found); assert_eq!(expected_le, found);
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u128(&mut reader, Endian::Big).unwrap(); let found = varint_decode_u128(&mut reader, Endianness::Big).unwrap();
assert_eq!(expected_be, found); assert_eq!(expected_be, found);
} }
@ -697,7 +703,7 @@ fn test_decode_u128() {
for (slice, expected) in errors { for (slice, expected) in errors {
let mut reader = crate::de::read::SliceReader::new(slice); let mut reader = crate::de::read::SliceReader::new(slice);
let found = varint_decode_u128(&mut reader, Endian::Little).unwrap_err(); let found = varint_decode_u128(&mut reader, Endianness::Little).unwrap_err();
std::dbg!(slice); std::dbg!(slice);
assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found)); assert_eq!(std::format!("{:?}", expected), std::format!("{:?}", found));
} }

28
src/varint/encode_signed.rs
View File

@ -1,9 +1,9 @@
use super::{varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64}; use super::{varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64};
use crate::{config::Endian, enc::write::Writer, error::EncodeError}; use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
pub fn varint_encode_i16<W: Writer>( pub fn varint_encode_i16<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: i16, val: i16,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
varint_encode_u16( varint_encode_u16(
@ -22,7 +22,7 @@ pub fn varint_encode_i16<W: Writer>(
pub fn varint_encode_i32<W: Writer>( pub fn varint_encode_i32<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: i32, val: i32,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
varint_encode_u32( varint_encode_u32(
@ -41,7 +41,7 @@ pub fn varint_encode_i32<W: Writer>(
pub fn varint_encode_i64<W: Writer>( pub fn varint_encode_i64<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: i64, val: i64,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
varint_encode_u64( varint_encode_u64(
@ -60,7 +60,7 @@ pub fn varint_encode_i64<W: Writer>(
pub fn varint_encode_i128<W: Writer>( pub fn varint_encode_i128<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: i128, val: i128,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
varint_encode_u128( varint_encode_u128(
@ -79,7 +79,7 @@ pub fn varint_encode_i128<W: Writer>(
pub fn varint_encode_isize<W: Writer>( pub fn varint_encode_isize<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: isize, val: isize,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
// isize is being encoded as a i64 // isize is being encoded as a i64
@ -116,14 +116,14 @@ fn test_encode_i16() {
// Little endian // Little endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i16(&mut writer, Endian::Little, value).unwrap(); varint_encode_i16(&mut writer, Endianness::Little, value).unwrap();
assert_eq!(writer.bytes_written(), expected_le.len()); assert_eq!(writer.bytes_written(), expected_le.len());
assert_eq!(&buffer[..expected_le.len()], expected_le); assert_eq!(&buffer[..expected_le.len()], expected_le);
// Big endian // Big endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i16(&mut writer, Endian::Big, value).unwrap(); varint_encode_i16(&mut writer, Endianness::Big, value).unwrap();
assert_eq!(writer.bytes_written(), expected_be.len()); assert_eq!(writer.bytes_written(), expected_be.len());
assert_eq!(&buffer[..expected_be.len()], expected_be); assert_eq!(&buffer[..expected_be.len()], expected_be);
@ -165,14 +165,14 @@ fn test_encode_i32() {
// Little endian // Little endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i32(&mut writer, Endian::Little, value).unwrap(); varint_encode_i32(&mut writer, Endianness::Little, value).unwrap();
assert_eq!(writer.bytes_written(), expected_le.len()); assert_eq!(writer.bytes_written(), expected_le.len());
assert_eq!(&buffer[..expected_le.len()], expected_le); assert_eq!(&buffer[..expected_le.len()], expected_le);
// Big endian // Big endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i32(&mut writer, Endian::Big, value).unwrap(); varint_encode_i32(&mut writer, Endianness::Big, value).unwrap();
assert_eq!(writer.bytes_written(), expected_be.len()); assert_eq!(writer.bytes_written(), expected_be.len());
assert_eq!(&buffer[..expected_be.len()], expected_be); assert_eq!(&buffer[..expected_be.len()], expected_be);
@ -219,14 +219,14 @@ fn test_encode_i64() {
// Little endian // Little endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i64(&mut writer, Endian::Little, value).unwrap(); varint_encode_i64(&mut writer, Endianness::Little, value).unwrap();
assert_eq!(writer.bytes_written(), expected_le.len()); assert_eq!(writer.bytes_written(), expected_le.len());
assert_eq!(&buffer[..expected_le.len()], expected_le); assert_eq!(&buffer[..expected_le.len()], expected_le);
// Big endian // Big endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i64(&mut writer, Endian::Big, value).unwrap(); varint_encode_i64(&mut writer, Endianness::Big, value).unwrap();
assert_eq!(writer.bytes_written(), expected_be.len()); assert_eq!(writer.bytes_written(), expected_be.len());
assert_eq!(&buffer[..expected_be.len()], expected_be); assert_eq!(&buffer[..expected_be.len()], expected_be);
@ -303,14 +303,14 @@ fn test_encode_i128() {
// Little endian // Little endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i128(&mut writer, Endian::Little, value).unwrap(); varint_encode_i128(&mut writer, Endianness::Little, value).unwrap();
assert_eq!(writer.bytes_written(), expected_le.len()); assert_eq!(writer.bytes_written(), expected_le.len());
assert_eq!(&buffer[..expected_le.len()], expected_le); assert_eq!(&buffer[..expected_le.len()], expected_le);
// Big endian // Big endian
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_i128(&mut writer, Endian::Big, value).unwrap(); varint_encode_i128(&mut writer, Endianness::Big, value).unwrap();
assert_eq!(writer.bytes_written(), expected_be.len()); assert_eq!(writer.bytes_written(), expected_be.len());
assert_eq!(&buffer[..expected_be.len()], expected_be); assert_eq!(&buffer[..expected_be.len()], expected_be);

108
src/varint/encode_unsigned.rs
View File

@ -1,9 +1,9 @@
use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE}; use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
use crate::{config::Endian, enc::write::Writer, error::EncodeError}; use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
pub fn varint_encode_u16<W: Writer>( pub fn varint_encode_u16<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: u16, val: u16,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ { if val <= SINGLE_BYTE_MAX as _ {
@ -11,15 +11,15 @@ pub fn varint_encode_u16<W: Writer>(
} else { } else {
writer.write(&[U16_BYTE])?; writer.write(&[U16_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&val.to_be_bytes()), Endianness::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()), Endianness::Little => writer.write(&val.to_le_bytes()),
} }
} }
} }
pub fn varint_encode_u32<W: Writer>( pub fn varint_encode_u32<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: u32, val: u32,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ { if val <= SINGLE_BYTE_MAX as _ {
@ -27,21 +27,21 @@ pub fn varint_encode_u32<W: Writer>(
} else if val <= u16::MAX as _ { } else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?; writer.write(&[U16_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()), Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()), Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
} }
} else { } else {
writer.write(&[U32_BYTE])?; writer.write(&[U32_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&val.to_be_bytes()), Endianness::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()), Endianness::Little => writer.write(&val.to_le_bytes()),
} }
} }
} }
pub fn varint_encode_u64<W: Writer>( pub fn varint_encode_u64<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: u64, val: u64,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ { if val <= SINGLE_BYTE_MAX as _ {
@ -49,27 +49,27 @@ pub fn varint_encode_u64<W: Writer>(
} else if val <= u16::MAX as _ { } else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?; writer.write(&[U16_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()), Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()), Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
} }
} else if val <= u32::MAX as _ { } else if val <= u32::MAX as _ {
writer.write(&[U32_BYTE])?; writer.write(&[U32_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u32).to_be_bytes()), Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
Endian::Little => writer.write(&(val as u32).to_le_bytes()), Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
} }
} else { } else {
writer.write(&[U64_BYTE])?; writer.write(&[U64_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&val.to_be_bytes()), Endianness::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()), Endianness::Little => writer.write(&val.to_le_bytes()),
} }
} }
} }
pub fn varint_encode_u128<W: Writer>( pub fn varint_encode_u128<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: u128, val: u128,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ { if val <= SINGLE_BYTE_MAX as _ {
@ -77,33 +77,33 @@ pub fn varint_encode_u128<W: Writer>(
} else if val <= u16::MAX as _ { } else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?; writer.write(&[U16_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()), Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()), Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
} }
} else if val <= u32::MAX as _ { } else if val <= u32::MAX as _ {
writer.write(&[U32_BYTE])?; writer.write(&[U32_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u32).to_be_bytes()), Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
Endian::Little => writer.write(&(val as u32).to_le_bytes()), Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
} }
} else if val <= u64::MAX as _ { } else if val <= u64::MAX as _ {
writer.write(&[U64_BYTE])?; writer.write(&[U64_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&(val as u64).to_be_bytes()), Endianness::Big => writer.write(&(val as u64).to_be_bytes()),
Endian::Little => writer.write(&(val as u64).to_le_bytes()), Endianness::Little => writer.write(&(val as u64).to_le_bytes()),
} }
} else { } else {
writer.write(&[U128_BYTE])?; writer.write(&[U128_BYTE])?;
match endian { match endian {
Endian::Big => writer.write(&val.to_be_bytes()), Endianness::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()), Endianness::Little => writer.write(&val.to_le_bytes()),
} }
} }
} }
pub fn varint_encode_usize<W: Writer>( pub fn varint_encode_usize<W: Writer>(
writer: &mut W, writer: &mut W,
endian: Endian, endian: Endianness,
val: usize, val: usize,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
// usize is being encoded as a u64 // usize is being encoded as a u64
@ -118,13 +118,13 @@ fn test_encode_u16() {
// these should all encode to a single byte // these should all encode to a single byte
for i in 0u16..=SINGLE_BYTE_MAX as u16 { for i in 0u16..=SINGLE_BYTE_MAX as u16 {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u16(&mut writer, Endian::Big, i).unwrap(); varint_encode_u16(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u16, i); assert_eq!(buffer[0] as u16, i);
// Assert endianness doesn't matter // Assert endianness doesn't matter
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u16(&mut writer, Endian::Little, i).unwrap(); varint_encode_u16(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u16, i); assert_eq!(buffer[0] as u16, i);
} }
@ -141,13 +141,13 @@ fn test_encode_u16() {
u16::MAX, u16::MAX,
] { ] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u16(&mut writer, Endian::Big, i).unwrap(); varint_encode_u16(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &i.to_be_bytes()); assert_eq!(&buffer[1..3], &i.to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u16(&mut writer, Endian::Little, i).unwrap(); varint_encode_u16(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &i.to_le_bytes()); assert_eq!(&buffer[1..3], &i.to_le_bytes());
@ -162,13 +162,13 @@ fn test_encode_u32() {
// these should all encode to a single byte // these should all encode to a single byte
for i in 0u32..=SINGLE_BYTE_MAX as u32 { for i in 0u32..=SINGLE_BYTE_MAX as u32 {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Big, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u32, i); assert_eq!(buffer[0] as u32, i);
// Assert endianness doesn't matter // Assert endianness doesn't matter
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Little, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u32, i); assert_eq!(buffer[0] as u32, i);
} }
@ -185,13 +185,13 @@ fn test_encode_u32() {
u16::MAX as u32, u16::MAX as u32,
] { ] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Big, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Little, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@ -201,13 +201,13 @@ fn test_encode_u32() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u16::MAX as u32 + 1, 100_000, 1_000_000, u32::MAX] { for i in [u16::MAX as u32 + 1, 100_000, 1_000_000, u32::MAX] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Big, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &i.to_be_bytes()); assert_eq!(&buffer[1..5], &i.to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u32(&mut writer, Endian::Little, i).unwrap(); varint_encode_u32(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &i.to_le_bytes()); assert_eq!(&buffer[1..5], &i.to_le_bytes());
@ -222,13 +222,13 @@ fn test_encode_u64() {
// these should all encode to a single byte // these should all encode to a single byte
for i in 0u64..=SINGLE_BYTE_MAX as u64 { for i in 0u64..=SINGLE_BYTE_MAX as u64 {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Big, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u64, i); assert_eq!(buffer[0] as u64, i);
// Assert endianness doesn't matter // Assert endianness doesn't matter
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Little, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u64, i); assert_eq!(buffer[0] as u64, i);
} }
@ -245,13 +245,13 @@ fn test_encode_u64() {
u16::MAX as u64, u16::MAX as u64,
] { ] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Big, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Little, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@ -261,13 +261,13 @@ fn test_encode_u64() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u16::MAX as u64 + 1, 100_000, 1_000_000, u32::MAX as u64] { for i in [u16::MAX as u64 + 1, 100_000, 1_000_000, u32::MAX as u64] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Big, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes()); assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Little, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes()); assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes());
@ -277,13 +277,13 @@ fn test_encode_u64() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u32::MAX as u64 + 1, 5_000_000_000, u64::MAX] { for i in [u32::MAX as u64 + 1, 5_000_000_000, u64::MAX] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Big, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 9); assert_eq!(writer.bytes_written(), 9);
assert_eq!(buffer[0], U64_BYTE); assert_eq!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &i.to_be_bytes()); assert_eq!(&buffer[1..9], &i.to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u64(&mut writer, Endian::Little, i).unwrap(); varint_encode_u64(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 9); assert_eq!(writer.bytes_written(), 9);
assert_eq!(buffer[0], U64_BYTE); assert_eq!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &i.to_le_bytes()); assert_eq!(&buffer[1..9], &i.to_le_bytes());
@ -298,13 +298,13 @@ fn test_encode_u128() {
// these should all encode to a single byte // these should all encode to a single byte
for i in 0u128..=SINGLE_BYTE_MAX as u128 { for i in 0u128..=SINGLE_BYTE_MAX as u128 {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Big, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u128, i); assert_eq!(buffer[0] as u128, i);
// Assert endianness doesn't matter // Assert endianness doesn't matter
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Little, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 1); assert_eq!(writer.bytes_written(), 1);
assert_eq!(buffer[0] as u128, i); assert_eq!(buffer[0] as u128, i);
} }
@ -321,13 +321,13 @@ fn test_encode_u128() {
u16::MAX as u128, u16::MAX as u128,
] { ] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Big, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Little, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 3); assert_eq!(writer.bytes_written(), 3);
assert_eq!(buffer[0], U16_BYTE); assert_eq!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes()); assert_eq!(&buffer[1..3], &(i as u16).to_le_bytes());
@ -337,13 +337,13 @@ fn test_encode_u128() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u16::MAX as u128 + 1, 100_000, 1_000_000, u32::MAX as u128] { for i in [u16::MAX as u128 + 1, 100_000, 1_000_000, u32::MAX as u128] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Big, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes()); assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Little, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 5); assert_eq!(writer.bytes_written(), 5);
assert_eq!(buffer[0], U32_BYTE); assert_eq!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes()); assert_eq!(&buffer[1..5], &(i as u32).to_le_bytes());
@ -353,13 +353,13 @@ fn test_encode_u128() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u32::MAX as u128 + 1, 5_000_000_000, u64::MAX as u128] { for i in [u32::MAX as u128 + 1, 5_000_000_000, u64::MAX as u128] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Big, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 9); assert_eq!(writer.bytes_written(), 9);
assert_eq!(buffer[0], U64_BYTE); assert_eq!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &(i as u64).to_be_bytes()); assert_eq!(&buffer[1..9], &(i as u64).to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Little, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 9); assert_eq!(writer.bytes_written(), 9);
assert_eq!(buffer[0], U64_BYTE); assert_eq!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &(i as u64).to_le_bytes()); assert_eq!(&buffer[1..9], &(i as u64).to_le_bytes());
@ -369,13 +369,13 @@ fn test_encode_u128() {
// Values chosen at random, add new cases as needed // Values chosen at random, add new cases as needed
for i in [u64::MAX as u128 + 1, u128::MAX] { for i in [u64::MAX as u128 + 1, u128::MAX] {
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Big, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Big, i).unwrap();
assert_eq!(writer.bytes_written(), 17); assert_eq!(writer.bytes_written(), 17);
assert_eq!(buffer[0], U128_BYTE); assert_eq!(buffer[0], U128_BYTE);
assert_eq!(&buffer[1..17], &i.to_be_bytes()); assert_eq!(&buffer[1..17], &i.to_be_bytes());
let mut writer = SliceWriter::new(&mut buffer); let mut writer = SliceWriter::new(&mut buffer);
varint_encode_u128(&mut writer, Endian::Little, i).unwrap(); varint_encode_u128(&mut writer, Endianness::Little, i).unwrap();
assert_eq!(writer.bytes_written(), 17); assert_eq!(writer.bytes_written(), 17);
assert_eq!(buffer[0], U128_BYTE); assert_eq!(buffer[0], U128_BYTE);
assert_eq!(&buffer[1..17], &i.to_le_bytes()); assert_eq!(&buffer[1..17], &i.to_le_bytes());