Struct shine_graph::svec::SVector

pub struct SVector<S> where
    S: Store,  { /* fields omitted */ }

Sparse Vector

Methods

impl<S> SVector<S> where
    S: Store, 

pub fn new(mask: VectorMask, store: S) -> Self

pub fn get_mask(&self) -> &VectorMask

Important traits for BitIter<B>

impl<B: BitSetView> Iterator for BitIter<B> type Item = usize;

pub fn mask_iter(&self) -> BitIter<&VectorMask>

pub fn capacity(&self) -> usize

The last known valid index

pub fn nnz(&self) -> usize

pub fn is_zero(&self) -> bool

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

pub fn get_unchecked(&self, idx: usize) -> &S::Item

pub fn get(&self, idx: usize) -> Option<&S::Item>

pub fn first(&self) -> Option<(usize, &S::Item)>

Important traits for DataIter<'a, S>

impl<'a, S> Iterator for DataIter<'a, S> where
    S: 'a + Store,  type Item = &'a S::Item;

pub fn data_iter(&self) -> DataIter<S>

pub fn read(&self) -> WrapRead<S>

impl<S> SVector<S> where
    S: StoreMut, 

pub fn clear(&mut self)

pub fn add(&mut self, idx: usize, value: S::Item) -> Option<S::Item>

pub fn add_with<F: FnOnce() -> S::Item>(
    &mut self,
    idx: usize,
    f: F
) -> Option<S::Item>

pub fn remove(&mut self, idx: usize) -> Option<S::Item>

pub fn get_mut_unchecked(&mut self, idx: usize) -> &mut S::Item

pub fn get_mut(&mut self, idx: usize) -> Option<&mut S::Item>

pub fn get_entry(&mut self, idx: usize) -> Entry<S>

pub fn first_mut(&mut self) -> Option<(usize, &mut S::Item)>

pub fn first_entry(&mut self) -> Option<(usize, Entry<S>)>

Important traits for DataIterMut<'a, S>

impl<'a, S> Iterator for DataIterMut<'a, S> where
    S: 'a + StoreMut,  type Item = &'a mut S::Item;

pub fn data_iter_mut(&mut self) -> DataIterMut<S>

Important traits for DrainIter<'a, S>

impl<'a, S> Iterator for DrainIter<'a, S> where
    S: 'a + StoreMut,  type Item = (usize, &'a mut S::Item);

pub fn drain_iter(&mut self) -> DrainIter<S>

pub fn update(&mut self) -> WrapUpdate<S>

pub fn write(&mut self) -> WrapWrite<S>

impl<T, S> SVector<S> where
    T: Default,
    S: StoreMut<Item = T>, 

pub fn add_default(&mut self, idx: usize) -> Option<S::Item>

Trait Implementations

impl<S> Default for SVector<S> where
    S: Default + Store, 

fn default() -> SVector<S>

Returns the "default value" for a type.

impl<T, S> Debug for SVector<S> where
    T: Debug,
    S: Store<Item = T>, 

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

Formats the value using the given formatter.