mirror of
https://codeberg.org/icewind/bitbuffer.git
synced 2026-06-03 16:44:06 +02:00
rename bitbuffer/bitstream to bitreadbuffer/bitreadstream
This commit is contained in:
parent
0e58b89ae9
commit
6fc3785fc9
8 changed files with 227 additions and 226 deletions
|
|
@ -2,10 +2,10 @@
|
|||
|
||||
extern crate test;
|
||||
|
||||
use bitbuffer::{BigEndian, BitBuffer, BitRead, BitStream, Endianness, LittleEndian};
|
||||
use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, Endianness, LittleEndian};
|
||||
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 mut pos = 0;
|
||||
let len = buffer.bit_len();
|
||||
|
|
@ -23,7 +23,7 @@ fn read_perf<E: Endianness>(buffer: &BitBuffer<E>) -> u16 {
|
|||
#[bench]
|
||||
fn perf_le(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 10];
|
||||
let buffer = BitBuffer::new(data, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(data, LittleEndian);
|
||||
b.iter(|| {
|
||||
let data = read_perf(&buffer);
|
||||
assert_eq!(data, 0);
|
||||
|
|
@ -34,7 +34,7 @@ fn perf_le(b: &mut Bencher) {
|
|||
#[bench]
|
||||
fn perf_be(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 10];
|
||||
let buffer = BitBuffer::new(data, BigEndian);
|
||||
let buffer = BitReadBuffer::new(data, BigEndian);
|
||||
b.iter(|| {
|
||||
let data = read_perf(&buffer);
|
||||
assert_eq!(data, 0);
|
||||
|
|
@ -45,7 +45,7 @@ fn perf_be(b: &mut Bencher) {
|
|||
#[bench]
|
||||
fn perf_f32_be(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 10];
|
||||
let buffer = BitBuffer::new(data, BigEndian);
|
||||
let buffer = BitReadBuffer::new(data, BigEndian);
|
||||
b.iter(|| {
|
||||
let mut pos = 0;
|
||||
let len = buffer.bit_len();
|
||||
|
|
@ -66,7 +66,7 @@ fn perf_f32_be(b: &mut Bencher) {
|
|||
#[bench]
|
||||
fn perf_f32_le(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 10];
|
||||
let buffer = BitBuffer::new(data, LittleEndian);
|
||||
let buffer = BitReadBuffer::new(data, LittleEndian);
|
||||
b.iter(|| {
|
||||
let mut pos = 0;
|
||||
let len = buffer.bit_len();
|
||||
|
|
@ -89,7 +89,7 @@ const F64_RESULT: f64 = 0.000000000000000000000000000000000000000000000000000000
|
|||
#[bench]
|
||||
fn perf_f64(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 10];
|
||||
let buffer = BitBuffer::new(data, BigEndian);
|
||||
let buffer = BitReadBuffer::new(data, BigEndian);
|
||||
b.iter(|| {
|
||||
let mut pos = 0;
|
||||
let len = buffer.bit_len();
|
||||
|
|
@ -110,7 +110,7 @@ fn perf_f64(b: &mut Bencher) {
|
|||
#[bench]
|
||||
fn perf_bool(b: &mut Bencher) {
|
||||
let data = vec![1u8; 1024 * 1024 * 1];
|
||||
let buffer = BitBuffer::new(data, BigEndian);
|
||||
let buffer = BitReadBuffer::new(data, BigEndian);
|
||||
b.iter(|| {
|
||||
let mut pos = 0;
|
||||
let len = buffer.bit_len();
|
||||
|
|
@ -151,7 +151,7 @@ fn get_string_buffer() -> Vec<u8> {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 0;
|
||||
|
|
@ -169,7 +169,7 @@ fn perf_string_be(b: &mut Bencher) {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 0;
|
||||
|
|
@ -187,7 +187,7 @@ fn perf_string_le(b: &mut Bencher) {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 0;
|
||||
|
|
@ -205,7 +205,7 @@ fn perf_bytes_be(b: &mut Bencher) {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 0;
|
||||
|
|
@ -223,7 +223,7 @@ fn perf_bytes_le(b: &mut Bencher) {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 3;
|
||||
|
|
@ -241,7 +241,7 @@ fn perf_bytes_be_unaligned(b: &mut Bencher) {
|
|||
|
||||
#[bench]
|
||||
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(|| {
|
||||
let mut pos = 3;
|
||||
|
|
@ -268,10 +268,10 @@ struct BasicStruct {
|
|||
|
||||
#[bench]
|
||||
fn perf_struct(b: &mut Bencher) {
|
||||
let buffer = BitBuffer::new(get_string_buffer(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(get_string_buffer(), LittleEndian);
|
||||
|
||||
b.iter(|| {
|
||||
let mut stream: BitStream<LittleEndian> = buffer.clone().into();
|
||||
let mut stream: BitReadStream<LittleEndian> = buffer.clone().into();
|
||||
while stream.bits_left() > 40 {
|
||||
let result = stream.read::<BasicStruct>().unwrap();
|
||||
test::black_box(result);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
//!
|
||||
//! ```
|
||||
//! # use bitbuffer::{BitRead, Endianness, BitStream};
|
||||
//! # use bitbuffer::{BitRead, Endianness, BitReadStream};
|
||||
//! #
|
||||
//! #[derive(BitRead)]
|
||||
//! #[endianness = "E"]
|
||||
//! struct EndiannessStruct<E: Endianness> {
|
||||
//! size: u8,
|
||||
//! #[size = "size"]
|
||||
//! stream: BitStream<E>,
|
||||
//! stream: BitReadStream<E>,
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! This is also required if you specify which endianness the struct has
|
||||
//! ```
|
||||
//! # use bitbuffer::{BitRead, BigEndian, BitStream};
|
||||
//! # use bitbuffer::{BitRead, BigEndian, BitReadStream};
|
||||
//! #
|
||||
//! #[derive(BitRead)]
|
||||
//! #[endianness = "BigEndian"]
|
||||
//! struct EndiannessStruct {
|
||||
//! size: u8,
|
||||
//! #[size = "size"]
|
||||
//! stream: BitStream<BigEndian>,
|
||||
//! stream: BitReadStream<BigEndian>,
|
||||
//! }
|
||||
//! ```
|
||||
extern crate proc_macro;
|
||||
|
|
@ -221,7 +221,7 @@ fn derive_bitread_trait(
|
|||
//
|
||||
let expanded = quote! {
|
||||
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
|
||||
match <Self as #trait_def>::#size_method_name(#extra_param_call) {
|
||||
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
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,8 @@
|
|||
#![allow(unreachable_patterns)]
|
||||
|
||||
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};
|
||||
|
||||
|
|
@ -44,8 +45,8 @@ fn test_read_struct() {
|
|||
0b0101_0101,
|
||||
0b1010_1010,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct {
|
||||
foo: 12,
|
||||
|
|
@ -82,8 +83,8 @@ fn test_read_bare_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(TestBareEnum::Asd, stream.read().unwrap());
|
||||
assert_eq!(TestBareEnum::Foo, stream.read().unwrap());
|
||||
assert_eq!(TestBareEnum::Bar, stream.read().unwrap());
|
||||
|
|
@ -113,8 +114,8 @@ fn test_read_unnamed_field_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestUnnamedFieldEnum::Asd(0b_00_0110_10),
|
||||
stream.read().unwrap()
|
||||
|
|
@ -143,8 +144,8 @@ fn test_read_struct_sized() {
|
|||
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,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStructSized {
|
||||
foo: 12,
|
||||
|
|
@ -179,8 +180,8 @@ fn test_read_unnamed_field_enum_sized() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestUnnamedFieldEnumSized::Asd(0b_00_0110),
|
||||
stream.read_sized(6).unwrap()
|
||||
|
|
@ -212,8 +213,8 @@ fn test_read_struct2() {
|
|||
'l' as u8,
|
||||
'e' as u8,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct2 {
|
||||
size: 5,
|
||||
|
|
@ -229,14 +230,14 @@ fn test_read_struct2() {
|
|||
struct TestStruct3<E: Endianness> {
|
||||
size: u8,
|
||||
#[size = "size"]
|
||||
stream: BitStream<E>,
|
||||
stream: BitReadStream<E>,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_read_struct3() {
|
||||
let bytes = vec![0b0000_0101, 0, 0, 0, 0, 0, 0, 0];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
let result: TestStruct3<BigEndian> = stream.read().unwrap();
|
||||
assert_eq!(5, result.size);
|
||||
assert_eq!(5, result.stream.bit_len());
|
||||
|
|
@ -264,8 +265,8 @@ fn test_read_rest_enum() {
|
|||
0b1000_0100,
|
||||
0b1000_0100,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(TestEnumRest::Asd, stream.read().unwrap());
|
||||
assert_eq!(TestEnumRest::Foo, stream.read().unwrap());
|
||||
assert_eq!(TestEnumRest::Bar, stream.read().unwrap());
|
||||
|
|
@ -280,8 +281,8 @@ fn test_unnamed_struct() {
|
|||
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,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
|
||||
assert_eq!(
|
||||
UnnamedSize(12, "hello".to_string(), false),
|
||||
|
|
@ -294,8 +295,8 @@ struct EmptyStruct;
|
|||
|
||||
fn test_empty_struct() {
|
||||
let bytes = vec![0, 0, 0, 0];
|
||||
let buffer = BitBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, BigEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(EmptyStruct, stream.read().unwrap());
|
||||
assert_eq!(0, stream.pos());
|
||||
assert_eq!(Some(0), bit_size_of::<EmptyStruct>());
|
||||
|
|
|
|||
14
src/lib.rs
14
src/lib.rs
|
|
@ -16,7 +16,7 @@
|
|||
//!
|
||||
//! ```
|
||||
//! # use bitbuffer::Result;
|
||||
//! use bitbuffer::{BitBuffer, LittleEndian, BitStream, BitRead};
|
||||
//! use bitbuffer::{BitReadBuffer, LittleEndian, BitReadStream, BitRead};
|
||||
//!
|
||||
//! #[derive(BitRead)]
|
||||
//! struct ComplexType {
|
||||
|
|
@ -31,8 +31,8 @@
|
|||
//! 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
//! 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
//! ];
|
||||
//! let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
//! let mut stream = BitStream::new(buffer);
|
||||
//! let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
//! let mut stream = BitReadStream::new(buffer);
|
||||
//! let value: u8 = stream.read_int(7)?;
|
||||
//! let complex: ComplexType = stream.read()?;
|
||||
//! #
|
||||
|
|
@ -60,16 +60,16 @@ use std::fmt::Display;
|
|||
pub use std::string::FromUtf8Error;
|
||||
|
||||
pub use bitbuffer_derive::{BitRead, BitReadSized};
|
||||
pub use buffer::BitBuffer;
|
||||
pub use endianness::*;
|
||||
pub use read::{BitRead, BitReadSized, LazyBitRead, LazyBitReadSized};
|
||||
pub use stream::BitStream;
|
||||
pub use readbuffer::BitReadBuffer;
|
||||
pub use readstream::BitReadStream;
|
||||
|
||||
mod buffer;
|
||||
mod endianness;
|
||||
mod is_signed;
|
||||
mod read;
|
||||
mod stream;
|
||||
mod readbuffer;
|
||||
mod readstream;
|
||||
mod unchecked_primitive;
|
||||
|
||||
/// Errors that can be returned when trying to read from a buffer
|
||||
|
|
|
|||
88
src/read.rs
88
src/read.rs
|
|
@ -1,5 +1,5 @@
|
|||
use crate::endianness::{BigEndian, LittleEndian};
|
||||
use crate::{BitStream, Endianness, Result};
|
||||
use crate::{BitReadStream, Endianness, Result};
|
||||
use std::cell::RefCell;
|
||||
use std::cmp::min;
|
||||
use std::collections::HashMap;
|
||||
|
|
@ -91,14 +91,14 @@ use std::sync::Arc;
|
|||
/// [read]: struct.BitStream.html#method.read
|
||||
pub trait BitRead<E: Endianness>: Sized {
|
||||
/// 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
|
||||
///
|
||||
/// any other validations (e.g. checking for valid utf8) still needs to be done
|
||||
#[doc(hidden)]
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
Self::read(stream)
|
||||
}
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ pub trait BitRead<E: Endianness>: Sized {
|
|||
///
|
||||
/// This might be faster than reading it if the size is known beforehand
|
||||
#[inline]
|
||||
fn skip(stream: &mut BitStream<E>) -> Result<()> {
|
||||
fn skip(stream: &mut BitReadStream<E>) -> Result<()> {
|
||||
match Self::bit_size() {
|
||||
Some(size) => stream.skip_bits(size),
|
||||
None => Self::read(stream).map(|_| ()),
|
||||
|
|
@ -125,12 +125,12 @@ macro_rules! impl_read_int {
|
|||
($type:ty) => {
|
||||
impl<E: Endianness> BitRead<E> for $type {
|
||||
#[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)
|
||||
}
|
||||
|
||||
#[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))
|
||||
}
|
||||
|
||||
|
|
@ -146,12 +146,12 @@ macro_rules! impl_read_int_nonzero {
|
|||
($type:ty) => {
|
||||
impl BitRead<LittleEndian> for Option<$type> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<LittleEndian>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(stream.read()?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitStream<LittleEndian>) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<LittleEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(
|
||||
stream.read_int_unchecked(size_of::<$type>() * 8),
|
||||
))
|
||||
|
|
@ -165,12 +165,12 @@ macro_rules! impl_read_int_nonzero {
|
|||
|
||||
impl BitRead<BigEndian> for Option<$type> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<BigEndian>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(stream.read()?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn read_unchecked(stream: &mut BitStream<BigEndian>) -> Result<Self> {
|
||||
unsafe fn read_unchecked(stream: &mut BitReadStream<BigEndian>) -> Result<Self> {
|
||||
Ok(<$type>::new(
|
||||
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 {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<f32> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<f32> {
|
||||
stream.read_float::<f32>()
|
||||
}
|
||||
|
||||
#[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>())
|
||||
}
|
||||
|
||||
|
|
@ -220,12 +220,12 @@ impl<E: Endianness> BitRead<E> for f32 {
|
|||
|
||||
impl<E: Endianness> BitRead<E> for f64 {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<f64> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<f64> {
|
||||
stream.read_float::<f64>()
|
||||
}
|
||||
|
||||
#[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>())
|
||||
}
|
||||
|
||||
|
|
@ -237,12 +237,12 @@ impl<E: Endianness> BitRead<E> for f64 {
|
|||
|
||||
impl<E: Endianness> BitRead<E> for bool {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<bool> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<bool> {
|
||||
stream.read_bool()
|
||||
}
|
||||
|
||||
#[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())
|
||||
}
|
||||
|
||||
|
|
@ -254,19 +254,19 @@ impl<E: Endianness> BitRead<E> for bool {
|
|||
|
||||
impl<E: Endianness> BitRead<E> for String {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<String> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<String> {
|
||||
stream.read_string(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Rc<T> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
Ok(Rc::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[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)?))
|
||||
}
|
||||
|
||||
|
|
@ -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> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
Ok(Arc::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[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)?))
|
||||
}
|
||||
|
||||
|
|
@ -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> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
Ok(Box::new(T::read(stream)?))
|
||||
}
|
||||
|
||||
#[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)?))
|
||||
}
|
||||
|
||||
|
|
@ -314,12 +314,12 @@ macro_rules! impl_read_tuple {
|
|||
($($type:ident),*) => {
|
||||
impl<E: Endianness, $($type: BitRead<E>),*> BitRead<E> for ($($type),*) {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
Ok(($(<$type>::read(stream)?),*))
|
||||
}
|
||||
|
||||
#[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)?),*))
|
||||
}
|
||||
|
||||
|
|
@ -401,11 +401,11 @@ impl_read_tuple!(T1, T2, T3, T4);
|
|||
/// [read]: struct.BitStream.html#method.read
|
||||
pub trait BitReadSized<E: Endianness>: Sized {
|
||||
/// 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)]
|
||||
#[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)
|
||||
}
|
||||
|
||||
|
|
@ -413,7 +413,7 @@ pub trait BitReadSized<E: Endianness>: Sized {
|
|||
///
|
||||
/// This might be faster than reading it if the size is known beforehand
|
||||
#[inline]
|
||||
fn skip(stream: &mut BitStream<E>, size: usize) -> Result<()> {
|
||||
fn skip(stream: &mut BitReadStream<E>, size: usize) -> Result<()> {
|
||||
match Self::bit_size_sized(size) {
|
||||
Some(size) => stream.skip_bits(size),
|
||||
None => Self::read(stream, size).map(|_| ()),
|
||||
|
|
@ -432,12 +432,12 @@ macro_rules! impl_read_int_sized {
|
|||
( $ type: ty) => {
|
||||
impl<E: Endianness> BitReadSized<E> for $type {
|
||||
#[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)
|
||||
}
|
||||
|
||||
#[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))
|
||||
}
|
||||
|
||||
|
|
@ -462,7 +462,7 @@ impl_read_int_sized!(i128);
|
|||
|
||||
impl<E: Endianness> BitReadSized<E> for String {
|
||||
#[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))
|
||||
}
|
||||
|
||||
|
|
@ -474,7 +474,7 @@ impl<E: Endianness> BitReadSized<E> for String {
|
|||
|
||||
/// Read a boolean, if true, read `T`, else return `None`
|
||||
impl<E: Endianness, T: BitRead<E>> BitRead<E> for Option<T> {
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
if stream.read()? {
|
||||
Ok(Some(stream.read()?))
|
||||
} 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> {
|
||||
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
if stream.read()? {
|
||||
Ok(Some(stream.read_sized(size)?))
|
||||
} 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]
|
||||
fn read(stream: &mut BitStream<E>, size: usize) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>, size: usize) -> Result<Self> {
|
||||
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>`
|
||||
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));
|
||||
for _ in 0..size {
|
||||
vec.push(stream.read()?)
|
||||
|
|
@ -516,7 +516,7 @@ impl<E: Endianness, T: BitRead<E>> BitReadSized<E> for Vec<T> {
|
|||
}
|
||||
|
||||
#[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));
|
||||
for _ in 0..size {
|
||||
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
|
||||
//impl<E: Endianness> ReadSized<E> for Vec<u8> {
|
||||
// #[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)
|
||||
// }
|
||||
//}
|
||||
|
||||
/// 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> {
|
||||
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));
|
||||
for _ in 0..size {
|
||||
let key = stream.read()?;
|
||||
|
|
@ -551,7 +551,7 @@ impl<E: Endianness, K: BitRead<E> + Eq + Hash, T: BitRead<E>> BitReadSized<E> fo
|
|||
}
|
||||
|
||||
#[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));
|
||||
for _ in 0..size {
|
||||
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)]
|
||||
/// Struct that lazily reads it's contents from the stream
|
||||
pub struct LazyBitRead<T: BitRead<E>, E: Endianness> {
|
||||
source: BitStream<E>,
|
||||
source: BitReadStream<E>,
|
||||
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> {
|
||||
#[inline]
|
||||
fn read(stream: &mut BitStream<E>) -> Result<Self> {
|
||||
fn read(stream: &mut BitReadStream<E>) -> Result<Self> {
|
||||
match T::bit_size() {
|
||||
Some(bit_size) => Ok(LazyBitRead {
|
||||
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)]
|
||||
/// Struct that lazily reads it's contents from the stream
|
||||
pub struct LazyBitReadSized<T: BitReadSized<E>, E: Endianness> {
|
||||
source: RefCell<BitStream<E>>,
|
||||
source: RefCell<BitReadStream<E>>,
|
||||
size: usize,
|
||||
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> {
|
||||
#[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) {
|
||||
Some(bit_size) => Ok(LazyBitReadSized {
|
||||
source: RefCell::new(stream.read_bits(bit_size)?),
|
||||
|
|
|
|||
|
|
@ -21,21 +21,21 @@ const USIZE_SIZE: usize = size_of::<usize>();
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bitbuffer::{BitBuffer, LittleEndian, Result};
|
||||
/// use bitbuffer::{BitReadBuffer, LittleEndian, Result};
|
||||
///
|
||||
/// # fn main() -> Result<()> {
|
||||
/// let bytes = vec![
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 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
|
||||
/// let result: u8 = buffer.read_int(3, 7)?;
|
||||
/// #
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
pub struct BitBuffer<E>
|
||||
pub struct BitReadBuffer<E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -44,7 +44,7 @@ where
|
|||
endianness: PhantomData<E>,
|
||||
}
|
||||
|
||||
impl<E> BitBuffer<E>
|
||||
impl<E> BitReadBuffer<E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -53,20 +53,20 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bitbuffer::{BitBuffer, LittleEndian};
|
||||
/// use bitbuffer::{BitReadBuffer, LittleEndian};
|
||||
///
|
||||
/// let bytes = vec![
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 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 {
|
||||
let byte_len = bytes.len();
|
||||
|
||||
// pad with usize worth of bytes to ensure we can always read a full usize
|
||||
bytes.extend_from_slice(&0usize.to_le_bytes());
|
||||
BitBuffer {
|
||||
BitReadBuffer {
|
||||
bytes: Rc::new(bytes),
|
||||
bit_len: byte_len * 8,
|
||||
endianness: PhantomData,
|
||||
|
|
@ -74,7 +74,7 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<E> BitBuffer<E>
|
||||
impl<E> BitReadBuffer<E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -137,14 +137,14 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 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)?;
|
||||
/// assert_eq!(result, true);
|
||||
/// #
|
||||
|
|
@ -191,14 +191,14 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 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)?;
|
||||
/// assert_eq!(result, 0b100_0110_10);
|
||||
/// #
|
||||
|
|
@ -327,14 +327,14 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 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(0, 8)?, &[
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
|
|
@ -407,7 +407,7 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
|
|
@ -416,7 +416,7 @@ where
|
|||
/// # 0x72, 0x6c, 0x64, 0,
|
||||
/// # 0, 0, 0, 0
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// // Fixed length string
|
||||
/// assert_eq!(buffer.read_string(0, Some(13))?, "Hello world".to_owned());
|
||||
/// // fixed length with null padding
|
||||
|
|
@ -499,14 +499,14 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 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)?;
|
||||
/// #
|
||||
/// # Ok(())
|
||||
|
|
@ -564,7 +564,7 @@ where
|
|||
});
|
||||
}
|
||||
|
||||
Ok(BitBuffer {
|
||||
Ok(BitReadBuffer {
|
||||
bytes: Rc::clone(&self.bytes),
|
||||
bit_len,
|
||||
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 {
|
||||
let byte_len = bytes.len();
|
||||
BitBuffer {
|
||||
BitReadBuffer {
|
||||
bytes: Rc::new(bytes),
|
||||
bit_len: byte_len * 8,
|
||||
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 {
|
||||
BitBuffer {
|
||||
BitReadBuffer {
|
||||
bytes: Rc::clone(&self.bytes),
|
||||
bit_len: self.bit_len(),
|
||||
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 {
|
||||
write!(
|
||||
f,
|
||||
|
|
@ -6,7 +6,7 @@ use num_traits::{Float, PrimInt};
|
|||
use crate::endianness::Endianness;
|
||||
use crate::is_signed::IsSigned;
|
||||
use crate::unchecked_primitive::{UncheckedPrimitiveFloat, UncheckedPrimitiveInt};
|
||||
use crate::BitBuffer;
|
||||
use crate::BitReadBuffer;
|
||||
use crate::{BitRead, BitReadSized, ReadError, Result};
|
||||
use std::cmp::min;
|
||||
|
||||
|
|
@ -15,28 +15,28 @@ use std::cmp::min;
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bitbuffer::{BitBuffer, BitStream, LittleEndian};
|
||||
/// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
|
||||
///
|
||||
/// let bytes = vec![
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer);
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitReadStream::new(buffer);
|
||||
/// ```
|
||||
///
|
||||
/// [`BitBuffer`]: struct.BitBuffer.html
|
||||
#[derive(Debug)]
|
||||
pub struct BitStream<E>
|
||||
pub struct BitReadStream<E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
buffer: BitBuffer<E>,
|
||||
buffer: BitReadBuffer<E>,
|
||||
start_pos: usize,
|
||||
pos: usize,
|
||||
}
|
||||
|
||||
impl<E> BitStream<E>
|
||||
impl<E> BitReadStream<E>
|
||||
where
|
||||
E: Endianness,
|
||||
{
|
||||
|
|
@ -45,19 +45,19 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bitbuffer::{BitBuffer, BitStream, LittleEndian};
|
||||
/// use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian};
|
||||
///
|
||||
/// let bytes = vec![
|
||||
/// 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// ];
|
||||
/// let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitStream::new(buffer);
|
||||
/// let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// let mut stream = BitReadStream::new(buffer);
|
||||
/// ```
|
||||
///
|
||||
/// [`BitBuffer`]: struct.BitBuffer.html
|
||||
pub fn new(buffer: BitBuffer<E>) -> Self {
|
||||
BitStream {
|
||||
pub fn new(buffer: BitReadBuffer<E>) -> Self {
|
||||
BitReadStream {
|
||||
start_pos: 0,
|
||||
pos: 0,
|
||||
buffer,
|
||||
|
|
@ -73,15 +73,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_bool()?, true);
|
||||
/// assert_eq!(stream.read_bool()?, false);
|
||||
/// assert_eq!(stream.pos(), 2);
|
||||
|
|
@ -118,15 +118,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_int::<u16>(3)?, 0b101);
|
||||
/// assert_eq!(stream.read_int::<u16>(3)?, 0b110);
|
||||
/// assert_eq!(stream.pos(), 6);
|
||||
|
|
@ -169,15 +169,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let result = stream.read_float::<f32>()?;
|
||||
/// assert_eq!(stream.pos(), 32);
|
||||
/// #
|
||||
|
|
@ -220,15 +220,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.read_bytes(3)?, &[0b1011_0101, 0b0110_1010, 0b1010_1100]);
|
||||
/// assert_eq!(stream.pos(), 24);
|
||||
/// #
|
||||
|
|
@ -268,7 +268,7 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
|
|
@ -277,8 +277,8 @@ where
|
|||
/// # 0x72, 0x6c, 0x64, 0,
|
||||
/// # 0, 0, 0, 0
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// // Fixed length string
|
||||
/// stream.set_pos(0);
|
||||
/// assert_eq!(stream.read_string(Some(11))?, "Hello world".to_owned());
|
||||
|
|
@ -345,15 +345,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let mut bits = stream.read_bits(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(bits.pos(), 0);
|
||||
|
|
@ -368,7 +368,7 @@ where
|
|||
///
|
||||
/// [`ReadError::NotEnoughData`]: enum.ReadError.html#variant.NotEnoughData
|
||||
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)?,
|
||||
start_pos: self.pos,
|
||||
pos: self.pos,
|
||||
|
|
@ -386,15 +386,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// stream.skip_bits(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
|
||||
|
|
@ -425,15 +425,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// stream.set_pos(3)?;
|
||||
/// assert_eq!(stream.pos(), 3);
|
||||
/// assert_eq!(stream.read_int::<u8>(3)?, 0b110);
|
||||
|
|
@ -459,15 +459,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.bit_len(), 64);
|
||||
/// #
|
||||
/// # Ok(())
|
||||
|
|
@ -482,15 +482,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.pos(), 0);
|
||||
/// stream.skip_bits(5)?;
|
||||
/// assert_eq!(stream.pos(), 5);
|
||||
|
|
@ -507,15 +507,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// assert_eq!(stream.bits_left(), 64);
|
||||
/// stream.skip_bits(5)?;
|
||||
/// assert_eq!(stream.bits_left(), 59);
|
||||
|
|
@ -532,15 +532,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let int: u8 = stream.read()?;
|
||||
/// assert_eq!(int, 0b1011_0101);
|
||||
/// 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;
|
||||
/// #
|
||||
/// #[derive(BitRead, Debug, PartialEq)]
|
||||
|
|
@ -567,8 +567,8 @@ where
|
|||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let data: ComplexType = stream.read()?;
|
||||
/// assert_eq!(data, ComplexType {
|
||||
/// first: 0b1011_0101,
|
||||
|
|
@ -597,15 +597,15 @@ where
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # use bitbuffer::{BitBuffer, BitStream, LittleEndian, Result};
|
||||
/// # use bitbuffer::{BitReadBuffer, BitReadStream, LittleEndian, Result};
|
||||
/// #
|
||||
/// # fn main() -> Result<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let int: u8 = stream.read_sized(7)?;
|
||||
/// 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<()> {
|
||||
/// # let bytes = vec![
|
||||
/// # 0b1011_0101, 0b0110_1010, 0b1010_1100, 0b1001_1001,
|
||||
/// # 0b1001_1001, 0b1001_1001, 0b1001_1001, 0b1110_0111
|
||||
/// # ];
|
||||
/// # let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitStream::new(buffer);
|
||||
/// # let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
/// # let mut stream = BitReadStream::new(buffer);
|
||||
/// let data: Vec<u16> = stream.read_sized(3)?;
|
||||
/// assert_eq!(data, vec![0b0110_1010_1011_0101, 0b1001_1001_1010_1100, 0b1001_1001_1001_1001]);
|
||||
/// #
|
||||
|
|
@ -653,9 +653,9 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Endianness> Clone for BitStream<E> {
|
||||
impl<E: Endianness> Clone for BitReadStream<E> {
|
||||
fn clone(&self) -> Self {
|
||||
BitStream {
|
||||
BitReadStream {
|
||||
buffer: self.buffer.clone(),
|
||||
start_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> {
|
||||
fn from(buffer: BitBuffer<E>) -> Self {
|
||||
BitStream::new(buffer)
|
||||
impl<E: Endianness> From<BitReadBuffer<E>> for BitReadStream<E> {
|
||||
fn from(buffer: BitReadBuffer<E>) -> Self {
|
||||
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 {
|
||||
BitStream::new(BitBuffer::from(bytes))
|
||||
BitReadStream::new(BitReadBuffer::from(bytes))
|
||||
}
|
||||
}
|
||||
|
|
@ -3,7 +3,7 @@ use std::num::NonZeroU16;
|
|||
|
||||
use maplit::hashmap;
|
||||
|
||||
use bitbuffer::{BigEndian, BitBuffer, BitRead, BitStream, LittleEndian};
|
||||
use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, LittleEndian};
|
||||
|
||||
const BYTES: &'static [u8] = &[
|
||||
0b1011_0101,
|
||||
|
|
@ -22,7 +22,7 @@ const BYTES: &'static [u8] = &[
|
|||
|
||||
#[test]
|
||||
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>(1, 1).unwrap(), 0b0);
|
||||
|
|
@ -35,7 +35,7 @@ fn read_u8_le() {
|
|||
|
||||
#[test]
|
||||
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>(1, 1).unwrap(), 0b0);
|
||||
|
|
@ -47,21 +47,21 @@ fn read_u8_be() {
|
|||
|
||||
#[test]
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_u32_le() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -71,7 +71,7 @@ fn read_u32_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u32_be() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u32>(6, 24).unwrap(),
|
||||
|
|
@ -81,7 +81,7 @@ fn read_u32_be() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_le() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -103,7 +103,7 @@ fn read_u64_le() {
|
|||
|
||||
#[test]
|
||||
fn read_u64_be() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<u64>(6, 34).unwrap(),
|
||||
|
|
@ -121,7 +121,7 @@ fn read_u64_be() {
|
|||
|
||||
#[test]
|
||||
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, 8).unwrap(), -0b100_1011);
|
||||
|
|
@ -129,7 +129,7 @@ fn read_i8_le() {
|
|||
|
||||
#[test]
|
||||
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>(0, 3).unwrap(), -0b11);
|
||||
|
|
@ -138,7 +138,7 @@ fn read_i8_be() {
|
|||
|
||||
#[test]
|
||||
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, 13).unwrap(), -0b11_1001_0101_10);
|
||||
|
|
@ -146,7 +146,7 @@ fn read_i16_le() {
|
|||
|
||||
#[test]
|
||||
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>(7, 12).unwrap(), -0b1001_0101_011);
|
||||
|
|
@ -154,7 +154,7 @@ fn read_i16_be() {
|
|||
|
||||
#[test]
|
||||
fn read_i32_le() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), LittleEndian);
|
||||
|
||||
assert_eq!(
|
||||
buffer.read_int::<i32>(6, 24).unwrap(),
|
||||
|
|
@ -165,14 +165,14 @@ fn read_i32_le() {
|
|||
|
||||
#[test]
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
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, 59).unwrap(), -27471957726940758);
|
||||
|
|
@ -181,7 +181,7 @@ fn read_i64_le() {
|
|||
|
||||
#[test]
|
||||
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, 60).unwrap(), -336251766397153476);
|
||||
|
|
@ -190,23 +190,23 @@ fn read_i64_be() {
|
|||
|
||||
#[test]
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
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);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_from() {
|
||||
let buffer: BitBuffer<LittleEndian> = BitBuffer::from(BYTES.to_vec());
|
||||
let _: BitStream<LittleEndian> = BitStream::from(buffer);
|
||||
let _: BitStream<LittleEndian> = BitStream::from(BYTES.to_vec());
|
||||
let buffer: BitReadBuffer<LittleEndian> = BitReadBuffer::from(BYTES.to_vec());
|
||||
let _: BitReadStream<LittleEndian> = BitReadStream::from(buffer);
|
||||
let _: BitReadStream<LittleEndian> = BitReadStream::from(BYTES.to_vec());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -214,7 +214,7 @@ fn test_read_str_be() {
|
|||
let bytes = vec![
|
||||
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!(
|
||||
buffer.read_string(0, Some(13)).unwrap(),
|
||||
"Hello world".to_owned()
|
||||
|
|
@ -234,7 +234,7 @@ fn test_read_str_no_null_termination_le() {
|
|||
let bytes = vec![
|
||||
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!(
|
||||
buffer.read_string(0, None).unwrap(),
|
||||
"Hello world".to_owned()
|
||||
|
|
@ -246,7 +246,7 @@ fn test_read_str_no_null_termination_be() {
|
|||
let bytes = vec![
|
||||
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!(
|
||||
buffer.read_string(0, None).unwrap(),
|
||||
"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,
|
||||
'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(11)).unwrap(),
|
||||
|
|
@ -273,8 +273,8 @@ fn test_read_str_le() {
|
|||
|
||||
#[test]
|
||||
fn read_trait() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read().unwrap();
|
||||
assert_eq!(0b1011_0101, a);
|
||||
let b: i8 = stream.read().unwrap();
|
||||
|
|
@ -293,8 +293,8 @@ fn read_trait() {
|
|||
#[test]
|
||||
fn read_trait_unchecked() {
|
||||
unsafe {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_unchecked().unwrap();
|
||||
assert_eq!(0b1011_0101, a);
|
||||
let b: i8 = stream.read_unchecked().unwrap();
|
||||
|
|
@ -313,8 +313,8 @@ fn read_trait_unchecked() {
|
|||
|
||||
#[test]
|
||||
fn read_sized_trait() {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_sized(4).unwrap();
|
||||
assert_eq!(0b1011, a);
|
||||
stream.set_pos(0).unwrap();
|
||||
|
|
@ -337,15 +337,15 @@ fn read_sized_trait() {
|
|||
result
|
||||
);
|
||||
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());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_sized_trait_unchecked() {
|
||||
unsafe {
|
||||
let buffer = BitBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitStream::new(buffer);
|
||||
let buffer = BitReadBuffer::new(BYTES.to_vec(), BigEndian);
|
||||
let mut stream = BitReadStream::new(buffer);
|
||||
let a: u8 = stream.read_sized_unchecked(4).unwrap();
|
||||
assert_eq!(0b1011, a);
|
||||
stream.set_pos(0).unwrap();
|
||||
|
|
@ -368,7 +368,7 @@ fn read_sized_trait_unchecked() {
|
|||
result
|
||||
);
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
@ -411,8 +411,8 @@ fn test_read_struct() {
|
|||
0b0101_0101,
|
||||
0b1010_1010,
|
||||
];
|
||||
let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(
|
||||
TestStruct {
|
||||
foo: 12,
|
||||
|
|
@ -431,21 +431,21 @@ fn test_read_struct() {
|
|||
#[test]
|
||||
fn test_read_nonzero() {
|
||||
let bytes = vec![12, 0, 0, 0];
|
||||
let buffer = BitBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitStream::from(buffer);
|
||||
let buffer = BitReadBuffer::new(bytes, LittleEndian);
|
||||
let mut stream = BitReadStream::from(buffer);
|
||||
assert_eq!(NonZeroU16::new(12), stream.read().unwrap());
|
||||
assert_eq!(None, stream.read::<Option<NonZeroU16>>().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
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);
|
||||
|
||||
let bytes = (-10i32).to_le_bytes();
|
||||
let mut byte_vec = Vec::with_capacity(4);
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue