Struct VecMap

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

An associative array that uses a Vec of Options to map usize keys to elements.

Implementations

impl<T> VecMap<T>

pub fn new() -> Self

Constructs a new, empty VecMap. It will not allocate until elements are pushed onto it.

Examples

let map = VecMap::<()>::new();

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

Examples

let mut map = VecMap::<()>::new();
assert_eq!(map.capacity(), 0);
map.reserve(10);
assert!(map.capacity() >= 10);

pub fn len(&self) -> usize

Returns the number of elements in the map, also referred to as its ‘length’.

Examples

let mut map = VecMap::<()>::new();
assert_eq!(map.len(), 0);
map.insert(1, ());
assert_eq!(map.len(), 1);

pub fn clear(&mut self)

Clears the map, removing all values. Note that this method has no effect on the allocated capacity of the map.

Examples

let mut map = VecMap::<()>::new();
map.insert(1, ());
map.clear();
assert_eq!(map.len(), 0);

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in this map. The collection may reserve more space to avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the capacity overflows.

Examples

let mut map = VecMap::<()>::new();
map.reserve(10);
assert!(map.capacity() >= 10);

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

Returns a reference to the value corresponding to the index i .

Examples

let mut map = VecMap::<i32>::new();
let idx = 2;
map.insert(idx, 123);
assert_eq!(map.get(idx), Some(&123));
assert!(map.get(3).is_none());

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

Returns a mutable reference to the value corresponding to the index i .

Examples

let mut map = VecMap::<i32>::new();
let idx = 1;
map.insert(idx, 123);
*map.get_mut(idx).unwrap() += 1;
assert_eq!(map.get(idx), Some(&124));

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

Inserts value into the map, allocating more capacity if necessary. The existing key-value in the map is returned.

Panics

Panics if the capacity overflows.

Examples

let mut map = VecMap::<i32>::new();
let idx = 1;
assert!(map.insert(idx, 123).is_none());
assert_eq!(map.insert(idx, 456), Some(123));
assert!(map.insert(0, 123).is_none());
assert_eq!(map.get(idx), Some(&456));

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

Removes and returns the element at index i from the map if exists.

Examples

let mut map = VecMap::<i32>::new();
map.insert(1, 123);
assert_eq!(map.remove(1), Some(123));
assert_eq!(map.remove(1), None);

pub fn retain(&mut self, f: impl FnMut(usize, &mut T) -> bool)

Retains only the elements specified by the predicate, passing a mutable reference to it. In other words, removes all elements such that f(index, &value) returns false.

Examples

let mut map = VecMap::<i32>::new();
map.insert(1, 1);
map.insert(0, 2);
map.retain(|_, val| { if *val == 1 { *val = 3; true } else { false } });
assert_eq!(map.get(1), Some(&3));
assert_eq!(map.len(), 1);

pub fn iter( &self, ) -> FilterMap<Enumerate<Iter<'_, Option<T>>>, fn((usize, &Option<T>)) -> Option<(usize, &T)>>

Returns an iterator over this map.

Examples

let mut map = VecMap::<usize>::new();
for i in 0..10 {
    map.insert(i * 2, i * 2);
}

let mut count = 0;
for (i, value) in map.iter() {
    assert_eq!(i, count * 2);
    count += 1;
}
assert_eq!(count, 10);

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

Returns an iterator that allows modifying each value over this map.

Examples

let mut map = VecMap::<usize>::new();
for i in 0..10 {
    map.insert(i * 2, i * 2);
}

let mut count = 0;
for (i, value) in map.iter_mut() {
    *value += 1;
    assert_eq!(i, count * 2);
    assert_eq!(*value, count * 2 + 1);
    count += 1;
}
assert_eq!(count, 10);

Trait Implementations

impl<T> Clear for VecMap<T>

fn clear(&mut self)

Clears self, removing all values.

impl<T: Clone> Clone for VecMap<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for VecMap<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for VecMap<T>

fn default() -> VecMap<T>

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for VecMap<T>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, T: Clone + 'a, I: Borrow<usize> + 'a> Extend<(I, &'a T)> for VecMap<T>

fn extend<It: IntoIterator<Item = (I, &'a T)>>(&mut self, iter: It)

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> Extend<(usize, T)> for VecMap<T>

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

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<'a, T: Clone + 'a, I: Borrow<usize> + 'a> FromIterator<(I, &'a T)> for VecMap<T>

fn from_iter<It: IntoIterator<Item = (I, &'a T)>>(iter: It) -> Self

Creates a value from an iterator.

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

fn from_iter<It: IntoIterator<Item = (usize, T)>>(iter: It) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for VecMap<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for VecMap<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 VecMap<T>

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

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

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

type Item = (usize, &'a T)

The type of the elements being iterated over.

type IntoIter = FilterMap<Enumerate<Iter<'a, Option<T>>>, fn((usize, &Option<T>)) -> Option<(usize, &T)>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut VecMap<T>

type Item = (usize, &'a mut T)

The type of the elements being iterated over.

type IntoIter = FilterMap<Enumerate<IterMut<'a, Option<T>>>, fn((usize, &mut Option<T>)) -> Option<(usize, &mut T)>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for VecMap<T>

type Item = (usize, T)

The type of the elements being iterated over.

type IntoIter = FilterMap<Enumerate<IntoIter<Option<T>>>, fn((usize, Option<T>)) -> Option<(usize, T)>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Len for VecMap<T>

fn len(&self) -> usize

Returns the number of elements in the collection.

fn is_empty(&self) -> bool

Returns true if the collection contains no elements.

impl<T> Map for VecMap<T>

type Key = usize

Key type

type Value = T

Value type

impl<T> MapGet<usize> for VecMap<T>

fn get(&self, key: &usize) -> Option<&Self::Value>

Returns a reference to the value corresponding to the key if exists.

fn contains_key(&self, key: &K) -> bool

Returns true if the map contains a value for the key.

impl<T> MapInsert for VecMap<T>

fn insert(&mut self, key: Self::Key, value: Self::Value) -> Option<Self::Value>

Inserts value into the map. The existing value in the map is returned.

impl<T> MapMut<usize> for VecMap<T>

fn get_mut(&mut self, key: &usize) -> Option<&mut Self::Value>

Returns a mutable reference to the value corresponding to the key if exists.

fn remove(&mut self, key: &usize) -> Option<Self::Value>

Removes and returns the element at key from the map if exists.

impl<T: Ord> Ord for VecMap<T>

fn cmp(&self, other: &VecMap<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<T: PartialEq> PartialEq for VecMap<T>

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

fn partial_cmp(&self, other: &VecMap<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<T> Retain for VecMap<T>

type Key = usize

Key type

type Value = T

Value type

fn retain(&mut self, f: impl FnMut(&Self::Key, &mut Self::Value) -> bool)

Retains only the elements specified by the predicate, passing a mutable reference to it. In other words, removes all elements such that f(&index, &mut value) returns false.

impl<T: Serialize> Serialize for VecMap<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for VecMap<T>

impl<T> StructuralPartialEq for VecMap<T>