Struct FixedBitSet

pub struct FixedBitSet { /* private fields */ }

Expand description

FixedBitSet is a simple fixed size set of bits that each can be enabled (1 / true) or disabled (0 / false).

The bit set has a fixed capacity in terms of enabling bits (and the capacity can grow using the grow method).

Derived traits depend on both the zeros and ones, so [0,1] is not equal to [0,1,0].

Implementations§

§

impl FixedBitSet

pub const fn new() -> FixedBitSet

Create a new empty FixedBitSet.

pub fn with_capacity(bits: usize) -> FixedBitSet

Create a new FixedBitSet with a specific number of bits, all initially clear.

pub fn with_capacity_and_blocks(bits: usize, blocks: I) -> FixedBitSet
where I: IntoIterator<Item = usize>,

Create a new FixedBitSet with a specific number of bits, initialized from provided blocks.

If the blocks are not the exact size needed for the capacity they will be padded with zeros (if shorter) or truncated to the capacity (if longer).

For example:

let data = vec![4];
let bs = fixedbitset::FixedBitSet::with_capacity_and_blocks(4, data);
assert_eq!(format!("{:b}", bs), "0010");

pub fn grow(&mut self, bits: usize)

Grow capacity to bits, all new bits initialized to zero

pub fn grow_and_insert(&mut self, bits: usize)

Grows the internal size of the bitset before inserting a bit

Unlike insert, this cannot panic, but may allocate if the bit is outside of the existing buffer’s range.

This is faster than calling grow then insert in succession.

pub fn len(&self) -> usize

The length of the FixedBitSet in bits.

Note: len includes both set and unset bits.

let bitset = FixedBitSet::with_capacity(10);
// there are 0 set bits, but 10 unset bits
assert_eq!(bitset.len(), 10);

len does not return the count of set bits. For that, use bitset.count_ones(..) instead.

pub fn is_empty(&self) -> bool

true if the FixedBitSet is empty.

Note that an “empty” FixedBitSet is a FixedBitSet with no bits (meaning: it’s length is zero). If you want to check if all bits are unset, use FixedBitSet::is_clear.

let bitset = FixedBitSet::with_capacity(10);
assert!(!bitset.is_empty());

let bitset = FixedBitSet::with_capacity(0);
assert!(bitset.is_empty());

pub fn is_clear(&self) -> bool

true if all bits in the FixedBitSet are unset.

As opposed to FixedBitSet::is_empty, which is true only for sets without any bits, set or unset.

let mut bitset = FixedBitSet::with_capacity(10);
assert!(bitset.is_clear());

bitset.insert(2);
assert!(!bitset.is_clear());

This is equivalent to bitset.count_ones(..) == 0.

pub fn minimum(&self) -> Option<usize>

Finds the lowest set bit in the bitset.

Returns None if there aren’t any set bits.

let mut bitset = FixedBitSet::with_capacity(10);
assert_eq!(bitset.minimum(), None);

bitset.insert(2);
assert_eq!(bitset.minimum(), Some(2));
bitset.insert(8);
assert_eq!(bitset.minimum(), Some(2));

pub fn maximum(&self) -> Option<usize>

Finds the highest set bit in the bitset.

Returns None if there aren’t any set bits.

let mut bitset = FixedBitSet::with_capacity(10);
assert_eq!(bitset.maximum(), None);

bitset.insert(8);
assert_eq!(bitset.maximum(), Some(8));
bitset.insert(2);
assert_eq!(bitset.maximum(), Some(8));

pub fn is_full(&self) -> bool

true if all bits in the FixedBitSet are set.

let mut bitset = FixedBitSet::with_capacity(10);
assert!(!bitset.is_full());

bitset.insert_range(..);
assert!(bitset.is_full());

This is equivalent to bitset.count_ones(..) == bitset.len().

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

Return true if the bit is enabled in the FixedBitSet, false otherwise.

Note: bits outside the capacity are always disabled.

Note: Also available with index syntax: bitset[bit].

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

Return true if the bit is enabled in the FixedBitSet, false otherwise.

Note: unlike contains, calling this with an invalid bit is undefined behavior.

§Safety

bit must be less than self.len()

pub fn clear(&mut self)

Clear all bits.

pub fn insert(&mut self, bit: usize)

Enable bit.

Panics if bit is out of bounds.

pub unsafe fn insert_unchecked(&mut self, bit: usize)

Enable bit without any length checks.

§Safety

bit must be less than self.len()

pub fn remove(&mut self, bit: usize)

Disable bit.

Panics if bit is out of bounds.

pub unsafe fn remove_unchecked(&mut self, bit: usize)

Disable bit without any bounds checking.

§Safety

bit must be less than self.len()

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

Enable bit, and return its previous value.

Panics if bit is out of bounds.

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

Enable bit, and return its previous value without doing any bounds checking.

§Safety

bit must be less than self.len()

pub fn toggle(&mut self, bit: usize)

Toggle bit (inverting its state).

Panics if bit is out of bounds

pub unsafe fn toggle_unchecked(&mut self, bit: usize)

Toggle bit (inverting its state) without any bounds checking.

§Safety

bit must be less than self.len()

pub fn set(&mut self, bit: usize, enabled: bool)

Sets a bit to the provided enabled value.

Panics if bit is out of bounds.

pub unsafe fn set_unchecked(&mut self, bit: usize, enabled: bool)

Sets a bit to the provided enabled value without doing any bounds checking.

§Safety

bit must be less than self.len()

pub fn copy_bit(&mut self, from: usize, to: usize)

Copies boolean value from specified bit to the specified bit.

If from is out-of-bounds, to will be unset.

Panics if to is out of bounds.

pub unsafe fn copy_bit_unchecked(&mut self, from: usize, to: usize)

Copies boolean value from specified bit to the specified bit.

Note: unlike copy_bit, calling this with an invalid from is undefined behavior.

§Safety

to must both be less than self.len()

pub fn count_ones<T>(&self, range: T) -> usize
where T: IndexRange,

Count the number of set bits in the given bit range.

This function is potentially much faster than using ones(other).count(). Use .. to count the whole content of the bitset.