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:
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
T: InternalEndianConfig + InternalIntEncodingConfig + InternalLimitConfig + Copy + Clone
impl<T> Config for T
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.
@ -185,7 +205,7 @@ impl<T> Config for T where
pub struct BigEndian {}
impl InternalEndianConfig for BigEndian {
const ENDIAN: Endian = Endian::Big;
const ENDIAN: Endianness = Endianness::Big;
}
/// Encodes all integer types in little endian.
@ -193,7 +213,7 @@ impl InternalEndianConfig for BigEndian {
pub struct LittleEndian {}
impl InternalEndianConfig for LittleEndian {
const ENDIAN: Endian = Endian::Little;
const ENDIAN: Endianness = Endianness::Little;
}
/// Use fixed-size integer encoding.
@ -226,21 +246,35 @@ impl<const N: usize> InternalLimitConfig for Limit<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 {
use super::Configuration;
use super::{Configuration, Endianness, IntEncoding};
pub trait InternalEndianConfig {
const ENDIAN: Endian;
const ENDIAN: Endianness;
}
impl<E: InternalEndianConfig, I, L> InternalEndianConfig for Configuration<E, I, L> {
const ENDIAN: Endian = E::ENDIAN;
}
#[derive(PartialEq, Eq)]
pub enum Endian {
Little,
Big,
const ENDIAN: Endianness = E::ENDIAN;
}
pub trait InternalIntEncodingConfig {
@ -251,12 +285,6 @@ mod internal {
const INT_ENCODING: IntEncoding = I::INT_ENCODING;
}
#[derive(PartialEq, Eq)]
pub enum IntEncoding {
Fixed,
Variable,
}
pub trait InternalLimitConfig {
const LIMIT: Option<usize>;
}

50
src/de/impls.rs
View File

@ -3,7 +3,7 @@ use super::{
BorrowDecode, BorrowDecoder, Decode, Decoder,
};
use crate::{
config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
error::{DecodeError, IntegerType},
impl_borrow_decode,
};
@ -65,8 +65,8 @@ impl Decode for u16 {
let mut bytes = [0u8; 2];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => u16::from_le_bytes(bytes),
Endian::Big => u16::from_be_bytes(bytes),
Endianness::Little => u16::from_le_bytes(bytes),
Endianness::Big => u16::from_be_bytes(bytes),
})
}
}
@ -94,8 +94,8 @@ impl Decode for u32 {
let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => u32::from_le_bytes(bytes),
Endian::Big => u32::from_be_bytes(bytes),
Endianness::Little => u32::from_le_bytes(bytes),
Endianness::Big => u32::from_be_bytes(bytes),
})
}
}
@ -123,8 +123,8 @@ impl Decode for u64 {
let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes),
Endianness::Little => u64::from_le_bytes(bytes),
Endianness::Big => u64::from_be_bytes(bytes),
})
}
}
@ -152,8 +152,8 @@ impl Decode for u128 {
let mut bytes = [0u8; 16];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => u128::from_le_bytes(bytes),
Endian::Big => u128::from_be_bytes(bytes),
Endianness::Little => u128::from_le_bytes(bytes),
Endianness::Big => u128::from_be_bytes(bytes),
})
}
}
@ -182,8 +182,8 @@ impl Decode for usize {
decoder.reader().read(&mut bytes)?;
let value = match D::C::ENDIAN {
Endian::Little => u64::from_le_bytes(bytes),
Endian::Big => u64::from_be_bytes(bytes),
Endianness::Little => u64::from_le_bytes(bytes),
Endianness::Big => u64::from_be_bytes(bytes),
};
value
@ -234,8 +234,8 @@ impl Decode for i16 {
let mut bytes = [0u8; 2];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => i16::from_le_bytes(bytes),
Endian::Big => i16::from_be_bytes(bytes),
Endianness::Little => i16::from_le_bytes(bytes),
Endianness::Big => i16::from_be_bytes(bytes),
})
}
}
@ -263,8 +263,8 @@ impl Decode for i32 {
let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => i32::from_le_bytes(bytes),
Endian::Big => i32::from_be_bytes(bytes),
Endianness::Little => i32::from_le_bytes(bytes),
Endianness::Big => i32::from_be_bytes(bytes),
})
}
}
@ -292,8 +292,8 @@ impl Decode for i64 {
let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes),
Endianness::Little => i64::from_le_bytes(bytes),
Endianness::Big => i64::from_be_bytes(bytes),
})
}
}
@ -321,8 +321,8 @@ impl Decode for i128 {
let mut bytes = [0u8; 16];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => i128::from_le_bytes(bytes),
Endian::Big => i128::from_be_bytes(bytes),
Endianness::Little => i128::from_le_bytes(bytes),
Endianness::Big => i128::from_be_bytes(bytes),
})
}
}
@ -350,8 +350,8 @@ impl Decode for isize {
let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => i64::from_le_bytes(bytes),
Endian::Big => i64::from_be_bytes(bytes),
Endianness::Little => i64::from_le_bytes(bytes),
Endianness::Big => i64::from_be_bytes(bytes),
} as isize)
}
}
@ -374,8 +374,8 @@ impl Decode for f32 {
let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => f32::from_le_bytes(bytes),
Endian::Big => f32::from_be_bytes(bytes),
Endianness::Little => f32::from_le_bytes(bytes),
Endianness::Big => f32::from_be_bytes(bytes),
})
}
}
@ -387,8 +387,8 @@ impl Decode for f64 {
let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?;
Ok(match D::C::ENDIAN {
Endian::Little => f64::from_le_bytes(bytes),
Endian::Big => f64::from_be_bytes(bytes),
Endianness::Little => f64::from_le_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 crate::{
config::{Endian, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
error::EncodeError,
};
use core::{
@ -51,8 +51,8 @@ impl Encode for u16 {
crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&(*self as u64).to_be_bytes()),
Endian::Little => encoder.writer().write(&(*self as u64).to_le_bytes()),
Endianness::Big => encoder.writer().write(&(*self as u64).to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_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)
}
IntEncoding::Fixed => match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
Endian::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
Endianness::Big => encoder.writer().write(&(*self as i64).to_be_bytes()),
Endianness::Little => encoder.writer().write(&(*self as i64).to_le_bytes()),
},
}
}
@ -259,8 +259,8 @@ impl Encode for NonZeroIsize {
impl Encode for f32 {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}
}
}
@ -268,8 +268,8 @@ impl Encode for f32 {
impl Encode for f64 {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
Endianness::Big => encoder.writer().write(&self.to_be_bytes()),
Endianness::Little => encoder.writer().write(&self.to_le_bytes()),
}
}
}

