Struct fixedbitset::FixedBitSet[−][src]

pub struct FixedBitSet { /* fields omitted */ }

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).

Implementations

`impl FixedBitSet`[src]

`pub fn with_capacity(bits: usize) -> Self`[src]

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

`pub fn with_capacity_and_blocks<I: IntoIterator<Item = u32>>( bits: usize, blocks: I ) -> Self`[src]

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)`[src]

Grow capacity to bits, all new bits initialized to zero

`pub fn len(&self) -> usize`[src]

Return the length of the FixedBitSet in bits.

`pub fn contains(&self, bit: usize) -> bool`[src]

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 fn clear(&mut self)`[src]

Clear all bits.

`pub fn insert(&mut self, bit: usize)`[src]

Enable bit.

Panics if bit is out of bounds.

`pub fn put(&mut self, bit: usize) -> bool`[src]

Enable bit, and return its previous value.

Panics if bit is out of bounds.

`pub fn toggle(&mut self, bit: usize)`[src]

Toggle bit (inverting its state).

Panics if bit is out of bounds

`pub fn set(&mut self, bit: usize, enabled: bool)`[src]

Panics if bit is out of bounds.

`pub fn copy_bit(&mut self, from: usize, to: usize)`[src]

Copies boolean value from specified bit to the specified bit.

Panics if to is out of bounds.

`pub fn count_ones<T: IndexRange>(&self, range: T) -> usize`[src]

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

Use .. to count the whole content of the bitset.

Panics if the range extends past the end of the bitset.

`pub fn set_range<T: IndexRange>(&mut self, range: T, enabled: bool)`[src]

Sets every bit in the given range to the given state (enabled)

Use .. to set the whole bitset.

Panics if the range extends past the end of the bitset.

`pub fn insert_range<T: IndexRange>(&mut self, range: T)`[src]

Enables every bit in the given range.

Use .. to make the whole bitset ones.

Panics if the range extends past the end of the bitset.

`pub fn toggle_range<T: IndexRange>(&mut self, range: T)`[src]

Toggles (inverts) every bit in the given range.

Use .. to toggle the whole bitset.

Panics if the range extends past the end of the bitset.

`pub fn as_slice(&self) -> &[u32]`[src]

View the bitset as a slice of u32 blocks

`pub fn as_mut_slice(&mut self) -> &mut [u32]`[src]

View the bitset as a mutable slice of u32 blocks. Writing past the bitlength in the last will cause contains to return potentially incorrect results for bits past the bitlength.

`pub fn ones(&self) -> Ones<'_>ⓘNotable traits for Ones<'a> impl<'a> Iterator for Ones<'a> type Item = usize;`[src]

Iterates over all enabled bits.

Iterator element is the index of the 1 bit, type usize.

`pub fn intersection<'a>(&'a self, other: &'a FixedBitSet) -> Intersection<'a>ⓘNotable traits for Intersection<'a> impl<'a> Iterator for Intersection<'a> type Item = usize;`[src]

Returns a lazy iterator over the intersection of two FixedBitSets

`pub fn union<'a>(&'a self, other: &'a FixedBitSet) -> Union<'a>ⓘNotable traits for Union<'a> impl<'a> Iterator for Union<'a> type Item = usize;`[src]

Returns a lazy iterator over the union of two FixedBitSets.

`pub fn difference<'a>(&'a self, other: &'a FixedBitSet) -> Difference<'a>ⓘNotable traits for Difference<'a> impl<'a> Iterator for Difference<'a> type Item = usize;`[src]

Returns a lazy iterator over the difference of two FixedBitSets. The difference of a and b is the elements of a which are not in b.

`pub fn symmetric_difference<'a>( &'a self, other: &'a FixedBitSet ) -> SymmetricDifference<'a>ⓘNotable traits for SymmetricDifference<'a> impl<'a> Iterator for SymmetricDifference<'a> type Item = usize;`[src]

Returns a lazy iterator over the symmetric difference of two FixedBitSets. The symmetric difference of a and b is the elements of one, but not both, sets.