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.

Implementations

impl SmallBitVec

pub const 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 fn last(&self) -> Option<bool>

Get the last 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.

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

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

pub fn range(&self, range: Range<usize>) -> VecRange<'_>

Returns an immutable view of a range of bits from this vec.

#[macro_use] extern crate smallbitvec;
let v = sbvec![true, false, true];
let r = v.range(1..3);
assert_eq!(r[1], true);

pub fn all_false(&self) -> bool

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

On an empty vector, returns true.

pub fn all_true(&self) -> bool

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

On an empty vector, returns true.

pub fn truncate(&mut self, len: usize)

Shorten the vector, keeping the first len elements and dropping the rest.

If len is greater than or equal to the vector’s current length, this has no effect.

This does not re-allocate.

pub fn resize(&mut self, len: usize, value: bool)

Resizes the vector so that its length is equal to len.

If len is less than the current length, the vector simply truncated.

If len is greater than the current length, value is appended to the vector until its length equals len.

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.

pub fn into_storage(self) -> InternalStorage

Converts this SmallBitVec into its internal representation.

The layout of the data inside both enum variants is a private implementation detail.

pub unsafe fn from_storage(storage: InternalStorage) -> SmallBitVec

Creates a SmallBitVec directly from the internal storage of another SmallBitVec.

Safety

This is highly unsafe. storage needs to have been previously generated via SmallBitVec::into_storage (at least, it’s highly likely to be incorrect if it wasn’t.) Violating this may cause problems like corrupting the allocator’s internal data structures.

Examples

fn main() {
    let v = SmallBitVec::from_elem(200, false);

    // Get the internal representation of the SmallBitVec.
    // unless we transfer its ownership somewhere else.
    let storage = v.into_storage();

    /// Make a copy of the SmallBitVec's data.
    let cloned_storage = match storage {
        InternalStorage::Spilled(vs) => InternalStorage::Spilled(vs.clone()),
        inline => inline,
    };

    /// Create a new SmallBitVec from the coped storage.
    let v = unsafe { SmallBitVec::from_storage(cloned_storage) };
}

Trait Implementations

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 Debug for SmallBitVec

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

Formats the value using the given formatter.

impl Default for SmallBitVec

fn default() -> Self

Returns the “default value” for a type.

impl Drop for SmallBitVec

fn drop(&mut self)

Executes the destructor for this type.

impl Extend<bool> for SmallBitVec

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<bool> for SmallBitVec

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

Creates a value from an iterator.

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 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 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?

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?

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

Creates an iterator from a value.

impl PartialEq<SmallBitVec> 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