Struct IndexMap 

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

A wrapper around [indexmap::IndexMap] that only provides fallible allocation.

Implementations

impl<K, V> IndexMap<K, V>

pub fn new() -> Self

Same as [indexmap::IndexMap::new].

pub fn with_capacity(n: usize) -> Result<Self, OutOfMemory>

Same as [indexmap::IndexMap::with_capacity] but returns an error on allocation failure.

impl<K, V, S> IndexMap<K, V, S>

pub fn with_capacity_and_hasher( n: usize, hash_builder: S, ) -> Result<Self, OutOfMemory>

Same as [indexmap::IndexMap::with_capacity_and_hasher] but returns an error on allocation failure.

pub const fn with_hasher(hash_builder: S) -> Self

Same as [indexmap::IndexMap::with_hasher].

pub fn capacity(&self) -> usize

Same as [indexmap::IndexMap::capacity].

pub fn hasher(&self) -> &S

Same as [indexmap::IndexMap::hasher].

pub fn len(&self) -> usize

Same as [indexmap::IndexMap::len].

pub fn is_empty(&self) -> bool

Same as [indexmap::IndexMap::is_empty].

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

Same as [indexmap::IndexMap::iter].

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

Same as [indexmap::IndexMap::iter_mut].

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

Same as [indexmap::IndexMap::keys].

pub fn into_keys(self) -> IntoKeys<K, V>

Same as [indexmap::IndexMap::into_keys].

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

Same as [indexmap::IndexMap::values].

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

Same as [indexmap::IndexMap::values_mut].

pub fn into_values(self) -> IntoValues<K, V>

Same as [indexmap::IndexMap::into_values].

pub fn clear(&mut self)

Same as [indexmap::IndexMap::clear].

pub fn truncate(&mut self, len: usize)

Same as [indexmap::IndexMap::truncate].

pub fn drain<R>(&mut self, range: R) -> Drain<'_, K, V>

where R: RangeBounds<usize>,

Same as [indexmap::IndexMap::drain].

pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, F>

where F: FnMut(&K, &mut V) -> bool, R: RangeBounds<usize>,

Same as [indexmap::IndexMap::extract_if].

pub fn split_off(&mut self, at: usize) -> Result<Self, OutOfMemory>

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

Same as [indexmap::IndexMap::split_off] but returns an error on allocation failure.

pub fn reserve(&mut self, additional: usize) -> Result<(), OutOfMemory>

Same as [indexmap::IndexMap::reserve] but returns an error on allocation failure.

pub fn reserve_exact(&mut self, additional: usize) -> Result<(), OutOfMemory>

Same as [indexmap::IndexMap::reserve_exact] but returns an error on allocation failure.

impl<K, V, S> IndexMap<K, V, S>

where K: Hash + Eq, S: BuildHasher,

pub fn insert(&mut self, key: K, value: V) -> Result<Option<V>, OutOfMemory>

Same as [indexmap::IndexMap::insert] but returns an error on allocation failure.

pub fn insert_full( &mut self, key: K, value: V, ) -> Result<(usize, Option<V>), OutOfMemory>

Same as [indexmap::IndexMap::insert_full] but returns an error on allocation failure.

pub fn insert_sorted( &mut self, key: K, value: V, ) -> Result<(usize, Option<V>), OutOfMemory>

where K: Ord,

Same as [indexmap::IndexMap::insert_sorted] but returns an error on allocation failure.

pub fn insert_sorted_by<F>( &mut self, key: K, value: V, cmp: F, ) -> Result<(usize, Option<V>), OutOfMemory>

where F: FnMut(&K, &V, &K, &V) -> Ordering,

Same as [indexmap::IndexMap::insert_sorted_by] but returns an error on allocation failure.

pub fn insert_sorted_by_key<B, F>( &mut self, key: K, value: V, sort_key: F, ) -> Result<(usize, Option<V>), OutOfMemory>

where B: Ord, F: FnMut(&K, &V) -> B,

Same as [indexmap::IndexMap::insert_sorted_by_key] but returns an error on allocation failure.

pub fn insert_before( &mut self, index: usize, key: K, value: V, ) -> Result<(usize, Option<V>), OutOfMemory>

Same as [indexmap::IndexMap::insert_before] but returns an error on allocation failure.

pub fn shift_insert( &mut self, index: usize, key: K, value: V, ) -> Result<Option<V>, OutOfMemory>

Same as [indexmap::IndexMap::shift_insert] but returns an error on allocation failure.

pub fn replace_index(&mut self, index: usize, key: K) -> Result<K, (usize, K)>

Same as [indexmap::IndexMap::shift_insert].

impl<K, V, S> IndexMap<K, V, S>

where S: BuildHasher,

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::contains_key].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_key_value].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_full].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_index_of].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_mut].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_key_value_mut].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_full_mut].

pub fn get_disjoint_mut<Q, const N: usize>( &mut self, keys: [&Q; N], ) -> [Option<&mut V>; N]

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::get_disjoint_mut].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::swap_remove].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::swap_remove_entry].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::swap_remove_full].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::shift_remove].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::shift_remove_entry].

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

where Q: ?Sized + Hash + Eq, K: Borrow<Q>,

Same as [indexmap::IndexMap::shift_remove_full].

impl<K, V, S> IndexMap<K, V, S>

pub fn pop(&mut self) -> Option<(K, V)>

Same as [indexmap::IndexMap::pop].

pub fn retain<F>(&mut self, keep: F)

where F: FnMut(&K, &mut V) -> bool,

Same as [indexmap::IndexMap::retain].

pub fn sort_keys(&mut self)

where K: Ord,

