Struct bitmaps::Bitmap

pub struct Bitmap<const SIZE: usize> where
    BitsImpl<{ SIZE }>: Bits,  { /* fields omitted */ }

A compact array of bits.

The type used to store the bitmap will be the minimum unsigned integer type required to fit the number of bits, from u8 to u128. If the size is 1, bool is used. If the size exceeds 128, an array of u128 will be used, sized as appropriately. The maximum supported size is currently 1024, represented by an array [u128; 8].

Implementations

impl Bitmap<128>

pub unsafe fn load_m128i(&self) -> __m128i

This is supported with target feature sse2 only.

impl Bitmap<256>

pub unsafe fn load_m128i(&self) -> [__m128i; 2]

This is supported with target feature sse2 only.

pub unsafe fn load_m256i(&self) -> __m256i

This is supported with target feature avx only.

impl Bitmap<512>

pub unsafe fn load_m128i(&self) -> [__m128i; 4]

This is supported with target feature sse2 only.

pub unsafe fn load_m256i(&self) -> [__m256i; 2]

This is supported with target feature avx only.

impl Bitmap<768>

pub unsafe fn load_m128i(&self) -> [__m128i; 6]

This is supported with target feature sse2 only.

pub unsafe fn load_m256i(&self) -> [__m256i; 3]

This is supported with target feature avx only.

impl Bitmap<1024>

pub unsafe fn load_m128i(&self) -> [__m128i; 8]

This is supported with target feature sse2 only.

pub unsafe fn load_m256i(&self) -> [__m256i; 4]

This is supported with target feature avx only.

impl<const SIZE: usize> Bitmap<{ SIZE }> where
    BitsImpl<SIZE>: Bits, 

pub fn new() -> Self

Construct a bitmap with every bit set to false.

pub fn mask(bits: usize) -> Self

Construct a bitmap where every bit with index less than bits is true, and every other bit is false.

pub fn from_value(data: <BitsImpl<SIZE> as Bits>::Store) -> Self

Construct a bitmap from a value of the same type as its backing store.

pub fn into_value(self) -> <BitsImpl<SIZE> as Bits>::Store

Convert this bitmap into a value of the type of its backing store.

pub fn as_value(&self) -> &<BitsImpl<SIZE> as Bits>::Store

Get a reference to this bitmap’s backing store.

pub fn len(self) -> usize

Count the number of true bits in the bitmap.

pub fn is_empty(self) -> bool

Test if the bitmap contains only false bits.

pub fn is_full(self) -> bool

Test if the bitmap contains only true bits.

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

Get the value of the bit at a given index.

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

Set the value of the bit at a given index.

Returns the previous value of the bit.

pub fn first_index(self) -> Option<usize>

Find the index of the first true bit in the bitmap.

pub fn first_false_index(self) -> Option<usize>

Find the index of the first false bit in the bitmap.

pub fn invert(&mut self)

Invert all the bits in the bitmap.

Trait Implementations

impl<const SIZE: usize> BitAnd<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const SIZE: usize> BitAndAssign<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const SIZE: usize> BitOr<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const SIZE: usize> BitOrAssign<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const SIZE: usize> BitXor<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const SIZE: usize> BitXorAssign<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const SIZE: usize> Clone for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const SIZE: usize> Copy for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

impl<const SIZE: usize> Debug for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

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

Formats the value using the given formatter.

impl<const SIZE: usize> Default for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

fn default() -> Self

Returns the “default value” for a type.

impl<const SIZE: usize> Eq for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

impl From<[u128; 2]> for Bitmap<256>

fn from(data: [u128; 2]) -> Self

Performs the conversion.

impl From<[u128; 3]> for Bitmap<384>

fn from(data: [u128; 3]) -> Self

Performs the conversion.

impl From<[u128; 4]> for Bitmap<512>

fn from(data: [u128; 4]) -> Self

Performs the conversion.

impl From<[u128; 5]> for Bitmap<640>

fn from(data: [u128; 5]) -> Self

Performs the conversion.

impl From<[u128; 6]> for Bitmap<768>

fn from(data: [u128; 6]) -> Self

Performs the conversion.

impl From<[u128; 7]> for Bitmap<896>

fn from(data: [u128; 7]) -> Self

Performs the conversion.

impl From<[u128; 8]> for Bitmap<1024>

fn from(data: [u128; 8]) -> Self

Performs the conversion.

impl From<__m128i> for Bitmap<128>

fn from(data: __m128i) -> Self

Performs the conversion.

impl From<__m256i> for Bitmap<256>

fn from(data: __m256i) -> Self

Performs the conversion.

impl<const SIZE: usize> Hash for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits,
    <BitsImpl<{ SIZE }> as Bits>::Store: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a, const SIZE: usize> IntoIterator for &'a Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

type Item = usize

The type of the elements being iterated over.

type IntoIter = Iter<'a, { SIZE }>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const SIZE: usize> Not for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const SIZE: usize> Ord for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits,
    <BitsImpl<{ SIZE }> as Bits>::Store: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<const SIZE: usize> PartialEq<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<const SIZE: usize> PartialOrd<Bitmap<SIZE>> for Bitmap<{ SIZE }> where
    BitsImpl<{ SIZE }>: Bits,
    <BitsImpl<{ SIZE }> as Bits>::Store: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.