mirror of
https://codeberg.org/icewind/bitbuffer.git
synced 2026-06-03 16:44:06 +02:00
make the buffer take ownership of the data, use Rc to get multiple streams of a buffer
This commit is contained in:
parent
8d09284040
commit
c39b8675ac
4 changed files with 87 additions and 102 deletions
|
|
@ -46,7 +46,7 @@ impl IsPadded for Padded {
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// ```
|
||||
///
|
||||
/// You can also provide a slice padded with at least `size_of::<usize>() - 1` bytes,
|
||||
|
|
@ -60,22 +60,21 @@ impl IsPadded for Padded {
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111,
|
||||
/// 0, 0, 0, 0, 0, 0, 0, 0
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::from_padded_slice(bytes, 8, LittleEndian);
|
||||
/// let buffer = BitBuffer::from_padded(bytes.to_vec(), 8, LittleEndian);
|
||||
/// ```
|
||||
#[derive(Copy)]
|
||||
pub struct BitBuffer<'a, E, S>
|
||||
pub struct BitBuffer<E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
S: IsPadded,
|
||||
{
|
||||
bytes: &'a [u8],
|
||||
bytes: Vec<u8>,
|
||||
bit_len: usize,
|
||||
byte_len: usize,
|
||||
endianness: PhantomData<E>,
|
||||
is_padded: PhantomData<S>,
|
||||
}
|
||||
|
||||
impl<'a, E> BitBuffer<'a, E, NonPadded>
|
||||
impl<E> BitBuffer<E, NonPadded>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -90,9 +89,9 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// ```
|
||||
pub fn new(bytes: &'a [u8], _endianness: E) -> Self {
|
||||
pub fn new(bytes: Vec<u8>, _endianness: E) -> Self {
|
||||
let byte_len = bytes.len();
|
||||
BitBuffer {
|
||||
bytes,
|
||||
|
|
@ -104,7 +103,7 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, E> BitBuffer<'a, E, Padded>
|
||||
impl<E> BitBuffer<E, Padded>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -126,9 +125,9 @@ where
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111,
|
||||
/// 0, 0, 0, 0, 0, 0, 0, 0
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::from_padded_slice(bytes, 8, LittleEndian);
|
||||
/// let buffer = BitBuffer::from_padded(bytes.to_vec(), 8, LittleEndian);
|
||||
/// ```
|
||||
pub fn from_padded_slice(bytes: &'a [u8], byte_len: usize, _endianness: E) -> Self {
|
||||
pub fn from_padded(bytes: Vec<u8>, byte_len: usize, _endianness: E) -> Self {
|
||||
if bytes.len() < byte_len + USIZE_SIZE - 1 {
|
||||
panic!(
|
||||
"not enough padding bytes, {} required, {} provided",
|
||||
|
|
@ -146,7 +145,7 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, E, S> BitBuffer<'a, E, S>
|
||||
impl<E, S> BitBuffer<E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
S: IsPadded,
|
||||
|
|
@ -209,7 +208,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let result = buffer.read_bool(5).unwrap();
|
||||
/// assert_eq!(result, true);
|
||||
/// ```
|
||||
|
|
@ -245,7 +244,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let result = buffer.read_int::<u16>(10, 9).unwrap();
|
||||
/// assert_eq!(result, 0b100_0110_10);
|
||||
/// ```
|
||||
|
|
@ -323,7 +322,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// assert_eq!(buffer.read_bytes(5, 3).unwrap(), &[0b0_1010_101, 0b0_1100_011, 0b1_1001_101]);
|
||||
/// assert_eq!(buffer.read_bytes(0, 8).unwrap(), &[
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
|
|
@ -367,7 +366,7 @@ where
|
|||
/// 0x72, 0x6c, 0x64, 0,
|
||||
/// 0, 0, 0, 0
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// // Fixed length string
|
||||
/// assert_eq!(buffer.read_string(0, Some(13)).unwrap(), "Hello world".to_owned());
|
||||
/// // fixed length with null padding
|
||||
|
|
@ -412,7 +411,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let result = buffer.read_float::<f32>(10).unwrap();
|
||||
/// ```
|
||||
pub fn read_float<T>(&self, position: usize) -> Result<T>
|
||||
|
|
@ -428,19 +427,3 @@ where
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, E, P> Clone for BitBuffer<'a, E, P>
|
||||
where
|
||||
E: Endianness,
|
||||
P: IsPadded,
|
||||
{
|
||||
fn clone(&self) -> Self {
|
||||
BitBuffer {
|
||||
bytes: self.bytes,
|
||||
byte_len: self.byte_len,
|
||||
bit_len: self.bit_len,
|
||||
endianness: PhantomData,
|
||||
is_padded: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
48
src/read.rs
48
src/read.rs
|
|
@ -1,16 +1,16 @@
|
|||
use crate::{BitStream, Endianness, IsPadded, Result};
|
||||
|
||||
/// Trait for types that can be read from a stream without requiring the size to be configured
|
||||
pub trait Read<'a, E: Endianness, P: IsPadded>: Sized {
|
||||
pub trait Read<E: Endianness, P: IsPadded>: Sized {
|
||||
/// Read the type from stream
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<Self>;
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<Self>;
|
||||
}
|
||||
|
||||
macro_rules! impl_read_int {
|
||||
($type:ty, $len:expr) => {
|
||||
impl<'a, E: Endianness, P: IsPadded> Read<'a, E, P> for $type {
|
||||
impl<E: Endianness, P: IsPadded> Read<E, P> for $type {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<$type> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<$type> {
|
||||
stream.read_int::<$type>($len)
|
||||
}
|
||||
}
|
||||
|
|
@ -28,45 +28,45 @@ impl_read_int!(i32, 32);
|
|||
impl_read_int!(i64, 64);
|
||||
impl_read_int!(i128, 128);
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded> Read<'a, E, P> for f32 {
|
||||
impl<E: Endianness, P: IsPadded> Read<E, P> for f32 {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<f32> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<f32> {
|
||||
stream.read_float::<f32>()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded> Read<'a, E, P> for f64 {
|
||||
impl<E: Endianness, P: IsPadded> Read<E, P> for f64 {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<f64> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<f64> {
|
||||
stream.read_float::<f64>()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded> Read<'a, E, P> for bool {
|
||||
impl<E: Endianness, P: IsPadded> Read<E, P> for bool {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<bool> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<bool> {
|
||||
stream.read_bool()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded> Read<'a, E, P> for String {
|
||||
impl<E: Endianness, P: IsPadded> Read<E, P> for String {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<String> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<String> {
|
||||
stream.read_string(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Trait for types that can be read from a stream wit requiring the size to be configured
|
||||
pub trait ReadSized<'a, E: Endianness, P: IsPadded>: Sized {
|
||||
pub trait ReadSized<E: Endianness, P: IsPadded>: Sized {
|
||||
/// Read the type from stream
|
||||
fn read(stream: &mut BitStream<'a, E, P>, size: usize) -> Result<Self>;
|
||||
fn read(stream: &mut BitStream<E, P>, size: usize) -> Result<Self>;
|
||||
}
|
||||
|
||||
macro_rules! impl_read_int_sized {
|
||||
($type:ty) => {
|
||||
impl<'a, E: Endianness, P: IsPadded> ReadSized<'a, E, P> for $type {
|
||||
impl<E: Endianness, P: IsPadded> ReadSized<E, P> for $type {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>, size: usize) -> Result<$type> {
|
||||
fn read(stream: &mut BitStream<E, P>, size: usize) -> Result<$type> {
|
||||
stream.read_int::<$type>(size)
|
||||
}
|
||||
}
|
||||
|
|
@ -84,16 +84,16 @@ impl_read_int_sized!(i32);
|
|||
impl_read_int_sized!(i64);
|
||||
impl_read_int_sized!(i128);
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded> ReadSized<'a, E, P> for String {
|
||||
impl<E: Endianness, P: IsPadded> ReadSized<E, P> for String {
|
||||
#[inline(always)]
|
||||
fn read(stream: &mut BitStream<'a, E, P>, size: usize) -> Result<String> {
|
||||
fn read(stream: &mut BitStream<E, P>, size: usize) -> Result<String> {
|
||||
stream.read_string(Some(size))
|
||||
}
|
||||
}
|
||||
|
||||
/// Read a boolean, if true, read the value, else return None
|
||||
impl<'a, E: Endianness, P: IsPadded, T: Read<'a, E, P>> Read<'a, E, P> for Option<T> {
|
||||
fn read(stream: &mut BitStream<'a, E, P>) -> Result<Self> {
|
||||
impl<E: Endianness, P: IsPadded, T: Read<E, P>> Read<E, P> for Option<T> {
|
||||
fn read(stream: &mut BitStream<E, P>) -> Result<Self> {
|
||||
if stream.read()? {
|
||||
Ok(Some(stream.read()?))
|
||||
} else {
|
||||
|
|
@ -102,8 +102,8 @@ impl<'a, E: Endianness, P: IsPadded, T: Read<'a, E, P>> Read<'a, E, P> for Optio
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, E: Endianness, P: IsPadded, T: Read<'a, E, P>> ReadSized<'a, E, P> for Vec<T> {
|
||||
fn read(stream: &mut BitStream<'a, E, P>, size: usize) -> Result<Self> {
|
||||
impl<E: Endianness, P: IsPadded, T: Read<E, P>> ReadSized<E, P> for Vec<T> {
|
||||
fn read(stream: &mut BitStream<E, P>, size: usize) -> Result<Self> {
|
||||
let mut vec = Vec::with_capacity(size);
|
||||
for _ in 0..size {
|
||||
vec.push(stream.read()?)
|
||||
|
|
@ -113,9 +113,9 @@ impl<'a, E: Endianness, P: IsPadded, T: Read<'a, E, P>> ReadSized<'a, E, P> for
|
|||
}
|
||||
|
||||
// Once we have something like https://github.com/rust-lang/rfcs/issues/1053 we can do this optimization
|
||||
//impl<'a, E: Endianness, P: IsPadded> ReadSized<'a, E, P> for Vec<u8> {
|
||||
//impl<E: Endianness, P: IsPadded> ReadSized<E, P> for Vec<u8> {
|
||||
// #[inline(always)]
|
||||
// fn read(stream: &mut BitStream<'a, E, P>, size: usize) -> Result<Self> {
|
||||
// fn read(stream: &mut BitStream<E, P>, size: usize) -> Result<Self> {
|
||||
// stream.read_bytes(size)
|
||||
// }
|
||||
//}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
use std::mem::size_of;
|
||||
use std::ops::BitOrAssign;
|
||||
use std::rc::Rc;
|
||||
|
||||
use num_traits::{Float, PrimInt};
|
||||
|
||||
|
|
@ -20,21 +21,21 @@ use crate::{Read, ReadError, ReadSized, Result};
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// ```
|
||||
pub struct BitStream<'a, E, S>
|
||||
pub struct BitStream<E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
S: IsPadded,
|
||||
{
|
||||
buffer: BitBuffer<'a, E, S>,
|
||||
buffer: Rc<BitBuffer<E, S>>,
|
||||
start_pos: usize,
|
||||
pos: usize,
|
||||
bit_len: usize,
|
||||
}
|
||||
|
||||
impl<'a, E, S> BitStream<'a, E, S>
|
||||
impl<E, S> BitStream<E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
S: IsPadded,
|
||||
|
|
@ -55,14 +56,10 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// ```
|
||||
pub fn new(
|
||||
buffer: BitBuffer<'a, E, S>,
|
||||
start_pos: Option<usize>,
|
||||
bit_len: Option<usize>,
|
||||
) -> Self {
|
||||
pub fn new(buffer: BitBuffer<E, S>, start_pos: Option<usize>, bit_len: Option<usize>) -> Self {
|
||||
let buffer_len = buffer.bit_len();
|
||||
let start = start_pos.unwrap_or_default();
|
||||
if start > buffer_len {
|
||||
|
|
@ -72,7 +69,7 @@ where
|
|||
start_pos: start,
|
||||
pos: start,
|
||||
bit_len: bit_len.unwrap_or(buffer_len - start),
|
||||
buffer,
|
||||
buffer: Rc::new(buffer),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -102,7 +99,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.read_bool().unwrap(), true);
|
||||
/// assert_eq!(stream.read_bool().unwrap(), false);
|
||||
|
|
@ -133,7 +130,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.read_int::<u16>(3).unwrap(), 0b101);
|
||||
/// assert_eq!(stream.read_int::<u16>(3).unwrap(), 0b110);
|
||||
|
|
@ -166,7 +163,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// let result = stream.read_float::<f32>().unwrap();
|
||||
/// assert_eq!(stream.pos(), 32);
|
||||
|
|
@ -199,7 +196,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.read_bytes(3).unwrap(), &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
|
||||
/// assert_eq!(stream.pos(), 24);
|
||||
|
|
@ -234,7 +231,7 @@ where
|
|||
/// 0x72, 0x6c, 0x64, 0,
|
||||
/// 0, 0, 0, 0
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// // Fixed length string
|
||||
/// stream.set_pos(0);
|
||||
|
|
@ -274,7 +271,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// let mut bits = stream.read_bits(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -285,7 +282,12 @@ where
|
|||
/// ```
|
||||
pub fn read_bits(&mut self, count: usize) -> Result<Self> {
|
||||
self.verify_bits_left(count)?;
|
||||
let result = BitStream::new(self.buffer.clone(), Some(self.pos), Some(count));
|
||||
let result = BitStream {
|
||||
buffer: Rc::clone(&self.buffer),
|
||||
start_pos: self.pos,
|
||||
pos: self.pos,
|
||||
bit_len: count,
|
||||
};
|
||||
self.pos += count;
|
||||
Ok(result)
|
||||
}
|
||||
|
|
@ -305,7 +307,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// stream.skip(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -332,7 +334,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// stream.set_pos(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
|
|
@ -360,7 +362,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.bit_len(), 64);
|
||||
/// ```
|
||||
|
|
@ -379,7 +381,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.pos(), 0);
|
||||
/// stream.skip(5).unwrap();
|
||||
|
|
@ -400,7 +402,7 @@ where
|
|||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let buffer = BitBuffer::new(bytes.to_vec(), LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.bits_left(), 64);
|
||||
/// stream.skip(5).unwrap();
|
||||
|
|
@ -411,12 +413,12 @@ where
|
|||
}
|
||||
|
||||
/// Read a value based on the provided type
|
||||
pub fn read<T: Read<'a, E, S>>(&mut self) -> Result<T> {
|
||||
pub fn read<T: Read<E, S>>(&mut self) -> Result<T> {
|
||||
T::read(self)
|
||||
}
|
||||
|
||||
/// Read a value based on the provided type and size
|
||||
pub fn read_sized<T: ReadSized<'a, E, S>>(&mut self, size: usize) -> Result<T> {
|
||||
pub fn read_sized<T: ReadSized<E, S>>(&mut self, size: usize) -> Result<T> {
|
||||
T::read(self, size)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
40
src/tests.rs
40
src/tests.rs
|
|
@ -20,7 +20,7 @@ const BYTES: &'static [u8] = &[
|
|||
|
||||
#[test]
|
||||
fn read_u8_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
|
||||
|
|
@ -33,7 +33,7 @@ fn read_u8_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u8_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
|
||||
|
|
@ -45,21 +45,21 @@ fn read_u8_be() {
|
|||
|
||||
#[test]
|
||||
fn read_u16_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u16_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u32_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -69,7 +69,7 @@ fn read_u32_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u32_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -79,7 +79,7 @@ fn read_u32_be() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -101,7 +101,7 @@ fn read_u64_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -119,7 +119,7 @@ fn read_u64_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i8_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b011_0101);
|
||||
|
|
@ -127,7 +127,7 @@ fn read_i8_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i8_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i8>(1, 2).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
|
||||
|
|
@ -136,7 +136,7 @@ fn read_i8_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i16_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b00_0110_1010_10);
|
||||
|
|
@ -144,7 +144,7 @@ fn read_i16_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i16_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b0110_1010_101);
|
||||
|
|
@ -152,7 +152,7 @@ fn read_i16_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i32_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i32>(6, 24).unwrap(),
|
||||
|
|
@ -166,7 +166,7 @@ fn read_i32_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i32_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i32>(7, 24).unwrap(),
|
||||
|
|
@ -176,7 +176,7 @@ fn read_i32_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i64_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i64>(6, 34).unwrap(),
|
||||
|
|
@ -194,7 +194,7 @@ fn read_i64_le() {
|
|||
|
||||
#[test]
|
||||
fn read_i64_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i64>(7, 34).unwrap(),
|
||||
|
|
@ -212,21 +212,21 @@ fn read_i64_be() {
|
|||
|
||||
#[test]
|
||||
fn read_f32_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_f64_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read_float::<f64>(6).unwrap(), 135447455835963910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_trait() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer, None, None);
|
||||
let a: u8 = stream.read().unwrap();
|
||||
assert_eq!(0b1011_0101, a);
|
||||
|
|
@ -245,7 +245,7 @@ fn read_trait() {
|
|||
|
||||
#[test]
|
||||
fn read_sized_trait() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer, None, None);
|
||||
let a: u8 = stream.read_sized(4).unwrap();
|
||||
assert_eq!(0b1011, a);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue