Struct slotmapvec::SlotMapVec

pub struct SlotMapVec<T> { /* private fields */ }

Slot map: array storage with persistent indices

See module documentation for more details.

Implementations

impl<T> SlotMapVec<T>

pub fn new() -> SlotMapVec<T>

Construct a new, empty SlotMapVec.

The function does not allocate.

Examples

let slotmap :SlotMapVec<i32> = SlotMapVec::new();

pub fn with_capacity(capacity: usize) -> SlotMapVec<T>

Construct a new SlotMapVec with the specified capacity.

pub fn capacity(&self) -> usize

Returns the number of values the map can store without reallocating.

pub fn len(&self) -> usize

Returns the number of stored values.

pub fn is_empty(&self) -> bool

Returns true if no values are stored in the map.

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

Return an iterator over all elements of the map along with their index.

Examples

let mut map = SlotMapVec::new();

for i in 0..3 {
  map.insert(i);
}

let mut i = 0;
for (idx,val) in map.iter() {
  assert_eq!(*val, i);
  i += 1;
}

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

Return an iterator over mutable references to all elements of the map along with their index.

Examples

let mut map = SlotMapVec::new();

for i in 0..3 {
  map.insert(i);
}

let mut i = 0;
for (idx,val) in map.iter_mut() {
  *val *= 2;
  assert_eq!(*val, i);
  i += 2;
}

pub fn get(&self, key: SlotMapIndex) -> Option<&T>

Returns a reference to the value associated with the given key.

If the given key is not associated with a values, then None is returned.

pub fn get_mut(&mut self, key: SlotMapIndex) -> Option<&mut T>

Returns a mutable reference to the value associated with the given key.

If the given key is not associated with a values, then None is returned.

pub fn insert(&mut self, val: T) -> SlotMapIndex

Insert a value into the map, returning the index to the value.

The returned index will always refer uniquely to the inserted value (though it may be mutated), even after objects have been deleted and inserted into the same storage slot.

Examples

let mut map = SlotMapVec::new();
let key = map.insert("hello");
assert_eq!(map[key], "hello");

pub fn remove(&mut self, key: SlotMapIndex) -> Option<T>

Removes and returs the value associated with the given key.

The key is never reused in this map, except if the underlying storage type overflows.

pub fn contains(&self, key: SlotMapIndex) -> bool

Return true if a value is associated with the given key.

Trait Implementations

impl<T: Clone> Clone for SlotMapVec<T>

fn clone(&self) -> SlotMapVec<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SlotMapVec<T>

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

Formats the value using the given formatter.

impl<T> Default for SlotMapVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Index<SlotMapIndex> for SlotMapVec<T>

type Output = T

The returned type after indexing.

fn index(&self, key: SlotMapIndex) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<SlotMapIndex> for SlotMapVec<T>

fn index_mut(&mut self, key: SlotMapIndex) -> &mut T

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

impl<'a, T> IntoIterator for &'a SlotMapVec<T>

type Item = (SlotMapIndex, &'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, T> IntoIterator for &'a mut SlotMapVec<T>

type Item = (SlotMapIndex, &'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.