Struct grit_bitvec::BitVec

pub struct BitVec<ELEM>where
    ELEM: BitElem,{ /* private fields */ }

Implementations

impl<ELEM> BitVec<ELEM>where ELEM: BitElem,

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) -> Result<Self, String>

pub fn grow_if_needed(&mut self, elem_count: ElementCount) -> Result<(), String>

pub fn grow_if_needed_custom( &mut self, elem_count: ElementCount, grow: Grow ) -> Result<(), String>

pub fn clear(&mut self)

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

pub fn push_custom_grow( &mut self, val: ELEM::Base, grow: Grow ) -> Result<(), String>

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

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

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

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

pub fn insert_custom_grow( &mut self, idx: usize, val: ELEM::Base, grow: Grow ) -> Result<(), String>

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

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

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

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<ELEM::Base, String>

pub unsafe fn swap_pop_unchecked(&mut self, idx_a: usize) -> ELEM::Base

pub fn shrink(&mut self, shrink: Shrink) -> Result<(), String>

pub fn set_exact_capacity(&mut self, new_cap: usize) -> Result<(), String>

pub fn append<II>(&mut self, source: II) -> Result<(), String>where II: IntoIterator<Item = ELEM::Base>,

pub fn append_custom_grow<II>( &mut self, source: II, grow: Grow ) -> Result<(), String>where II: IntoIterator<Item = ELEM::Base>,

pub fn clone_val(&self, idx: usize) -> Result<ELEM::Base, String>where ELEM::Base: Clone,

pub unsafe fn clone_val_unchecked(&self, idx: usize) -> ELEM::Basewhere ELEM::Base: Clone,

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

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

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

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

pub fn drain<'vec>(&'vec mut self) -> BVecDrain<'vec, ELEM>

Trait Implementations

impl<ELEM> IntoIterator for BitVec<ELEM>where ELEM: BitElem,

type Item = <ELEM as BitElem>::Base

The type of the elements being iterated over.

type IntoIter = BVecIter<ELEM>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.