mirror of
https://codeberg.org/icewind/bitbuffer.git
synced 2026-06-03 08:34:07 +02:00
borrow data
This commit is contained in:
parent
a276e5a457
commit
0c8d2ebe18
9 changed files with 195 additions and 167 deletions
|
|
@ -112,10 +112,10 @@
|
|||
//! #
|
||||
//! #[derive(BitRead)]
|
||||
//! #[endianness = "E"]
|
||||
//! struct EndiannessStruct<E: Endianness> {
|
||||
//! struct EndiannessStruct<'a, E: Endianness> {
|
||||
//! size: u8,
|
||||
//! #[size = "size"]
|
||||
//! stream: BitReadStream<E>,
|
||||
//! stream: BitReadStream<'a, E>,
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
|
|
@ -125,10 +125,10 @@
|
|||
//! #
|
||||
//! #[derive(BitRead)]
|
||||
//! #[endianness = "BigEndian"]
|
||||
//! struct EndiannessStruct {
|
||||
//! struct EndiannessStruct<'a> {
|
||||
//! size: u8,
|
||||
//! #[size = "size"]
|
||||
//! stream: BitReadStream<BigEndian>,
|
||||
//! stream: BitReadStream<'a, BigEndian>,
|
||||
//! }
|
||||
//! ```
|
||||
extern crate proc_macro;
|
||||
|
|
@ -138,7 +138,7 @@ use quote::{quote, quote_spanned};
|
|||
use syn::spanned::Spanned;
|
||||
use syn::{
|
||||
parse_macro_input, parse_quote, parse_str, Attribute, Data, DataStruct, DeriveInput, Expr,
|
||||
Fields, Ident, Lit, LitStr, Path, Variant,
|
||||
Fields, GenericParam, Ident, Lit, LitStr, Path, Variant,
|
||||
};
|
||||
use syn_util::get_attribute_value;
|
||||
|
||||
|
|
@ -175,6 +175,18 @@ fn derive_bitread_trait(
|
|||
let mut trait_generics = input.generics.clone();
|
||||
// we need these separate generics to only add out Endianness param to the 'impl'
|
||||
let (_, ty_generics, where_clause) = input.generics.split_for_impl();
|
||||
let lifetime: Option<&GenericParam> = trait_generics
|
||||
.params
|
||||
.iter()
|
||||
.filter(|param| matches!(param, GenericParam::Lifetime(_)))
|
||||
.next();
|
||||
let lifetime = match lifetime {
|
||||
Some(GenericParam::Lifetime(lifetime)) => lifetime.lifetime.clone(),
|
||||
_ => {
|
||||
trait_generics.params.push(parse_quote!('a));
|
||||
parse_quote!('a)
|
||||
}
|
||||
};
|
||||
if endianness.is_none() {
|
||||
trait_generics
|
||||
.params
|
||||
|
|
@ -193,7 +205,10 @@ fn derive_bitread_trait(
|
|||
let parsed_unchecked = parse(input.data.clone(), &name, &input.attrs, true);
|
||||
|
||||
let endianness_placeholder = endianness.unwrap_or_else(|| "_E".to_owned());
|
||||
let trait_def_str = format!("::bitbuffer::{}<{}>", trait_name, &endianness_placeholder);
|
||||
let trait_def_str = format!(
|
||||
"::bitbuffer::{}<{}, {}>",
|
||||
trait_name, lifetime, &endianness_placeholder
|
||||
);
|
||||
let trait_def = parse_str::<Path>(&trait_def_str).unwrap();
|
||||
|
||||
let endianness_ident = Ident::new(&endianness_placeholder, span);
|
||||
|
|
@ -218,10 +233,10 @@ fn derive_bitread_trait(
|
|||
},
|
||||
Span::call_site(),
|
||||
);
|
||||
//
|
||||
|
||||
let expanded = quote! {
|
||||
impl #impl_generics #trait_def for #name #ty_generics #where_clause {
|
||||
fn read(stream: &mut ::bitbuffer::BitReadStream<#endianness_ident>#extra_param) -> ::bitbuffer::Result<Self> {
|
||||
fn read(stream: &mut ::bitbuffer::BitReadStream<#lifetime, #endianness_ident>#extra_param) -> ::bitbuffer::Result<Self> {
|
||||
// if the read has a predicable size, we can do the bounds check in one go
|
||||
match <Self as #trait_def>::#size_method_name(#extra_param_call) {
|
||||
Some(size) => {
|
||||
|
|
@ -236,7 +251,7 @@ fn derive_bitread_trait(
|
|||
}
|
||||
}
|
||||
|
||||
unsafe fn read_unchecked(stream: &mut ::bitbuffer::BitReadStream<#endianness_ident>#extra_param, end: bool) -> ::bitbuffer::Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut ::bitbuffer::BitReadStream<#lifetime, #endianness_ident>#extra_param, end: bool) -> ::bitbuffer::Result<Self> {
|
||||
#parsed_unchecked
|
||||
}
|
||||
|
||||
|
|
@ -410,12 +425,12 @@ fn size(data: Data, struct_name: &Ident, attrs: &[Attribute], has_input_size: bo
|
|||
match size {
|
||||
Some(size) => {
|
||||
quote_spanned! { span =>
|
||||
<#field_type as ::bitbuffer::BitReadSized<::bitbuffer::LittleEndian>>::bit_size_sized(#size)
|
||||
<#field_type as ::bitbuffer::BitReadSized<'_, ::bitbuffer::LittleEndian>>::bit_size_sized(#size)
|
||||
}
|
||||
}
|
||||
None => {
|
||||
quote_spanned! { span =>
|
||||
<#field_type as ::bitbuffer::BitRead<::bitbuffer::LittleEndian>>::bit_size()
|
||||
<#field_type as ::bitbuffer::BitRead<'_, ::bitbuffer::LittleEndian>>::bit_size()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
10
bitbuffer_derive/tests/expand.rs
Normal file
10
bitbuffer_derive/tests/expand.rs
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
#![allow(dead_code)]
|
||||
#![allow(unreachable_patterns)]
|
||||
|
||||
use bitbuffer_derive::BitRead;
|
||||
|
||||
#[derive(BitRead)]
|
||||
struct TestStruct {
|
||||
foo: u8,
|
||||
str: String,
|
||||
}
|
||||
|
|
@ -45,7 +45,7 @@ fn test_read_struct() {
|
|||
0b0101_0101,
|
||||
0b1010_1010,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct {
|
||||
|
|
@ -83,7 +83,7 @@ fn test_read_bare_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(TestBareEnum::Asd, stream.read().unwrap());
|
||||
assert_eq!(TestBareEnum::Foo, stream.read().unwrap());
|
||||
|
|
@ -114,7 +114,7 @@ fn test_read_unnamed_field_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestUnnamedFieldEnum::Asd(0b_00_0110_10),
|
||||
|
|
@ -144,7 +144,7 @@ fn test_read_struct_sized() {
|
|||
let bytes = vec![
|
||||
12, 'h' as u8, 'e' as u8, 'l' as u8, 'l' as u8, 'o' as u8, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStructSized {
|
||||
|
|
@ -180,7 +180,7 @@ fn test_read_unnamed_field_enum_sized() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestUnnamedFieldEnumSized::Asd(0b_00_0110),
|
||||
|
|
@ -213,7 +213,7 @@ fn test_read_struct2() {
|
|||
'l' as u8,
|
||||
'e' as u8,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct2 {
|
||||
|
|
@ -227,16 +227,16 @@ fn test_read_struct2() {
|
|||
|
||||
#[derive(BitRead)]
|
||||
#[endianness = "E"]
|
||||
struct TestStruct3<E: Endianness> {
|
||||
struct TestStruct3<'a, E: Endianness> {
|
||||
size: u8,
|
||||
#[size = "size"]
|
||||
stream: BitReadStream<E>,
|
||||
stream: BitReadStream<'a, E>,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_read_struct3() {
|
||||
let bytes = vec![0b0000_0101, 0, 0, 0, 0, 0, 0, 0];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
let result: TestStruct3<BigEndian> = stream.read().unwrap();
|
||||
assert_eq!(5, result.size);
|
||||
|
|
@ -265,7 +265,7 @@ fn test_read_rest_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(TestEnumRest::Asd, stream.read().unwrap());
|
||||
assert_eq!(TestEnumRest::Foo, stream.read().unwrap());
|
||||
|
|
@ -281,7 +281,7 @@ fn test_unnamed_struct() {
|
|||
let bytes = vec![
|
||||
12, 'h' as u8, 'e' as u8, 'l' as u8, 'l' as u8, 'o' as u8, 0, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
|
||||
assert_eq!(
|
||||
|
|
@ -295,7 +295,7 @@ struct EmptyStruct;
|
|||
|
||||
fn test_empty_struct() {
|
||||
let bytes = vec![0, 0, 0, 0];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(EmptyStruct, stream.read().unwrap());
|
||||
assert_eq!(0, stream.pos());
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@
|
|||
//! 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
//! 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
//! ];
|
||||
//! let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
//! let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
//! let mut stream = BitReadStream::new(buffer);
|
||||
//! let value: u8 = stream.read_int(7)?;
|
||||
//! let complex: ComplexType = stream.read()?;
|
||||
|
|
@ -144,12 +144,12 @@ pub type Result<T> = std::result::Result<T, BitError>;
|
|||
|
||||
/// Get the number of bits required to read a type from stream
|
||||
#[inline(always)]
|
||||
pub fn bit_size_of<T: BitRead<LittleEndian>>() -> Option<usize> {
|
||||
pub fn bit_size_of<'a, T: BitRead<'a, LittleEndian>>() -> Option<usize> {
|
||||
T::bit_size()
|
||||
}
|
||||
|
||||
/// Get the number of bits required to read a type from stream
|
||||
#[inline(always)]
|
||||
pub fn bit_size_of_sized<T: BitReadSized<LittleEndian>>(size: usize) -> Option<usize> {
|
||||
pub fn bit_size_of_sized<'a, T: BitReadSized<'a, LittleEndian>>(size: usize) -> Option<usize> {
|
||||
T::bit_size_sized(size)
|
||||
}
|
||||
|
|
|
|||
105
src/read.rs
105
src/read.rs
|
|
@ -89,16 +89,16 @@ use std::sync::Arc;
|
|||
/// [`BitReadSized`]: trait.BitReadSized.html
|
||||
/// [read_sized]: struct.BitStream.html#method.read_sized
|
||||
/// [read]: struct.BitStream.html#method.read
|
||||
pub trait BitRead<E: Endianness>: Sized {
|
||||
pub trait BitRead<'a, E: Endianness>: Sized {
|
||||
/// Read the type from stream
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self>;
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self>;
|
||||
|
||||
/// Note: only the bounds are unchecked
|
||||
///
|
||||
/// any other validations (e.g. checking for valid utf8) still needs to be done
|
||||
#[doc(hidden)]
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>, _end: bool) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<'a, E>, _end: bool) -> Result<Self> {
|
||||
Self::read(stream)
|
||||
}
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ pub trait BitRead<E: Endianness>: Sized {
|
|||
///
|
||||
/// This might be faster than reading it if the size is known beforehand
|
||||
#[inline]
|
||||
fn skip(stream: &mut BitReadStream<E>) -> Result<()> {
|
||||
fn skip(stream: &mut BitReadStream<'a, E>) -> Result<()> {
|
||||
match Self::bit_size() {
|
||||
Some(size) => stream.skip_bits(size),
|
||||
None => Self::read(stream).map(|_| ()),
|
||||
|
|
@ -123,7 +123,7 @@ pub trait BitRead<E: Endianness>: Sized {
|
|||
|
||||
macro_rules! impl_read_int {
|
||||
($type:ty) => {
|
||||
impl<E: Endianness> BitRead<E> for $type {
|
||||
impl<E: Endianness> BitRead<'_, E> for $type {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<$type> {
|
||||
stream.read_int::<$type>(size_of::<$type>() * 8)
|
||||
|
|
@ -144,7 +144,7 @@ macro_rules! impl_read_int {
|
|||
|
||||
macro_rules! impl_read_int_nonzero {
|
||||
($type:ty) => {
|
||||
impl BitRead<LittleEndian> for Option<$type> {
|
||||
impl BitRead<'_, LittleEndian> for Option<$type> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(stream.read()?))
|
||||
|
|
@ -166,7 +166,7 @@ macro_rules! impl_read_int_nonzero {
|
|||
}
|
||||
}
|
||||
|
||||
impl BitRead<BigEndian> for Option<$type> {
|
||||
impl BitRead<'_, BigEndian> for Option<$type> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(stream.read()?))
|
||||
|
|
@ -207,7 +207,7 @@ impl_read_int_nonzero!(std::num::NonZeroU32);
|
|||
impl_read_int_nonzero!(std::num::NonZeroU64);
|
||||
impl_read_int_nonzero!(std::num::NonZeroU128);
|
||||
|
||||
impl<E: Endianness> BitRead<E> for f32 {
|
||||
impl<E: Endianness> BitRead<'_, E> for f32 {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<f32> {
|
||||
stream.read_float::<f32>()
|
||||
|
|
@ -224,7 +224,7 @@ impl<E: Endianness> BitRead<E> for f32 {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> BitRead<E> for f64 {
|
||||
impl<E: Endianness> BitRead<'_, E> for f64 {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<f64> {
|
||||
stream.read_float::<f64>()
|
||||
|
|
@ -241,7 +241,7 @@ impl<E: Endianness> BitRead<E> for f64 {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> BitRead<E> for bool {
|
||||
impl<E: Endianness> BitRead<'_, E> for bool {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<bool> {
|
||||
stream.read_bool()
|
||||
|
|
@ -258,21 +258,21 @@ impl<E: Endianness> BitRead<E> for bool {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> BitRead<E> for String {
|
||||
impl<E: Endianness> BitRead<'_, E> for String {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<String> {
|
||||
stream.read_string(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
|
||||
impl<'a, E: Endianness, T: BitRead<'a, E>> BitRead<'a, E> for Rc<T> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
Ok(Rc::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>, end: bool) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<'a, E>, end: bool) -> Result<Self> {
|
||||
Ok(Rc::new(T::read_unchecked(stream, end)?))
|
||||
}
|
||||
|
||||
|
|
@ -282,14 +282,14 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
|
||||
impl<'a, E: Endianness, T: BitRead<'a, E>> BitRead<'a, E> for Arc<T> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
Ok(Arc::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>, end: bool) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<'a, E>, end: bool) -> Result<Self> {
|
||||
Ok(Arc::new(T::read_unchecked(stream, end)?))
|
||||
}
|
||||
|
||||
|
|
@ -299,14 +299,14 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Box<T> {
|
||||
impl<'a, E: Endianness, T: BitRead<'a, E>> BitRead<'a, E> for Box<T> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
Ok(Box::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>, end: bool) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<'a, E>, end: bool) -> Result<Self> {
|
||||
Ok(Box::new(T::read_unchecked(stream, end)?))
|
||||
}
|
||||
|
||||
|
|
@ -318,14 +318,14 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Box<T> {
|
|||
|
||||
macro_rules! impl_read_tuple {
|
||||
($($type:ident),*) => {
|
||||
impl<E: Endianness, $($type: BitRead<E>),*> BitRead<E> for ($($type),*) {
|
||||
impl<'a, E: Endianness, $($type: BitRead<'a, E>),*> BitRead<'a, E> for ($($type),*) {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
Ok(($(<$type>::read(stream)?),*))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>, end: bool) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<'a, E>, end: bool) -> Result<Self> {
|
||||
Ok(($(<$type>::read_unchecked(stream, end)?),*))
|
||||
}
|
||||
|
||||
|
|
@ -405,14 +405,14 @@ impl_read_tuple!(T1, T2, T3, T4);
|
|||
/// [`BitRead`]: trait.BitRead.html
|
||||
/// [read_sized]: struct.BitStream.html#method.read_sized
|
||||
/// [read]: struct.BitStream.html#method.read
|
||||
pub trait BitReadSized<E: Endianness>: Sized {
|
||||
pub trait BitReadSized<'a, E: Endianness>: Sized {
|
||||
/// Read the type from stream
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self>;
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self>;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(
|
||||
stream: &mut BitReadStream<E>,
|
||||
stream: &mut BitReadStream<'a, E>,
|
||||
size: usize,
|
||||
_end: bool,
|
||||
) -> Result<Self> {
|
||||
|
|
@ -423,7 +423,7 @@ pub trait BitReadSized<E: Endianness>: Sized {
|
|||
///
|
||||
/// This might be faster than reading it if the size is known beforehand
|
||||
#[inline]
|
||||
fn skip(stream: &mut BitReadStream<E>, size: usize) -> Result<()> {
|
||||
fn skip(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<()> {
|
||||
match Self::bit_size_sized(size) {
|
||||
Some(size) => stream.skip_bits(size),
|
||||
None => Self::read(stream, size).map(|_| ()),
|
||||
|
|
@ -440,7 +440,7 @@ pub trait BitReadSized<E: Endianness>: Sized {
|
|||
|
||||
macro_rules! impl_read_int_sized {
|
||||
( $ type: ty) => {
|
||||
impl<E: Endianness> BitReadSized<E> for $type {
|
||||
impl<E: Endianness> BitReadSized<'_, E> for $type {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> {
|
||||
stream.read_int::<$type>(size)
|
||||
|
|
@ -474,7 +474,7 @@ impl_read_int_sized!(i32);
|
|||
impl_read_int_sized!(i64);
|
||||
impl_read_int_sized!(i128);
|
||||
|
||||
impl<E: Endianness> BitReadSized<E> for String {
|
||||
impl<E: Endianness> BitReadSized<'_, E> for String {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<String> {
|
||||
stream.read_string(Some(size))
|
||||
|
|
@ -487,8 +487,8 @@ impl<E: Endianness> BitReadSized<E> for String {
|
|||
}
|
||||
|
||||
/// Read a boolean, if true, read `T`, else return `None`
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
impl<'a, E: Endianness, T: BitRead<'a, E>> BitRead<'a, E> for Option<T> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
if stream.read()? {
|
||||
Ok(Some(stream.read()?))
|
||||
} else {
|
||||
|
|
@ -497,8 +497,8 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
impl<'a, E: Endianness, T: BitReadSized<'a, E>> BitReadSized<'a, E> for Option<T> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
|
||||
if stream.read()? {
|
||||
Ok(Some(stream.read_sized(size)?))
|
||||
} else {
|
||||
|
|
@ -507,9 +507,9 @@ impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> BitReadSized<E> for BitReadStream<E> {
|
||||
impl<'a, E: Endianness> BitReadSized<'a, E> for BitReadStream<'a, E> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
|
||||
stream.read_bits(size)
|
||||
}
|
||||
|
||||
|
|
@ -520,8 +520,9 @@ impl<E: Endianness> BitReadSized<E> for BitReadStream<E> {
|
|||
}
|
||||
|
||||
/// Read `T` `size` times and return as `Vec<T>`
|
||||
impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
impl<'a, E: Endianness, T: BitRead<'a, E>> BitReadSized<'a, E> for Vec<T> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
|
||||
// todo check size and use unchecked
|
||||
let mut vec = Vec::with_capacity(min(size, 128));
|
||||
for _ in 0..size {
|
||||
vec.push(stream.read()?)
|
||||
|
|
@ -531,7 +532,7 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
|
|||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(
|
||||
stream: &mut BitReadStream<E>,
|
||||
stream: &mut BitReadStream<'a, E>,
|
||||
size: usize,
|
||||
end: bool,
|
||||
) -> Result<Self> {
|
||||
|
|
@ -558,8 +559,10 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
|
|||
|
||||
/// Read `K` and `T` `size` times and return as `HashMap<K, T>`
|
||||
#[allow(clippy::implicit_hasher)]
|
||||
impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> for HashMap<K, T> {
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
impl<'a, E: Endianness, K: BitRead<'a, E> + Eq + Hash, T: BitRead<'a, E>> BitReadSized<'a, E>
|
||||
for HashMap<K, T>
|
||||
{
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
|
||||
let mut map = HashMap::with_capacity(min(size, 128));
|
||||
for _ in 0..size {
|
||||
let key = stream.read()?;
|
||||
|
|
@ -571,7 +574,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
|
|||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(
|
||||
stream: &mut BitReadStream<E>,
|
||||
stream: &mut BitReadStream<'a, E>,
|
||||
size: usize,
|
||||
end: bool,
|
||||
) -> Result<Self> {
|
||||
|
|
@ -596,12 +599,12 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
|
|||
|
||||
#[derive(Clone, Debug)]
|
||||
/// Struct that lazily reads it's contents from the stream
|
||||
pub struct LazyBitRead<T: BitRead<E>, E: Endianness> {
|
||||
source: BitReadStream<E>,
|
||||
pub struct LazyBitRead<'a, T: BitRead<'a, E>, E: Endianness> {
|
||||
source: BitReadStream<'a, E>,
|
||||
inner_type: PhantomData<T>,
|
||||
}
|
||||
|
||||
impl<T: BitRead<E>, E: Endianness> LazyBitRead<T, E> {
|
||||
impl<'a, T: BitRead<'a, E>, E: Endianness> LazyBitRead<'a, T, E> {
|
||||
#[inline]
|
||||
/// Get the contents of the lazy struct
|
||||
pub fn read(mut self) -> Result<T> {
|
||||
|
|
@ -609,9 +612,9 @@ impl<T: BitRead<E>, E: Endianness> LazyBitRead<T, E> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> {
|
||||
impl<'a, T: BitRead<'a, E>, E: Endianness> BitRead<'a, E> for LazyBitRead<'a, T, E> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
|
||||
match T::bit_size() {
|
||||
Some(bit_size) => Ok(LazyBitRead {
|
||||
source: stream.read_bits(bit_size)?,
|
||||
|
|
@ -629,13 +632,13 @@ impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> {
|
|||
|
||||
#[derive(Clone, Debug)]
|
||||
/// Struct that lazily reads it's contents from the stream
|
||||
pub struct LazyBitReadSized<T: BitReadSized<E>, E: Endianness> {
|
||||
source: RefCell<BitReadStream<E>>,
|
||||
pub struct LazyBitReadSized<'a, T: BitReadSized<'a, E>, E: Endianness> {
|
||||
source: RefCell<BitReadStream<'a, E>>,
|
||||
size: usize,
|
||||
inner_type: PhantomData<T>,
|
||||
}
|
||||
|
||||
impl<T: BitReadSized<E>, E: Endianness> LazyBitReadSized<T, E> {
|
||||
impl<'a, T: BitReadSized<'a, E>, E: Endianness> LazyBitReadSized<'a, T, E> {
|
||||
#[inline]
|
||||
/// Get the contents of the lazy struct
|
||||
pub fn value(self) -> Result<T> {
|
||||
|
|
@ -643,9 +646,9 @@ impl<T: BitReadSized<E>, E: Endianness> LazyBitReadSized<T, E> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: BitReadSized<E>, E: Endianness> BitReadSized<E> for LazyBitReadSized<T, E> {
|
||||
impl<'a, T: BitReadSized<'a, E>, E: Endianness> BitReadSized<'a, E> for LazyBitReadSized<'a, T, E> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
|
||||
match T::bit_size_sized(size) {
|
||||
Some(bit_size) => Ok(LazyBitReadSized {
|
||||
source: RefCell::new(stream.read_bits(bit_size)?),
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ use std::fmt::Debug;
|
|||
use std::marker::PhantomData;
|
||||
use std::mem::size_of;
|
||||
use std::ops::{BitOrAssign, BitXor};
|
||||
use std::rc::Rc;
|
||||
|
||||
use num_traits::{Float, PrimInt};
|
||||
|
||||
|
|
@ -28,23 +27,23 @@ const USIZE_BIT_SIZE: usize = USIZE_SIZE * 8;
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// // read 7 bits as u8, starting from bit 3
|
||||
/// let result: u8 = buffer.read_int(3, 7)?;
|
||||
/// #
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub struct BitReadBuffer<E>
|
||||
pub struct BitReadBuffer<'a, E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
bytes: Rc<Vec<u8>>,
|
||||
bytes: &'a [u8],
|
||||
bit_len: usize,
|
||||
endianness: PhantomData<E>,
|
||||
}
|
||||
|
||||
impl<E> BitReadBuffer<E>
|
||||
impl<'a, E> BitReadBuffer<'a, E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -59,13 +58,13 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// ```
|
||||
pub fn new(bytes: Vec<u8>, _endianness: E) -> Self {
|
||||
pub fn new(bytes: &'a [u8], _endianness: E) -> Self {
|
||||
let byte_len = bytes.len();
|
||||
|
||||
BitReadBuffer {
|
||||
bytes: Rc::new(bytes),
|
||||
bytes,
|
||||
bit_len: byte_len * 8,
|
||||
endianness: PhantomData,
|
||||
}
|
||||
|
|
@ -88,7 +87,7 @@ pub(crate) fn get_bits_from_usize<E: Endianness>(
|
|||
shifted & mask
|
||||
}
|
||||
|
||||
impl<E> BitReadBuffer<E>
|
||||
impl<'a, E> BitReadBuffer<'a, E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -159,7 +158,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// let result = buffer.read_bool(5)?;
|
||||
/// assert_eq!(result, true);
|
||||
/// #
|
||||
|
|
@ -218,7 +217,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// let result = buffer.read_int::<u16>(10, 9)?;
|
||||
/// assert_eq!(result, 0b100_0110_10);
|
||||
/// #
|
||||
|
|
@ -359,7 +358,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// assert_eq!(buffer.read_bytes(5, 3)?, &[0b0_1010_101, 0b0_1100_011, 0b1_1001_101]);
|
||||
/// assert_eq!(buffer.read_bytes(0, 8)?, &[
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
|
|
@ -443,7 +442,7 @@ where
|
|||
/// # 0x72, 0x6c, 0x64, 0,
|
||||
/// # 0, 0, 0, 0
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// // Fixed length string
|
||||
/// assert_eq!(buffer.read_string(0, Some(13))?, "Hello world".to_owned());
|
||||
/// // fixed length with null padding
|
||||
|
|
@ -533,7 +532,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// let result = buffer.read_float::<f32>(10)?;
|
||||
/// #
|
||||
/// # Ok(())
|
||||
|
|
@ -597,35 +596,35 @@ where
|
|||
}
|
||||
|
||||
Ok(BitReadBuffer {
|
||||
bytes: Rc::clone(&self.bytes),
|
||||
bytes: self.bytes,
|
||||
bit_len,
|
||||
endianness: PhantomData,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> From<Vec<u8>> for BitReadBuffer<E> {
|
||||
fn from(bytes: Vec<u8>) -> Self {
|
||||
impl<'a, E: Endianness> From<&'a [u8]> for BitReadBuffer<'a, E> {
|
||||
fn from(bytes: &'a [u8]) -> Self {
|
||||
let byte_len = bytes.len();
|
||||
BitReadBuffer {
|
||||
bytes: Rc::new(bytes),
|
||||
bytes,
|
||||
bit_len: byte_len * 8,
|
||||
endianness: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> Clone for BitReadBuffer<E> {
|
||||
impl<'a, E: Endianness> Clone for BitReadBuffer<'a, E> {
|
||||
fn clone(&self) -> Self {
|
||||
BitReadBuffer {
|
||||
bytes: Rc::clone(&self.bytes),
|
||||
bytes: self.bytes,
|
||||
bit_len: self.bit_len(),
|
||||
endianness: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> Debug for BitReadBuffer<E> {
|
||||
impl<E: Endianness> Debug for BitReadBuffer<'_, E> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(
|
||||
f,
|
||||
|
|
|
|||
|
|
@ -20,22 +20,22 @@ use std::cmp::min;
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// let mut stream = BitReadStream::new(buffer);
|
||||
/// ```
|
||||
///
|
||||
/// [`BitBuffer`]: struct.BitBuffer.html
|
||||
#[derive(Debug)]
|
||||
pub struct BitReadStream<E>
|
||||
pub struct BitReadStream<'a, E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
buffer: BitReadBuffer<E>,
|
||||
buffer: BitReadBuffer<'a, E>,
|
||||
start_pos: usize,
|
||||
pos: usize,
|
||||
}
|
||||
|
||||
impl<E> BitReadStream<E>
|
||||
impl<'a, E> BitReadStream<'a, E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -50,12 +50,12 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// let mut stream = BitReadStream::new(buffer);
|
||||
/// ```
|
||||
///
|
||||
/// [`BitBuffer`]: struct.BitBuffer.html
|
||||
pub fn new(buffer: BitReadBuffer<E>) -> Self {
|
||||
pub fn new(buffer: BitReadBuffer<'a, E>) -> Self {
|
||||
BitReadStream {
|
||||
start_pos: 0,
|
||||
pos: 0,
|
||||
|
|
@ -79,7 +79,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_bool()?, true);
|
||||
/// assert_eq!(stream.read_bool()?, false);
|
||||
|
|
@ -124,7 +124,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_int::<u16>(3)?, 0b101);
|
||||
/// assert_eq!(stream.read_int::<u16>(3)?, 0b110);
|
||||
|
|
@ -175,7 +175,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let result = stream.read_float::<f32>()?;
|
||||
/// assert_eq!(stream.pos(), 32);
|
||||
|
|
@ -226,7 +226,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_bytes(3)?, &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
|
||||
/// assert_eq!(stream.pos(), 24);
|
||||
|
|
@ -276,7 +276,7 @@ where
|
|||
/// # 0x72, 0x6c, 0x64, 0,
|
||||
/// # 0, 0, 0, 0
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// // Fixed length string
|
||||
/// stream.set_pos(0);
|
||||
|
|
@ -351,7 +351,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let mut bits = stream.read_bits(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -392,7 +392,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// stream.skip_bits(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -431,7 +431,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// stream.set_pos(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -465,7 +465,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.bit_len(), 64);
|
||||
/// #
|
||||
|
|
@ -488,7 +488,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.pos(), 0);
|
||||
/// stream.skip_bits(5)?;
|
||||
|
|
@ -513,7 +513,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.bits_left(), 64);
|
||||
/// stream.skip_bits(5)?;
|
||||
|
|
@ -538,7 +538,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let int: u8 = stream.read()?;
|
||||
/// assert_eq!(int, 0b1011_0101);
|
||||
|
|
@ -566,7 +566,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let data: ComplexType = stream.read()?;
|
||||
/// assert_eq!(data, ComplexType {
|
||||
|
|
@ -579,13 +579,13 @@ where
|
|||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn read<T: BitRead<E>>(&mut self) -> Result<T> {
|
||||
pub fn read<T: BitRead<'a, E>>(&mut self) -> Result<T> {
|
||||
T::read(self)
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[inline]
|
||||
pub unsafe fn read_unchecked<T: BitRead<E>>(&mut self, end: bool) -> Result<T> {
|
||||
pub unsafe fn read_unchecked<T: BitRead<'a, E>>(&mut self, end: bool) -> Result<T> {
|
||||
T::read_unchecked(self, end)
|
||||
}
|
||||
|
||||
|
|
@ -603,7 +603,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let int: u8 = stream.read_sized(7)?;
|
||||
/// assert_eq!(int, 0b011_0101);
|
||||
|
|
@ -620,7 +620,7 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let data: Vec<u16> = stream.read_sized(3)?;
|
||||
/// assert_eq!(data, vec![0b0110_1010_1011_0101, 0b1001_1001_1010_1100, 0b1001_1001_1001_1001]);
|
||||
|
|
@ -629,13 +629,13 @@ where
|
|||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn read_sized<T: BitReadSized<E>>(&mut self, size: usize) -> Result<T> {
|
||||
pub fn read_sized<T: BitReadSized<'a, E>>(&mut self, size: usize) -> Result<T> {
|
||||
T::read(self, size)
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[inline]
|
||||
pub unsafe fn read_sized_unchecked<T: BitReadSized<E>>(
|
||||
pub unsafe fn read_sized_unchecked<T: BitReadSized<'a, E>>(
|
||||
&mut self,
|
||||
size: usize,
|
||||
end: bool,
|
||||
|
|
@ -660,7 +660,7 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> Clone for BitReadStream<E> {
|
||||
impl<'a, E: Endianness> Clone for BitReadStream<'a, E> {
|
||||
fn clone(&self) -> Self {
|
||||
BitReadStream {
|
||||
buffer: self.buffer.clone(),
|
||||
|
|
@ -670,14 +670,14 @@ impl<E: Endianness> Clone for BitReadStream<E> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> From<BitReadBuffer<E>> for BitReadStream<E> {
|
||||
fn from(buffer: BitReadBuffer<E>) -> Self {
|
||||
impl<'a, E: Endianness> From<BitReadBuffer<'a, E>> for BitReadStream<'a, E> {
|
||||
fn from(buffer: BitReadBuffer<'a, E>) -> Self {
|
||||
BitReadStream::new(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> From<Vec<u8>> for BitReadStream<E> {
|
||||
fn from(bytes: Vec<u8>) -> Self {
|
||||
impl<'a, E: Endianness> From<&'a [u8]> for BitReadStream<'a, E> {
|
||||
fn from(bytes: &'a [u8]) -> Self {
|
||||
BitReadStream::new(BitReadBuffer::from(bytes))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ const BYTES: &'static [u8] = &[
|
|||
|
||||
#[test]
|
||||
fn read_u8_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_bool(0).unwrap(), true);
|
||||
|
|
@ -37,7 +37,7 @@ fn read_u8_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u8_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
|
||||
|
|
@ -52,21 +52,21 @@ fn read_u8_be() {
|
|||
|
||||
#[test]
|
||||
fn read_u16_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u16_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u32_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -76,7 +76,7 @@ fn read_u32_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u32_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -86,7 +86,7 @@ fn read_u32_be() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -108,7 +108,7 @@ fn read_u64_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -126,7 +126,7 @@ fn read_u64_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i8_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b11);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b100_1011);
|
||||
|
|
@ -134,7 +134,7 @@ fn read_i8_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i8_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i8>(1, 2).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b11);
|
||||
|
|
@ -143,7 +143,7 @@ fn read_i8_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i16_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b11_1001_0101_10);
|
||||
|
|
@ -151,7 +151,7 @@ fn read_i16_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i16_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b1001_0101_011);
|
||||
|
|
@ -159,7 +159,7 @@ fn read_i16_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i32_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i32>(6, 24).unwrap(),
|
||||
|
|
@ -170,14 +170,14 @@ fn read_i32_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i32_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i32>(7, 24).unwrap(), -4893108);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_i64_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i64>(6, 34).unwrap(), -6871928406);
|
||||
assert_eq!(buffer.read_int::<i64>(6, 59).unwrap(), -27471957726940758);
|
||||
|
|
@ -186,7 +186,7 @@ fn read_i64_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i64_be() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i64>(7, 34).unwrap(), -5010541773);
|
||||
assert_eq!(buffer.read_int::<i64>(7, 60).unwrap(), -336251766397153476);
|
||||
|
|
@ -195,23 +195,23 @@ fn read_i64_be() {
|
|||
|
||||
#[test]
|
||||
fn read_f32_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_f64_le() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_from() {
|
||||
let buffer: BitReadBuffer<LittleEndian> = BitReadBuffer::from(BYTES.to_vec());
|
||||
let buffer: BitReadBuffer<LittleEndian> = BitReadBuffer::from(BYTES);
|
||||
let _: BitReadStream<LittleEndian> = BitReadStream::from(buffer);
|
||||
let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES.to_vec());
|
||||
let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -219,7 +219,7 @@ fn test_read_str_be() {
|
|||
let bytes = vec![
|
||||
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
assert_eq!(
|
||||
buffer.read_string(0, Some(13)).unwrap(),
|
||||
"Hello world".to_owned()
|
||||
|
|
@ -239,7 +239,7 @@ fn test_read_str_no_null_termination_le() {
|
|||
let bytes = vec![
|
||||
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
assert_eq!(
|
||||
buffer.read_string(0, None).unwrap(),
|
||||
"Hello world".to_owned()
|
||||
|
|
@ -251,7 +251,7 @@ fn test_read_str_no_null_termination_be() {
|
|||
let bytes = vec![
|
||||
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, BigEndian);
|
||||
assert_eq!(
|
||||
buffer.read_string(0, None).unwrap(),
|
||||
"Hello world".to_owned()
|
||||
|
|
@ -264,7 +264,7 @@ fn test_read_str_le() {
|
|||
'h' as u8, 'e' as u8, 'l' as u8, 'l' as u8, 'o' as u8, ' ' as u8, 'w' as u8, 'o' as u8,
|
||||
'r' as u8, 'l' as u8, 'd' as u8, 0, 'f' as u8, 'o' as u8, 'o' as u8, 0, 0, 0, 0, 0,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
assert_eq!(buffer.read_string(0, Some(3)).unwrap(), "hel".to_owned());
|
||||
assert_eq!(
|
||||
buffer.read_string(0, Some(11)).unwrap(),
|
||||
|
|
@ -278,7 +278,7 @@ fn test_read_str_le() {
|
|||
|
||||
#[test]
|
||||
fn read_trait() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read().unwrap();
|
||||
assert_eq!(0b1011_0101, a);
|
||||
|
|
@ -298,7 +298,7 @@ fn read_trait() {
|
|||
#[test]
|
||||
fn read_trait_unchecked() {
|
||||
unsafe {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_unchecked(true).unwrap();
|
||||
assert_eq!(0b1011_0101, a);
|
||||
|
|
@ -318,7 +318,7 @@ fn read_trait_unchecked() {
|
|||
|
||||
#[test]
|
||||
fn read_sized_trait() {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_sized(4).unwrap();
|
||||
assert_eq!(0b1011, a);
|
||||
|
|
@ -349,7 +349,7 @@ fn read_sized_trait() {
|
|||
#[test]
|
||||
fn read_sized_trait_unchecked() {
|
||||
unsafe {
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES, BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_sized_unchecked(4, true).unwrap();
|
||||
assert_eq!(0b1011, a);
|
||||
|
|
@ -416,7 +416,7 @@ fn test_read_struct() {
|
|||
0b0101_0101,
|
||||
0b1010_1010,
|
||||
];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct {
|
||||
|
|
@ -436,7 +436,7 @@ fn test_read_struct() {
|
|||
#[test]
|
||||
fn test_read_nonzero() {
|
||||
let bytes = vec![12, 0, 0, 0];
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(NonZeroU16::new(12), stream.read().unwrap());
|
||||
assert_eq!(None, stream.read::<Option<NonZeroU16>>().unwrap());
|
||||
|
|
@ -444,13 +444,14 @@ fn test_read_nonzero() {
|
|||
|
||||
#[test]
|
||||
fn read_read_signed() {
|
||||
let buffer = BitReadBuffer::new(vec![255, 255, 255, 255, 255, 255, 255, 255], LittleEndian);
|
||||
let bytes = vec![255, 255, 255, 255, 255, 255, 255, 255];
|
||||
let buffer = BitReadBuffer::new(&bytes, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i32>(0, 32).unwrap(), -1);
|
||||
|
||||
let bytes = (-10i32).to_le_bytes();
|
||||
let mut byte_vec = Vec::with_capacity(4);
|
||||
byte_vec.extend_from_slice(&bytes);
|
||||
let buffer = BitReadBuffer::new(byte_vec, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(&byte_vec, LittleEndian);
|
||||
assert_eq!(buffer.read_int::<i32>(0, 32).unwrap(), -10);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ fn test_write_bool_le() {
|
|||
stream.write_bool(true).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, LittleEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
|
||||
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
|
|
@ -31,7 +31,7 @@ fn test_write_bool_be() {
|
|||
stream.write_bool(true).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, BigEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, BigEndian));
|
||||
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
|
|
@ -51,7 +51,7 @@ fn test_write_bool_number_le() {
|
|||
stream.write_int(13253u64, 64).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, LittleEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
|
||||
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
assert_eq!(3253u16, read.read().unwrap());
|
||||
|
|
@ -70,7 +70,7 @@ fn test_write_bool_number_be() {
|
|||
stream.write_int(13253u64, 64).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, BigEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, BigEndian));
|
||||
|
||||
assert_eq!(1u8, read.read_int(1).unwrap());
|
||||
assert_eq!(3253u16, read.read().unwrap());
|
||||
|
|
@ -88,7 +88,7 @@ fn test_write_float_le() {
|
|||
stream.write_float(3253.12f32).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, LittleEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
|
||||
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
assert_eq!(3253.12f32, read.read().unwrap());
|
||||
|
|
@ -105,7 +105,7 @@ fn test_write_float_be() {
|
|||
stream.write_float(3253.12f32).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, BigEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, BigEndian));
|
||||
|
||||
assert_eq!(1u8, read.read_int(1).unwrap());
|
||||
assert_eq!(3253.12f32, read.read().unwrap());
|
||||
|
|
@ -124,7 +124,7 @@ fn test_write_string_le() {
|
|||
stream.write_string("fixed length2", Some(16)).unwrap();
|
||||
|
||||
let data = stream.finish();
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(data, LittleEndian));
|
||||
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
|
||||
|
||||
assert_eq!(true, read.read_bool().unwrap());
|
||||
assert_eq!("null terminated", read.read_string(None).unwrap());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue