Struct BitSpanMut 

pub struct BitSpanMut<'a, T: BitWord> { /* private fields */ }

A non-owning mutable view into a bit array.

BitSpanMut provides a view into a sequence of bits stored in memory, allowing both reading and writing of individual bits or ranges of bits. It can be used to efficiently operate on a subset of bits without copying or allocating memory.

The span is defined by:

• A pointer to the start of the word array
• A bit offset from the start of the first word
• A length in bits

Safety

This type uses raw pointers internally. The caller must ensure that:

• The referenced memory remains valid for the lifetime of the span
• No other references (mutable or immutable) to the same memory are used during the lifetime of the span to avoid aliasing violations
• The offset and length parameters don’t cause out-of-bounds access

Implementations

impl<'a, T: BitWord> BitSpanMut<'a, T>

pub fn from_raw_parts_mut(ptr: *mut T, offset: usize, len: usize) -> Self

Creates a new BitSpanMut from raw parts.

This function allows creating a mutable span directly from a raw pointer, which is useful for interfacing with external memory or creating mutable views into existing bit arrays.

Arguments

• ptr - A mutable pointer to the word array (will be converted to non-null)
• offset - The bit offset from the start of the first word
• len - The number of bits in the span

Safety

The caller must ensure that:

• The pointer is valid for reads and writes of len bits starting at offset
• The memory remains valid for the lifetime of the returned span
• No other references to the same memory are used during the lifetime of the span

If ptr is null, a dangling pointer will be used. This is safe as long as len is 0, but will lead to undefined behavior otherwise.

Trait Implementations

impl<'a, 'b, T: BitWord> BitAndAssign<&'b BitSpan<'b, T>> for BitSpanMut<'a, T>

fn bitand_assign(&mut self, rhs: &'b BitSpan<'b, T>)

Performs the &= operation.

impl<'a, 'b, T: BitWord> BitOrAssign<&'b BitSpan<'b, T>> for BitSpanMut<'a, T>

fn bitor_assign(&mut self, rhs: &'b BitSpan<'b, T>)

Performs the |= operation.

impl<'a, T: BitWord> BitRead for BitSpanMut<'a, T>

type Iter<'b> = BitSpanIter<'b, T> where Self: 'b

The iterator type returned by the iter method.

fn len(&self) -> usize

Returns the number of bits in the span.

fn is_empty(&self) -> bool

Returns true if the span is empty or contains no set bits.

This implementation considers a span empty if either:

• It has zero length
• It has no bits set to 1

fn test(&self, idx: usize) -> bool

Tests if the bit at the given index is set.

Arguments

• idx - The index of the bit to test

Returns

true if the bit is set, false otherwise

Panics

Debug builds will assert if idx is out of bounds (>= self.len).

fn count_ones(&self) -> usize

Counts the number of bits set to 1 in the span.

Returns

The number of bits set to 1

fn all(&self) -> bool

Returns true if all bits in the span are set to 1.

Returns

true if the span is non-empty and all bits are set to 1, false otherwise

fn any(&self) -> bool

Returns true if any bit in the span is set to 1.

Returns

true if at least one bit is set to 1, false otherwise

fn iter(&self) -> Self::Iter<'_>

Returns an iterator over the indices of bits set to 1.

Returns

An iterator that yields the indices of all bits set to 1 in ascending order

fn none(&self) -> bool

impl<'a, T: BitWord> BitWrite for BitSpanMut<'a, T>

fn set(&mut self, idx: usize)

Sets the bit at the given index to 1.

Arguments

• idx - The index of the bit to set

Panics

Debug builds will assert if idx is out of bounds (>= self.len).

fn reset(&mut self, idx: usize)

Sets the bit at the given index to 0.

Arguments

• idx - The index of the bit to clear

Panics

Debug builds will assert if idx is out of bounds (>= self.len).

fn flip(&mut self, idx: usize)

Flips the bit at the given index (0 becomes 1, 1 becomes 0).

Arguments

• idx - The index of the bit to flip

Panics

Panics if idx is out of bounds (>= self.len).

fn test_and_set(&mut self, idx: usize) -> bool

Sets the bit at the given index to 1 and returns the previous value.

Arguments

• idx - The index of the bit to set

Returns

true if the bit was already set, false otherwise

Panics

Debug builds will assert if idx is out of bounds (>= self.len).

fn fill(&mut self)

Sets all bits in the span to 1.

This method efficiently sets all bits within the span’s range to 1, taking care to only modify bits that are part of the span.

fn clear(&mut self)

Sets all bits in the span to 0.

This method efficiently clears all bits within the span’s range, taking care to only modify bits that are part of the span.

fn take(&mut self, idx: usize) -> bool

return and clear bit at idx.

fn replace(&mut self, idx: usize, value: bool) -> bool

set bit to value, return old.

impl<'a, 'b, T: BitWord> BitXorAssign<&'b BitSpan<'b, T>> for BitSpanMut<'a, T>

fn bitxor_assign(&mut self, rhs: &'b BitSpan<'b, T>)

Performs the ^= operation.