Struct BitBufferMut 

pub struct BitBufferMut { /* private fields */ }

A mutable bitset buffer that allows random access to individual bits for set and get.

Example

use vortex_buffer::BitBufferMut;

let mut bools = BitBufferMut::new_unset(10);
bools.set_to(9, true);
for i in 0..9 {
   assert!(!bools.value(i));
}
assert!(bools.value(9));

// Freeze into a new bools vector.
let bools = bools.freeze();

See also: BitBuffer.

Implementations

impl BitBufferMut

pub fn from_buffer(buffer: ByteBufferMut, offset: usize, len: usize) -> Self

Create new bit buffer from given byte buffer and logical bit length

pub fn copy_from(bit_buffer: &BitBuffer) -> Self

Creates a BitBufferMut from a BitBuffer by copying all of the data over.

pub fn with_capacity(capacity: usize) -> Self

Create a new empty mutable bit buffer with requested capacity (in bits).

pub fn new_set(len: usize) -> Self

Create a new mutable buffer with requested len and all bits set to true.

pub fn new_unset(len: usize) -> Self

Create a new mutable buffer with requested len and all bits set to false.

pub fn empty() -> Self

Create a new empty BitBufferMut.

pub fn full(value: bool, len: usize) -> Self

Create a new mutable buffer with requested len and all bits set to value.

pub fn inner(&self) -> &ByteBufferMut

Return the underlying byte buffer.

pub fn into_inner(self) -> ByteBufferMut

Consumes the buffer and return the underlying byte buffer.

pub fn len(&self) -> usize

Get the current populated length of the buffer.

pub fn is_empty(&self) -> bool

True if the buffer has length 0.

pub fn offset(&self) -> usize

Get the current bit offset of the buffer.

pub fn value(&self, index: usize) -> bool

Get the value at the requested index.

pub unsafe fn value_unchecked(&self, index: usize) -> bool

Get the value at the requested index without bounds checking.

Safety

The caller must ensure that index is less than the length of the buffer.

pub fn chunks(&self) -> BitChunks<'_>

Access chunks of the underlying buffer as 8 byte chunks with a final trailer

If you’re performing operations on a single buffer, prefer BitBuffer::unaligned_chunks

pub fn capacity(&self) -> usize

Get the bit capacity of the buffer.

pub fn reserve(&mut self, additional: usize)

Reserve additional bit capacity for the buffer.

pub fn clear(&mut self)

Clears the bit buffer (but keeps any allocated memory).

pub fn set_to(&mut self, index: usize, value: bool)

Set the bit at index to the given boolean value.

This operation is checked so if index exceeds the buffer length, this will panic.

pub unsafe fn set_to_unchecked(&mut self, index: usize, value: bool)

Set the bit at index to the given boolean value without checking bounds.

Safety

The caller must ensure that index does not exceed the largest bit index in the backing buffer.

pub fn set(&mut self, index: usize)

Set a position to true.

This operation is checked so if index exceeds the buffer length, this will panic.

pub fn unset(&mut self, index: usize)

Set a position to false.

This operation is checked so if index exceeds the buffer length, this will panic.

pub unsafe fn set_len(&mut self, new_len: usize)

Foces the length of the BitBufferMut to new_len.

Safety

• new_len must be less than or equal to capacity()
• The elements at old_len..new_len must be initialized

pub fn truncate(&mut self, len: usize)

Truncate the buffer to the given length.

If the given length is greater than the current length, this is a no-op.

pub fn append(&mut self, value: bool)

Append a new boolean into the bit buffer, incrementing the length.

pub fn append_true(&mut self)

Append a new true value to the buffer.

pub fn append_false(&mut self)

Append a new false value to the buffer.

pub fn append_n(&mut self, value: bool, n: usize)

Append several boolean values into the bit buffer. After this operation, the length will be incremented by n.

Panics if the buffer does not have n slots left.

pub fn append_buffer(&mut self, buffer: &BitBuffer)

Append a BitBuffer to this BitBufferMut

This efficiently copies all bits from the source buffer to the end of this buffer.

pub fn split_off(&mut self, at: usize) -> Self

Splits the bit buffer into two at the given index.

Afterward, self contains elements [0, at), and the returned buffer contains elements [at, capacity).

Unlike bytes, if the split position is not on a byte-boundary this operation will copy data into the result type, and mutate self.

pub fn unsplit(&mut self, other: Self)

Absorbs a mutable buffer that was previously split off.

If the two buffers were previously contiguous and not mutated in a way that causes re-allocation i.e., if other was created by calling split_off on this buffer, then this is an O(1) operation that just decreases a reference count and sets a few indices.

Otherwise, this method degenerates to self.append_buffer(&other).

pub fn freeze(self) -> BitBuffer

Freeze the buffer in its current state into an immutable BoolBuffer.

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

Get the underlying bytes as a slice

pub fn as_mut_slice(&mut self) -> &mut [u8]

Get the underlying bytes as a mutable slice

pub fn as_mut_ptr(&mut self) -> *mut u8

Returns a raw mutable pointer to the internal buffer.

pub fn unaligned_chunks(&self) -> UnalignedBitChunk<'_>

Access chunks of the buffer aligned to 8 byte boundary as [prefix, <full chunks>, suffix]

pub fn true_count(&self) -> usize

Get the number of set bits in the buffer.

pub fn false_count(&self) -> usize

Get the number of unset bits in the buffer.

impl BitBufferMut

pub fn iter_bit_views<const NB: usize>( &self, ) -> impl Iterator<Item = BitView<'_, NB>> + '_

Iterate the buffer as BitViews of size NB where the number of bits in each view is NB * 8.

The final chunk will be filled with unset padding bits if the bit buffer’s length is not a multiple of N.

The number of bits N must be a multiple of 64.

Panics

If the bit offset is not zero

Trait Implementations

impl Clone for BitBufferMut

fn clone(&self) -> BitBufferMut

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BitBufferMut

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

Formats the value using the given formatter.

impl Default for BitBufferMut

fn default() -> Self

Returns the “default value” for a type.

impl From<&[bool]> for BitBufferMut

fn from(value: &[bool]) -> Self

Converts to this type from the input type.

impl From<Vec<bool>> for BitBufferMut

fn from(value: Vec<bool>) -> Self

Converts to this type from the input type.

impl FromIterator<bool> for BitBufferMut

fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self

Creates a value from an iterator.

impl Not for BitBufferMut

type Output = BitBufferMut

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for BitBufferMut

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for BitBufferMut