Struct IndexVec

pub struct IndexVec<I: Idx, T> {
    pub raw: Vec<T>,
    /* private fields */
}

Fields

raw: Vec<T>

Implementations

impl<I: Idx, T> IndexVec<I, T>

pub fn new() -> Self

pub fn from_raw(raw: Vec<T>) -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn from_fn_n(func: impl FnMut(I) -> T, n: usize) -> Self

Create an IndexVec with n elements, where the value of each element is the result of func(i). (The underlying vector will be allocated only once, with a capacity of at least n.)

pub fn push(&mut self, d: T) -> I

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

pub fn len(&self) -> usize

pub fn next_index(&self) -> I

Gives the next index that will be assigned when push is called.

pub fn is_empty(&self) -> bool

pub fn into_iter(self) -> IntoIter<T>

pub fn into_iter_enumerated(self) -> Enumerated<I, IntoIter<T>>

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

pub fn iter_enumerated(&self) -> Enumerated<I, Iter<'_, T>>

pub fn indices(&self) -> Map<Range<usize>, IntoIdx<I>>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

pub fn iter_enumerated_mut(&mut self) -> Enumerated<I, IterMut<'_, T>>

pub fn drain<'a, R: RangeBounds<usize>>( &'a mut self, range: R, ) -> impl Iterator<Item = T> + 'a

pub fn drain_enumerated<'a, R: RangeBounds<usize>>( &'a mut self, range: R, ) -> impl Iterator<Item = (I, T)> + 'a

pub fn last(&self) -> Option<I>

pub fn shrink_to_fit(&mut self)

pub fn swap(&mut self, a: I, b: I)

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

pub fn get(&self, index: I) -> Option<&T>

pub fn get_mut(&mut self, index: I) -> Option<&mut T>

pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T>

pub fn ensure_contains_elem(&mut self, elem: I, fill_value: impl FnMut() -> T)

Grows the index vector so that it contains an entry for elem; if that is already true, then has no effect. Otherwise, inserts new values as needed by invoking fill_value.

pub fn resize_to_elem(&mut self, elem: I, fill_value: impl FnMut() -> T)

Trait Implementations

impl<I: Clone + Idx, T: Clone> Clone for IndexVec<I, T>

fn clone(&self) -> IndexVec<I, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Idx, T: Debug> Debug for IndexVec<I, T>

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

Formats the value using the given formatter.

impl<I: Idx, T> Default for IndexVec<I, T>

fn default() -> Self

Returns the “default value” for a type.

impl<I: Hash + Idx, T: Hash> Hash for IndexVec<I, T>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: Idx, T> Index<I> for IndexVec<I, T>

type Output = T

The returned type after indexing.

fn index(&self, index: I) -> &T

Performs the indexing (container[index]) operation.

impl<I: Idx, T> IndexMut<I> for IndexVec<I, T>

fn index_mut(&mut self, index: I) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<I: PartialEq + Idx, T: PartialEq> PartialEq for IndexVec<I, T>

fn eq(&self, other: &IndexVec<I, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Eq + Idx, T: Eq> Eq for IndexVec<I, T>

impl<I: Idx, T> StructuralPartialEq for IndexVec<I, T>