Struct StaticBitmap

pub struct StaticBitmap<D, B> { /* private fields */ }

A bitmap that cannot be resized.

Any structure that implements the ContainerRead (for read-only access) and ContainerWrite (for mutable access) traits can be a container of bitmap (e.g. [T; N], &[T], Vec<T>, etc.).

Usage example:

use bitmac::{StaticBitmap, LSB};

// You can directly check every single bit
let bitmap = StaticBitmap::<_, LSB>::new([0b0000_0001u8, 0b0000_1000]);
assert!(bitmap.get(0));
assert!(bitmap.get(11));
assert!(!bitmap.get(13));
// Out of bounds bits always return false
assert!(!bitmap.get(128));

// You can iterate over bits
let bitmap = StaticBitmap::<_, LSB>::new([0b0000_1001u8, 0b0000_1000]);
let mut iter = bitmap.iter().by_bits().enumerate();
assert_eq!(iter.next(), Some((0, true)));
assert_eq!(iter.next(), Some((1, false)));
assert_eq!(iter.next(), Some((2, false)));
assert_eq!(iter.next(), Some((3, true)));
assert_eq!(iter.next(), Some((4, false)));

// You can check multiple bits at the same time through the intersection
use bitmac::Intersection;
let bitmap = StaticBitmap::<_, LSB>::new([0b0000_1001u8, 0b0000_1000]);
// .. by creating specific new container for result
let test = [0b0000_1001u8, 0b0000_0000];
assert_eq!(bitmap.intersection::<[u8; 2]>(&test), test);
// .. by using preallocated container for result
let test = [0b0000_1001u8, 0b0000_0000];
let mut result = [0u8; 2];
bitmap.intersection_in(&test, &mut result);
assert_eq!(result, test);
// .. by comparing length of difference that is equivalent to count of ones (bits) in result
let test = [0b0000_1001u8, 0b0000_0000];
assert_eq!(bitmap.intersection_len(&test), test.iter().fold(0, |acc, &v| acc + v.count_ones() as usize));

// You can directly change every single bit
let mut bitmap = StaticBitmap::<_, LSB>::new([0b0000_1001u8, 0b0001_1000]);
assert!(bitmap.get(0));
assert!(bitmap.get(3));
assert!(bitmap.get(11));
assert!(bitmap.get(12));
assert!(!bitmap.get(13));
assert!(!bitmap.get(128));
bitmap.set(12, false);
assert!(!bitmap.get(12));
bitmap.set(13, true);
assert!(bitmap.get(13));
// Out of bounds bits return error
assert!(bitmap.try_set(128, true).is_err());
assert!(!bitmap.get(128));

Implementations

impl<D, N, B> StaticBitmap<D, B>

where D: ContainerRead<B, Slot = N>, N: Number, B: BitAccess,

pub fn new(data: D) -> Self

Creates new bitmap from container.

pub fn count_ones(&self) -> usize

Returns number of ones in the bitmap.

pub fn count_zeros(&self) -> usize

Returns number of zeros in the bitmap.

impl<D, B> StaticBitmap<D, B>

pub fn into_inner(self) -> D

Converts bitmap into inner container.

impl<D, B> StaticBitmap<D, B>

where D: ContainerRead<B>, B: BitAccess,

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

Gets single bit state.

Usage example:

use bitmac::{StaticBitmap, LSB};

let bitmap = StaticBitmap::<_, LSB>::new([0b0000_0001u8, 0b0000_1000]);
assert!(bitmap.get(0));
assert!(bitmap.get(11));
assert!(!bitmap.get(13));
// Out of bounds bits always return false
assert!(!bitmap.get(128));

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

Returns iterator over slots.

impl<D, B> StaticBitmap<D, B>

where D: ContainerWrite<B>, B: BitAccess,

pub fn set(&mut self, idx: usize, val: bool)

Sets new state for a single bit.

Panic

Panics if idx is out of bounds. See non-panic function try_set.

Usage example:

use bitmac::{StaticBitmap, LSB};

let mut bitmap = StaticBitmap::<_, LSB>::new([0b0000_1001u8, 0b0001_1000]);
bitmap.set(12, false);
assert!(!bitmap.get(12));
bitmap.set(13, true);
assert!(bitmap.get(13));

pub fn try_set(&mut self, idx: usize, val: bool) -> Result<(), OutOfBoundsError>

Sets new state for a single bit.

Returns Err(_) if idx is out of bounds.

Usage example:

use bitmac::{StaticBitmap, LSB};

let mut bitmap = StaticBitmap::<_, LSB>::new([0b0000_1001u8, 0b0001_1000]);
assert!(bitmap.try_set(12, true).is_ok());
assert!(bitmap.get(12));
assert!(bitmap.try_set(12, false).is_ok());
assert!(!bitmap.get(12));
// Out of bounds bits return error
assert!(bitmap.try_set(128, true).is_err());
assert!(!bitmap.get(128));

Trait Implementations

impl<D, B> AsMut<D> for StaticBitmap<D, B>

fn as_mut(&mut self) -> &mut D