Same as [indexmap::IndexMap::sort_keys].

pub fn sort_by<F>(&mut self, cmp: F)

where F: FnMut(&K, &V, &K, &V) -> Ordering,

Same as [indexmap::IndexMap::sort_by].

pub fn sorted_by<F>(self, cmp: F) -> IntoIter<K, V>

where F: FnMut(&K, &V, &K, &V) -> Ordering,

Same as [indexmap::IndexMap::sorted_by].

pub fn sort_by_key<T, F>(&mut self, sort_key: F)

where T: Ord, F: FnMut(&K, &V) -> T,

Same as [indexmap::IndexMap::sort_by_key].

pub fn sort_unstable_keys(&mut self)

where K: Ord,

Same as [indexmap::IndexMap::sort_unstable_keys].

pub fn sort_unstable_by<F>(&mut self, cmp: F)

where F: FnMut(&K, &V, &K, &V) -> Ordering,

Same as [indexmap::IndexMap::sort_unstable_by].

pub fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<K, V>

where F: FnMut(&K, &V, &K, &V) -> Ordering,

Same as [indexmap::IndexMap::sorted_unstable_by].

pub fn sort_unstable_by_key<T, F>(&mut self, sort_key: F)

where T: Ord, F: FnMut(&K, &V) -> T,

Same as [indexmap::IndexMap::sort_unstable_by_key].

pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>

where K: Ord,

Same as [indexmap::IndexMap::binary_search_keys].

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> Ordering,

Same as [indexmap::IndexMap::binary_search_by].

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> B, B: Ord,

Same as [indexmap::IndexMap::binary_search_by_key].

pub fn is_sorted(&self) -> bool

where K: PartialOrd,

Same as [indexmap::IndexMap::is_sorted].

pub fn is_sorted_by<'a, F>(&'a self, cmp: F) -> bool

where F: FnMut(&'a K, &'a V, &'a K, &'a V) -> bool,

Same as [indexmap::IndexMap::is_sorted_by].

pub fn is_sorted_by_key<'a, F, T>(&'a self, sort_key: F) -> bool

where F: FnMut(&'a K, &'a V) -> T, T: PartialOrd,

Same as [indexmap::IndexMap::is_sorted_by_key].

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&K, &V) -> bool,

Same as [indexmap::IndexMap::partition_point].

pub fn reverse(&mut self)

Same as [indexmap::IndexMap::reverse].

pub fn get_index(&self, index: usize) -> Option<(&K, &V)>

Same as [indexmap::IndexMap::get_index].

pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)>

Same as [indexmap::IndexMap::get_index_mut].

pub fn get_disjoint_indices_mut<const N: usize>( &mut self, indices: [usize; N], ) -> Result<[(&K, &mut V); N], GetDisjointMutError>

Same as [indexmap::IndexMap::get_disjoint_indices_mut].

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

Same as [indexmap::IndexMap::first].

pub fn first_mut(&mut self) -> Option<(&K, &mut V)>

Same as [indexmap::IndexMap::first_mut].

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

Same as [indexmap::IndexMap::last].

pub fn last_mut(&mut self) -> Option<(&K, &mut V)>

Same as [indexmap::IndexMap::last_mut].

pub fn swap_remove_index(&mut self, index: usize) -> Option<(K, V)>

Same as [indexmap::IndexMap::swap_remove_index].

pub fn shift_remove_index(&mut self, index: usize) -> Option<(K, V)>

Same as [indexmap::IndexMap::shift_remove_index].

pub fn move_index(&mut self, from: usize, to: usize)

Same as [indexmap::IndexMap::move_index].

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

Same as [indexmap::IndexMap::swap_indices].

Trait Implementations

impl<K, V, S> Debug for IndexMap<K, V, S>

where K: Debug, V: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<K, V, S> Default for IndexMap<K, V, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for IndexMap<K, V>

where K: Deserialize<'de> + Hash + Eq, V: Deserialize<'de>,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, S> From<IndexMap<K, V, S>> for IndexMap<K, V, S>

fn from(map: IndexMap<K, V, S>) -> Self

Converts to this type from the input type.

impl<K, V, S> From<IndexMap<K, V, S>> for IndexMap<K, V, S>

fn from(inner: IndexMap<K, V, S>) -> Self

Converts to this type from the input type.

impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>

where Q: ?Sized + Hash + Eq, K: Borrow<Q>, S: BuildHasher,

type Output = V

The returned type after indexing.

fn index(&self, key: &Q) -> &V

Performs the indexing (container[index]) operation.

impl<K, V, S> Index<usize> for IndexMap<K, V, S>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V, Q, S> IndexMut<&Q> for IndexMap<K, V, S>

where Q: ?Sized + Hash + Eq, K: Borrow<Q>, S: BuildHasher,

fn index_mut(&mut self, key: &Q) -> &mut V

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

impl<K, V, S> IndexMut<usize> for IndexMap<K, V, S>

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

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

impl<'a, K, V, S> IntoIterator for &'a IndexMap<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 IndexMap<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 IndexMap<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<K, V1, S1, V2, S2> PartialEq<IndexMap<K, V2, S2>> for IndexMap<K, V1, S1>

where K: Hash + Eq, V1: PartialEq<V2>, S1: BuildHasher, S2: BuildHasher,

fn eq(&self, other: &IndexMap<K, V2, S2>) -> 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, H> Serialize for IndexMap<K, V, H>

where K: Serialize, V: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, S> TryClone for IndexMap<K, V, S>

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

fn try_clone(&self) -> Result<Self, OutOfMemory>

Attempt to clone self, returning an error if any allocation fails during cloning.

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

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