Struct BitVector

pub struct BitVector { /* private fields */ }

This is a space-efficient, resizeable bitvector class. In the common case it occupies one word, but if necessary, it will inflate this one word to point to a single chunk of out-of-line allocated storage to store an arbitrary number of bits.

• The bitvector remembers the bound of how many bits can be stored, but this may be slightly greater (by as much as some platform-specific constant) than the last argument passed to ensureSize().

• The bitvector can resize itself automatically (set, clear, get) or can be used in a manual mode, which is faster (quick_set, quick_clear, quick_get, ensure_size).

• Accesses assert! that you are within bounds.

• Bits are automatically initialized to zero.

On the other hand, this BitVector class may not be the fastest around, since it does conditionals on every get/set/clear. But it is great if you need to juggle a lot of variable-length BitVectors and you’re worried about wasting space.

Implementations

impl BitVector

pub fn new() -> Self

pub fn with_capacity(num_bits: usize) -> Self

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

Merge other into self, equal to bit-or.

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

Filter self by other, keeping only the bits that are set in both, equal to bit-and.

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

Exclude the bits in other from self, equal to bit-and-not.

pub fn is_empty(&self) -> bool

pub fn bit_count(&self) -> usize

Return number of set bits.

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

Search after index for the next bit with value value, returns index if no such bit is found.

pub fn len(&self) -> usize

Return number of bits in the bitvector.

pub fn quick_clear(&mut self, bit: usize) -> bool

Quick clear a bit. Does not reallocate.

Panics

Panics if bit is out of bounds.

pub fn quick_set(&mut self, bit: usize, value: bool) -> bool

Quick set bit. Does not reallocate.

Panics

Panics if bit is out of bounds.

pub fn quick_get(&self, bit: usize) -> bool

Quick get bit.

Panics

Panics if bit is out of bounds.

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

Get bit at index, or false if index is out of bounds.

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

Same as get

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

Clear bit at index, or return false if index is out of bounds.

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

Set bit at index. Resizes bitvector if necessary.

pub fn ensure_size(&mut self, num_bits: usize)

Ensure that the bitvector can hold at least num_bits bits.

pub fn resize(&mut self, num_bits: usize)

Resize the bitvector to num_bits bits.

pub fn clear_all(&mut self)

Set all bits to zero.

pub fn shift_right_by_multiple_of_64(&mut self, shift_in_bits: usize)

Shift right by shift_in_bits bits. Resizes bitvector if necessary.

pub fn iter(&self) -> BitVectorIter<'_>

Creates a new iterator over the bitvector.

Trait Implementations

impl Clone for BitVector

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitVector

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

Formats the value using the given formatter.

impl Default for BitVector

fn default() -> Self

Returns the “default value” for a type.

impl Drop for BitVector

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for BitVector

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BitVector

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

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

const 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 BitVector