Converts this type into a mutable reference of the (usually inferred) input type.

impl<D, B> AsRef<D> for StaticBitmap<D, B>

fn as_ref(&self) -> &D

Converts this type into a shared reference of the (usually inferred) input type.

impl<D: Clone, B: Clone> Clone for StaticBitmap<D, B>

fn clone(&self) -> StaticBitmap<D, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D, B> ContainerRead<B> for StaticBitmap<D, B>

where D: ContainerRead<B>, B: BitAccess,

type Slot = <D as ContainerRead<B>>::Slot

fn get_slot(&self, idx: usize) -> Self::Slot

Gets value of stored slot.

fn slots_count(&self) -> usize

Gets number of stored slots.

fn bits_count(&self) -> usize

Gets max number of bits.

impl<D, B> ContainerWrite<B> for StaticBitmap<D, B>

where D: ContainerWrite<B>, B: BitAccess,

fn get_mut_slot(&mut self, idx: usize) -> &mut Self::Slot

Gets mutable reference to stored slot.

impl<D, N, B> Debug for StaticBitmap<D, B>

where D: ContainerRead<B, Slot = N>, N: Number, B: BitAccess,

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

Formats the value using the given formatter.

impl<D: Default, B: Default> Default for StaticBitmap<D, B>

fn default() -> StaticBitmap<D, B>

Returns the “default value” for a type.

impl<D, N, B> From<D> for StaticBitmap<D, B>

where D: ContainerRead<B, Slot = N>, N: Number, B: BitAccess,

fn from(f: D) -> Self

Converts to this type from the input type.

impl<D, B, Rhs, N> Intersection<Rhs, N, B> for StaticBitmap<D, B>

where D: ContainerRead<B, Slot = N>, B: BitAccess, Rhs: ContainerRead<B, Slot = N>, N: Number,

fn intersection_in<Dst>(&self, rhs: &Rhs, dst: &mut Dst)

where Dst: ContainerWrite<B, Slot = N>,

Calculates intersection in-place. Result will be stored in dst.

fn try_intersection_in<Dst>( &self, rhs: &Rhs, dst: &mut Dst, ) -> Result<(), IntersectionError>

where Dst: ContainerWrite<B, Slot = N>,

Calculates intersection in-place. Result will be stored in dst.

fn intersection<Dst>(&self, rhs: &Rhs) -> Dst

where Dst: ContainerWrite<B, Slot = N> + TryWithSlots,

Calculates intersection. Result container will be created with try_with_slots function.

fn try_intersection<Dst>(&self, rhs: &Rhs) -> Result<Dst, IntersectionError>

where Dst: ContainerWrite<B, Slot = N> + TryWithSlots,

Calculates intersection. Result container will be created with try_with_slots function.

fn intersection_len(&self, rhs: &Rhs) -> usize

Calculates intersection length - ones count. It doesn’t allocate for storing intersection result.

impl<'a, D, B> IntoIterator for &'a StaticBitmap<D, B>

where D: ContainerRead<B>, B: BitAccess,

type Item = <Iter<'a, D, B> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = Iter<'a, D, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D, B> IntoIterator for StaticBitmap<D, B>

where D: ContainerRead<B>, B: BitAccess,

type Item = <IntoIter<D, B> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = IntoIter<D, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D: PartialEq, B: PartialEq> PartialEq for StaticBitmap<D, B>

fn eq(&self, other: &StaticBitmap<D, B>) -> bool

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

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<D, B> TryWithSlots for StaticBitmap<D, B>

where D: TryWithSlots, B: BitAccess,

fn try_with_slots(len: usize) -> Result<Self, WithSlotsError>

Creates new container with specified slots number.

impl<D, B, Rhs, N> Union<Rhs, N, B> for StaticBitmap<D, B>

where D: ContainerRead<B, Slot = N>, B: BitAccess, Rhs: ContainerRead<B, Slot = N>, N: Number,

fn union_in<Dst>(&self, rhs: &Rhs, dst: &mut Dst)

where Dst: ContainerWrite<B, Slot = N>,

Calculates union in-place. Result will be stored in dst.

fn try_union_in<Dst>(&self, rhs: &Rhs, dst: &mut Dst) -> Result<(), UnionError>

where Dst: ContainerWrite<B, Slot = N>,

Calculates union in-place. Result will be stored in dst.

fn union<Dst>(&self, rhs: &Rhs) -> Dst

where Dst: ContainerWrite<B, Slot = N> + TryWithSlots,

Calculates union. Result container will be created with try_with_slots function.

fn try_union<Dst>(&self, rhs: &Rhs) -> Result<Dst, UnionError>

where Dst: ContainerWrite<B, Slot = N> + TryWithSlots,

Calculates union. Result container will be created with try_with_slots function.

fn union_len(&self, rhs: &Rhs) -> usize

Calculates union length - ones count. It doesn’t allocate for storing union result.

impl<D: Eq, B: Eq> Eq for StaticBitmap<D, B>

impl<D, B> StructuralPartialEq for StaticBitmap<D, B>