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

6
src/lib.rs
View file

@ -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
View file

@ -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)?),

41
src/readbuffer.rs
View file

@ -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,

60
src/readstream.rs
View file

@ -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))
}
}