mirror of
https://codeberg.org/icewind/bitbuffer.git
synced 2026-06-03 16:44:06 +02:00
rename read -> read_int
This commit is contained in:
parent
dcaba5b98e
commit
deafc90b74
5 changed files with 150 additions and 120 deletions
|
|
@ -1,6 +1,6 @@
|
|||
use crate::{ReadError, Result};
|
||||
use crate::endianness::Endianness;
|
||||
use crate::is_signed::IsSigned;
|
||||
use crate::{ReadError, Result};
|
||||
use num_traits::{Float, PrimInt};
|
||||
use std::cmp::min;
|
||||
use std::marker::PhantomData;
|
||||
|
|
@ -62,6 +62,7 @@ impl IsPadded for Padded {
|
|||
/// ];
|
||||
/// let buffer = BitBuffer::from_padded_slice(bytes, 8, LittleEndian);
|
||||
/// ```
|
||||
#[derive(Copy)]
|
||||
pub struct BitBuffer<'a, E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
|
|
@ -174,8 +175,10 @@ impl<'a, E, S> BitBuffer<'a, E, S>
|
|||
};
|
||||
let bit_offset = position - byte_index * 8;
|
||||
let raw_container: &usize = unsafe {
|
||||
// this is only safe for us because we're sure that there is enough data in the slice
|
||||
std::mem::transmute(self.bytes.as_ptr().offset(byte_index as isize))
|
||||
// this is safe here because it's already verified that there is enough data in the slice
|
||||
// to read a usize from byte_index
|
||||
let ptr = self.bytes.as_ptr().add(byte_index);
|
||||
std::mem::transmute(ptr)
|
||||
};
|
||||
let container = if E::is_le() {
|
||||
usize::from_le(*raw_container)
|
||||
|
|
@ -185,7 +188,7 @@ impl<'a, E, S> BitBuffer<'a, E, S>
|
|||
let shifted = if E::is_le() {
|
||||
container >> bit_offset
|
||||
} else {
|
||||
container >> USIZE_SIZE * 8 - bit_offset - count
|
||||
container >> (USIZE_SIZE * 8 - bit_offset - count)
|
||||
};
|
||||
let mask = !(usize::max_value() << count);
|
||||
Ok(shifted & mask)
|
||||
|
|
@ -243,10 +246,10 @@ impl<'a, E, S> BitBuffer<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let result = buffer.read::<u16>(10, 9).unwrap();
|
||||
/// let result = buffer.read_int::<u16>(10, 9).unwrap();
|
||||
/// assert_eq!(result, 0b100_0110_10);
|
||||
/// ```
|
||||
pub fn read<T>(&self, position: usize, count: usize) -> Result<T>
|
||||
pub fn read_int<T>(&self, position: usize, count: usize) -> Result<T>
|
||||
where
|
||||
T: PrimInt + BitOrAssign + IsSigned,
|
||||
{
|
||||
|
|
@ -379,7 +382,7 @@ impl<'a, E, S> BitBuffer<'a, E, S>
|
|||
let mut acc = vec![];
|
||||
let mut pos = position;
|
||||
loop {
|
||||
let byte = self.read(pos, 8)?;
|
||||
let byte = self.read_int(pos, 8)?;
|
||||
acc.push(byte);
|
||||
if byte == 0 {
|
||||
break;
|
||||
|
|
@ -417,11 +420,27 @@ impl<'a, E, S> BitBuffer<'a, E, S>
|
|||
T: Float,
|
||||
{
|
||||
if size_of::<T>() == 4 {
|
||||
let int = self.read::<u32>(position, 32)?;
|
||||
let int = self.read_int::<u32>(position, 32)?;
|
||||
Ok(T::from(f32::from_bits(int)).unwrap())
|
||||
} else {
|
||||
let int = self.read::<u64>(position, 64)?;
|
||||
let int = self.read_int::<u64>(position, 64)?;
|
||||
Ok(T::from(f64::from_bits(int)).unwrap())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,9 +17,11 @@ impl_is_signed!(u8, false);
|
|||
impl_is_signed!(u16, false);
|
||||
impl_is_signed!(u32, false);
|
||||
impl_is_signed!(u64, false);
|
||||
impl_is_signed!(u128, false);
|
||||
impl_is_signed!(usize, false);
|
||||
impl_is_signed!(i8, true);
|
||||
impl_is_signed!(i16, true);
|
||||
impl_is_signed!(i32, true);
|
||||
impl_is_signed!(i64, true);
|
||||
impl_is_signed!(i128, true);
|
||||
impl_is_signed!(isize, true);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
// for bench on nightly
|
||||
//extern crate test;
|
||||
|
||||
pub use buffer::{BitBuffer, IsPadded};
|
||||
pub use buffer::{BitBuffer, IsPadded, NonPadded, Padded};
|
||||
pub use endianness::*;
|
||||
pub use std::string::FromUtf8Error;
|
||||
pub use stream::BitStream;
|
||||
|
|
|
|||
|
|
@ -1,11 +1,13 @@
|
|||
use crate::{ReadError, Result};
|
||||
use crate::BitBuffer;
|
||||
use std::mem::size_of;
|
||||
use std::ops::BitOrAssign;
|
||||
|
||||
use num_traits::{Float, PrimInt};
|
||||
|
||||
use crate::buffer::IsPadded;
|
||||
use crate::endianness::Endianness;
|
||||
use crate::is_signed::IsSigned;
|
||||
use num_traits::{Float, PrimInt};
|
||||
use std::mem::size_of;
|
||||
use std::ops::BitOrAssign;
|
||||
use crate::BitBuffer;
|
||||
use crate::{ReadError, Result};
|
||||
|
||||
/// Stream that provides an easy way to iterate trough a BitBuffer
|
||||
///
|
||||
|
|
@ -19,14 +21,14 @@ use std::ops::BitOrAssign;
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// ```
|
||||
pub struct BitStream<'a, E, S>
|
||||
where
|
||||
E: Endianness,
|
||||
S: IsPadded,
|
||||
{
|
||||
buffer: &'a BitBuffer<'a, E, S>,
|
||||
buffer: BitBuffer<'a, E, S>,
|
||||
start_pos: usize,
|
||||
pos: usize,
|
||||
bit_len: usize,
|
||||
|
|
@ -39,6 +41,11 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
{
|
||||
/// Create a new stream for a buffer
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// - If the start_pos is higher than the bit length of the buffer
|
||||
///
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
|
|
@ -49,17 +56,22 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// ```
|
||||
pub fn new(
|
||||
buffer: &'a BitBuffer<'a, E, S>,
|
||||
buffer: BitBuffer<'a, 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 {
|
||||
panic!("start_pos out opf bounds of the buffer")
|
||||
}
|
||||
BitStream {
|
||||
start_pos: start_pos.unwrap_or(0),
|
||||
pos: start_pos.unwrap_or(0),
|
||||
bit_len: bit_len.unwrap_or(buffer.bit_len()),
|
||||
start_pos: start,
|
||||
pos: start,
|
||||
bit_len: bit_len.unwrap_or(buffer_len - start),
|
||||
buffer,
|
||||
}
|
||||
}
|
||||
|
|
@ -91,7 +103,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.read_bool().unwrap(), true);
|
||||
/// assert_eq!(stream.read_bool().unwrap(), false);
|
||||
/// assert_eq!(stream.pos(), 2);
|
||||
|
|
@ -99,9 +111,8 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
pub fn read_bool(&mut self) -> Result<bool> {
|
||||
self.verify_bits_left(1)?;
|
||||
let result = self.buffer.read_bool(self.pos);
|
||||
match result {
|
||||
Ok(_) => self.pos += 1,
|
||||
Err(_) => {}
|
||||
if result.is_ok() {
|
||||
self.pos += 1;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
|
@ -123,20 +134,19 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// assert_eq!(stream.read::<u16>(3).unwrap(), 0b101);
|
||||
/// assert_eq!(stream.read::<u16>(3).unwrap(), 0b110);
|
||||
/// 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);
|
||||
/// assert_eq!(stream.pos(), 6);
|
||||
/// ```
|
||||
pub fn read<T>(&mut self, count: usize) -> Result<T>
|
||||
pub fn read_int<T>(&mut self, count: usize) -> Result<T>
|
||||
where
|
||||
T: PrimInt + BitOrAssign + IsSigned,
|
||||
{
|
||||
self.verify_bits_left(count)?;
|
||||
let result = self.buffer.read(self.pos, count);
|
||||
match result {
|
||||
Ok(_) => self.pos += count,
|
||||
Err(_) => {}
|
||||
let result = self.buffer.read_int(self.pos, count);
|
||||
if result.is_ok() {
|
||||
self.pos += count;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
|
@ -157,7 +167,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// let result = stream.read_float::<f32>().unwrap();
|
||||
/// assert_eq!(stream.pos(), 32);
|
||||
/// ```
|
||||
|
|
@ -168,9 +178,8 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
let count = size_of::<T>() * 8;
|
||||
self.verify_bits_left(count)?;
|
||||
let result = self.buffer.read_float(self.pos);
|
||||
match result {
|
||||
Ok(_) => self.pos += count,
|
||||
Err(_) => {}
|
||||
if result.is_ok() {
|
||||
self.pos += count;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
|
@ -191,7 +200,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// 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);
|
||||
/// ```
|
||||
|
|
@ -199,9 +208,8 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
let count = byte_count * 8;
|
||||
self.verify_bits_left(count)?;
|
||||
let result = self.buffer.read_bytes(self.pos, byte_count);
|
||||
match result {
|
||||
Ok(_) => self.pos += count,
|
||||
Err(_) => {}
|
||||
if result.is_ok() {
|
||||
self.pos += count;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
|
@ -227,7 +235,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0, 0, 0, 0
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// // Fixed length string
|
||||
/// stream.set_pos(0);
|
||||
/// assert_eq!(stream.read_string(Some(11)).unwrap(), "Hello world".to_owned());
|
||||
|
|
@ -245,7 +253,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
let result = self.buffer.read_string(self.pos, byte_len)?;
|
||||
let read = match byte_len {
|
||||
Some(len) => len * 8,
|
||||
None => (result.len() + 1) * 8
|
||||
None => (result.len() + 1) * 8,
|
||||
};
|
||||
self.pos += read;
|
||||
Ok(result)
|
||||
|
|
@ -267,17 +275,17 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// let mut bits = stream.read_bits(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(bits.pos(), 0);
|
||||
/// assert_eq!(bits.bit_len(), 3);
|
||||
/// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
|
||||
/// assert_eq!(bits.read::<u8>(3).unwrap(), 0b101);
|
||||
/// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
|
||||
/// assert_eq!(bits.read_int::<u8>(3).unwrap(), 0b101);
|
||||
/// ```
|
||||
pub fn read_bits(&mut self, count: usize) -> Result<Self> {
|
||||
self.verify_bits_left(count)?;
|
||||
let result = BitStream::new(&self.buffer, Some(self.pos), Some(count));
|
||||
let result = BitStream::new(self.buffer.clone(), Some(self.pos), Some(count));
|
||||
self.pos += count;
|
||||
Ok(result)
|
||||
}
|
||||
|
|
@ -298,10 +306,10 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// stream.skip(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
|
||||
/// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
|
||||
/// ```
|
||||
pub fn skip(&mut self, count: usize) -> Result<()> {
|
||||
self.verify_bits_left(count)?;
|
||||
|
|
@ -325,10 +333,10 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// stream.set_pos(3).unwrap();
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(stream.read::<u8>(3).unwrap(), 0b110);
|
||||
/// assert_eq!(stream.read_int::<u8>(3).unwrap(), 0b110);
|
||||
/// ```
|
||||
pub fn set_pos(&mut self, pos: usize) -> Result<()> {
|
||||
if pos > self.bit_len {
|
||||
|
|
@ -353,7 +361,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.bit_len(), 64);
|
||||
/// ```
|
||||
pub fn bit_len(&self) -> usize {
|
||||
|
|
@ -372,7 +380,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.pos(), 0);
|
||||
/// stream.skip(5).unwrap();
|
||||
/// assert_eq!(stream.pos(), 5);
|
||||
|
|
@ -393,7 +401,7 @@ impl<'a, E, S> BitStream<'a, E, S>
|
|||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(&buffer, None, None);
|
||||
/// let mut stream = BitStream::new(buffer, None, None);
|
||||
/// assert_eq!(stream.bits_left(), 64);
|
||||
/// stream.skip(5).unwrap();
|
||||
/// assert_eq!(stream.bits_left(), 59);
|
||||
|
|
|
|||
83
src/tests.rs
83
src/tests.rs
|
|
@ -22,38 +22,39 @@ const BYTES: &'static [u8] = &[
|
|||
fn read_u8_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read::<u8>(1, 1).unwrap(), 0b0);
|
||||
assert_eq!(buffer.read::<u8>(2, 2).unwrap(), 0b01);
|
||||
assert_eq!(buffer.read::<u8>(0, 3).unwrap(), 0b101);
|
||||
assert_eq!(buffer.read::<u8>(7, 5).unwrap(), 0b1010_1);
|
||||
assert_eq!(buffer.read::<u8>(6, 5).unwrap(), 0b010_10);
|
||||
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>(2, 2).unwrap(), 0b01);
|
||||
assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
|
||||
assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1010_1);
|
||||
assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b010_10);
|
||||
assert_eq!(buffer.read_int::<u8>(12, 5).unwrap(), 0b0_0110);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u8_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read::<u8>(0, 1).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read::<u8>(1, 1).unwrap(), 0b0);
|
||||
assert_eq!(buffer.read::<u8>(2, 2).unwrap(), 0b11);
|
||||
assert_eq!(buffer.read::<u8>(0, 3).unwrap(), 0b101);
|
||||
assert_eq!(buffer.read::<u8>(7, 5).unwrap(), 0b1011_0);
|
||||
assert_eq!(buffer.read::<u8>(6, 5).unwrap(), 0b01_011);
|
||||
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>(2, 2).unwrap(), 0b11);
|
||||
assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
|
||||
assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1011_0);
|
||||
assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b01_011);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u16_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u16_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
|
||||
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -61,7 +62,7 @@ fn read_u32_le() {
|
|||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<u32>(6, 24).unwrap(),
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
0b01_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
}
|
||||
|
|
@ -71,7 +72,7 @@ fn read_u32_be() {
|
|||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<u32>(6, 24).unwrap(),
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
0b01_0110_1010_1010_1100_1001_10
|
||||
);
|
||||
}
|
||||
|
|
@ -81,19 +82,19 @@ fn read_u64_le() {
|
|||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 34).unwrap(),
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
0b1001_1001_1001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 60).unwrap(),
|
||||
buffer.read_int::<u64>(6, 60).unwrap(),
|
||||
0b01_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 64).unwrap(),
|
||||
buffer.read_int::<u64>(6, 64).unwrap(),
|
||||
0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(8, 62).unwrap(),
|
||||
buffer.read_int::<u64>(8, 62).unwrap(),
|
||||
0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010
|
||||
);
|
||||
}
|
||||
|
|
@ -103,15 +104,15 @@ fn read_u64_be() {
|
|||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 34).unwrap(),
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
0b01_0110_1010_1010_1100_1001_1001_1001_1001
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 60).unwrap(),
|
||||
buffer.read_int::<u64>(6, 60).unwrap(),
|
||||
0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<u64>(6, 64).unwrap(),
|
||||
buffer.read_int::<u64>(6, 64).unwrap(),
|
||||
0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_10
|
||||
);
|
||||
}
|
||||
|
|
@ -120,33 +121,33 @@ fn read_u64_be() {
|
|||
fn read_i8_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read::<i8>(0, 3).unwrap(), -0b01);
|
||||
assert_eq!(buffer.read::<i8>(0, 8).unwrap(), -0b011_0101);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b011_0101);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_i8_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read::<i8>(1, 2).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read::<i8>(0, 3).unwrap(), -0b01);
|
||||
assert_eq!(buffer.read::<i8>(0, 8).unwrap(), -0b011_0101);
|
||||
assert_eq!(buffer.read_int::<i8>(1, 2).unwrap(), 0b1);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 3).unwrap(), -0b01);
|
||||
assert_eq!(buffer.read_int::<i8>(0, 8).unwrap(), -0b011_0101);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_i16_le() {
|
||||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(buffer.read::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
|
||||
assert_eq!(buffer.read::<i16>(6, 13).unwrap(), -0b00_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(), -0b00_0110_1010_10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_i16_be() {
|
||||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(buffer.read::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
|
||||
assert_eq!(buffer.read::<i16>(7, 12).unwrap(), -0b0110_1010_101);
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -154,11 +155,11 @@ fn read_i32_le() {
|
|||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<i32>(6, 24).unwrap(),
|
||||
buffer.read_int::<i32>(6, 24).unwrap(),
|
||||
0b1_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<i32>(6, 26).unwrap(),
|
||||
buffer.read_int::<i32>(6, 26).unwrap(),
|
||||
-0b001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
}
|
||||
|
|
@ -168,7 +169,7 @@ fn read_i32_be() {
|
|||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<i32>(7, 24).unwrap(),
|
||||
buffer.read_int::<i32>(7, 24).unwrap(),
|
||||
-0b0110_1010_1010_1100_1001_100
|
||||
);
|
||||
}
|
||||
|
|
@ -178,15 +179,15 @@ fn read_i64_le() {
|
|||
let buffer = BitBuffer::new(BYTES, LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(6, 34).unwrap(),
|
||||
buffer.read_int::<i64>(6, 34).unwrap(),
|
||||
-0b001_1001_1001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(6, 59).unwrap(),
|
||||
buffer.read_int::<i64>(6, 59).unwrap(),
|
||||
-0b1110_01111001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(1, 64).unwrap(),
|
||||
buffer.read_int::<i64>(1, 64).unwrap(),
|
||||
-0b1110_01111001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_1011_010
|
||||
);
|
||||
}
|
||||
|
|
@ -196,15 +197,15 @@ fn read_i64_be() {
|
|||
let buffer = BitBuffer::new(BYTES, BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(7, 34).unwrap(),
|
||||
buffer.read_int::<i64>(7, 34).unwrap(),
|
||||
-0b0110_1010_1010_1100_1001_1001_1001_1001_1
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(7, 60).unwrap(),
|
||||
buffer.read_int::<i64>(7, 60).unwrap(),
|
||||
-0b0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_100
|
||||
);
|
||||
assert_eq!(
|
||||
buffer.read::<i64>(7, 64).unwrap(),
|
||||
buffer.read_int::<i64>(7, 64).unwrap(),
|
||||
-0b0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_100
|
||||
);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue