## IndexVec

# Struct IndexVec

Source

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

Expand description

An owned contiguous collection of `T`s, 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§

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

#### pub fn append(&mut self, other: &mut Self)

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>

Source

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

## 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 last_index(&self) -> Option<I>

Source

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

Source

#### pub fn copy_within( &mut self, src: impl IntoSliceIdx<I, [T], Output: RangeBounds<usize>>, dest: I, )
where T: Copy,

Source

#### pub fn get<R: IntoSliceIdx<I, [T]>>( &self, index: R, ) -> Option<&<<R as IntoSliceIdx<I, [T]>>::Output as SliceIndex<[T]>>::Output>

Source

#### pub fn get_mut<R: IntoSliceIdx<I, [T]>>( &mut self, index: R, ) -> Option<&mut <<R as IntoSliceIdx<I, [T]>>::Output as SliceIndex<[T]>>::Output>

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` or if some of them are out of bounds.

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 or if some of them are out of bounds.

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.

## Trait Implementations§

Source§

### impl<I: Idx, T> Borrow<IndexSlice<I, T>> for IndexVec<I, T>

Source§

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

Immutably borrows from an owned value. Read more
Source§

### impl<I: Idx, T> BorrowMut<IndexSlice<I, T>> for IndexVec<I, T>

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

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

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl<D: Decoder, I: Idx, T: Decodable<D>> Decodable<D> for IndexVec<I, T>

Available on crate feature `nightly` only.
Source§

#### fn decode(d: &mut D) -> Self

Source§

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

Source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
Source§

### impl<I: Idx, T> Deref for IndexVec<I, T>

Source§

#### type Target = IndexSlice<I, T>

The resulting type after dereferencing.
Source§

#### fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

### impl<I: Idx, T> DerefMut for IndexVec<I, T>

Source§

#### fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

### impl<S: Encoder, I: Idx, T: Encodable<S>> Encodable<S> for IndexVec<I, T>

Available on crate feature `nightly` only.
Source§

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

Source§

### impl<I: Idx, T> Extend<T> for IndexVec<I, T>

Source§

#### fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J)

Extends a collection with the contents of an iterator. Read more
Source§

#### fn extend_one(&mut self, item: T)

🔬This is a nightly-only experimental API. (`extend_one`)
Extends a collection with exactly one element.
Source§

#### 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. Read more
Source§

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

Source§

#### fn from(array: [T; N]) -> Self

Converts to this type from the input type.
Source§

### impl<I: Idx, T> FromIterator<T> for IndexVec<I, T>

Source§

#### fn from_iter<J>(iter: J) -> Self
where J: IntoIterator<Item = T>,

Creates a value from an iterator. Read more
Source§

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

Source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · Source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
Source§

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

Source§

#### type Item = &'a T

The type of the elements being iterated over.
Source§

#### type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?
Source§

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

Creates an iterator from a value. Read more
Source§

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

Source§

#### type Item = &'a mut T

The type of the elements being iterated over.
Source§

#### type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?
Source§

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

Creates an iterator from a value. Read more
Source§

### impl<I: Idx, T> IntoIterator for IndexVec<I, T>

Source§

#### type Item = T

The type of the elements being iterated over.
Source§

#### type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
Source§

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

Creates an iterator from a value. Read more
Source§

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

Source§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

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

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

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

Source§

### impl<I: Idx, T> Send for IndexVec<I, T>
where T: Send,

Source§

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

## Auto Trait Implementations§

§

### impl<I, T> Freeze for IndexVec<I, T>

§

### impl<I, T> RefUnwindSafe for IndexVec<I, T>
where T: RefUnwindSafe,

§

### impl<I, T> Sync for IndexVec<I, T>
where T: Sync,

§

### impl<I, T> Unpin for IndexVec<I, T>
where T: Unpin,

§

### impl<I, T> UnwindSafe for IndexVec<I, T>
where T: UnwindSafe,

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

#### type Target = T

🔬This is a nightly-only experimental API. (`arbitrary_self_types`)
The target type on which the method may be called.
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

## 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