Struct x3::bitpacker::BitPacker

pub struct BitPacker<'a> { /* fields omitted */ }

BitPacker allows individual bits to be written to an array of bytes.

Implementations

impl<'a> BitPacker<'a>

pub fn new(array: &'a mut [u8]) -> BitPacker<'_>

pub fn bookmark(&mut self)

Save the current position as a bookmark. Later we will be able to write an array of bytes to this position.

pub fn bookmark_get_from(&self) -> &[u8]

Get the output array from the bookmark, to the last packed bit.

pub fn bookmark_get_offset(&self) -> usize

Get number of bytes from the bookmark to the current pointer.

pub fn bookmark_write(&mut self, array: &[u8])

Write the array from the bookmark onwards, until array is exhausted.

pub fn write_bytes(&mut self, array: &[u8])

Standard write an array

pub fn inc_counter_n_bytes(
    &mut self,
    n_bytes: usize
) -> Result<(), BitPackError>

This operates together with write_packed_bits. It only increments the p_bit value by 1, also incrementing p_byte where necessary.

Note: The bit pointer must be byte aligned.

Arguments

• n_bytes - The number of bytes to increment.

pub fn word_align(&mut self)

Align the packing to the next word, but only if we aren't already aligned.

pub fn write_bits(&mut self, value: usize, num_bits: usize)

Pack array value into the byte array. Starting at p_byte position of the array and p_bit bit offset.

Arguments

• value - The bits that will be written.
• num_bits - The number of bits in value that should be written.

pub fn write_packed_zeros(&mut self, num_zeros: usize)

This operates together with write_packed_bits. It allows zero values to be written. Although these are never actually written to the array, the offsets are just managed.

Arguments

• num_zeros - The number of zeros that should be written.

pub fn as_bytes(&self) -> &[u8]

Returns the packed bits as an array.