Struct VecMap 

pub struct VecMap<V, I: UnsignedNum = usize> { /* private fields */ }

The VecMap is a type of associative array that uses a Vec of Options to map unsigned integer keys to elements.

Implementations

impl<V, I: UnsignedNum> VecMap<V, I>

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 with_capacity(capacity: usize) -> Self

Constructs a new, empty VecMap with the specified capacity. It will be able to hold exactly capacity elements without reallocating. If capacity is 0, it will not allocate.

Panic

Panics if the capacity overflows.

Examples

let map = VecMap::<()>::with_capacity(10);
assert_eq!(map.capacity(), 10);

pub fn capacity(&self) -> usize

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

Examples

let map = VecMap::<()>::with_capacity(10);
assert_eq!(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 get(&self, i: &I) -> Option<&V>

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));
map.remove(&idx);
assert!(map.get(&idx).is_none());

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

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.remove(&idx), Some(124));
assert!(map.get_mut(&idx).is_none());

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!(map.len() == 0);

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

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).unwrap(), 123);
assert!(map.insert(0, 123).is_none());
assert_eq!(*map.get(&idx).unwrap(), 456);

pub fn remove(&mut self, i: &I) -> Option<V>

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(&I, &mut V) -> 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).unwrap(), 3);
assert!(map.get(&0).is_none());

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

Reserves capacity for at least additional more elements to be inserted in the given 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 iter(&self) -> Iter<'_, V, I>

Returns an iterator over the map.

Examples

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

for (idx, value) in &map {
    println!("{} is at index {:?}", value, idx);
}

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

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, i * i);
}

for (_, value) in &mut map {
    *value += 5;
}

Trait Implementations

impl<V: Clone, I: Clone + UnsignedNum> Clone for VecMap<V, I>

fn clone(&self) -> VecMap<V, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, I: Debug + UnsignedNum> Debug for VecMap<V, I>

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

Formats the value using the given formatter.

impl<V, I: UnsignedNum> Default for VecMap<V, I>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V, I> Deserialize<'de> for VecMap<V, I>

where V: Deserialize<'de>, I: UnsignedNum,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, V, I> Extend<(&'a I, &'a V)> for VecMap<V, I>

where I: UnsignedNum + 'a, V: Copy + 'a,

fn extend<It: IntoIterator<Item = (&'a I, &'a V)>>(&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, V, I> Extend<(I, &'a V)> for VecMap<V, I>

where I: UnsignedNum + 'a, V: Copy + 'a,

fn extend<It: IntoIterator<Item = (I, &'a V)>>(&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<V, I: UnsignedNum> Extend<(I, V)> for VecMap<V, I>

fn extend<It: IntoIterator<Item = (I, V)>>(&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<V, I: UnsignedNum> FromIterator<(I, V)> for VecMap<V, I>

fn from_iter<It: IntoIterator<Item = (I, V)>>(iter: It) -> Self

Creates a value from an iterator.

impl<V, I: UnsignedNum> Index<I> for VecMap<V, I>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<V, I: UnsignedNum> IndexMut<I> for VecMap<V, I>

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

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

impl<'a, V, I: UnsignedNum> IntoIterator for &'a VecMap<V, I>

type Item = (I, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, V, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V, I: UnsignedNum> IntoIterator for &'a mut VecMap<V, I>

type Item = (I, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, V, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, I: UnsignedNum> IntoIterator for VecMap<V, I>

type Item = (I, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<V, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, I: UnsignedNum> Map for VecMap<V, I>

type Key = I

Key type

type Value = V

Value type

fn len(&self) -> usize

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

fn get(&self, i: &Self::Key) -> Option<&Self::Value>

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

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

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

fn is_empty(&self) -> bool

Returns true if the map contains no elements.

impl<V, I: UnsignedNum> MapMut for VecMap<V, I>

fn clear(&mut self)

Clears the map, removing all values.

fn get_mut(&mut self, i: &Self::Key) -> Option<&mut Self::Value>

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

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

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

fn remove(&mut self, i: &Self::Key) -> Option<Self::Value>

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

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<V, I> Serialize for VecMap<V, I>

where V: Serialize, I: UnsignedNum,

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

where S: Serializer,

Serialize this value into the given Serde serializer.