Struct Vector

pub struct Vector<I, T>
where
    I: Idx,
{
    vector: IndexVec<I, Option<T>>,
    elem_count: usize,
}

Indexed vector. To prevent accidental id reuse, the vector supports reserving a slot to be filled later.

Fields

vector: IndexVec<I, Option<T>>

elem_count: usize

The number of non-None elements.

Implementations

impl<I, T> Vector<I, T>

where I: Idx,

pub fn new() -> Self

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

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

pub fn is_empty(&self) -> bool

pub fn elem_count(&self) -> usize

The number of elements stored in the vector.

pub fn slot_count(&self) -> usize

The number of slots allocated in the vector (empty or not).

pub fn next_id(&self) -> I

Gets the value of the next available id. Avoid if possible; use reserve_slot instead.

pub fn reserve_slot(&mut self) -> I

Reserve a spot in the vector.

pub fn set_slot(&mut self, id: I, x: T)

Fill the reserved slot.

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

Remove the value from this slot.

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

pub fn push_with(&mut self, f: impl FnOnce(I) -> T) -> I

pub fn push_all<It>( &mut self, it: It, ) -> impl Iterator<Item = I> + use<'_, I, T, It>

where It: Iterator<Item = T>,

pub fn extend<It>(&mut self, it: It)

where It: Iterator<Item = T>,

pub fn extend_from_slice(&mut self, other: &Self)

where T: Clone,

pub fn get_or_extend_and_insert( &mut self, id: I, f: impl FnOnce() -> T, ) -> &mut T

Get a mutable reference into the ith element. If the vector is too short, extend it until it has enough elements. If the element doesn’t exist, use the provided function to initialize it.

pub fn map<U>(self, f: impl FnMut(T) -> U) -> Vector<I, U>

Map each entry to a new one, keeping the same ids.

pub fn map_ref<'a, U>(&'a self, f: impl FnMut(&'a T) -> U) -> Vector<I, U>

Map each entry to a new one, keeping the same ids.

pub fn map_ref_mut<'a, U>( &'a mut self, f: impl FnMut(&'a mut T) -> U, ) -> Vector<I, U>

Map each entry to a new one, keeping the same ids.

pub fn map_ref_indexed<'a, U>( &'a self, f: impl FnMut(I, &'a T) -> U, ) -> Vector<I, U>

Map each entry to a new one, keeping the same ids.

pub fn map_opt<U>(self, f: impl FnMut(Option<T>) -> Option<U>) -> Vector<I, U>

Map each entry to a new one, keeping the same ids. Includes empty slots.

pub fn map_ref_opt<'a, U>( &'a self, f: impl FnMut(Option<&'a T>) -> Option<U>, ) -> Vector<I, U>

Map each entry to a new one, keeping the same ids. Includes empty slots.

pub fn iter(&self) -> impl Iterator<Item = &T> + DoubleEndedIterator + Clone

Iter over the nonempty slots.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> + DoubleEndedIterator

pub fn iter_indexed(&self) -> impl Iterator<Item = (I, &T)>

pub fn iter_mut_indexed(&mut self) -> impl Iterator<Item = (I, &mut T)>

pub fn into_iter_indexed(self) -> impl Iterator<Item = (I, T)>

pub fn iter_indexed_values(&self) -> impl Iterator<Item = (I, &T)>

pub fn into_iter_indexed_values(self) -> impl Iterator<Item = (I, T)>

pub fn iter_all_slots(&self) -> impl Iterator<Item = &Option<T>>

Iterate over all slots, even empty ones.

pub fn iter_indexed_all_slots(&self) -> impl Iterator<Item = (I, &Option<T>)>

pub fn iter_indices(&self) -> impl Iterator<Item = I> + '_

pub fn all_indices(&self) -> impl Iterator<Item = I>

pub fn split_off(&mut self, at: usize) -> Self

Like Vec::split_off.

Trait Implementations

impl<I: Idx, T: AstVisitable> AstVisitable for Vector<I, T>

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn name(&self) -> &'static str

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

Visit all occurrences of that type inside self, in pre-order traversal.

impl<I: Idx, T: BodyVisitable> BodyVisitable for Vector<I, T>

fn drive_body<V: VisitBody>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_body_mut<V: VisitBodyMut>( &mut self, v: &mut V, ) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn dyn_visit_in_body<T: BodyVisitable>(&self, f: impl FnMut(&T))

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_in_body_mut<T: BodyVisitable>(&mut self, f: impl FnMut(&mut T))

Visit all occurrences of that type inside self, in pre-order traversal.

impl<I, T: Clone> Clone for Vector<I, T>

where I: Idx + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, T: Debug> Debug for Vector<I, T>

where I: Idx + Debug,

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, I: Idx, T: Deserialize<'de>> Deserialize<'de> for Vector<I, T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'s, I: Idx, T, V: Visit<'s, T>> Drive<'s, V> for Vector<I, T>

fn drive_inner(&'s self, v: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, I: Idx, T, V: VisitMut<'s, T>> DriveMut<'s, V> for Vector<I, T>

fn drive_inner_mut(&'s mut self, v: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'a> Formatter<&Vector<BlockId, BlockData>> for FmtCtx<'a>

fn format_object(&self, x: &Vector<BlockId, BlockData>) -> String

impl<I, T> From<Vec<T>> for Vector<I, T>

where I: Idx,

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

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

where I: Idx,

fn from_iter<It: IntoIterator<Item = T>>(iter: It) -> Vector<I, T>

Creates a value from an iterator.

impl<I, T: Hash> Hash for Vector<I, T>

where I: Idx + Hash,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, R, T> Index<R> for Vector<I, T>

where I: Idx, R: IdxSliceIndex<I, Option<T>, Output = Option<T>>,

type Output = T

The returned type after indexing.

fn index(&self, index: R) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I, R, T> IndexMut<R> for Vector<I, T>

where I: Idx, R: IdxSliceIndex<I, Option<T>, Output = Option<T>>,

fn index_mut(&mut self, index: R) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

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

where I: Idx,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = impl Iterator<Item = &'a T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

where I: Idx,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = impl Iterator<Item = &'a mut T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

where I: Idx,

type Item = T

The type of the elements being iterated over.

type IntoIter = impl Iterator<Item = T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I, T: Ord> Ord for Vector<I, T>

where I: Idx + Ord,

fn cmp(&self, other: &Vector<I, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<I, T: PartialEq> PartialEq for Vector<I, T>

where I: Idx + PartialEq,

fn eq(&self, other: &Vector<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<I, T: PartialOrd> PartialOrd for Vector<I, T>

where I: Idx + PartialOrd,

fn partial_cmp(&self, other: &Vector<I, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I: Idx, T: Serialize> Serialize for Vector<I, T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<I, T: Eq> Eq for Vector<I, T>

where I: Idx + Eq,

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

where I: Idx,