Struct rustc_index::vec::IndexVec

pub struct IndexVec<I: Idx, T> {
    pub raw: Vec<T>,
    _marker: PhantomData<fn(_: &I)>,
}

Fields

raw: Vec<T>

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

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_elem<S>(elem: T, universe: &IndexVec<I, S>) -> Self where
    T: Clone, 

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

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 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 or panics otherwise.

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)

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

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

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

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

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

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

Formats the value using the given formatter.

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

fn decode(d: &mut D) -> Result<Self, D::Error>

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

fn default() -> Self

Returns the “default value” for a type.

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

fn encode(&self, s: &mut S) -> Result<(), S::Error>

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

fn encode(&self, s: &mut S) -> Result<(), S::Error>

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

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

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: Idx, T> FromIterator<T> for IndexVec<I, T>

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

Creates a value from an iterator.

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, 

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: Idx, T> IntoIterator for IndexVec<I, T>

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<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T>

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: Idx, T> IntoIterator for &'a mut IndexVec<I, T>

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: PartialEq + Idx, T: PartialEq> PartialEq<IndexVec<I, T>> for IndexVec<I, T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

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

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

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

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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