Struct LowMap 

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

A convenient wrapper around a Vec<Option<T>>.

It is called a LowMap because it maps a given index to a value, and this index must be small as it will be used as the inner Vec index.

let mut map = LowMap::new();
map.insert(0, "hey");
map.insert(2, "hoy");
map.insert(3, "foo");
map.insert(2, "bar");

assert_eq!(map.get(0), Some(&"hey"));
assert_eq!(map.get(1), None);
assert_eq!(map.get(2), Some(&"bar"));
assert_eq!(map.get(3), Some(&"foo"));

map[2] = "hoho";
assert_eq!(map.get(2), Some(&"hoho"));

Implementations

impl<T> LowMap<T>

pub fn new() -> Self

Constructs a new empty LowMap<T>.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new empty LowMap<T> with the given capacity.

pub fn len(&self) -> usize

Returns the number of stored elements.

pub fn capacity(&self) -> usize

Returns the capacity.

pub fn insert(&mut self, index: usize, value: T) -> Option<T>

Inserts an element at position index within the vector, returning the previous value if present.

pub fn stack_insert(&mut self, index: usize, value: T) -> StackInsert<'_, T>

Constructs a wrapper that temporarily inserts an element.

The returned wrapper will undo the insert when dropped.

pub fn remove(&mut self, index: usize) -> Option<T>

Removes and returns the element at position index if present.

pub fn get(&self, index: usize) -> Option<&T>

Returns a reference to the element at position index if present.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at position index if present.

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

Tests whether an element is present at position index or not.

pub fn push(&mut self, elem: T) -> usize

Finds the first free index to store the given elem.

Has a maxium complexity of O(n).

pub fn values(&self) -> Values<'_, T>

Returns an iterator over the value of stored elements.

pub fn values_mut(&mut self) -> ValuesMut<'_, T>

Returns a mutable iterator over the value of stored elements.

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

Returns an iterator over the index and value of stored elements.

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

Returns a mutable iterator over the index and value of stored elements.

pub fn indexes(&self) -> Indexes<'_, T>

Returns an iterator over the index of stored elements.

pub fn as_slice(&self) -> &[Option<T>]

Returns the wrapped vec as a slice.

Trait Implementations

impl<T: Clone> Clone for LowMap<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for LowMap<T>

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

Formats the value using the given formatter.

impl<T> Default for LowMap<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Extend<(usize, T)> for LowMap<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (usize, T)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬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<T> From<LowMap<T>> for Vec<Option<T>>

fn from(_: LowMap<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<Option<T>>> for LowMap<T>

fn from(vec: Vec<Option<T>>) -> Self

Converts to this type from the input type.

impl<T> FromIterator<(usize, T)> for LowMap<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (usize, T)>,

Creates a value from an iterator.

impl<T> Index<usize> for LowMap<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for LowMap<T>

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

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

impl<T> IntoIterator for LowMap<T>

type Item = (usize, 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) -> Self::IntoIter

Creates an iterator from a value.