Struct yabf::SmallYabf

pub struct SmallYabf { /* fields omitted */ }

Yet another bit field implementation. This is a simple, small and hopefully efficient bit field implementation. It uses SmallVec as an internal container. The first 128 bits will be stored on the stack.

It is intended for cases where a program iterates over list or other usize indexed containers and simple bit based bookkeeping is required.

Implementations

impl SmallYabf

pub fn with_capacity(bits: usize) -> Self

Construct an empty bit field with enough capacity pre-allocated to store at least n bits.

Will create a heap allocation only if n is larger than the inline capacity of the internal SmallVec.

let bf = SmallYabf::with_capacity(100);

assert!(bf.is_empty());
assert!(bf.capacity() >= 100);

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

Returns the value of the ‘n’:th bit in the bit field.

let mut bf = SmallYabf::default();

assert!(bf.is_empty());
assert!(!bf.bit(10));
bf.set_bit(10,true);
assert!(bf.bit(10));

pub fn set_bit(&mut self, n: usize, state: bool)

Sets the ‘n’:th bit in the bit field. If the bit field capacity is not large enough more space will be allocated.

let mut bf = SmallYabf::default();

assert!(bf.is_empty());
assert!(!bf.bit(10));
bf.set_bit(10,true);
assert!(bf.bit(10));

pub fn is_empty(&self) -> bool

Returns true if all bits are set to false

pub fn capacity(&self) -> usize

The number of bits the bit field can hold without reallocating

pub fn internal_len(&self) -> usize

The len() of the internal vector

pub fn reserve(&mut self, additional_bits: usize)

Reserve capacity for additional_bits more bits to be inserted.

May reserve more space to avoid frequent re-allocations.

Panics if the capacity computation overflows usize.

pub fn clear(&mut self)

Remove all elements from the vector. This method simply delegates clear() to the underlying vector std::vec::Vec or smallvec::SmallVec. So what actually happen depends on the feature set.

Trait Implementations

impl BitOrAssign<&'_ SmallYabf> for SmallYabf

bit or assign operation This is a relatively expensive O(size of container) operation.

let mut a = SmallYabf::default();
let mut b = SmallYabf::default();
a.set_bit(45,true);
b.set_bit(12345,true);
assert!(!a.bit(12345));
assert!(a.bit(45));
a |= &b;
assert!(a.bit(12345));
assert!(a.bit(45));

fn bitor_assign(&mut self, other: &SmallYabf)

Performs the |= operation.

impl Clone for SmallYabf

fn clone(&self) -> SmallYabf

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SmallYabf

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

Formats the value using the given formatter.

impl Default for SmallYabf

fn default() -> Self

Returns the “default value” for a type.

impl<'a> IntoIterator for &'a SmallYabf

type Item = usize

The type of the elements being iterated over.

type IntoIter = SmallYabfIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.