Struct IndexVec

#[repr(transparent)]
pub struct IndexVec<I, T>
where
    I: Idx,
{
    pub raw: Vec<T>,
    _marker: PhantomData<fn(_: &I)>,
}

An owned contiguous collection of Ts, indexed by I rather than by usize.

Why use this instead of a Vec?

An IndexVec allows element access only via a specific associated index type, meaning that trying to use the wrong index type (possibly accessing an invalid element) will fail at compile time.

It also documents what the index is indexing: in a HashMap<usize, Something> it’s not immediately clear what the usize means, while a HashMap<FieldIdx, Something> makes it obvious.

use rustc_index::{Idx, IndexVec};

fn f<I1: Idx, I2: Idx>(vec1: IndexVec<I1, u8>, idx1: I1, idx2: I2) {
  &vec1[idx1]; // Ok
  &vec1[idx2]; // Compile error!
}

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>

_marker: PhantomData<fn(_: &I)>

Implementations

impl<I, T> IndexVec<I, T>

where I: Idx,

pub const fn new() -> IndexVec<I, T>

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

pub const fn from_raw(raw: Vec<T>) -> IndexVec<I, T>

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

pub fn with_capacity(capacity: usize) -> IndexVec<I, T>

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

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.

pub fn from_elem_n(elem: T, n: usize) -> IndexVec<I, T>

where T: Clone,

Creates a new IndexVec with n copies of the elem.

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

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 as_slice(&self) -> &IndexSlice<I, T>

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

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

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

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

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

pub fn into_iter_enumerated( self, ) -> impl DoubleEndedIterator + ExactSizeIterator

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

where R: RangeBounds<usize>,

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

where R: RangeBounds<usize>,

pub fn shrink_to_fit(&mut self)

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

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.

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

where T: Clone,

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

pub fn append(&mut self, other: &mut IndexVec<I, T>)

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

where I: Idx,

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

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

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

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

pub fn contains(&self, index: I) -> bool

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

pub fn iter_enumerated(&self) -> impl DoubleEndedIterator + ExactSizeIterator

pub fn indices( &self, ) -> impl DoubleEndedIterator + ExactSizeIterator + Clone + 'static

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

pub fn iter_enumerated_mut( &mut self, ) -> impl DoubleEndedIterator + ExactSizeIterator

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

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

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

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

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.

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.

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

where T: Ord,

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.

Trait Implementations

impl<'tcx> ArenaAllocatable<'tcx> for IndexVec<Promoted, Body<'tcx>>

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut IndexVec<Promoted, Body<'tcx>>

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = IndexVec<Promoted, Body<'tcx>>>, ) -> &'tcx mut [IndexVec<Promoted, Body<'tcx>>]

impl<I, T> Borrow<IndexSlice<I, T>> for IndexVec<I, T>

where I: Idx,

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

Immutably borrows from an owned value.

impl<I, T> BorrowMut<IndexSlice<I, T>> for IndexVec<I, T>

where I: Idx,

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

Mutably borrows from an owned value.

impl<I, T> Clone for IndexVec<I, T>

where I: Clone + Idx, T: Clone,

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, T> Debug for IndexVec<I, T>

where I: Idx, T: Debug,

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

Formats the value using the given formatter.

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx IndexVec<Promoted, Body<'tcx>>

fn decode( d: &mut CacheDecoder<'a, 'tcx>, ) -> &'tcx IndexVec<Promoted, Body<'tcx>>

impl<D, I, T> Decodable<D> for IndexVec<I, T>

where D: Decoder, I: Idx, T: Decodable<D>,

fn decode(d: &mut D) -> IndexVec<I, T>

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

where I: Idx,

fn default() -> IndexVec<I, T>

Returns the “default value” for a type.

impl<I, T> Deref for IndexVec<I, T>

where I: Idx,

type Target = IndexSlice<I, T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<I, T> DerefMut for IndexVec<I, T>

where I: Idx,

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

Mutably dereferences the value.

impl<S, I, T> Encodable<S> for IndexVec<I, T>

where S: Encoder, I: Idx, T: Encodable<S>,

fn encode(&self, s: &mut S)

impl<I, T> Extend<T> for IndexVec<I, T>

where I: Idx,

fn extend<J>(&mut self, iter: J)

where J: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<I, T, const N: usize> From<[T; N]> for IndexVec<I, T>

where I: Idx,

fn from(array: [T; N]) -> IndexVec<I, T>

Converts to this type from the input type.

impl<I, T> FromIterator<T> for IndexVec<I, T>

where I: Idx,

fn from_iter<J>(iter: J) -> IndexVec<I, T>

where J: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'tcx> HasLocalDecls<'tcx> for IndexVec<Local, LocalDecl<'tcx>>

fn local_decls(&self) -> &IndexSlice<Local, LocalDecl<'tcx>>

impl<I, T> Hash for IndexVec<I, T>

where I: Hash + Idx, T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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, T, CTX> HashStable<CTX> for IndexVec<I, T>

where I: Idx, T: HashStable<CTX>,

fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher<SipHasher128>)

impl<'a, I, T> IntoIterator for &'a IndexVec<I, T>

where I: Idx,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, I, T> IntoIterator for &'a mut IndexVec<I, T>

where I: Idx,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<I, T> IntoIterator for IndexVec<I, T>

where I: Idx,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<I, T> ParameterizedOverTcx for IndexVec<I, T>

where I: Idx + 'static, T: ParameterizedOverTcx,

type Value<'tcx> = IndexVec<I, <T as ParameterizedOverTcx>::Value<'tcx>>

impl<I, T> PartialEq for IndexVec<I, T>

where I: PartialEq + Idx, T: PartialEq,

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<'tcx, D> RefDecodable<'tcx, D> for IndexVec<Promoted, Body<'tcx>>

where D: TyDecoder<I = TyCtxt<'tcx>>,

fn decode(decoder: &mut D) -> &'tcx IndexVec<Promoted, Body<'tcx>>

impl<I, T, Ix> TypeFoldable<I> for IndexVec<Ix, T>

where I: Interner, T: TypeFoldable<I>, Ix: Idx,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<IndexVec<Ix, T>, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<I, T, Ix> TypeVisitable<I> for IndexVec<Ix, T>

where I: Interner, T: TypeVisitable<I>, Ix: Idx,

fn visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Result

where V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<I, T> Eq for IndexVec<I, T>

where I: Eq + Idx, T: Eq,

impl<I, T> Send for IndexVec<I, T>

where I: Idx, T: Send,

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

where I: Idx,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes