Struct indexmap_nostd::map::IndexMap

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

A b-tree map where the iteration order of the key-value pairs is independent of the ordering of the keys.

The interface is closely compatible with the indexmap crate and a subset of the features that is relevant for the wasmparser-nostd crate.

Differences to original IndexMap

Since the goal of this crate was to maintain a simple no_std compatible fork of the indexmap crate there are some downsides and differences.

• Some operations such as IndexMap::insert now require K: Clone.
• It is to be expected that this fork performs worse than the original indexmap crate implementation.
• The implementation is based on BTreeMap internally instead of HashMap which has the effect that methods no longer require K: Hash but K: Ord instead.

Implementations

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

pub fn new() -> Self

Makes a new, empty IndexMap.

Does not allocate anything on its own.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty IndexMap with at least the specified capacity.

Does not allocate if capacity is zero.

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

Reserve capacity for at least additional more key-value pairs.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where
    K: Borrow<Q> + Ord,
    Q: Ord, 

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

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

pub fn insert(&mut self, key: K, value: V) -> Option<V> where
    K: Ord + Clone, 

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical.

pub fn insert_full(&mut self, key: K, value: V) -> Option<(usize, V)> where
    K: Ord + Clone, 

Inserts a key-value pair into the map.

Returns the unique index to the key-value pair alongside the previous value.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical.

pub fn entry(&mut self, key: K) -> Entry<'_, K, V> where
    K: Ord + Clone, 

Gets the given key’s corresponding entry in the map for in-place manipulation.

pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
    K: Borrow<Q> + Ord,
    Q: Ord, 

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

pub fn get_key_value<Q: ?Sized>(&self, key: &Q) -> Option<(&K, &V)> where
    K: Borrow<Q> + Ord,
    Q: Ord, 

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

pub fn get_full<Q: ?Sized>(&self, key: &Q) -> Option<(usize, &K, &V)> where
    K: Borrow<Q> + Ord,
    Q: Ord, 

Returns the key-value pair corresponding to the supplied key as well as the unique index of the returned key-value pair.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

pub fn get_index_of<Q: ?Sized>(&self, key: &Q) -> Option<usize> where
    K: Borrow<Q> + Ord,
    Q: Ord, 

Returns the unique index corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

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

Returns a shared reference to the key-value pair at the given index.

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

Returns an exclusive reference to the key-value pair at the given index.

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

Gets an iterator over the entries of the map, sorted by key.

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

Gets a mutable iterator over the entries of the map, sorted by key.

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

Gets an iterator over the values of the map, in order by key.

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

Gets a mutable iterator over the values of the map, in order by key.

pub fn clear(&mut self)

Clears the map, removing all elements.

Trait Implementations

impl<K: Clone, V: Clone> Clone for IndexMap<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for IndexMap<K, V> where
    K: Deserialize<'de> + Ord + Clone,
    V: Deserialize<'de>, 

Requires crate feature "serde"

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, K, V> Extend<(&'a K, &'a V)> for IndexMap<K, V> where
    K: Ord + Copy,
    V: Copy, 

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (&'a K, &'a V)>, 

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> Extend<(K, V)> for IndexMap<K, V> where
    K: Ord + Clone, 

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

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, const N: usize> From<[(K, V); N]> for IndexMap<K, V> where
    K: Ord + Clone, 

fn from(items: [(K, V); N]) -> Self

Converts to this type from the input type.

impl<K, V> FromIterator<(K, V)> for IndexMap<K, V> where
    K: Ord + Clone, 

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = (K, V)>, 

Creates a value from an iterator.

impl<'a, K, Q, V> Index<&'a Q> for IndexMap<K, V> where
    K: Borrow<Q> + Ord,
    Q: Ord, 

type Output = V

The returned type after indexing.

fn index(&self, key: &'a Q) -> &Self::Output

Performs the indexing (container[index]) operation.

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

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<'de, K, V, E> IntoDeserializer<'de, E> for IndexMap<K, V> where
    K: IntoDeserializer<'de, E> + Ord,
    V: IntoDeserializer<'de, E>,
    E: Error, 

type Deserializer = MapDeserializer<'de, <IndexMap<K, V> as IntoIterator>::IntoIter, E>

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

impl<'a, K, V> IntoIterator for &'a IndexMap<K, V>

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> IntoIterator for &'a mut IndexMap<K, V>

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> IntoIterator for IndexMap<K, V>

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: Ord, V: Ord> Ord for IndexMap<K, V>

fn cmp(&self, other: &IndexMap<K, V>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl<K: PartialEq, V: PartialEq> PartialEq<IndexMap<K, V>> for IndexMap<K, V>

fn eq(&self, other: &IndexMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: PartialOrd, V: PartialOrd> PartialOrd<IndexMap<K, V>> for IndexMap<K, V>

fn partial_cmp(&self, other: &IndexMap<K, V>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<K, V> Serialize for IndexMap<K, V> where
    K: Serialize + Ord,
    V: Serialize, 

Requires crate feature "serde"

fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error> where
    T: Serializer, 

Serialize this value into the given Serde serializer.

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

impl<K, V> StructuralEq for IndexMap<K, V>

impl<K, V> StructuralPartialEq for IndexMap<K, V>