Struct NEIndexMap 

pub struct NEIndexMap<K, V, S = RandomState> { /* private fields */ }

A non-empty, growable IndexMap.

Unlike HashMap and crate::NEMap, these feature a predictable iteration order.

use nonempty_collections::*;

let m = ne_indexmap! {"Netherlands" => 18, "Canada" => 40};
assert_eq!(2, m.len().get());

Implementations

impl<K, V, S> NEIndexMap<K, V, S>

pub fn capacity(&self) -> NonZeroUsize

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

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

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

Returns a regular iterator over the entries in this non-empty index map.

For a NonEmptyIterator see Self::nonempty_iter().

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

Returns a regular mutable iterator over the entries in this non-empty index map.

For a NonEmptyIterator see Self::nonempty_iter_mut().

pub fn nonempty_iter(&self) -> Iter<'_, K, V>

An iterator visiting all elements in their order.

pub fn nonempty_iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator visiting all elements in their order.

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

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

use nonempty_collections::*;

let m = ne_indexmap! {"Duke" => "Leto", "Doctor" => "Yueh", "Planetologist" => "Kynes"};
let v = m.keys().collect::<NEVec<_>>();
assert_eq!(nev![&"Duke", &"Doctor", &"Planetologist"], v);

pub fn len(&self) -> NonZeroUsize

Returns the number of elements in the map. Always 1 or more.

use nonempty_collections::*;

let m = ne_indexmap! {"a" => 1, "b" => 2};
assert_eq!(2, m.len().get());

pub const fn is_empty(&self) -> bool

👎Deprecated: A NEIndexMap is never empty.

A NEIndexMap is never empty.

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

An iterator visiting all values in order.

use nonempty_collections::*;

let m = ne_indexmap!["Caladan" => "Atreides", "Giedi Prime" => "Harkonnen", "Kaitain" => "Corrino"];
assert_eq!(vec![&"Atreides", &"Harkonnen", &"Corrino"], m.values().collect::<Vec<_>>());

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

Return an iterator visiting all mutable values in order.

use nonempty_collections::*;

let mut m = ne_indexmap![0 => "Fremen".to_string(), 1 => "Crysknife".to_string(), 2 => "Water of Life".to_string()];
m.values_mut().into_iter().for_each(|v| v.truncate(3));

assert_eq!(vec![&mut "Fre".to_string(), &mut "Cry".to_string(),&mut "Wat".to_string()], m.values_mut().collect::<Vec<_>>());

pub fn first(&self) -> (&K, &V)

Get the first element. Never fails.

pub fn last(&self) -> (&K, &V)

Get the last element. Never fails.

impl<K, V> NEIndexMap<K, V>

where K: Eq + Hash,

pub fn new(k: K, v: V) -> Self

Creates a new NEIndexMap with a single element.

pub fn with_capacity(capacity: NonZeroUsize, k: K, v: V) -> NEIndexMap<K, V>

Creates a new NEIndexMap with a single element and specified heap capacity.

impl<K, V, S> NEIndexMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

pub fn try_from_map(map: IndexMap<K, V, S>) -> Option<Self>

Attempt a conversion from IndexMap, consuming the given IndexMap. Will return None if the IndexMap is empty.

use indexmap::*;
use nonempty_collections::*;

assert_eq!(
    Some(ne_indexmap! {"a" => 1, "b" => 2}),
    NEIndexMap::try_from_map(indexmap! {"a" => 1, "b" => 2})
);
let m: IndexMap<(), ()> = indexmap! {};
assert_eq!(None, NEIndexMap::try_from_map(m));

