Struct BitChunks 

pub struct BitChunks<'a> {
    buffer: &'a [u8],
    bit_offset: usize,
    chunk_len: usize,
    remainder_len: usize,
}

Iterates over an arbitrarily aligned byte buffer 64 bits at a time

Self::iter yields iterator of u64, and a remainder. The first byte in the buffer will be the least significant byte in output u64

Fields

buffer: &'a [u8]

bit_offset: usize

chunk_len: usize

remainder_len: usize

Implementations

impl<'a> BitChunks<'a>

pub fn new(buffer: &'a [u8], offset: usize, len: usize) -> BitChunks<'a>

Create a new BitChunks from a byte array, and an offset and length in bits

impl<'a> BitChunks<'a>

pub const fn remainder_len(&self) -> usize

Returns the number of remaining bits, guaranteed to be between 0 and 63 (inclusive)

pub const fn chunk_len(&self) -> usize

Returns the number of u64 chunks

pub fn remainder_bits(&self) -> u64

Returns the bitmask of remaining bits

pub fn num_u64s(&self) -> usize

Return the number of u64 that are needed to represent all bits (including remainder).

This is equal to chunk_len + 1 if there is a remainder, otherwise it is equal to chunk_len.

pub fn num_bytes(&self) -> usize

Return the number of bytes that are needed to represent all bits (including remainder).

pub fn chunk(&self, index: usize) -> u64

Returns the indexth complete chunk of 64 bits, the value Self::iter yields at that position

Panics

Panics if index >= self.chunk_len()

Example

let buffer = Buffer::from((0..17_u8).collect::<Vec<_>>());
// Start at bit 8, so chunk 1 holds bytes 9 through 16
let chunks = buffer.bit_chunks(8, 128);
assert_eq!(chunks.chunk_len(), 2);
assert_eq!(chunks.chunk(1), 0x100f0e0d0c0b0a09);
assert_eq!(chunks.iter().nth(1), Some(chunks.chunk(1)));

pub const fn iter(&self) -> BitChunkIterator<'a>

Returns an iterator over chunks of 64 bits represented as an u64

pub fn iter_padded(&self) -> impl Iterator<Item = u64> + 'a

Returns an iterator over chunks of 64 bits, with the remaining bits zero padded to 64-bits

Trait Implementations

impl<'a> Debug for BitChunks<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> IntoIterator for BitChunks<'a>

type Item = u64

The type of the elements being iterated over.

type IntoIter = BitChunkIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <BitChunks<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &BitChunks<'a>

type Item = u64

The type of the elements being iterated over.

type IntoIter = BitChunkIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&BitChunks<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.