Struct rustc_index::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
.
While it’s possible to use u32
or usize
directly for I
,
you almost certainly want to use a newtype_index!
-generated type instead.
Fields§
§raw: Vec<T>
§_marker: PhantomData<fn(_: &I)>
Implementations§
source§impl<I: Idx, T> IndexVec<I, T>
impl<I: Idx, T> IndexVec<I, T>
pub const fn new() -> Self
pub const fn from_raw(raw: Vec<T>) -> Self
pub fn with_capacity(capacity: usize) -> Self
sourcepub fn from_elem<S>(elem: T, universe: &IndexSlice<I, S>) -> Selfwhere
T: Clone,
pub fn from_elem<S>(elem: T, universe: &IndexSlice<I, S>) -> Selfwhere 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) -> Selfwhere T: Clone,
sourcepub fn from_fn_n(func: impl FnMut(I) -> T, n: 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 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
pub fn pop(&mut self) -> Option<T>
pub fn into_iter(self) -> IntoIter<T>
pub fn into_iter_enumerated( self ) -> impl DoubleEndedIterator<Item = (I, T)> + ExactSizeIterator
pub fn drain<R: RangeBounds<usize>>( &mut self, range: R ) -> impl Iterator<Item = T> + '_
pub fn drain_enumerated<R: RangeBounds<usize>>( &mut self, range: R ) -> impl Iterator<Item = (I, T)> + '_
pub fn shrink_to_fit(&mut self)
pub fn truncate(&mut self, a: usize)
pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T>
sourcepub fn ensure_contains_elem(
&mut self,
elem: I,
fill_value: impl FnMut() -> T
) -> &mut T
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)
Methods from Deref<Target = IndexSlice<I, T>>§
pub fn len(&self) -> usize
pub fn is_empty(&self) -> bool
sourcepub fn next_index(&self) -> I
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<Item = (I, &T)> + ExactSizeIterator + '_
pub fn indices( &self ) -> impl DoubleEndedIterator<Item = I> + ExactSizeIterator + Clone + 'static
pub fn iter_mut(&mut self) -> IterMut<'_, T>
pub fn iter_enumerated_mut( &mut self ) -> impl DoubleEndedIterator<Item = (I, &mut T)> + 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>
sourcepub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &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
.
sourcepub fn pick3_mut(&mut self, a: I, b: I, c: I) -> (&mut T, &mut T, &mut T)
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,
sourcepub fn invert_bijective_mapping(&self) -> IndexVec<J, I>
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>
impl<I: Idx, T> Borrow<IndexSlice<I, T>> for IndexVec<I, T>
source§fn borrow(&self) -> &IndexSlice<I, T>
fn borrow(&self) -> &IndexSlice<I, T>
source§impl<I: Idx, T> BorrowMut<IndexSlice<I, T>> for IndexVec<I, T>
impl<I: Idx, T> BorrowMut<IndexSlice<I, T>> for IndexVec<I, T>
source§fn borrow_mut(&mut self) -> &mut IndexSlice<I, T>
fn borrow_mut(&mut self) -> &mut IndexSlice<I, T>
source§impl<I: Idx, T> Extend<T> for IndexVec<I, T>
impl<I: Idx, T> Extend<T> for IndexVec<I, T>
source§fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J)
fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J)
source§fn extend_one(&mut self, item: T)
fn extend_one(&mut self, item: T)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<I: Idx, T> FromIterator<T> for IndexVec<I, T>
impl<I: Idx, T> FromIterator<T> for IndexVec<I, T>
source§fn from_iter<J>(iter: J) -> Selfwhere
J: IntoIterator<Item = T>,
fn from_iter<J>(iter: J) -> Selfwhere J: IntoIterator<Item = T>,
source§impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T>
impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T>
source§impl<'a, I: Idx, T> IntoIterator for &'a mut IndexVec<I, T>
impl<'a, I: Idx, T> IntoIterator for &'a mut IndexVec<I, T>
source§impl<I: Idx, T> IntoIterator for IndexVec<I, T>
impl<I: Idx, T> IntoIterator for IndexVec<I, T>
source§impl<I: PartialEq + Idx, T: PartialEq> PartialEq<IndexVec<I, T>> for IndexVec<I, T>
impl<I: PartialEq + Idx, T: PartialEq> PartialEq<IndexVec<I, T>> for IndexVec<I, T>
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>
Auto Trait Implementations§
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> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
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