robin/bitbuffer
1
0
Fork 0
mirror of https://codeberg.org/icewind/bitbuffer.git synced 2026-06-03 16:44:06 +02:00
Code Issues Releases Wiki Activity

borrow data

Browse source
This commit is contained in:
Robin Appelman 2020-12-05 22:48:40 +01:00
commit 0c8d2ebe18
9 changed files with 195 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

37
bitbuffer_derive/src/lib.rs
View file

@ -112,10 +112,10 @@
//! # //! #
//! #[derive(BitRead)] //! #[derive(BitRead)]
//! #[endianness = "E"] //! #[endianness = "E"]
//! struct EndiannessStruct<E: Endianness> { //! struct EndiannessStruct<'a, E: Endianness> {
//! size: u8, //! size: u8,
//! #[size = "size"] //! #[size = "size"]
//! stream: BitReadStream<E>, //! stream: BitReadStream<'a, E>,
//! } //! }
//! ``` //! ```
//! //!
@ -125,10 +125,10 @@
//! # //! #
//! #[derive(BitRead)] //! #[derive(BitRead)]
//! #[endianness = "BigEndian"] //! #[endianness = "BigEndian"]
//! struct EndiannessStruct { //! struct EndiannessStruct<'a> {
//! size: u8, //! size: u8,
//! #[size = "size"] //! #[size = "size"]
//! stream: BitReadStream<BigEndian>, //! stream: BitReadStream<'a, BigEndian>,
//! } //! }
//! ``` //! ```
extern crate proc_macro; extern crate proc_macro;
@ -138,7 +138,7 @@ use quote::{quote, quote_spanned};
use syn::spanned::Spanned; use syn::spanned::Spanned;
use syn::{ use syn::{
parse_macro_input, parse_quote, parse_str, Attribute, Data, DataStruct, DeriveInput, Expr, 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; use syn_util::get_attribute_value;
@ -175,6 +175,18 @@ fn derive_bitread_trait(
let mut trait_generics = input.generics.clone(); let mut trait_generics = input.generics.clone();
// we need these separate generics to only add out Endianness param to the 'impl' // 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 (_, 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() { if endianness.is_none() {
trait_generics trait_generics
.params .params
@ -193,7 +205,10 @@ fn derive_bitread_trait(
let parsed_unchecked = parse(input.data.clone(), &name, &input.attrs, true); let parsed_unchecked = parse(input.data.clone(), &name, &input.attrs, true);
let endianness_placeholder = endianness.unwrap_or_else(|| "_E".to_owned()); 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 trait_def = parse_str::<Path>(&trait_def_str).unwrap();
let endianness_ident = Ident::new(&endianness_placeholder, span); let endianness_ident = Ident::new(&endianness_placeholder, span);
@ -218,10 +233,10 @@ fn derive_bitread_trait(
}, },
Span::call_site(), Span::call_site(),
); );
//
let expanded = quote! { let expanded = quote! {
impl #impl_generics #trait_def for #name #ty_generics #where_clause { 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 // 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) { match <Self as #trait_def>::#size_method_name(#extra_param_call) {
Some(size) => { 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 #parsed_unchecked
} }
@ -410,12 +425,12 @@ fn size(data: Data, struct_name: &Ident, attrs: &[Attribute], has_input_size: bo
match size { match size {
Some(size) => { Some(size) => {
quote_spanned! { span => 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 => { None => {
quote_spanned! { span => 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
View file

@ -0,0 +1,10 @@
#![allow(dead_code)]
#![allow(unreachable_patterns)]
use bitbuffer_derive::BitRead;
#[derive(BitRead)]
struct TestStruct {
foo: u8,
str: String,
}

24
bitbuffer_derive/tests/test.rs
View file

@ -45,7 +45,7 @@ fn test_read_struct() {
0b0101_0101, 0b0101_0101,
0b1010_1010, 0b1010_1010,
]; ];
let buffer = BitReadBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(&bytes, LittleEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct { TestStruct {
@ -83,7 +83,7 @@ fn test_read_bare_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitReadBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(&bytes, BigEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!(TestBareEnum::Asd, stream.read().unwrap()); assert_eq!(TestBareEnum::Asd, stream.read().unwrap());
assert_eq!(TestBareEnum::Foo, stream.read().unwrap()); assert_eq!(TestBareEnum::Foo, stream.read().unwrap());
@ -114,7 +114,7 @@ fn test_read_unnamed_field_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitReadBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(&bytes, BigEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestUnnamedFieldEnum::Asd(0b_00_0110_10), TestUnnamedFieldEnum::Asd(0b_00_0110_10),
@ -144,7 +144,7 @@ fn test_read_struct_sized() {
let bytes = vec![ 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, 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); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStructSized { TestStructSized {
@ -180,7 +180,7 @@ fn test_read_unnamed_field_enum_sized() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitReadBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(&bytes, BigEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestUnnamedFieldEnumSized::Asd(0b_00_0110), TestUnnamedFieldEnumSized::Asd(0b_00_0110),
@ -213,7 +213,7 @@ fn test_read_struct2() {
'l' as u8, 'l' as u8,
'e' as u8, 'e' as u8,
]; ];
let buffer = BitReadBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(&bytes, BigEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct2 { TestStruct2 {
@ -227,16 +227,16 @@ fn test_read_struct2() {
#[derive(BitRead)] #[derive(BitRead)]
#[endianness = "E"] #[endianness = "E"]
struct TestStruct3<E: Endianness> { struct TestStruct3<'a, E: Endianness> {
size: u8, size: u8,
#[size = "size"] #[size = "size"]
stream: BitReadStream<E>, stream: BitReadStream<'a, E>,
} }
#[test] #[test]
fn test_read_struct3() { fn test_read_struct3() {
let bytes = vec![0b0000_0101, 0, 0, 0, 0, 0, 0, 0]; 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 mut stream = BitReadStream::from(buffer);
let result: TestStruct3<BigEndian> = stream.read().unwrap(); let result: TestStruct3<BigEndian> = stream.read().unwrap();
assert_eq!(5, result.size); assert_eq!(5, result.size);
@ -265,7 +265,7 @@ fn test_read_rest_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitReadBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(&bytes, BigEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!(TestEnumRest::Asd, stream.read().unwrap()); assert_eq!(TestEnumRest::Asd, stream.read().unwrap());
assert_eq!(TestEnumRest::Foo, stream.read().unwrap()); assert_eq!(TestEnumRest::Foo, stream.read().unwrap());
@ -281,7 +281,7 @@ fn test_unnamed_struct() {
let bytes = vec![ 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, 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); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
@ -295,7 +295,7 @@ struct EmptyStruct;
fn test_empty_struct() { fn test_empty_struct() {
let bytes = vec![0, 0, 0, 0]; 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); let mut stream = BitReadStream::from(buffer);
assert_eq!(EmptyStruct, stream.read().unwrap()); assert_eq!(EmptyStruct, stream.read().unwrap());
assert_eq!(0, stream.pos()); assert_eq!(0, stream.pos());

6
src/lib.rs
View file

@ -31,7 +31,7 @@
//! 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, //! 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
//! 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 //! 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 stream = BitReadStream::new(buffer);
//! let value: u8 = stream.read_int(7)?; //! let value: u8 = stream.read_int(7)?;
//! let complex: ComplexType = stream.read()?; //! 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 /// Get the number of bits required to read a type from stream
#[inline(always)] #[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() T::bit_size()
} }
/// Get the number of bits required to read a type from stream /// Get the number of bits required to read a type from stream
#[inline(always)] #[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) T::bit_size_sized(size)
} }

105
src/read.rs
View file

@ -89,16 +89,16 @@ use std::sync::Arc;
/// [`BitReadSized`]: trait.BitReadSized.html /// [`BitReadSized`]: trait.BitReadSized.html
/// [read_sized]: struct.BitStream.html#method.read_sized /// [read_sized]: struct.BitStream.html#method.read_sized
/// [read]: struct.BitStream.html#method.read /// [read]: struct.BitStream.html#method.read
pub trait BitRead<E: Endianness>: Sized { pub trait BitRead<'a, E: Endianness>: Sized {
/// Read the type from stream /// 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 /// Note: only the bounds are unchecked
/// ///
/// any other validations (e.g. checking for valid utf8) still needs to be done /// any other validations (e.g. checking for valid utf8) still needs to be done
#[doc(hidden)] #[doc(hidden)]
#[inline] #[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) 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 /// This might be faster than reading it if the size is known beforehand
#[inline] #[inline]
fn skip(stream: &mut BitReadStream<E>) -> Result<()> { fn skip(stream: &mut BitReadStream<'a, E>) -> Result<()> {
match Self::bit_size() { match Self::bit_size() {
Some(size) => stream.skip_bits(size), Some(size) => stream.skip_bits(size),
None => Self::read(stream).map(|_| ()), None => Self::read(stream).map(|_| ()),
@ -123,7 +123,7 @@ pub trait BitRead<E: Endianness>: Sized {
macro_rules! impl_read_int { macro_rules! impl_read_int {
($type:ty) => { ($type:ty) => {
impl<E: Endianness> BitRead<E> for $type { impl<E: Endianness> BitRead<'_, E> for $type {
#[inline] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<$type> { fn read(stream: &mut BitReadStream<E>) -> Result<$type> {
stream.read_int::<$type>(size_of::<$type>() * 8) stream.read_int::<$type>(size_of::<$type>() * 8)
@ -144,7 +144,7 @@ macro_rules! impl_read_int {
macro_rules! impl_read_int_nonzero { macro_rules! impl_read_int_nonzero {
($type:ty) => { ($type:ty) => {
impl BitRead<LittleEndian> for Option<$type> { impl BitRead<'_, LittleEndian> for Option<$type> {
#[inline] #[inline]
fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> { fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
Ok(<$type>::new(stream.read()?)) 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] #[inline]
fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> { fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
Ok(<$type>::new(stream.read()?)) 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::NonZeroU64);
impl_read_int_nonzero!(std::num::NonZeroU128); impl_read_int_nonzero!(std::num::NonZeroU128);
impl<E: Endianness> BitRead<E> for f32 { impl<E: Endianness> BitRead<'_, E> for f32 {
#[inline] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<f32> { fn read(stream: &mut BitReadStream<E>) -> Result<f32> {
stream.read_float::<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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<f64> { fn read(stream: &mut BitReadStream<E>) -> Result<f64> {
stream.read_float::<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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<bool> { fn read(stream: &mut BitReadStream<E>) -> Result<bool> {
stream.read_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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<String> { fn read(stream: &mut BitReadStream<E>) -> Result<String> {
stream.read_string(None) 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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
Ok(Rc::new(T::read(stream)?)) Ok(Rc::new(T::read(stream)?))
} }
#[inline] #[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)?)) 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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
Ok(Arc::new(T::read(stream)?)) Ok(Arc::new(T::read(stream)?))
} }
#[inline] #[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)?)) 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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
Ok(Box::new(T::read(stream)?)) Ok(Box::new(T::read(stream)?))
} }
#[inline] #[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)?)) 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 { macro_rules! impl_read_tuple {
($($type:ident),*) => { ($($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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
Ok(($(<$type>::read(stream)?),*)) Ok(($(<$type>::read(stream)?),*))
} }
#[inline] #[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)?),*)) Ok(($(<$type>::read_unchecked(stream, end)?),*))
} }
@ -405,14 +405,14 @@ impl_read_tuple!(T1, T2, T3, T4);
/// [`BitRead`]: trait.BitRead.html /// [`BitRead`]: trait.BitRead.html
/// [read_sized]: struct.BitStream.html#method.read_sized /// [read_sized]: struct.BitStream.html#method.read_sized
/// [read]: struct.BitStream.html#method.read /// [read]: struct.BitStream.html#method.read
pub trait BitReadSized<E: Endianness>: Sized { pub trait BitReadSized<'a, E: Endianness>: Sized {
/// Read the type from stream /// 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)] #[doc(hidden)]
#[inline] #[inline]
unsafe fn read_unchecked( unsafe fn read_unchecked(
stream: &mut BitReadStream<E>, stream: &mut BitReadStream<'a, E>,
size: usize, size: usize,
_end: bool, _end: bool,
) -> Result<Self> { ) -> 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 /// This might be faster than reading it if the size is known beforehand
#[inline] #[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) { match Self::bit_size_sized(size) {
Some(size) => stream.skip_bits(size), Some(size) => stream.skip_bits(size),
None => Self::read(stream, size).map(|_| ()), None => Self::read(stream, size).map(|_| ()),
@ -440,7 +440,7 @@ pub trait BitReadSized<E: Endianness>: Sized {
macro_rules! impl_read_int_sized { macro_rules! impl_read_int_sized {
( $ type: ty) => { ( $ type: ty) => {
impl<E: Endianness> BitReadSized<E> for $type { impl<E: Endianness> BitReadSized<'_, E> for $type {
#[inline] #[inline]
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> { fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> {
stream.read_int::<$type>(size) stream.read_int::<$type>(size)
@ -474,7 +474,7 @@ impl_read_int_sized!(i32);
impl_read_int_sized!(i64); impl_read_int_sized!(i64);
impl_read_int_sized!(i128); impl_read_int_sized!(i128);
impl<E: Endianness> BitReadSized<E> for String { impl<E: Endianness> BitReadSized<'_, E> for String {
#[inline] #[inline]
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<String> { fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<String> {
stream.read_string(Some(size)) 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` /// Read a boolean, if true, read `T`, else return `None`
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> { impl<'a, E: Endianness, T: BitRead<'a, E>> BitRead<'a, E> for Option<T> {
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
if stream.read()? { if stream.read()? {
Ok(Some(stream.read()?)) Ok(Some(stream.read()?))
} else { } 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> { impl<'a, E: Endianness, T: BitReadSized<'a, E>> BitReadSized<'a, E> for Option<T> {
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
if stream.read()? { if stream.read()? {
Ok(Some(stream.read_sized(size)?)) Ok(Some(stream.read_sized(size)?))
} else { } 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] #[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) 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>` /// Read `T` `size` times and return as `Vec<T>`
impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> { impl<'a, E: Endianness, T: BitRead<'a, E>> BitReadSized<'a, E> for Vec<T> {
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> { 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)); let mut vec = Vec::with_capacity(min(size, 128));
for _ in 0..size { for _ in 0..size {
vec.push(stream.read()?) vec.push(stream.read()?)
@ -531,7 +532,7 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
#[inline] #[inline]
unsafe fn read_unchecked( unsafe fn read_unchecked(
stream: &mut BitReadStream<E>, stream: &mut BitReadStream<'a, E>,
size: usize, size: usize,
end: bool, end: bool,
) -> Result<Self> { ) -> 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>` /// Read `K` and `T` `size` times and return as `HashMap<K, T>`
#[allow(clippy::implicit_hasher)] #[allow(clippy::implicit_hasher)]
impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> for HashMap<K, T> { impl<'a, E: Endianness, K: BitRead<'a, E> + Eq + Hash, T: BitRead<'a, E>> BitReadSized<'a, E>
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> { for HashMap<K, T>
{
fn read(stream: &mut BitReadStream<'a, E>, size: usize) -> Result<Self> {
let mut map = HashMap::with_capacity(min(size, 128)); let mut map = HashMap::with_capacity(min(size, 128));
for _ in 0..size { for _ in 0..size {
let key = stream.read()?; let key = stream.read()?;
@ -571,7 +574,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
#[inline] #[inline]
unsafe fn read_unchecked( unsafe fn read_unchecked(
stream: &mut BitReadStream<E>, stream: &mut BitReadStream<'a, E>,
size: usize, size: usize,
end: bool, end: bool,
) -> Result<Self> { ) -> Result<Self> {
@ -596,12 +599,12 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
/// Struct that lazily reads it's contents from the stream /// Struct that lazily reads it's contents from the stream
pub struct LazyBitRead<T: BitRead<E>, E: Endianness> { pub struct LazyBitRead<'a, T: BitRead<'a, E>, E: Endianness> {
source: BitReadStream<E>, source: BitReadStream<'a, E>,
inner_type: PhantomData<T>, 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] #[inline]
/// Get the contents of the lazy struct /// Get the contents of the lazy struct
pub fn read(mut self) -> Result<T> { 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] #[inline]
fn read(stream: &mut BitReadStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<'a, E>) -> Result<Self> {
match T::bit_size() { match T::bit_size() {
Some(bit_size) => Ok(LazyBitRead { Some(bit_size) => Ok(LazyBitRead {
source: stream.read_bits(bit_size)?, 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)] #[derive(Clone, Debug)]
/// Struct that lazily reads it's contents from the stream /// Struct that lazily reads it's contents from the stream
pub struct LazyBitReadSized<T: BitReadSized<E>, E: Endianness> { pub struct LazyBitReadSized<'a, T: BitReadSized<'a, E>, E: Endianness> {
source: RefCell<BitReadStream<E>>, source: RefCell<BitReadStream<'a, E>>,
size: usize, size: usize,
inner_type: PhantomData<T>, 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] #[inline]
/// Get the contents of the lazy struct /// Get the contents of the lazy struct
pub fn value(self) -> Result<T> { 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] #[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) { match T::bit_size_sized(size) {
Some(bit_size) => Ok(LazyBitReadSized { Some(bit_size) => Ok(LazyBitReadSized {
source: RefCell::new(stream.read_bits(bit_size)?), source: RefCell::new(stream.read_bits(bit_size)?),

41
src/readbuffer.rs
View file

@ -4,7 +4,6 @@ use std::fmt::Debug;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::mem::size_of; use std::mem::size_of;
use std::ops::{BitOrAssign, BitXor}; use std::ops::{BitOrAssign, BitXor};
use std::rc::Rc;
use num_traits::{Float, PrimInt}; 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, /// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// 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 /// // read 7 bits as u8, starting from bit 3
/// let result: u8 = buffer.read_int(3, 7)?; /// let result: u8 = buffer.read_int(3, 7)?;
/// # /// #
/// # Ok(()) /// # Ok(())
/// # } /// # }
/// ``` /// ```
pub struct BitReadBuffer<E> pub struct BitReadBuffer<'a, E>
where where
E: Endianness, E: Endianness,
{ {
bytes: Rc<Vec<u8>>, bytes: &'a [u8],
bit_len: usize, bit_len: usize,
endianness: PhantomData<E>, endianness: PhantomData<E>,
} }
impl<E> BitReadBuffer<E> impl<'a, E> BitReadBuffer<'a, E>
where where
E: Endianness, E: Endianness,
{ {
@ -59,13 +58,13 @@ where
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// 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(); let byte_len = bytes.len();
BitReadBuffer { BitReadBuffer {
bytes: Rc::new(bytes), bytes,
bit_len: byte_len * 8, bit_len: byte_len * 8,
endianness: PhantomData, endianness: PhantomData,
} }
@ -88,7 +87,7 @@ pub(crate) fn get_bits_from_usize<E: Endianness>(
shifted & mask shifted & mask
} }
impl<E> BitReadBuffer<E> impl<'a, E> BitReadBuffer<'a, E>
where where
E: Endianness, E: Endianness,
{ {
@ -159,7 +158,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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)?; /// let result = buffer.read_bool(5)?;
/// assert_eq!(result, true); /// assert_eq!(result, true);
/// # /// #
@ -218,7 +217,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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)?; /// let result = buffer.read_int::<u16>(10, 9)?;
/// assert_eq!(result, 0b100_0110_10); /// assert_eq!(result, 0b100_0110_10);
/// # /// #
@ -359,7 +358,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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(5, 3)?, &[0b0_1010_101, 0b0_1100_011, 0b1_1001_101]);
/// assert_eq!(buffer.read_bytes(0, 8)?, &[ /// assert_eq!(buffer.read_bytes(0, 8)?, &[
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
@ -443,7 +442,7 @@ where
/// # 0x72, 0x6c, 0x64, 0, /// # 0x72, 0x6c, 0x64, 0,
/// # 0, 0, 0, 0 /// # 0, 0, 0, 0
/// # ]; /// # ];
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
/// // Fixed length string /// // Fixed length string
/// assert_eq!(buffer.read_string(0, Some(13))?, "Hello world".to_owned()); /// assert_eq!(buffer.read_string(0, Some(13))?, "Hello world".to_owned());
/// // fixed length with null padding /// // fixed length with null padding
@ -533,7 +532,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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)?; /// let result = buffer.read_float::<f32>(10)?;
/// # /// #
/// # Ok(()) /// # Ok(())
@ -597,35 +596,35 @@ where
} }
Ok(BitReadBuffer { Ok(BitReadBuffer {
bytes: Rc::clone(&self.bytes), bytes: self.bytes,
bit_len, bit_len,
endianness: PhantomData, endianness: PhantomData,
}) })
} }
} }
impl<E: Endianness> From<Vec<u8>> for BitReadBuffer<E> { impl<'a, E: Endianness> From<&'a [u8]> for BitReadBuffer<'a, E> {
fn from(bytes: Vec<u8>) -> Self { fn from(bytes: &'a [u8]) -> Self {
let byte_len = bytes.len(); let byte_len = bytes.len();
BitReadBuffer { BitReadBuffer {
bytes: Rc::new(bytes), bytes,
bit_len: byte_len * 8, bit_len: byte_len * 8,
endianness: PhantomData, endianness: PhantomData,
} }
} }
} }
impl<E: Endianness> Clone for BitReadBuffer<E> { impl<'a, E: Endianness> Clone for BitReadBuffer<'a, E> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
BitReadBuffer { BitReadBuffer {
bytes: Rc::clone(&self.bytes), bytes: self.bytes,
bit_len: self.bit_len(), bit_len: self.bit_len(),
endianness: PhantomData, 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 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!( write!(
f, f,

60
src/readstream.rs
View file

@ -20,22 +20,22 @@ use std::cmp::min;
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// 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 stream = BitReadStream::new(buffer);
/// ``` /// ```
/// ///
/// [`BitBuffer`]: struct.BitBuffer.html /// [`BitBuffer`]: struct.BitBuffer.html
#[derive(Debug)] #[derive(Debug)]
pub struct BitReadStream<E> pub struct BitReadStream<'a, E>
where where
E: Endianness, E: Endianness,
{ {
buffer: BitReadBuffer<E>, buffer: BitReadBuffer<'a, E>,
start_pos: usize, start_pos: usize,
pos: usize, pos: usize,
} }
impl<E> BitReadStream<E> impl<'a, E> BitReadStream<'a, E>
where where
E: Endianness, E: Endianness,
{ {
@ -50,12 +50,12 @@ where
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// 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 stream = BitReadStream::new(buffer);
/// ``` /// ```
/// ///
/// [`BitBuffer`]: struct.BitBuffer.html /// [`BitBuffer`]: struct.BitBuffer.html
pub fn new(buffer: BitReadBuffer<E>) -> Self { pub fn new(buffer: BitReadBuffer<'a, E>) -> Self {
BitReadStream { BitReadStream {
start_pos: 0, start_pos: 0,
pos: 0, pos: 0,
@ -79,7 +79,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.read_bool()?, true); /// assert_eq!(stream.read_bool()?, true);
/// assert_eq!(stream.read_bool()?, false); /// assert_eq!(stream.read_bool()?, false);
@ -124,7 +124,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.read_int::<u16>(3)?, 0b101); /// assert_eq!(stream.read_int::<u16>(3)?, 0b101);
/// assert_eq!(stream.read_int::<u16>(3)?, 0b110); /// assert_eq!(stream.read_int::<u16>(3)?, 0b110);
@ -175,7 +175,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let result = stream.read_float::<f32>()?; /// let result = stream.read_float::<f32>()?;
/// assert_eq!(stream.pos(), 32); /// assert_eq!(stream.pos(), 32);
@ -226,7 +226,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.read_bytes(3)?, &[0b1011_0101, 0b0110_1010, 0b1010_1100]); /// assert_eq!(stream.read_bytes(3)?, &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
/// assert_eq!(stream.pos(), 24); /// assert_eq!(stream.pos(), 24);
@ -276,7 +276,7 @@ where
/// # 0x72, 0x6c, 0x64, 0, /// # 0x72, 0x6c, 0x64, 0,
/// # 0, 0, 0, 0 /// # 0, 0, 0, 0
/// # ]; /// # ];
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(&bytes, LittleEndian);
/// # let mut stream = BitReadStream::new(buffer); /// # let mut stream = BitReadStream::new(buffer);
/// // Fixed length string /// // Fixed length string
/// stream.set_pos(0); /// stream.set_pos(0);
@ -351,7 +351,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let mut bits = stream.read_bits(3)?; /// let mut bits = stream.read_bits(3)?;
/// assert_eq!(stream.pos(), 3); /// assert_eq!(stream.pos(), 3);
@ -392,7 +392,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// stream.skip_bits(3)?; /// stream.skip_bits(3)?;
/// assert_eq!(stream.pos(), 3); /// assert_eq!(stream.pos(), 3);
@ -431,7 +431,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// stream.set_pos(3)?; /// stream.set_pos(3)?;
/// assert_eq!(stream.pos(), 3); /// assert_eq!(stream.pos(), 3);
@ -465,7 +465,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.bit_len(), 64); /// assert_eq!(stream.bit_len(), 64);
/// # /// #
@ -488,7 +488,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.pos(), 0); /// assert_eq!(stream.pos(), 0);
/// stream.skip_bits(5)?; /// stream.skip_bits(5)?;
@ -513,7 +513,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// assert_eq!(stream.bits_left(), 64); /// assert_eq!(stream.bits_left(), 64);
/// stream.skip_bits(5)?; /// stream.skip_bits(5)?;
@ -538,7 +538,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let int: u8 = stream.read()?; /// let int: u8 = stream.read()?;
/// assert_eq!(int, 0b1011_0101); /// assert_eq!(int, 0b1011_0101);
@ -566,7 +566,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let data: ComplexType = stream.read()?; /// let data: ComplexType = stream.read()?;
/// assert_eq!(data, ComplexType { /// assert_eq!(data, ComplexType {
@ -579,13 +579,13 @@ where
/// # } /// # }
/// ``` /// ```
#[inline] #[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) T::read(self)
} }
#[doc(hidden)] #[doc(hidden)]
#[inline] #[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) T::read_unchecked(self, end)
} }
@ -603,7 +603,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let int: u8 = stream.read_sized(7)?; /// let int: u8 = stream.read_sized(7)?;
/// assert_eq!(int, 0b011_0101); /// assert_eq!(int, 0b011_0101);
@ -620,7 +620,7 @@ where
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001, /// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111 /// # 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 stream = BitReadStream::new(buffer);
/// let data: Vec<u16> = stream.read_sized(3)?; /// let data: Vec<u16> = stream.read_sized(3)?;
/// assert_eq!(data, vec![0b0110_1010_1011_0101, 0b1001_1001_1010_1100, 0b1001_1001_1001_1001]); /// assert_eq!(data, vec![0b0110_1010_1011_0101, 0b1001_1001_1010_1100, 0b1001_1001_1001_1001]);
@ -629,13 +629,13 @@ where
/// # } /// # }
/// ``` /// ```
#[inline] #[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) T::read(self, size)
} }
#[doc(hidden)] #[doc(hidden)]
#[inline] #[inline]
pub unsafe fn read_sized_unchecked<T: BitReadSized<E>>( pub unsafe fn read_sized_unchecked<T: BitReadSized<'a, E>>(
&mut self, &mut self,
size: usize, size: usize,
end: bool, 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 { fn clone(&self) -> Self {
BitReadStream { BitReadStream {
buffer: self.buffer.clone(), buffer: self.buffer.clone(),
@ -670,14 +670,14 @@ impl<E: Endianness> Clone for BitReadStream<E> {
} }
} }
impl<E: Endianness> From<BitReadBuffer<E>> for BitReadStream<E> { impl<'a, E: Endianness> From<BitReadBuffer<'a, E>> for BitReadStream<'a, E> {
fn from(buffer: BitReadBuffer<E>) -> Self { fn from(buffer: BitReadBuffer<'a, E>) -> Self {
BitReadStream::new(buffer) BitReadStream::new(buffer)
} }
} }
impl<E: Endianness> From<Vec<u8>> for BitReadStream<E> { impl<'a, E: Endianness> From<&'a [u8]> for BitReadStream<'a, E> {
fn from(bytes: Vec<u8>) -> Self { fn from(bytes: &'a [u8]) -> Self {
BitReadStream::new(BitReadBuffer::from(bytes)) BitReadStream::new(BitReadBuffer::from(bytes))
} }
} }

65
tests/read_tests.rs
View file

@ -22,7 +22,7 @@ const BYTES: &'static [u8] = &[
#[test] #[test]
fn read_u8_le() { 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_int::<u8>(0, 1).unwrap(), 0b1);
assert_eq!(buffer.read_bool(0).unwrap(), true); assert_eq!(buffer.read_bool(0).unwrap(), true);
@ -37,7 +37,7 @@ fn read_u8_le() {
#[test] #[test]
fn read_u8_be() { 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>(0, 1).unwrap(), 0b1);
assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0); assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
@ -52,21 +52,21 @@ fn read_u8_be() {
#[test] #[test]
fn read_u16_le() { 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); assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
} }
#[test] #[test]
fn read_u16_be() { 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); assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
} }
#[test] #[test]
fn read_u32_le() { fn read_u32_le() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(), buffer.read_int::<u32>(6, 24).unwrap(),
@ -76,7 +76,7 @@ fn read_u32_le() {
#[test] #[test]
fn read_u32_be() { fn read_u32_be() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES, BigEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(), buffer.read_int::<u32>(6, 24).unwrap(),
@ -86,7 +86,7 @@ fn read_u32_be() {
#[test] #[test]
fn read_u64_le() { fn read_u64_le() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u64>(6, 34).unwrap(), buffer.read_int::<u64>(6, 34).unwrap(),
@ -108,7 +108,7 @@ fn read_u64_le() {
#[test] #[test]
fn read_u64_be() { fn read_u64_be() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES, BigEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u64>(6, 34).unwrap(), buffer.read_int::<u64>(6, 34).unwrap(),
@ -126,7 +126,7 @@ fn read_u64_be() {
#[test] #[test]
fn read_i8_le() { 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, 3).unwrap(), -0b11);
assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b100_1011); assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b100_1011);
@ -134,7 +134,7 @@ fn read_i8_le() {
#[test] #[test]
fn read_i8_be() { 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>(1, 2).unwrap(), 0b1);
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b11); assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b11);
@ -143,7 +143,7 @@ fn read_i8_be() {
#[test] #[test]
fn read_i16_le() { 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, 12).unwrap(), 0b0_0110_1010_10);
assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b11_1001_0101_10); assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b11_1001_0101_10);
@ -151,7 +151,7 @@ fn read_i16_le() {
#[test] #[test]
fn read_i16_be() { 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>(6, 12).unwrap(), 0b1_0110_1010_10);
assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b1001_0101_011); assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b1001_0101_011);
@ -159,7 +159,7 @@ fn read_i16_be() {
#[test] #[test]
fn read_i32_le() { fn read_i32_le() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<i32>(6, 24).unwrap(), buffer.read_int::<i32>(6, 24).unwrap(),
@ -170,14 +170,14 @@ fn read_i32_le() {
#[test] #[test]
fn read_i32_be() { 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); assert_eq!(buffer.read_int::<i32>(7, 24).unwrap(), -4893108);
} }
#[test] #[test]
fn read_i64_le() { 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, 34).unwrap(), -6871928406);
assert_eq!(buffer.read_int::<i64>(6, 59).unwrap(), -27471957726940758); assert_eq!(buffer.read_int::<i64>(6, 59).unwrap(), -27471957726940758);
@ -186,7 +186,7 @@ fn read_i64_le() {
#[test] #[test]
fn read_i64_be() { 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, 34).unwrap(), -5010541773);
assert_eq!(buffer.read_int::<i64>(7, 60).unwrap(), -336251766397153476); assert_eq!(buffer.read_int::<i64>(7, 60).unwrap(), -336251766397153476);
@ -195,23 +195,23 @@ fn read_i64_be() {
#[test] #[test]
fn read_f32_le() { 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); assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
} }
#[test] #[test]
fn read_f64_le() { 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); assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
} }
#[test] #[test]
fn test_from() { 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(buffer);
let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES.to_vec()); let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES);
} }
#[test] #[test]
@ -219,7 +219,7 @@ fn test_read_str_be() {
let bytes = vec![ let bytes = vec![
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0, 0, 0, 0, 0, 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!( assert_eq!(
buffer.read_string(0, Some(13)).unwrap(), buffer.read_string(0, Some(13)).unwrap(),
"Hello world".to_owned() "Hello world".to_owned()
@ -239,7 +239,7 @@ fn test_read_str_no_null_termination_le() {
let bytes = vec![ let bytes = vec![
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 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!( assert_eq!(
buffer.read_string(0, None).unwrap(), buffer.read_string(0, None).unwrap(),
"Hello world".to_owned() "Hello world".to_owned()
@ -251,7 +251,7 @@ fn test_read_str_no_null_termination_be() {
let bytes = vec![ let bytes = vec![
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 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!( assert_eq!(
buffer.read_string(0, None).unwrap(), buffer.read_string(0, None).unwrap(),
"Hello world".to_owned() "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, '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, '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(3)).unwrap(), "hel".to_owned());
assert_eq!( assert_eq!(
buffer.read_string(0, Some(11)).unwrap(), buffer.read_string(0, Some(11)).unwrap(),
@ -278,7 +278,7 @@ fn test_read_str_le() {
#[test] #[test]
fn read_trait() { fn read_trait() {
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES, BigEndian);
let mut stream = BitReadStream::new(buffer); let mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read().unwrap(); let a: u8 = stream.read().unwrap();
assert_eq!(0b1011_0101, a); assert_eq!(0b1011_0101, a);
@ -298,7 +298,7 @@ fn read_trait() {
#[test] #[test]
fn read_trait_unchecked() { fn read_trait_unchecked() {
unsafe { unsafe {
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES, BigEndian);
let mut stream = BitReadStream::new(buffer); let mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read_unchecked(true).unwrap(); let a: u8 = stream.read_unchecked(true).unwrap();
assert_eq!(0b1011_0101, a); assert_eq!(0b1011_0101, a);
@ -318,7 +318,7 @@ fn read_trait_unchecked() {
#[test] #[test]
fn read_sized_trait() { 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 mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read_sized(4).unwrap(); let a: u8 = stream.read_sized(4).unwrap();
assert_eq!(0b1011, a); assert_eq!(0b1011, a);
@ -349,7 +349,7 @@ fn read_sized_trait() {
#[test] #[test]
fn read_sized_trait_unchecked() { fn read_sized_trait_unchecked() {
unsafe { unsafe {
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES, BigEndian);
let mut stream = BitReadStream::new(buffer); let mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read_sized_unchecked(4, true).unwrap(); let a: u8 = stream.read_sized_unchecked(4, true).unwrap();
assert_eq!(0b1011, a); assert_eq!(0b1011, a);
@ -416,7 +416,7 @@ fn test_read_struct() {
0b0101_0101, 0b0101_0101,
0b1010_1010, 0b1010_1010,
]; ];
let buffer = BitReadBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(&bytes, LittleEndian);
let mut stream = BitReadStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct { TestStruct {
@ -436,7 +436,7 @@ fn test_read_struct() {
#[test] #[test]
fn test_read_nonzero() { fn test_read_nonzero() {
let bytes = vec![12, 0, 0, 0]; 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); let mut stream = BitReadStream::from(buffer);
assert_eq!(NonZeroU16::new(12), stream.read().unwrap()); assert_eq!(NonZeroU16::new(12), stream.read().unwrap());
assert_eq!(None, stream.read::<Option<NonZeroU16>>().unwrap()); assert_eq!(None, stream.read::<Option<NonZeroU16>>().unwrap());
@ -444,13 +444,14 @@ fn test_read_nonzero() {
#[test] #[test]
fn read_read_signed() { 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); assert_eq!(buffer.read_int::<i32>(0, 32).unwrap(), -1);
let bytes = (-10i32).to_le_bytes(); let bytes = (-10i32).to_le_bytes();
let mut byte_vec = Vec::with_capacity(4); let mut byte_vec = Vec::with_capacity(4);
byte_vec.extend_from_slice(&bytes); 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); assert_eq!(buffer.read_int::<i32>(0, 32).unwrap(), -10);
} }

14
tests/write_tests.rs
View file

@ -10,7 +10,7 @@ fn test_write_bool_le() {
stream.write_bool(true).unwrap(); stream.write_bool(true).unwrap();
let data = stream.finish(); 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());
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(); stream.write_bool(true).unwrap();
let data = stream.finish(); 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());
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(); stream.write_int(13253u64, 64).unwrap();
let data = stream.finish(); 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());
assert_eq!(3253u16, read.read().unwrap()); assert_eq!(3253u16, read.read().unwrap());
@ -70,7 +70,7 @@ fn test_write_bool_number_be() {
stream.write_int(13253u64, 64).unwrap(); stream.write_int(13253u64, 64).unwrap();
let data = stream.finish(); 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!(1u8, read.read_int(1).unwrap());
assert_eq!(3253u16, read.read().unwrap()); assert_eq!(3253u16, read.read().unwrap());
@ -88,7 +88,7 @@ fn test_write_float_le() {
stream.write_float(3253.12f32).unwrap(); stream.write_float(3253.12f32).unwrap();
let data = stream.finish(); 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());
assert_eq!(3253.12f32, read.read().unwrap()); assert_eq!(3253.12f32, read.read().unwrap());
@ -105,7 +105,7 @@ fn test_write_float_be() {
stream.write_float(3253.12f32).unwrap(); stream.write_float(3253.12f32).unwrap();
let data = stream.finish(); 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!(1u8, read.read_int(1).unwrap());
assert_eq!(3253.12f32, read.read().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(); stream.write_string("fixed length2", Some(16)).unwrap();
let data = stream.finish(); 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());
assert_eq!("null terminated", read.read_string(None).unwrap()); assert_eq!("null terminated", read.read_string(None).unwrap());