Struct IndexMap

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

A map of usize to value, which allows efficient O(1) inserts, O(1) indexing and O(1) removal.

See crate level documentation for more information.

Implementations

impl<T> IndexMap<T>

pub fn keys(&self) -> Keys<'_, T>

An iterator visiting all keys in ascending order. The iterator element type is usize.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
map.insert("b");
map.insert("c");

for key in map.keys() {
    println!("{}", key);
}

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

An iterator visiting all values in ascending order of their keys. The iterator element type is &T.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
map.insert("b");
map.insert("c");

for val in map.values() {
    println!("{}", val);
}

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

An iterator visiting all values mutably in ascending order of their keys. The iterator element type is &mut T.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert(2);
map.insert(4);
map.insert(6);

for val in map.values_mut() {
    *val *= 2;
}

for val in map.values() {
    println!("{}", val);
}

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

An iterator visiting all key-value pairs in ascending order of keys. The iterator element type is (usize, &T).

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
map.insert("b");
map.insert("c");

for (key, val) in map.iter() {
    println!("key: {} val: {}", key, val);
}

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

An iterator visiting all key-value pairs in ascending order of keys, with mutable references to the values. The iterator element type is (usize, &mut T).

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert(2);
map.insert(4);
map.insert(6);

// Update all values
for (_, val) in map.iter_mut() {
    *val *= 2;
}

for (key, val) in map.iter() {
    println!("key: {} val: {}", key, val);
}

pub fn drain(&mut self) -> Drain<'_, T>

Clears the map, returning all key-value pairs as an iterator. Keeps the allocated memory for reuse.

Examples

use index_map::IndexMap;

let mut a = IndexMap::new();
a.insert("a");
a.insert("b");

let mut iter = a.drain();
assert_eq!(iter.next(), Some((0, "a")));
assert_eq!(iter.next(), Some((1, "b")));
assert_eq!(iter.next(), None);

assert!(a.is_empty());

impl<T> IndexMap<T>

pub fn new() -> Self

Creates a new IndexMap.

It initially has a capacity of 0, and won’t allocate until first inserted into.

Examples

use index_map::IndexMap;
let mut map: IndexMap<&str> = IndexMap::new();

pub fn with_capacity(capacity: usize) -> Self

Creates an empty IndexMap with the specified capacity.

The map will be able to hold at least capacity elements without reallocating. If capacity is 0, the map will not allocate.

Examples

use index_map::IndexMap;
let mut map: IndexMap<&str> = IndexMap::with_capacity(10);

pub fn capacity(&self) -> usize

Returns the number of elements map can hold without reallocating.

Examples

use index_map::IndexMap;
let mut map: IndexMap<&str> = IndexMap::with_capacity(10);
assert!(map.capacity() >= 10);

pub fn len(&self) -> usize

Returns the number of elements present in the map.

Examples

use index_map::IndexMap;
let mut map = IndexMap::new();
assert_eq!(map.len(), 0);
map.insert("a");
assert_eq!(map.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

Examples

use index_map::IndexMap;
let mut map = IndexMap::new();
assert!(map.is_empty());
map.insert("a");
assert!(!map.is_empty());

pub fn clear(&mut self)

Clears the map, dropping all key-value pairs. Keeps the allocated memory for reuse.

Examples

use index_map::IndexMap;
let mut map = IndexMap::new();

map.insert("a");
map.clear();

assert!(map.is_empty());

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

Reserves capacity for at least additional more elements to be inserted in the IndexMap The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Examples

use index_map::IndexMap;
let mut map: IndexMap<&str> = IndexMap::new();
map.reserve(10);
assert!(map.capacity() >= 10);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space to keep keys valid.

Examples

use index_map::IndexMap;
let mut map = IndexMap::with_capacity(100);
map.insert("a");
map.insert("b");
assert!(map.capacity() >= 100);
map.shrink_to_fit();
assert!(map.capacity() >= 2);

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

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

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
assert_eq!(map.contains_key(0), true);
assert_eq!(map.contains_key(1), false);

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

Inserts a value into the map, returning the generated key, for it.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
assert_eq!(map.insert("a"), 0);
assert_eq!(map.is_empty(), false);

let b = map.insert("b");
assert_eq!(map[b], "b");

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

Removes a key from the map, returning the value at the key if the key was previously in the map.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
let a = map.insert("a");
assert_eq!(map.remove(a), Some("a"));
assert_eq!(map.remove(a), None);

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

Removes a key from the map, returning the key and value if the key was previously in the map.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
let a = map.insert("a");
assert_eq!(map.remove_entry(a), Some((0, "a")));
assert_eq!(map.remove(a), None);

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

Returns a reference to the value corresponding to the key.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
assert_eq!(map.get(0), Some(&"a"));
assert_eq!(map.get(1), None);

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

Returns the key-value pair corresponding to the key.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
map.insert("a");
assert_eq!(map.get_key_value(0), Some((0, &"a")));
assert_eq!(map.get_key_value(1), None);

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

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

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
let a = map.insert("a");
if let Some(x) = map.get_mut(a) {
    *x = "b";
}
assert_eq!(map[a], "b");

pub fn retain<P>(&mut self, predicate: P)

where P: FnMut(usize, &mut T) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(k, &mut v) returns false.

Examples

use index_map::IndexMap;

let mut map = IndexMap::new();
for i in 0..6 {
    map.insert(i*2);
}
map.retain(|k, _| k % 2 == 0);
assert_eq!(map.len(), 3);

Trait Implementations

impl<T: Clone> Clone for IndexMap<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for IndexMap<T>

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

Formats the value using the given formatter.

impl<T> Default for IndexMap<T>

fn default() -> Self

Creates an empty IndexMap, same as calling new.

impl<T> Index<usize> for IndexMap<T>

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

Returns a reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the IndexMap.

type Output = T

The returned type after indexing.

impl<T> IndexMut<usize> for IndexMap<T>

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

Returns a mutable reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the IndexMap.

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

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

Creates an iterator from a value.

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

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

Creates an iterator from a value.

impl<T> IntoIterator for IndexMap<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.

impl<T: Ord> Ord for IndexMap<T>

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

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

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

impl<T> StructuralPartialEq for IndexMap<T>