pub fn contains_key<Q>(&self, k: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

Returns true if the map contains a value.

use nonempty_collections::*;

let m = ne_indexmap! {"Paul" => ()};
assert!(m.contains_key("Paul"));
assert!(!m.contains_key("Atreides"));

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where Q: Hash + Equivalent<K> + ?Sized,

Return a reference to the value stored for key, if it is present, else None.

use nonempty_collections::*;

let m = ne_indexmap! {"Arrakis" => 3};
assert_eq!(Some(&3), m.get("Arrakis"));
assert_eq!(None, m.get("Caladan"));

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return references to the key-value pair stored for key, if it is present, else None.

use nonempty_collections::*;

let m = ne_indexmap! {"Year" => 1963, "Pages" => 896};
assert_eq!(Some((&"Year", &1963)), m.get_key_value(&"Year"));
assert_eq!(Some((&"Pages", &896)), m.get_key_value(&"Pages"));
assert_eq!(None, m.get_key_value(&"Title"));

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where Q: Hash + Equivalent<K> + ?Sized,

Return a mutable reference to the value stored for key, if it is present, else None.

use nonempty_collections::*;

let mut m = ne_indexmap! {"Mentat" => 3, "Bene Gesserit" => 14};
let v = m.get_mut(&"Mentat");
assert_eq!(Some(&mut 3), v);
*v.unwrap() += 1;
assert_eq!(Some(&mut 4), m.get_mut(&"Mentat"));

let v = m.get_mut(&"Bene Gesserit");
assert_eq!(Some(&mut 14), v);
*v.unwrap() -= 1;
assert_eq!(Some(&mut 13), m.get_mut(&"Bene Gesserit"));

assert_eq!(None, m.get_mut(&"Sandworm"));

pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>

where Q: Hash + Equivalent<K> + ?Sized,

Return item index, if it exists in the map.

use nonempty_collections::*;
let m = ne_indexmap! {"Title" => "Dune", "Author" => "Frank Herbert", "Language" => "English"};

assert_eq!(Some(0), m.get_index_of(&"Title"));
assert_eq!(Some(1), m.get_index_of(&"Author"));
assert_eq!(None, m.get_index_of(&"Genre"));

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

Insert a key-value pair into the map.

If an equivalent key already exists in the map: the key remains and retains in its place in the order, its corresponding value is updated with value, and the older value is returned inside Some(_).

If no equivalent key existed in the map: the new key-value pair is inserted, last in order, and None is returned.

use nonempty_collections::*;

let mut m = ne_indexmap! {"Duke" => "Leto", "Doctor" => "Yueh"};
assert_eq!(None, m.insert("Lady", "Jessica"));
assert_eq!(
    vec!["Duke", "Doctor", "Lady"],
    m.keys().copied().collect::<Vec<_>>()
);

// Spoiler alert: there is a different duke at some point
assert_eq!(Some("Leto"), m.insert("Duke", "Paul"));
assert_eq!(
    vec!["Paul", "Yueh", "Jessica"],
    m.values().copied().collect::<Vec<_>>()
);

pub fn shrink_to_fit(&mut self)

Shrink the capacity of the map as much as possible.

pub fn with_capacity_and_hasher( capacity: NonZeroUsize, hasher: S, k: K, v: V, ) -> NEIndexMap<K, V, S>

Creates a new NEIndexMap with a single element and specified heap capacity and hasher.

pub fn with_hasher(hasher: S, k: K, v: V) -> NEIndexMap<K, V, S>

See IndexMap::with_hasher.

pub fn swap_indices(&mut self, a: usize, b: usize)

Swaps the position of two key-value pairs in the map.

Panics

If a or b are out of bounds.

Trait Implementations

impl<K, V, S> AsMut<IndexMap<K, V, S>> for NEIndexMap<K, V, S>

fn as_mut(&mut self) -> &mut IndexMap<K, V, S>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<K, V, S> AsRef<IndexMap<K, V, S>> for NEIndexMap<K, V, S>

fn as_ref(&self) -> &IndexMap<K, V, S>

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: Clone, V: Clone, S: Clone> Clone for NEIndexMap<K, V, S>

fn clone(&self) -> NEIndexMap<K, V, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S> Debug for NEIndexMap<K, V, S>

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

Formats the value using the given formatter.

impl<K, V> Extend<(K, V)> for NEIndexMap<K, V>

where K: Eq + Hash,

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

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<K, V, S> From<NEIndexMap<K, V, S>> for IndexMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

fn from(m: NEIndexMap<K, V, S>) -> Self

use indexmap::IndexMap;
use nonempty_collections::*;

let m: IndexMap<&str, usize> = ne_indexmap! {"population" => 1000}.into();
assert!(m.contains_key("population"));

impl<K, V, S> FromNonEmptyIterator<(K, V)> for NEIndexMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

use nonempty_collections::*;

let v = nev![('a', 1), ('b', 2), ('c', 3), ('a', 4)];
let m0 = v.into_nonempty_iter().collect::<NEIndexMap<_, _>>();
let m1 = ne_indexmap! {'a' => 4, 'b' => 2, 'c' => 3};
assert_eq!(m0, m1);

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

where I: IntoNonEmptyIterator<Item = (K, V)>,

Creates a value from a NonEmptyIterator.

impl<K, V> Index<usize> for NEIndexMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, index: usize) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K, V, S> IntoIterator for &'a NEIndexMap<K, V, S>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, S> IntoIterator for &'a mut NEIndexMap<K, V, S>

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, S> IntoIterator for NEIndexMap<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, S> IntoNonEmptyIterator for &'a NEIndexMap<K, V, S>

type IntoNEIter = Iter<'a, K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

impl<K, V, S> IntoNonEmptyIterator for NEIndexMap<K, V, S>

type IntoNEIter = IntoIter<K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

impl<K, V, S> PartialEq for NEIndexMap<K, V, S>

where K: Eq + Hash, V: Eq, S: BuildHasher,

fn eq(&self, other: &Self) -> 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<K, V> Singleton for NEIndexMap<K, V>

where K: Eq + Hash,

fn singleton((k, v): Self::Item) -> Self

use nonempty_collections::{NEIndexMap, Singleton, ne_indexmap};

let m = NEIndexMap::singleton(('a', 1));
assert_eq!(ne_indexmap!['a' => 1], m);

type Item = (K, V)

impl<K, V, S> Eq for NEIndexMap<K, V, S>

where K: Eq + Hash, V: Eq, S: BuildHasher,