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

rename bitbuffer/bitstream to bitreadbuffer/bitreadstream

Browse source
This commit is contained in:
Robin Appelman 2020-02-12 23:53:59 +01:00
commit 6fc3785fc9
8 changed files with 227 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

32
benches/bench.rs
View file

@ -2,10 +2,10 @@
extern crate test; extern crate test;
use bitbuffer::{BigEndian, BitBuffer, BitRead, BitStream, Endianness, LittleEndian}; use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, Endianness, LittleEndian};
use test::Bencher; use test::Bencher;
fn read_perf<E: Endianness>(buffer: &BitBuffer<E>) -> u16 { fn read_perf<E: Endianness>(buffer: &BitReadBuffer<E>) -> u16 {
let size = 5; let size = 5;
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
@ -23,7 +23,7 @@ fn read_perf<E: Endianness>(buffer: &BitBuffer<E>) -> u16 {
#[bench] #[bench]
fn perf_le(b: &mut Bencher) { fn perf_le(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitBuffer::new(data, LittleEndian); let buffer = BitReadBuffer::new(data, LittleEndian);
b.iter(|| { b.iter(|| {
let data = read_perf(&buffer); let data = read_perf(&buffer);
assert_eq!(data, 0); assert_eq!(data, 0);
@ -34,7 +34,7 @@ fn perf_le(b: &mut Bencher) {
#[bench] #[bench]
fn perf_be(b: &mut Bencher) { fn perf_be(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitBuffer::new(data, BigEndian); let buffer = BitReadBuffer::new(data, BigEndian);
b.iter(|| { b.iter(|| {
let data = read_perf(&buffer); let data = read_perf(&buffer);
assert_eq!(data, 0); assert_eq!(data, 0);
@ -45,7 +45,7 @@ fn perf_be(b: &mut Bencher) {
#[bench] #[bench]
fn perf_f32_be(b: &mut Bencher) { fn perf_f32_be(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitBuffer::new(data, BigEndian); let buffer = BitReadBuffer::new(data, BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
@ -66,7 +66,7 @@ fn perf_f32_be(b: &mut Bencher) {
#[bench] #[bench]
fn perf_f32_le(b: &mut Bencher) { fn perf_f32_le(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitBuffer::new(data, LittleEndian); let buffer = BitReadBuffer::new(data, LittleEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
@ -89,7 +89,7 @@ const F64_RESULT: f64 = 0.000000000000000000000000000000000000000000000000000000
#[bench] #[bench]
fn perf_f64(b: &mut Bencher) { fn perf_f64(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitBuffer::new(data, BigEndian); let buffer = BitReadBuffer::new(data, BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
@ -110,7 +110,7 @@ fn perf_f64(b: &mut Bencher) {
#[bench] #[bench]
fn perf_bool(b: &mut Bencher) { fn perf_bool(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 1]; let data = vec![1u8; 1024 * 1024 * 1];
let buffer = BitBuffer::new(data, BigEndian); let buffer = BitReadBuffer::new(data, BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
@ -151,7 +151,7 @@ fn get_string_buffer() -> Vec<u8> {
#[bench] #[bench]
fn perf_string_be(b: &mut Bencher) { fn perf_string_be(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), BigEndian); let buffer = BitReadBuffer::new(get_string_buffer(), BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
@ -169,7 +169,7 @@ fn perf_string_be(b: &mut Bencher) {
#[bench] #[bench]
fn perf_string_le(b: &mut Bencher) { fn perf_string_le(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), LittleEndian); let buffer = BitReadBuffer::new(get_string_buffer(), LittleEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
@ -187,7 +187,7 @@ fn perf_string_le(b: &mut Bencher) {
#[bench] #[bench]
fn perf_bytes_be(b: &mut Bencher) { fn perf_bytes_be(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), BigEndian); let buffer = BitReadBuffer::new(get_string_buffer(), BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
@ -205,7 +205,7 @@ fn perf_bytes_be(b: &mut Bencher) {
#[bench] #[bench]
fn perf_bytes_le(b: &mut Bencher) { fn perf_bytes_le(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), LittleEndian); let buffer = BitReadBuffer::new(get_string_buffer(), LittleEndian);
b.iter(|| { b.iter(|| {
let mut pos = 0; let mut pos = 0;
@ -223,7 +223,7 @@ fn perf_bytes_le(b: &mut Bencher) {
#[bench] #[bench]
fn perf_bytes_be_unaligned(b: &mut Bencher) { fn perf_bytes_be_unaligned(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), BigEndian); let buffer = BitReadBuffer::new(get_string_buffer(), BigEndian);
b.iter(|| { b.iter(|| {
let mut pos = 3; let mut pos = 3;
@ -241,7 +241,7 @@ fn perf_bytes_be_unaligned(b: &mut Bencher) {
#[bench] #[bench]
fn perf_bytes_le_unaligned(b: &mut Bencher) { fn perf_bytes_le_unaligned(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), LittleEndian); let buffer = BitReadBuffer::new(get_string_buffer(), LittleEndian);
b.iter(|| { b.iter(|| {
let mut pos = 3; let mut pos = 3;
@ -268,10 +268,10 @@ struct BasicStruct {
#[bench] #[bench]
fn perf_struct(b: &mut Bencher) { fn perf_struct(b: &mut Bencher) {
let buffer = BitBuffer::new(get_string_buffer(), LittleEndian); let buffer = BitReadBuffer::new(get_string_buffer(), LittleEndian);
b.iter(|| { b.iter(|| {
let mut stream: BitStream<LittleEndian> = buffer.clone().into(); let mut stream: BitReadStream<LittleEndian> = buffer.clone().into();
while stream.bits_left() > 40 { while stream.bits_left() > 40 {
let result = stream.read::<BasicStruct>().unwrap(); let result = stream.read::<BasicStruct>().unwrap();
test::black_box(result); test::black_box(result);

12
bitbuffer_derive/src/lib.rs
View file

@ -108,27 +108,27 @@
//! If the struct that `BitRead` or `BitReadSized` is derived for requires a Endianness type parameter, you need to tell the derive macro the name of the type parameter used //! If the struct that `BitRead` or `BitReadSized` is derived for requires a Endianness type parameter, you need to tell the derive macro the name of the type parameter used
//! //!
//! ``` //! ```
//! # use bitbuffer::{BitRead, Endianness, BitStream}; //! # use bitbuffer::{BitRead, Endianness, BitReadStream};
//! # //! #
//! #[derive(BitRead)] //! #[derive(BitRead)]
//! #[endianness = "E"] //! #[endianness = "E"]
//! struct EndiannessStruct<E: Endianness> { //! struct EndiannessStruct<E: Endianness> {
//! size: u8, //! size: u8,
//! #[size = "size"] //! #[size = "size"]
//! stream: BitStream<E>, //! stream: BitReadStream<E>,
//! } //! }
//! ``` //! ```
//! //!
//! This is also required if you specify which endianness the struct has //! This is also required if you specify which endianness the struct has
//! ``` //! ```
//! # use bitbuffer::{BitRead, BigEndian, BitStream}; //! # use bitbuffer::{BitRead, BigEndian, BitReadStream};
//! # //! #
//! #[derive(BitRead)] //! #[derive(BitRead)]
//! #[endianness = "BigEndian"] //! #[endianness = "BigEndian"]
//! struct EndiannessStruct { //! struct EndiannessStruct {
//! size: u8, //! size: u8,
//! #[size = "size"] //! #[size = "size"]
//! stream: BitStream<BigEndian>, //! stream: BitReadStream<BigEndian>,
//! } //! }
//! ``` //! ```
extern crate proc_macro; extern crate proc_macro;
@ -221,7 +221,7 @@ fn derive_bitread_trait(
// //
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::BitStream<#endianness_ident>#extra_param) -> ::bitbuffer::Result<Self> { fn read(stream: &mut ::bitbuffer::BitReadStream<#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 +236,7 @@ fn derive_bitread_trait(
} }
} }
unsafe fn read_unchecked(stream: &mut ::bitbuffer::BitStream<#endianness_ident>#extra_param) -> ::bitbuffer::Result<Self> { unsafe fn read_unchecked(stream: &mut ::bitbuffer::BitReadStream<#endianness_ident>#extra_param) -> ::bitbuffer::Result<Self> {
#parsed_unchecked #parsed_unchecked
} }

45
bitbuffer_derive/tests/test.rs
View file

@ -2,7 +2,8 @@
#![allow(unreachable_patterns)] #![allow(unreachable_patterns)]
use bitbuffer::{ use bitbuffer::{
bit_size_of, bit_size_of_sized, BigEndian, BitBuffer, BitStream, Endianness, LittleEndian, bit_size_of, bit_size_of_sized, BigEndian, BitReadBuffer, BitReadStream, Endianness,
LittleEndian,
}; };
use bitbuffer_derive::{BitRead, BitReadSized}; use bitbuffer_derive::{BitRead, BitReadSized};
@ -44,8 +45,8 @@ fn test_read_struct() {
0b0101_0101, 0b0101_0101,
0b1010_1010, 0b1010_1010,
]; ];
let buffer = BitBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(bytes, LittleEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct { TestStruct {
foo: 12, foo: 12,
@ -82,8 +83,8 @@ fn test_read_bare_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::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());
assert_eq!(TestBareEnum::Bar, stream.read().unwrap()); assert_eq!(TestBareEnum::Bar, stream.read().unwrap());
@ -113,8 +114,8 @@ fn test_read_unnamed_field_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestUnnamedFieldEnum::Asd(0b_00_0110_10), TestUnnamedFieldEnum::Asd(0b_00_0110_10),
stream.read().unwrap() stream.read().unwrap()
@ -143,8 +144,8 @@ 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 = BitBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(bytes, LittleEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStructSized { TestStructSized {
foo: 12, foo: 12,
@ -179,8 +180,8 @@ fn test_read_unnamed_field_enum_sized() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestUnnamedFieldEnumSized::Asd(0b_00_0110), TestUnnamedFieldEnumSized::Asd(0b_00_0110),
stream.read_sized(6).unwrap() stream.read_sized(6).unwrap()
@ -212,8 +213,8 @@ fn test_read_struct2() {
'l' as u8, 'l' as u8,
'e' as u8, 'e' as u8,
]; ];
let buffer = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct2 { TestStruct2 {
size: 5, size: 5,
@ -229,14 +230,14 @@ fn test_read_struct2() {
struct TestStruct3<E: Endianness> { struct TestStruct3<E: Endianness> {
size: u8, size: u8,
#[size = "size"] #[size = "size"]
stream: BitStream<E>, stream: BitReadStream<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 = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::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);
assert_eq!(5, result.stream.bit_len()); assert_eq!(5, result.stream.bit_len());
@ -264,8 +265,8 @@ fn test_read_rest_enum() {
0b1000_0100, 0b1000_0100,
0b1000_0100, 0b1000_0100,
]; ];
let buffer = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::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());
assert_eq!(TestEnumRest::Bar, stream.read().unwrap()); assert_eq!(TestEnumRest::Bar, stream.read().unwrap());
@ -280,8 +281,8 @@ 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 = BitBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(bytes, LittleEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
UnnamedSize(12, "hello".to_string(), false), UnnamedSize(12, "hello".to_string(), false),
@ -294,8 +295,8 @@ 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 = BitBuffer::new(bytes, BigEndian); let buffer = BitReadBuffer::new(bytes, BigEndian);
let mut stream = BitStream::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());
assert_eq!(Some(0), bit_size_of::<EmptyStruct>()); assert_eq!(Some(0), bit_size_of::<EmptyStruct>());

14
src/lib.rs
View file

@ -16,7 +16,7 @@
//! //!
//! ``` //! ```
//! # use bitbuffer::Result; //! # use bitbuffer::Result;
//! use bitbuffer::{BitBuffer, LittleEndian, BitStream, BitRead}; //! use bitbuffer::{BitReadBuffer, LittleEndian, BitReadStream, BitRead};
//! //!
//! #[derive(BitRead)] //! #[derive(BitRead)]
//! struct ComplexType { //! struct ComplexType {
@ -31,8 +31,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 = BitBuffer::new(bytes, LittleEndian); //! let buffer = BitReadBuffer::new(bytes, LittleEndian);
//! let mut stream = BitStream::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()?;
//! # //! #
@ -60,16 +60,16 @@ use std::fmt::Display;
pub use std::string::FromUtf8Error; pub use std::string::FromUtf8Error;
pub use bitbuffer_derive::{BitRead, BitReadSized}; pub use bitbuffer_derive::{BitRead, BitReadSized};
pub use buffer::BitBuffer;
pub use endianness::*; pub use endianness::*;
pub use read::{BitRead, BitReadSized, LazyBitRead, LazyBitReadSized}; pub use read::{BitRead, BitReadSized, LazyBitRead, LazyBitReadSized};
pub use stream::BitStream; pub use readbuffer::BitReadBuffer;
pub use readstream::BitReadStream;
mod buffer;
mod endianness; mod endianness;
mod is_signed; mod is_signed;
mod read; mod read;
mod stream; mod readbuffer;
mod readstream;
mod unchecked_primitive; mod unchecked_primitive;
/// Errors that can be returned when trying to read from a buffer /// Errors that can be returned when trying to read from a buffer

88
src/read.rs
View file

@ -1,5 +1,5 @@
use crate::endianness::{BigEndian, LittleEndian}; use crate::endianness::{BigEndian, LittleEndian};
use crate::{BitStream, Endianness, Result}; use crate::{BitReadStream, Endianness, Result};
use std::cell::RefCell; use std::cell::RefCell;
use std::cmp::min; use std::cmp::min;
use std::collections::HashMap; use std::collections::HashMap;
@ -91,14 +91,14 @@ use std::sync::Arc;
/// [read]: struct.BitStream.html#method.read /// [read]: struct.BitStream.html#method.read
pub trait BitRead<E: Endianness>: Sized { pub trait BitRead<E: Endianness>: Sized {
/// Read the type from stream /// Read the type from stream
fn read(stream: &mut BitStream<E>) -> Result<Self>; fn read(stream: &mut BitReadStream<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 BitStream<E>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> 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 BitStream<E>) -> Result<()> { fn skip(stream: &mut BitReadStream<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(|_| ()),
@ -125,12 +125,12 @@ 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 BitStream<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)
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<$type> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<$type> {
Ok(stream.read_int_unchecked::<$type>(size_of::<$type>() * 8)) Ok(stream.read_int_unchecked::<$type>(size_of::<$type>() * 8))
} }
@ -146,12 +146,12 @@ 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 BitStream<LittleEndian>) -> Result<Self> { fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
Ok(<$type>::new(stream.read()?)) Ok(<$type>::new(stream.read()?))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<LittleEndian>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
Ok(<$type>::new( Ok(<$type>::new(
stream.read_int_unchecked(size_of::<$type>() * 8), stream.read_int_unchecked(size_of::<$type>() * 8),
)) ))
@ -165,12 +165,12 @@ macro_rules! impl_read_int_nonzero {
impl BitRead<BigEndian> for Option<$type> { impl BitRead<BigEndian> for Option<$type> {
#[inline] #[inline]
fn read(stream: &mut BitStream<BigEndian>) -> Result<Self> { fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
Ok(<$type>::new(stream.read()?)) Ok(<$type>::new(stream.read()?))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<BigEndian>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
Ok(<$type>::new( Ok(<$type>::new(
stream.read_int_unchecked(size_of::<$type>() * 8), stream.read_int_unchecked(size_of::<$type>() * 8),
)) ))
@ -203,12 +203,12 @@ 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 BitStream<E>) -> Result<f32> { fn read(stream: &mut BitReadStream<E>) -> Result<f32> {
stream.read_float::<f32>() stream.read_float::<f32>()
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<f32> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<f32> {
Ok(stream.read_float_unchecked::<f32>()) Ok(stream.read_float_unchecked::<f32>())
} }
@ -220,12 +220,12 @@ 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 BitStream<E>) -> Result<f64> { fn read(stream: &mut BitReadStream<E>) -> Result<f64> {
stream.read_float::<f64>() stream.read_float::<f64>()
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<f64> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<f64> {
Ok(stream.read_float_unchecked::<f64>()) Ok(stream.read_float_unchecked::<f64>())
} }
@ -237,12 +237,12 @@ 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 BitStream<E>) -> Result<bool> { fn read(stream: &mut BitReadStream<E>) -> Result<bool> {
stream.read_bool() stream.read_bool()
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<bool> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<bool> {
Ok(stream.read_bool_unchecked()) Ok(stream.read_bool_unchecked())
} }
@ -254,19 +254,19 @@ 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 BitStream<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<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Rc::new(T::read(stream)?)) Ok(Rc::new(T::read(stream)?))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Rc::new(T::read_unchecked(stream)?)) Ok(Rc::new(T::read_unchecked(stream)?))
} }
@ -278,12 +278,12 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> { impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Arc::new(T::read(stream)?)) Ok(Arc::new(T::read(stream)?))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Arc::new(T::read_unchecked(stream)?)) Ok(Arc::new(T::read_unchecked(stream)?))
} }
@ -295,12 +295,12 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Arc<T> {
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Box<T> { impl<E: Endianness, T: BitRead<E>> BitRead<E> for Box<T> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Box::new(T::read(stream)?)) Ok(Box::new(T::read(stream)?))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(Box::new(T::read_unchecked(stream)?)) Ok(Box::new(T::read_unchecked(stream)?))
} }
@ -314,12 +314,12 @@ macro_rules! impl_read_tuple {
($($type:ident),*) => { ($($type:ident),*) => {
impl<E: Endianness, $($type: BitRead<E>),*> BitRead<E> for ($($type),*) { impl<E: Endianness, $($type: BitRead<E>),*> BitRead<E> for ($($type),*) {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(($(<$type>::read(stream)?),*)) Ok(($(<$type>::read(stream)?),*))
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
Ok(($(<$type>::read_unchecked(stream)?),*)) Ok(($(<$type>::read_unchecked(stream)?),*))
} }
@ -401,11 +401,11 @@ impl_read_tuple!(T1, T2, T3, T4);
/// [read]: struct.BitStream.html#method.read /// [read]: struct.BitStream.html#method.read
pub trait BitReadSized<E: Endianness>: Sized { pub trait BitReadSized<E: Endianness>: Sized {
/// Read the type from stream /// Read the type from stream
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self>; fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self>;
#[doc(hidden)] #[doc(hidden)]
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
Self::read(stream, size) Self::read(stream, size)
} }
@ -413,7 +413,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 BitStream<E>, size: usize) -> Result<()> { fn skip(stream: &mut BitReadStream<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(|_| ()),
@ -432,12 +432,12 @@ 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 BitStream<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)
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<$type> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<$type> {
Ok(stream.read_int_unchecked::<$type>(size)) Ok(stream.read_int_unchecked::<$type>(size))
} }
@ -462,7 +462,7 @@ 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 BitStream<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))
} }
@ -474,7 +474,7 @@ 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<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
if stream.read()? { if stream.read()? {
Ok(Some(stream.read()?)) Ok(Some(stream.read()?))
} else { } else {
@ -484,7 +484,7 @@ impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
} }
impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> { impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<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 {
@ -493,9 +493,9 @@ impl<E: Endianness, T: BitReadSized<E>> BitReadSized<E> for Option<T> {
} }
} }
impl<E: Endianness> BitReadSized<E> for BitStream<E> { impl<E: Endianness> BitReadSized<E> for BitReadStream<E> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
stream.read_bits(size) stream.read_bits(size)
} }
@ -507,7 +507,7 @@ impl<E: Endianness> BitReadSized<E> for BitStream<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<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
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()?)
@ -516,7 +516,7 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
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_unchecked()?) vec.push(stream.read_unchecked()?)
@ -533,14 +533,14 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
// Once we have something like https://github.com/rust-lang/rfcs/issues/1053 we can do this optimization // Once we have something like https://github.com/rust-lang/rfcs/issues/1053 we can do this optimization
//impl<E: Endianness> ReadSized<E> for Vec<u8> { //impl<E: Endianness> ReadSized<E> for Vec<u8> {
// #[inline] // #[inline]
// fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { // fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
// stream.read_bytes(size) // stream.read_bytes(size)
// } // }
//} //}
/// Read `K` and `T` `size` times and return as `HashMap<K, T>` /// Read `K` and `T` `size` times and return as `HashMap<K, T>`
impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> for HashMap<K, T> { impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> for HashMap<K, T> {
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<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()?;
@ -551,7 +551,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
} }
#[inline] #[inline]
unsafe fn read_unchecked(stream: &mut BitStream<E>, size: usize) -> Result<Self> { unsafe fn read_unchecked(stream: &mut BitReadStream<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_unchecked()?; let key = stream.read_unchecked()?;
@ -574,7 +574,7 @@ 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<T: BitRead<E>, E: Endianness> {
source: BitStream<E>, source: BitReadStream<E>,
inner_type: PhantomData<T>, inner_type: PhantomData<T>,
} }
@ -588,7 +588,7 @@ impl<T: BitRead<E>, E: Endianness> LazyBitRead<T, E> {
impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> { impl<T: BitRead<E>, E: Endianness> BitRead<E> for LazyBitRead<T, E> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>) -> Result<Self> { fn read(stream: &mut BitReadStream<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)?,
@ -607,7 +607,7 @@ 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<T: BitReadSized<E>, E: Endianness> {
source: RefCell<BitStream<E>>, source: RefCell<BitReadStream<E>>,
size: usize, size: usize,
inner_type: PhantomData<T>, inner_type: PhantomData<T>,
} }
@ -622,7 +622,7 @@ impl<T: BitReadSized<E>, E: Endianness> LazyBitReadSized<T, E> {
impl<T: BitReadSized<E>, E: Endianness> BitReadSized<E> for LazyBitReadSized<T, E> { impl<T: BitReadSized<E>, E: Endianness> BitReadSized<E> for LazyBitReadSized<T, E> {
#[inline] #[inline]
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> { fn read(stream: &mut BitReadStream<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)?),

48
src/buffer.rs → src/readbuffer.rs
View file

@ -21,21 +21,21 @@ const USIZE_SIZE: usize = size_of::<usize>();
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use bitbuffer::{BitBuffer, LittleEndian, Result}; /// use bitbuffer::{BitReadBuffer, LittleEndian, Result};
/// ///
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// let bytes = vec![ /// let bytes = vec![
/// 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 = BitBuffer::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 BitBuffer<E> pub struct BitReadBuffer<E>
where where
E: Endianness, E: Endianness,
{ {
@ -44,7 +44,7 @@ where
endianness: PhantomData<E>, endianness: PhantomData<E>,
} }
impl<E> BitBuffer<E> impl<E> BitReadBuffer<E>
where where
E: Endianness, E: Endianness,
{ {
@ -53,20 +53,20 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use bitbuffer::{BitBuffer, LittleEndian}; /// use bitbuffer::{BitReadBuffer, LittleEndian};
/// ///
/// let bytes = vec![ /// let bytes = vec![
/// 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 = BitBuffer::new(bytes, LittleEndian); /// let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// ``` /// ```
pub fn new(mut bytes: Vec<u8>, _endianness: E) -> Self { pub fn new(mut bytes: Vec<u8>, _endianness: E) -> Self {
let byte_len = bytes.len(); let byte_len = bytes.len();
// pad with usize worth of bytes to ensure we can always read a full usize // pad with usize worth of bytes to ensure we can always read a full usize
bytes.extend_from_slice(&0usize.to_le_bytes()); bytes.extend_from_slice(&0usize.to_le_bytes());
BitBuffer { BitReadBuffer {
bytes: Rc::new(bytes), bytes: Rc::new(bytes),
bit_len: byte_len * 8, bit_len: byte_len * 8,
endianness: PhantomData, endianness: PhantomData,
@ -74,7 +74,7 @@ where
} }
} }
impl<E> BitBuffer<E> impl<E> BitReadBuffer<E>
where where
E: Endianness, E: Endianness,
{ {
@ -137,14 +137,14 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::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);
/// # /// #
@ -191,14 +191,14 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::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);
/// # /// #
@ -327,14 +327,14 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::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,
@ -407,7 +407,7 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
@ -416,7 +416,7 @@ where
/// # 0x72, 0x6c, 0x64, 0, /// # 0x72, 0x6c, 0x64, 0,
/// # 0, 0, 0, 0 /// # 0, 0, 0, 0
/// # ]; /// # ];
/// # let buffer = BitBuffer::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
@ -499,14 +499,14 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::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(())
@ -564,7 +564,7 @@ where
}); });
} }
Ok(BitBuffer { Ok(BitReadBuffer {
bytes: Rc::clone(&self.bytes), bytes: Rc::clone(&self.bytes),
bit_len, bit_len,
endianness: PhantomData, endianness: PhantomData,
@ -572,10 +572,10 @@ where
} }
} }
impl<E: Endianness> From<Vec<u8>> for BitBuffer<E> { impl<E: Endianness> From<Vec<u8>> for BitReadBuffer<E> {
fn from(bytes: Vec<u8>) -> Self { fn from(bytes: Vec<u8>) -> Self {
let byte_len = bytes.len(); let byte_len = bytes.len();
BitBuffer { BitReadBuffer {
bytes: Rc::new(bytes), bytes: Rc::new(bytes),
bit_len: byte_len * 8, bit_len: byte_len * 8,
endianness: PhantomData, endianness: PhantomData,
@ -583,9 +583,9 @@ impl<E: Endianness> From<Vec<u8>> for BitBuffer<E> {
} }
} }
impl<E: Endianness> Clone for BitBuffer<E> { impl<E: Endianness> Clone for BitReadBuffer<E> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
BitBuffer { BitReadBuffer {
bytes: Rc::clone(&self.bytes), bytes: Rc::clone(&self.bytes),
bit_len: self.bit_len(), bit_len: self.bit_len(),
endianness: PhantomData, endianness: PhantomData,
@ -593,7 +593,7 @@ impl<E: Endianness> Clone for BitBuffer<E> {
} }
} }
impl<E: Endianness> Debug for BitBuffer<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,

130
src/stream.rs → src/readstream.rs
View file

@ -6,7 +6,7 @@ use num_traits::{Float, PrimInt};
use crate::endianness::Endianness; use crate::endianness::Endianness;
use crate::is_signed::IsSigned; use crate::is_signed::IsSigned;
use crate::unchecked_primitive::{UncheckedPrimitiveFloat, UncheckedPrimitiveInt}; use crate::unchecked_primitive::{UncheckedPrimitiveFloat, UncheckedPrimitiveInt};
use crate::BitBuffer; use crate::BitReadBuffer;
use crate::{BitRead, BitReadSized, ReadError, Result}; use crate::{BitRead, BitReadSized, ReadError, Result};
use std::cmp::min; use std::cmp::min;
@ -15,28 +15,28 @@ use std::cmp::min;
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use bitbuffer::{BitBuffer, BitStream, LittleEndian}; /// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
/// ///
/// let bytes = vec![ /// let bytes = vec![
/// 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 = BitBuffer::new(bytes, LittleEndian); /// let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// let mut stream = BitStream::new(buffer); /// let mut stream = BitReadStream::new(buffer);
/// ``` /// ```
/// ///
/// [`BitBuffer`]: struct.BitBuffer.html /// [`BitBuffer`]: struct.BitBuffer.html
#[derive(Debug)] #[derive(Debug)]
pub struct BitStream<E> pub struct BitReadStream<E>
where where
E: Endianness, E: Endianness,
{ {
buffer: BitBuffer<E>, buffer: BitReadBuffer<E>,
start_pos: usize, start_pos: usize,
pos: usize, pos: usize,
} }
impl<E> BitStream<E> impl<E> BitReadStream<E>
where where
E: Endianness, E: Endianness,
{ {
@ -45,19 +45,19 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use bitbuffer::{BitBuffer, BitStream, LittleEndian}; /// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
/// ///
/// let bytes = vec![ /// let bytes = vec![
/// 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 = BitBuffer::new(bytes, LittleEndian); /// let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// let mut stream = BitStream::new(buffer); /// let mut stream = BitReadStream::new(buffer);
/// ``` /// ```
/// ///
/// [`BitBuffer`]: struct.BitBuffer.html /// [`BitBuffer`]: struct.BitBuffer.html
pub fn new(buffer: BitBuffer<E>) -> Self { pub fn new(buffer: BitReadBuffer<E>) -> Self {
BitStream { BitReadStream {
start_pos: 0, start_pos: 0,
pos: 0, pos: 0,
buffer, buffer,
@ -73,15 +73,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// assert_eq!(stream.pos(), 2); /// assert_eq!(stream.pos(), 2);
@ -118,15 +118,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// assert_eq!(stream.pos(), 6); /// assert_eq!(stream.pos(), 6);
@ -169,15 +169,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// # /// #
@ -220,15 +220,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// # /// #
@ -268,7 +268,7 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
@ -277,8 +277,8 @@ where
/// # 0x72, 0x6c, 0x64, 0, /// # 0x72, 0x6c, 0x64, 0,
/// # 0, 0, 0, 0 /// # 0, 0, 0, 0
/// # ]; /// # ];
/// # let buffer = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::new(buffer); /// # let mut stream = BitReadStream::new(buffer);
/// // Fixed length string /// // Fixed length string
/// stream.set_pos(0); /// stream.set_pos(0);
/// assert_eq!(stream.read_string(Some(11))?, "Hello world".to_owned()); /// assert_eq!(stream.read_string(Some(11))?, "Hello world".to_owned());
@ -345,15 +345,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// assert_eq!(bits.pos(), 0); /// assert_eq!(bits.pos(), 0);
@ -368,7 +368,7 @@ where
/// ///
/// [`ReadError::NotEnoughData`]: enum.ReadError.html#variant.NotEnoughData /// [`ReadError::NotEnoughData`]: enum.ReadError.html#variant.NotEnoughData
pub fn read_bits(&mut self, count: usize) -> Result<Self> { pub fn read_bits(&mut self, count: usize) -> Result<Self> {
let result = BitStream { let result = BitReadStream {
buffer: self.buffer.get_sub_buffer(self.pos + count)?, buffer: self.buffer.get_sub_buffer(self.pos + count)?,
start_pos: self.pos, start_pos: self.pos,
pos: self.pos, pos: self.pos,
@ -386,15 +386,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// assert_eq!(stream.read_int::<u8>(3)?, 0b110); /// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
@ -425,15 +425,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// assert_eq!(stream.read_int::<u8>(3)?, 0b110); /// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
@ -459,15 +459,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::new(buffer); /// # let mut stream = BitReadStream::new(buffer);
/// assert_eq!(stream.bit_len(), 64); /// assert_eq!(stream.bit_len(), 64);
/// # /// #
/// # Ok(()) /// # Ok(())
@ -482,15 +482,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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)?;
/// assert_eq!(stream.pos(), 5); /// assert_eq!(stream.pos(), 5);
@ -507,15 +507,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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)?;
/// assert_eq!(stream.bits_left(), 59); /// assert_eq!(stream.bits_left(), 59);
@ -532,15 +532,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// let boolean: bool = stream.read()?; /// let boolean: bool = stream.read()?;
@ -551,7 +551,7 @@ where
/// ``` /// ```
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// use bitbuffer::BitRead; /// use bitbuffer::BitRead;
/// # /// #
/// #[derive(BitRead, Debug, PartialEq)] /// #[derive(BitRead, Debug, PartialEq)]
@ -567,8 +567,8 @@ 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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 {
/// first: 0b1011_0101, /// first: 0b1011_0101,
@ -597,15 +597,15 @@ where
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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);
/// # /// #
@ -614,15 +614,15 @@ where
/// ``` /// ```
/// ///
/// ``` /// ```
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result}; /// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
/// # /// #
/// # fn main() -> Result<()> { /// # fn main() -> Result<()> {
/// # let bytes = vec![ /// # let bytes = vec![
/// # 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 = BitBuffer::new(bytes, LittleEndian); /// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
/// # let mut stream = BitStream::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]);
/// # /// #
@ -653,9 +653,9 @@ where
} }
} }
impl<E: Endianness> Clone for BitStream<E> { impl<E: Endianness> Clone for BitReadStream<E> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
BitStream { BitReadStream {
buffer: self.buffer.clone(), buffer: self.buffer.clone(),
start_pos: self.pos, start_pos: self.pos,
pos: self.pos, pos: self.pos,
@ -663,14 +663,14 @@ impl<E: Endianness> Clone for BitStream<E> {
} }
} }
impl<E: Endianness> From<BitBuffer<E>> for BitStream<E> { impl<E: Endianness> From<BitReadBuffer<E>> for BitReadStream<E> {
fn from(buffer: BitBuffer<E>) -> Self { fn from(buffer: BitReadBuffer<E>) -> Self {
BitStream::new(buffer) BitReadStream::new(buffer)
} }
} }
impl<E: Endianness> From<Vec<u8>> for BitStream<E> { impl<E: Endianness> From<Vec<u8>> for BitReadStream<E> {
fn from(bytes: Vec<u8>) -> Self { fn from(bytes: Vec<u8>) -> Self {
BitStream::new(BitBuffer::from(bytes)) BitReadStream::new(BitReadBuffer::from(bytes))
} }
} }

84
tests/tests.rs
View file

@ -3,7 +3,7 @@ use std::num::NonZeroU16;
use maplit::hashmap; use maplit::hashmap;
use bitbuffer::{BigEndian, BitBuffer, BitRead, BitStream, LittleEndian}; use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, LittleEndian};
const BYTES: &'static [u8] = &[ const BYTES: &'static [u8] = &[
0b1011_0101, 0b1011_0101,
@ -22,7 +22,7 @@ const BYTES: &'static [u8] = &[
#[test] #[test]
fn read_u8_le() { fn read_u8_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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_int::<u8>(1, 1).unwrap(), 0b0); assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
@ -35,7 +35,7 @@ fn read_u8_le() {
#[test] #[test]
fn read_u8_be() { fn read_u8_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -47,21 +47,21 @@ fn read_u8_be() {
#[test] #[test]
fn read_u16_le() { fn read_u16_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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 = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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 = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(), buffer.read_int::<u32>(6, 24).unwrap(),
@ -71,7 +71,7 @@ fn read_u32_le() {
#[test] #[test]
fn read_u32_be() { fn read_u32_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(), buffer.read_int::<u32>(6, 24).unwrap(),
@ -81,7 +81,7 @@ fn read_u32_be() {
#[test] #[test]
fn read_u64_le() { fn read_u64_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u64>(6, 34).unwrap(), buffer.read_int::<u64>(6, 34).unwrap(),
@ -103,7 +103,7 @@ fn read_u64_le() {
#[test] #[test]
fn read_u64_be() { fn read_u64_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
assert_eq!( assert_eq!(
buffer.read_int::<u64>(6, 34).unwrap(), buffer.read_int::<u64>(6, 34).unwrap(),
@ -121,7 +121,7 @@ fn read_u64_be() {
#[test] #[test]
fn read_i8_le() { fn read_i8_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -129,7 +129,7 @@ fn read_i8_le() {
#[test] #[test]
fn read_i8_be() { fn read_i8_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -138,7 +138,7 @@ fn read_i8_be() {
#[test] #[test]
fn read_i16_le() { fn read_i16_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::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, 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);
@ -146,7 +146,7 @@ fn read_i16_le() {
#[test] #[test]
fn read_i16_be() { fn read_i16_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -154,7 +154,7 @@ fn read_i16_be() {
#[test] #[test]
fn read_i32_le() { fn read_i32_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
assert_eq!( assert_eq!(
buffer.read_int::<i32>(6, 24).unwrap(), buffer.read_int::<i32>(6, 24).unwrap(),
@ -165,14 +165,14 @@ fn read_i32_le() {
#[test] #[test]
fn read_i32_be() { fn read_i32_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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 = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -181,7 +181,7 @@ fn read_i64_le() {
#[test] #[test]
fn read_i64_be() { fn read_i64_be() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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);
@ -190,23 +190,23 @@ fn read_i64_be() {
#[test] #[test]
fn read_f32_le() { fn read_f32_le() {
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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 = BitBuffer::new(BYTES.to_vec(), LittleEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), 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: BitBuffer<LittleEndian> = BitBuffer::from(BYTES.to_vec()); let buffer: BitReadBuffer<LittleEndian> = BitReadBuffer::from(BYTES.to_vec());
let _: BitStream<LittleEndian> = BitStream::from(buffer); let _: BitReadStream<LittleEndian> = BitReadStream::from(buffer);
let _: BitStream<LittleEndian> = BitStream::from(BYTES.to_vec()); let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES.to_vec());
} }
#[test] #[test]
@ -214,7 +214,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 = BitBuffer::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()
@ -234,7 +234,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 = BitBuffer::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()
@ -246,7 +246,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 = BitBuffer::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()
@ -259,7 +259,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 = BitBuffer::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(),
@ -273,8 +273,8 @@ fn test_read_str_le() {
#[test] #[test]
fn read_trait() { fn read_trait() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
let mut stream = BitStream::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);
let b: i8 = stream.read().unwrap(); let b: i8 = stream.read().unwrap();
@ -293,8 +293,8 @@ fn read_trait() {
#[test] #[test]
fn read_trait_unchecked() { fn read_trait_unchecked() {
unsafe { unsafe {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
let mut stream = BitStream::new(buffer); let mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read_unchecked().unwrap(); let a: u8 = stream.read_unchecked().unwrap();
assert_eq!(0b1011_0101, a); assert_eq!(0b1011_0101, a);
let b: i8 = stream.read_unchecked().unwrap(); let b: i8 = stream.read_unchecked().unwrap();
@ -313,8 +313,8 @@ fn read_trait_unchecked() {
#[test] #[test]
fn read_sized_trait() { fn read_sized_trait() {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
let mut stream = BitStream::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);
stream.set_pos(0).unwrap(); stream.set_pos(0).unwrap();
@ -337,15 +337,15 @@ fn read_sized_trait() {
result result
); );
stream.set_pos(0).unwrap(); stream.set_pos(0).unwrap();
let mut result: BitStream<BigEndian> = stream.read_sized(4).unwrap(); let mut result: BitReadStream<BigEndian> = stream.read_sized(4).unwrap();
assert_eq!(0b10u8, result.read_int(2).unwrap()); assert_eq!(0b10u8, result.read_int(2).unwrap());
} }
#[test] #[test]
fn read_sized_trait_unchecked() { fn read_sized_trait_unchecked() {
unsafe { unsafe {
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian); let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
let mut stream = BitStream::new(buffer); let mut stream = BitReadStream::new(buffer);
let a: u8 = stream.read_sized_unchecked(4).unwrap(); let a: u8 = stream.read_sized_unchecked(4).unwrap();
assert_eq!(0b1011, a); assert_eq!(0b1011, a);
stream.set_pos(0).unwrap(); stream.set_pos(0).unwrap();
@ -368,7 +368,7 @@ fn read_sized_trait_unchecked() {
result result
); );
stream.set_pos(0).unwrap(); stream.set_pos(0).unwrap();
let mut result: BitStream<BigEndian> = stream.read_sized_unchecked(4).unwrap(); let mut result: BitReadStream<BigEndian> = stream.read_sized_unchecked(4).unwrap();
assert_eq!(0b10u8, result.read_int(2).unwrap()); assert_eq!(0b10u8, result.read_int(2).unwrap());
} }
} }
@ -411,8 +411,8 @@ fn test_read_struct() {
0b0101_0101, 0b0101_0101,
0b1010_1010, 0b1010_1010,
]; ];
let buffer = BitBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(bytes, LittleEndian);
let mut stream = BitStream::from(buffer); let mut stream = BitReadStream::from(buffer);
assert_eq!( assert_eq!(
TestStruct { TestStruct {
foo: 12, foo: 12,
@ -431,21 +431,21 @@ 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 = BitBuffer::new(bytes, LittleEndian); let buffer = BitReadBuffer::new(bytes, LittleEndian);
let mut stream = BitStream::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());
} }
#[test] #[test]
fn read_read_signed() { fn read_read_signed() {
let buffer = BitBuffer::new(vec![255, 255, 255, 255, 255, 255, 255, 255], LittleEndian); let buffer = BitReadBuffer::new(vec![255, 255, 255, 255, 255, 255, 255, 255], 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 = BitBuffer::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);
} }