Struct ra_ap_rustc_index::IndexVec

source ·

#[repr(transparent)]
pub struct IndexVec<I: Idx, T> {
    pub raw: Vec<T>,
    /* private fields */
}

Expand description

An owned contiguous collection of Ts, indexed by I rather than by usize. Its purpose is to avoid mixing indexes.

While it’s possible to use u32 or usize directly for I, you almost certainly want to use a newtype_index!-generated type instead.

This allows to index the IndexVec with the new index type.

Fields§

§raw: Vec<T>

Implementations§

source §

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

source

pub const fn new() -> Self

Constructs a new, empty IndexVec<I, T>.

source

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

Constructs a new IndexVec<I, T> from a Vec<T>.

source

pub fn with_capacity(capacity: usize) -> Self

source

pub fn from_elem<S>(elem: T, universe: &IndexSlice<I, S>) -> Self
where T: Clone,

Creates a new vector with a copy of elem for each index in universe.

Thus IndexVec::from_elem(elem, &universe) is equivalent to IndexVec::<I, _>::from_elem_n(elem, universe.len()). That can help type inference as it ensures that the resulting vector uses the same index type as universe, rather than something potentially surprising.

For example, if you want to store data for each local in a MIR body, using let mut uses = IndexVec::from_elem(vec![], &body.local_decls); ensures that uses is an IndexVec<Local, _>, and thus can give better error messages later if one accidentally mismatches indices.

source

pub fn from_elem_n(elem: T, n: usize) -> Self
where T: Clone,

Creates a new IndexVec with n copies of the elem.

source

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.)

source

pub fn as_slice(&self) -> &IndexSlice<I, T>

source

pub fn as_mut_slice(&mut self) -> &mut IndexSlice<I, T>

source

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

Pushes an element to the array returning the index where it was pushed to.

source

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

source

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

source

pub fn into_iter_enumerated( self ) -> impl DoubleEndedIterator<Item = (I, T)> + ExactSizeIterator

source

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

source

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

source

pub fn shrink_to_fit(&mut self)

source

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

source

pub fn ensure_contains_elem( &mut self, elem: I, fill_value: impl FnMut() -> T ) -> &mut 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.

Returns a reference to the elem entry.

source

pub fn resize(&mut self, new_len: usize, value: T)
where T: Clone,

source

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

source §

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

IndexVec is often used as a map, so it provides some map-like APIs.

source

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

source

pub fn get_or_insert_with( &mut self, index: I, value: impl FnOnce() -> T ) -> &mut T

source

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

Methods from Deref<Target = IndexSlice<I, T>>§

source

pub fn len(&self) -> usize

source

pub fn is_empty(&self) -> bool

source

pub fn next_index(&self) -> I

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

Manual bounds checks can be done using idx < slice.next_index() (as opposed to idx.index() < slice.len()).

source

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

source

pub fn iter_enumerated( &self ) -> impl DoubleEndedIterator<Item = (I, &T)> + ExactSizeIterator + '_

source

pub fn indices( &self ) -> impl DoubleEndedIterator<Item = I> + ExactSizeIterator + Clone + 'static

source

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

source

pub fn iter_enumerated_mut( &mut self ) -> impl DoubleEndedIterator<Item = (I, &mut T)> + ExactSizeIterator + '_

source

pub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &mut T)

Returns mutable references to two distinct elements, a and b.

Panics if a == b.

source

pub fn pick3_mut(&mut self, a: I, b: I, c: I) -> (&mut T, &mut T, &mut T)

Returns mutable references to three distinct elements.

Panics if the elements are not distinct.

source

pub fn binary_search(&self, value: &T) -> Result<I, I>
where T: Ord,

source

pub fn invert_bijective_mapping(&self) -> IndexVec<J, I>

Invert a bijective mapping, i.e. invert(map)[y] = x if map[x] = y, assuming the values in self are a permutation of 0..self.len().

This is used to go between memory_index (source field order to memory order) and inverse_memory_index (memory order to source field order). See also FieldsShape::Arbitrary::memory_index for more details.