Struct TypedBitVec

pub struct TypedBitVec<T: TypedBitElem>(/* private fields */);

TypedBitVec: “Typed Bitwise Vector”

A BitVec where all the data needed to access and translate the generic <T> to and from the expected usize is stored in a monomorphized constant inside the trait TypedBitElem

This is a thin wrapper around RawBitVec that simply calls the underlying raw method and passes the associated BitProto along with it, translating the input type to and from usize according to the specific implementation of TypedBitElem. Unlike RawBitVec this is safe because it is impossible to ever use the wrong BitProto

Pros

• Simpler, safer API than RawBitVec
• Same stack-size as RawBitVec and Vec (3 usize)
• Allows for constant-propogation optimizations
• Values are automatically translated to and from the generic type <T>

Cons

• Every separate value of <T> creates a distinct type with its own copy of all methods (larger binary)
• Cannot store TypedBitVec’s with diferent <T>’s in the same homogenous collection (Array, Vec, HashMap, etc.)
• May require aditional processing to translate the normal usize to and from <T>
• <T> must implement TypedBitElem (simple integer implementations are provided via crate features)

Implementations

impl<T: TypedBitElem> TypedBitVec<T>

pub fn len(&self) -> usize

pub fn cap(&self) -> usize

pub fn free(&self) -> usize

pub fn new() -> Self

pub fn with_capacity(cap: usize) -> Self

pub fn grow_exact_for_additional_elements_if_needed( &mut self, extra_elements: usize, ) -> Result<(), String>

pub fn grow_exact_for_total_elements_if_needed( &mut self, total_elements: usize, ) -> Result<(), String>

pub fn grow_for_additional_elements_if_needed( &mut self, extra_elements: usize, ) -> Result<(), String>

pub fn grow_for_total_elements_if_needed( &mut self, total_elements: usize, ) -> Result<(), String>

pub fn clear(&mut self)

pub fn push(&mut self, val: T::Base) -> Result<(), String>

pub unsafe fn push_unchecked(&mut self, val: T::Base)

pub fn pop(&mut self) -> Result<T::Base, String>

pub unsafe fn pop_unchecked(&mut self) -> T::Base

pub fn insert(&mut self, idx: usize, val: T::Base) -> Result<(), String>

pub unsafe fn insert_unchecked(&mut self, idx: usize, val: T::Base)

pub fn insert_bitvec( &mut self, insert_idx: usize, bitvec: Self, ) -> Result<(), String>

pub unsafe fn insert_bitvec_unchecked( &mut self, insert_idx: usize, bitvec: Self, )

pub fn insert_iter<II, TO, ESI>( &mut self, insert_idx: usize, source: II, ) -> Result<(), String>

where II: IntoIterator<Item = TO, IntoIter = ESI>, TO: ToOwned<Owned = usize>, ESI: ExactSizeIterator + Iterator<Item = TO>,

pub unsafe fn insert_iter_unchecked<II, TO, ESI>( &mut self, insert_idx: usize, source: II, )

where II: IntoIterator<Item = TO, IntoIter = ESI>, TO: ToOwned<Owned = usize>, ESI: ExactSizeIterator + Iterator<Item = TO>,

pub fn remove(&mut self, idx: usize) -> Result<T::Base, String>

pub unsafe fn remove_unchecked(&mut self, idx: usize) -> T::Base

pub fn remove_range(&mut self, idx_range: Range<usize>) -> Result<Self, String>

pub unsafe fn remove_range_unchecked(&mut self, idx_range: Range<usize>) -> Self

pub fn trim_range( &mut self, idx_range: RangeFrom<usize>, ) -> Result<Self, String>

pub unsafe fn trim_range_unchecked( &mut self, idx_range: RangeFrom<usize>, ) -> Self

pub fn swap(&mut self, idx_a: usize, idx_b: usize) -> Result<(), String>

pub unsafe fn swap_unchecked(&mut self, idx_a: usize, idx_b: usize)

pub fn swap_pop(&mut self, idx: usize) -> Result<T::Base, String>

pub unsafe fn swap_pop_unchecked(&mut self, idx: usize) -> T::Base

pub fn trim_excess_capacity( &mut self, extra_capacity_to_keep: usize, ) -> Result<(), String>

pub fn append_bitvec(&mut self, bitvec: Self) -> Result<(), String>

pub unsafe fn append_bitvec_unchecked(&mut self, bitvec: Self)

pub fn append_iter<II, TO, ESI>(&mut self, source: II) -> Result<(), String>

where II: IntoIterator<Item = TO, IntoIter = ESI>, TO: ToOwned<Owned = T::Base>, ESI: ExactSizeIterator + Iterator<Item = TO>,

pub unsafe fn append_iter_unchecked<I, TO>(&mut self, iter: I)

where I: Iterator<Item = TO> + ExactSizeIterator, TO: ToOwned<Owned = T::Base>,

pub fn get(&self, idx: usize) -> Result<T::Base, String>

pub unsafe fn get_unchecked(&self, idx: usize) -> T::Base

pub fn replace(&mut self, idx: usize, val: T::Base) -> Result<T::Base, String>

pub unsafe fn replace_unchecked(&mut self, idx: usize, val: T::Base) -> T::Base

pub fn set(&mut self, idx: usize, val: T::Base) -> Result<(), String>

pub unsafe fn set_unchecked(&mut self, idx: usize, val: T::Base)

pub fn discard_from_end(&mut self, count: usize)

pub fn drain<'vec>(&'vec mut self) -> TypedBitVecDrain<'vec, T>

pub unsafe fn into_raw(self) -> RawBitVec

Trait Implementations

impl<T: TypedBitElem> Drop for TypedBitVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: TypedBitElem> IntoIterator for TypedBitVec<T>

type Item = <T as TypedBitElem>::Base

The type of the elements being iterated over.

type IntoIter = TypedBitVecIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.