18
src/varint/decode_signed.rs
View File

@ -1,10 +1,10 @@
use crate::{
config::Endian,
config::Endianness,
de::read::Reader,
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)
.map_err(DecodeError::change_integer_type_to_signed)?;
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)
.map_err(DecodeError::change_integer_type_to_signed)?;
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)
.map_err(DecodeError::change_integer_type_to_signed)?;
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)
.map_err(DecodeError::change_integer_type_to_signed)?;
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) {
Ok(val) => Ok(val as isize),
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 crate::{
config::Endian,
config::Endianness,
de::read::Reader,
error::{DecodeError, IntegerType},
};
#[inline(never)]
#[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
R: Reader,
{
@ -21,8 +21,8 @@ where
let mut bytes = [0u8; 2];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes),
Endian::Little => u16::from_le_bytes(bytes),
Endianness::Big => u16::from_be_bytes(bytes),
Endianness::Little => u16::from_le_bytes(bytes),
})
}
U32_BYTE => invalid_varint_discriminant(IntegerType::U16, IntegerType::U32),
@ -34,7 +34,7 @@ where
#[inline(never)]
#[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
R: Reader,
{
@ -46,16 +46,16 @@ where
let mut bytes = [0u8; 2];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u32,
Endian::Little => u16::from_le_bytes(bytes) as u32,
Endianness::Big => u16::from_be_bytes(bytes) as u32,
Endianness::Little => u16::from_le_bytes(bytes) as u32,
})
}
U32_BYTE => {
let mut bytes = [0u8; 4];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes),
Endian::Little => u32::from_le_bytes(bytes),
Endianness::Big => u32::from_be_bytes(bytes),
Endianness::Little => u32::from_le_bytes(bytes),
})
}
U64_BYTE => invalid_varint_discriminant(IntegerType::U32, IntegerType::U64),
@ -66,7 +66,7 @@ where
#[inline(never)]
#[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
R: Reader,
{
@ -78,24 +78,24 @@ where
let mut bytes = [0u8; 2];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u64,
Endian::Little => u16::from_le_bytes(bytes) as u64,
Endianness::Big => u16::from_be_bytes(bytes) as u64,
Endianness::Little => u16::from_le_bytes(bytes) as u64,
})
}
U32_BYTE => {
let mut bytes = [0u8; 4];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as u64,
Endian::Little => u32::from_le_bytes(bytes) as u64,
Endianness::Big => u32::from_be_bytes(bytes) as u64,
Endianness::Little => u32::from_le_bytes(bytes) as u64,
})
}
U64_BYTE => {
let mut bytes = [0u8; 8];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes),
Endian::Little => u64::from_le_bytes(bytes),
Endianness::Big => u64::from_be_bytes(bytes),
Endianness::Little => u64::from_le_bytes(bytes),
})
}
U128_BYTE => invalid_varint_discriminant(IntegerType::U64, IntegerType::U128),
@ -105,7 +105,7 @@ where
#[inline(never)]
#[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
R: Reader,
{
@ -117,24 +117,24 @@ where
let mut bytes = [0u8; 2];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as usize,
Endian::Little => u16::from_le_bytes(bytes) as usize,
Endianness::Big => u16::from_be_bytes(bytes) as usize,
Endianness::Little => u16::from_le_bytes(bytes) as usize,
})
}
U32_BYTE => {
let mut bytes = [0u8; 4];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as usize,
Endian::Little => u32::from_le_bytes(bytes) as usize,
Endianness::Big => u32::from_be_bytes(bytes) as usize,
Endianness::Little => u32::from_le_bytes(bytes) as usize,
})
}
U64_BYTE => {
let mut bytes = [0u8; 8];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes) as usize,
Endian::Little => u64::from_le_bytes(bytes) as usize,
Endianness::Big => u64::from_be_bytes(bytes) as usize,
Endianness::Little => u64::from_le_bytes(bytes) as usize,
})
}
U128_BYTE => invalid_varint_discriminant(IntegerType::Usize, IntegerType::U128),
@ -144,7 +144,7 @@ where
#[inline(never)]
#[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
R: Reader,
{
@ -156,32 +156,32 @@ where
let mut bytes = [0u8; 2];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u16::from_be_bytes(bytes) as u128,
Endian::Little => u16::from_le_bytes(bytes) as u128,
Endianness::Big => u16::from_be_bytes(bytes) as u128,
Endianness::Little => u16::from_le_bytes(bytes) as u128,
})
}
U32_BYTE => {
let mut bytes = [0u8; 4];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u32::from_be_bytes(bytes) as u128,
Endian::Little => u32::from_le_bytes(bytes) as u128,
Endianness::Big => u32::from_be_bytes(bytes) as u128,
Endianness::Little => u32::from_le_bytes(bytes) as u128,
})
}
U64_BYTE => {
let mut bytes = [0u8; 8];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u64::from_be_bytes(bytes) as u128,
Endian::Little => u64::from_le_bytes(bytes) as u128,
Endianness::Big => u64::from_be_bytes(bytes) as u128,
Endianness::Little => u64::from_le_bytes(bytes) as u128,
})
}
U128_BYTE => {
let mut bytes = [0u8; 16];
read.read(&mut bytes)?;
Ok(match endian {
Endian::Big => u128::from_be_bytes(bytes),
Endian::Little => u128::from_le_bytes(bytes),
Endianness::Big => u128::from_be_bytes(bytes),
Endianness::Little => u128::from_le_bytes(bytes),
})
}
_ => invalid_varint_discriminant(IntegerType::U128, IntegerType::Reserved),
@ -197,15 +197,15 @@ fn invalid_varint_discriminant<T>(
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) {
let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u16, 1),
U16_BYTE => {
let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
};
(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) {
let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u32, 1),
U16_BYTE => {
let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
};
(val as u32, 3)
}
U32_BYTE => {
let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
};
(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) {
let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u64, 1),
U16_BYTE => {
let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
};
(val as u64, 3)
}
U32_BYTE => {
let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
};
(val as u64, 5)
}
U64_BYTE => {
let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
};
(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) {
let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as usize, 1),
U16_BYTE => {
let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
};
(val as usize, 3)
}
U32_BYTE => {
let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
};
(val as usize, 5)
}
U64_BYTE => {
let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
};
(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) {
let (discriminant, bytes) = bytes.split_at(1);
let (out, used) = match discriminant[0] {
byte @ 0..=SINGLE_BYTE_MAX => (byte as u128, 1),
U16_BYTE => {
let val = match endian {
Endian::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endian::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
Endianness::Big => u16::from_be_bytes(bytes[..2].try_into().unwrap()),
Endianness::Little => u16::from_le_bytes(bytes[..2].try_into().unwrap()),
};
(val as u128, 3)
}
U32_BYTE => {
let val = match endian {
Endian::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endian::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
Endianness::Big => u32::from_be_bytes(bytes[..4].try_into().unwrap()),
Endianness::Little => u32::from_le_bytes(bytes[..4].try_into().unwrap()),
};
(val as u128, 5)
}
U64_BYTE => {
let val = match endian {
Endian::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endian::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
Endianness::Big => u64::from_be_bytes(bytes[..8].try_into().unwrap()),
Endianness::Little => u64::from_le_bytes(bytes[..8].try_into().unwrap()),
};
(val as u128, 9)
}
U128_BYTE => {
let val = match endian {
Endian::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()),
Endian::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()),
Endianness::Big => u128::from_be_bytes(bytes[..16].try_into().unwrap()),
Endianness::Little => u128::from_le_bytes(bytes[..16].try_into().unwrap()),
};
(val, 17)
@ -392,11 +398,11 @@ fn test_decode_u16() {
];
for &(slice, expected_le, expected_be) in cases {
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);
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);
}
@ -428,7 +434,7 @@ fn test_decode_u16() {
for (slice, expected) in errors {
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));
}
}
@ -443,11 +449,11 @@ fn test_decode_u32() {
];
for &(slice, expected_le, expected_be) in cases {
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);
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);
}
@ -482,7 +488,7 @@ fn test_decode_u32() {
for (slice, expected) in errors {
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));
}
}
@ -502,11 +508,11 @@ fn test_decode_u64() {
];
for &(slice, expected_le, expected_be) in cases {
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);
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);
}
@ -560,7 +566,7 @@ fn test_decode_u64() {
for (slice, expected) in errors {
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));
}
}
@ -585,11 +591,11 @@ fn test_decode_u128() {
];
for &(slice, expected_le, expected_be) in cases {
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);
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);
}
@ -697,7 +703,7 @@ fn test_decode_u128() {
for (slice, expected) in errors {
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);
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 crate::{config::Endian, enc::write::Writer, error::EncodeError};
use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
pub fn varint_encode_i16<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: i16,
) -> Result<(), EncodeError> {
varint_encode_u16(
@ -22,7 +22,7 @@ pub fn varint_encode_i16<W: Writer>(
pub fn varint_encode_i32<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: i32,
) -> Result<(), EncodeError> {
varint_encode_u32(
@ -41,7 +41,7 @@ pub fn varint_encode_i32<W: Writer>(
pub fn varint_encode_i64<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: i64,
) -> Result<(), EncodeError> {
varint_encode_u64(
@ -60,7 +60,7 @@ pub fn varint_encode_i64<W: Writer>(
pub fn varint_encode_i128<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: i128,
) -> Result<(), EncodeError> {
varint_encode_u128(
@ -79,7 +79,7 @@ pub fn varint_encode_i128<W: Writer>(
pub fn varint_encode_isize<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: isize,
) -> Result<(), EncodeError> {
// isize is being encoded as a i64
@ -116,14 +116,14 @@ fn test_encode_i16() {
// Little endian
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!(&buffer[..expected_le.len()], expected_le);
// Big endian
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!(&buffer[..expected_be.len()], expected_be);
@ -165,14 +165,14 @@ fn test_encode_i32() {
// Little endian
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!(&buffer[..expected_le.len()], expected_le);
// Big endian
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!(&buffer[..expected_be.len()], expected_be);
@ -219,14 +219,14 @@ fn test_encode_i64() {
// Little endian
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!(&buffer[..expected_le.len()], expected_le);
// Big endian
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!(&buffer[..expected_be.len()], expected_be);
@ -303,14 +303,14 @@ fn test_encode_i128() {
// Little endian
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!(&buffer[..expected_le.len()], expected_le);
// Big endian
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!(&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 crate::{config::Endian, enc::write::Writer, error::EncodeError};
use crate::{config::Endianness, enc::write::Writer, error::EncodeError};
pub fn varint_encode_u16<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: u16,
) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ {
@ -11,15 +11,15 @@ pub fn varint_encode_u16<W: Writer>(
} else {
writer.write(&[U16_BYTE])?;
match endian {
Endian::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()),
Endianness::Big => writer.write(&val.to_be_bytes()),
Endianness::Little => writer.write(&val.to_le_bytes()),
}
}
}
pub fn varint_encode_u32<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: u32,
) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ {
@ -27,21 +27,21 @@ pub fn varint_encode_u32<W: Writer>(
} else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()),
Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
}
} else {
writer.write(&[U32_BYTE])?;
match endian {
Endian::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()),
Endianness::Big => writer.write(&val.to_be_bytes()),
Endianness::Little => writer.write(&val.to_le_bytes()),
}
}
}
pub fn varint_encode_u64<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: u64,
) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ {
@ -49,27 +49,27 @@ pub fn varint_encode_u64<W: Writer>(
} else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()),
Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
}
} else if val <= u32::MAX as _ {
writer.write(&[U32_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u32).to_be_bytes()),
Endian::Little => writer.write(&(val as u32).to_le_bytes()),
Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
}
} else {
writer.write(&[U64_BYTE])?;
match endian {
Endian::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()),
Endianness::Big => writer.write(&val.to_be_bytes()),
Endianness::Little => writer.write(&val.to_le_bytes()),
}
}
}
pub fn varint_encode_u128<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: u128,
) -> Result<(), EncodeError> {
if val <= SINGLE_BYTE_MAX as _ {
@ -77,33 +77,33 @@ pub fn varint_encode_u128<W: Writer>(
} else if val <= u16::MAX as _ {
writer.write(&[U16_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u16).to_be_bytes()),
Endian::Little => writer.write(&(val as u16).to_le_bytes()),
Endianness::Big => writer.write(&(val as u16).to_be_bytes()),
Endianness::Little => writer.write(&(val as u16).to_le_bytes()),
}
} else if val <= u32::MAX as _ {
writer.write(&[U32_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u32).to_be_bytes()),
Endian::Little => writer.write(&(val as u32).to_le_bytes()),
Endianness::Big => writer.write(&(val as u32).to_be_bytes()),
Endianness::Little => writer.write(&(val as u32).to_le_bytes()),
}
} else if val <= u64::MAX as _ {
writer.write(&[U64_BYTE])?;
match endian {
Endian::Big => writer.write(&(val as u64).to_be_bytes()),
Endian::Little => writer.write(&(val as u64).to_le_bytes()),
Endianness::Big => writer.write(&(val as u64).to_be_bytes()),
Endianness::Little => writer.write(&(val as u64).to_le_bytes()),
}
} else {
writer.write(&[U128_BYTE])?;
match endian {
Endian::Big => writer.write(&val.to_be_bytes()),
Endian::Little => writer.write(&val.to_le_bytes()),
Endianness::Big => writer.write(&val.to_be_bytes()),
Endianness::Little => writer.write(&val.to_le_bytes()),
}
}
}
pub fn varint_encode_usize<W: Writer>(
writer: &mut W,
endian: Endian,
endian: Endianness,
val: usize,
) -> Result<(), EncodeError> {
// usize is being encoded as a u64
@ -118,13 +118,13 @@ fn test_encode_u16() {
// these should all encode to a single byte
for i in 0u16..=SINGLE_BYTE_MAX as u16 {
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!(buffer[0] as u16, i);
// Assert endianness doesn't matter
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!(buffer[0] as u16, i);
}
@ -141,13 +141,13 @@ fn test_encode_u16() {
u16::MAX,
] {
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!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &i.to_be_bytes());
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!(buffer[0], U16_BYTE);
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
for i in 0u32..=SINGLE_BYTE_MAX as u32 {
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!(buffer[0] as u32, i);
// Assert endianness doesn't matter
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!(buffer[0] as u32, i);
}
@ -185,13 +185,13 @@ fn test_encode_u32() {
u16::MAX as u32,
] {
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!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
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!(buffer[0], U16_BYTE);
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
for i in [u16::MAX as u32 + 1, 100_000, 1_000_000, u32::MAX] {
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!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &i.to_be_bytes());
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!(buffer[0], U32_BYTE);
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
for i in 0u64..=SINGLE_BYTE_MAX as u64 {
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!(buffer[0] as u64, i);
// Assert endianness doesn't matter
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!(buffer[0] as u64, i);
}
@ -245,13 +245,13 @@ fn test_encode_u64() {
u16::MAX as u64,
] {
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!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
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!(buffer[0], U16_BYTE);
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
for i in [u16::MAX as u64 + 1, 100_000, 1_000_000, u32::MAX as u64] {
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!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
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!(buffer[0], U32_BYTE);
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
for i in [u32::MAX as u64 + 1, 5_000_000_000, u64::MAX] {
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!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &i.to_be_bytes());
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!(buffer[0], U64_BYTE);
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
for i in 0u128..=SINGLE_BYTE_MAX as u128 {
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!(buffer[0] as u128, i);
// Assert endianness doesn't matter
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!(buffer[0] as u128, i);
}
@ -321,13 +321,13 @@ fn test_encode_u128() {
u16::MAX as u128,
] {
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!(buffer[0], U16_BYTE);
assert_eq!(&buffer[1..3], &(i as u16).to_be_bytes());
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!(buffer[0], U16_BYTE);
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
for i in [u16::MAX as u128 + 1, 100_000, 1_000_000, u32::MAX as u128] {
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!(buffer[0], U32_BYTE);
assert_eq!(&buffer[1..5], &(i as u32).to_be_bytes());
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!(buffer[0], U32_BYTE);
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
for i in [u32::MAX as u128 + 1, 5_000_000_000, u64::MAX as u128] {
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!(buffer[0], U64_BYTE);
assert_eq!(&buffer[1..9], &(i as u64).to_be_bytes());
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!(buffer[0], U64_BYTE);
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
for i in [u64::MAX as u128 + 1, u128::MAX] {
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!(buffer[0], U128_BYTE);
assert_eq!(&buffer[1..17], &i.to_be_bytes());
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!(buffer[0], U128_BYTE);
assert_eq!(&buffer[1..17], &i.to_le_bytes());