Struct bitmap32::BitMap

source ·

#[repr(transparent)]
pub struct BitMap<B: BitBlock, const BLOCKS: usize>(pub [B; BLOCKS]);

Expand description

A bitmap that is internally represented as [B; BLOCKS].

Tuple Fields§

§0: [B; BLOCKS]

Implementations§

source §

impl<B: BitBlock, const BLOCKS: usize> BitMap<LE, BLOCKS>where LE: BitBlock,

source

pub fn from_raw_le(raw: [B; BLOCKS]) -> Self

Convenience function for creating little endian bitmaps. This is planned to become const when the needed rust features are stabilized.
For now, something like BitBlock::from_raw([LE(0b00100111), LE(0b01100011)]) may be used instead.

source §

impl<B: BitBlock, const BLOCKS: usize> BitMap<B, BLOCKS>

source

pub const fn new() -> Self

Creates a zero-initialized bitmap

source

pub const fn from_raw(raw: [B; BLOCKS]) -> Self

Same as raw.into() but usable in const contexts;

Methods from Deref<Target = BitSlice>§

source

pub fn len_blocks(&self) -> usize

Returns the length of self in blocks.

source

pub fn len_bits(&self) -> usize

Returns the length of self in bits.

source

pub fn get_blocks<I: SliceIndex<[B]>>(&self, index: I) -> Option<&I::Output>

source

pub fn get_blocks_mut<I: SliceIndex<[B]>>( &mut self, index: I ) -> Option<&mut I::Output>

source

pub fn blocks(&self) -> Iter<'_, B>

Iterates over the blocks in Self

source

pub fn blocks_mut(&mut self) -> IterMut<'_, B>

Mutable iterates over the blocks in Self

source

pub fn bits(&self) -> Bits<'_, B> ⓘ

Iterates over the bits in self.

source

pub fn ones(&self) -> Ones<'_, B> ⓘ

Iterates over the indices of the 1s in self. This is equivalent to self.bits().enumerate().filter_map(|(i, bit)| bit.then_some(i)), but it makes use of several optimizations and usually a count leading zero instruction or something similar.

source

pub fn zeros(&self) -> Zeros<'_, B> ⓘ

Iterates over the indices of the 0s in self. This is equivalent to self.bits().enumerate().filter_map(|(i, bit)| (!bit).then_some(i)), but it makes use of several optimizations and usually a count leading zero instruction or something similar.

source

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

Returns true if the bit at idx is a 1. If idx is out of range, None is returned.

source

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

Sets the bit at idx to 1. If idx is out of range, false is returned.

source

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

Sets the bit at idx to 0. If idx is out of range, false is returned.

source

pub fn clear(&mut self)

Zeros all of the bits in self.

source

pub fn bit_or_assign_iter<I: IntoIterator<Item = B>>(&mut self, other: I)

Does a BitOrAssign between rhs and self. If rhs is bigger than self, the overflowing bits are ignored.

source

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

Does a BitOrAssign between rhs and self. If rhs is bigger than self, the overflowing bits are ignored.
This function is purely a convinience function for Self::bit_or_assign_iter.

Note: the reason why the BitOrAssign trait isn’t used is because it requires that Self is Sized.

source

pub fn fill_ones_checked(&mut self, start: usize, length: NonZeroUsize) -> bool

source

pub fn fill_zeros_checked(&mut self, start: usize, length: NonZeroUsize) -> bool

source

pub fn bit_or_assign_raw<I: IntoIterator<Item = &'a B>>(&mut self, other: I)

Does a BitOrAssign between rhs and self. If rhs is bigger than self, the overflowing bits are ignored.
This function is purely a convinience function for Self::bit_or_assign_iter.

Example

let mut foo = BitMap::from([0b00110000u8, 0b00010010u8]);

foo.bit_or_assign_raw(&[0b10000000]);
assert_eq!(foo.test(0), Some(true));
assert_eq!(foo.test(8), Some(false));