Struct smallbitvec::SmallBitVec

pub struct SmallBitVec { /* fields omitted */ }

A resizable bit vector, optimized for size and inline storage.

SmallBitVec is exactly one word wide. Depending on the required capacity, this word either stores the bits inline, or it stores a pointer to a separate buffer on the heap.

Methods

impl SmallBitVec

pub fn new() -> SmallBitVec

Create an empty vector.

pub fn from_elem(len: usize, val: bool) -> SmallBitVec

Create a vector containing len bits, each set to val.

pub fn with_capacity(cap: usize) -> SmallBitVec

Create an empty vector with enough storage pre-allocated to store at least cap bits without resizing.

pub fn len(&self) -> usize

The number of bits stored in this bit vector.

pub fn is_empty(&self) -> bool

Returns true if this vector contains no bits.

pub fn capacity(&self) -> usize

The number of bits that can be stored in this bit vector without re-allocating.

pub fn get(&self, n: usize) -> Option<bool>

Get the nth bit in this bit vector.

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

Get the nth bit in this bit vector, without bounds checks.

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

Set the nth bit in this bit vector to val. Panics if the index is out of bounds.

pub unsafe fn set_unchecked(&mut self, n: usize, val: bool)

Set the nth bit in this bit vector to val, without bounds checks.

pub fn push(&mut self, val: bool)

Append a bit to the end of the vector.

use smallbitvec::SmallBitVec;
let mut v = SmallBitVec::new();
v.push(true);

assert_eq!(v.len(), 1);
assert_eq!(v.get(0), Some(true));

pub fn pop(&mut self) -> Option<bool>

Remove the last bit from the vector and return it, if there is one.

use smallbitvec::SmallBitVec;
let mut v = SmallBitVec::new();
v.push(false);

assert_eq!(v.pop(), Some(false));
assert_eq!(v.len(), 0);
assert_eq!(v.pop(), None);

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

Remove and return the bit at index idx, shifting all later bits toward the front.

Panics if the index is out of bounds.

pub fn clear(&mut self)

Remove all elements from the vector, without deallocating its buffer.

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

Reserve capacity for at least additional more elements to be inserted.

May reserve more space than requested, to avoid frequent reallocations.

Panics if the new capacity overflows usize.

Re-allocates only if self.capacity() < self.len() + additional.

Important traits for Iter<'a>

impl<'a> Iterator for Iter<'a> type Item = bool;

pub fn iter(&self) -> Iter

Returns an iterator that yields the bits of the vector in order, as bool values.

pub fn all_false(&self) -> bool

Returns true if all the bits in the vec are set to zero/false.

pub fn all_true(&self) -> bool

Returns true if all the bits in the vec are set to one/true.

pub fn heap_ptr(&self) -> Option<*const usize>

If the vector owns a heap allocation, returns a pointer to the start of the allocation.

The layout of the data at this allocation is a private implementation detail.

Trait Implementations

impl Debug for SmallBitVec

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for SmallBitVec

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

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

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

This method tests for !=.

impl Eq for SmallBitVec

impl Drop for SmallBitVec

fn drop(&mut self)

Executes the destructor for this type.

impl Clone for SmallBitVec

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Index<usize> for SmallBitVec

type Output = bool

The returned type after indexing.

fn index(&self, i: usize) -> &bool

Performs the indexing (container[index]) operation.

impl Hash for SmallBitVec

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl Extend<bool> for SmallBitVec

fn extend<I: IntoIterator<Item = bool>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl FromIterator<bool> for SmallBitVec

fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self

Creates a value from an iterator.

impl IntoIterator for SmallBitVec

type Item = bool

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

Important traits for IntoIter

impl Iterator for IntoIter type Item = bool;

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a SmallBitVec

type Item = bool

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

Important traits for Iter<'a>

impl<'a> Iterator for Iter<'a> type Item = bool;

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.