Struct OrderedHashMap 

pub struct OrderedHashMap<Key, Value, BH = RandomState>(/* private fields */);

Implementations

impl<Key, Value, BH> OrderedHashMap<Key, Value, BH>

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

Returns an iterator over the key-value pairs of the map, in their order.

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

Returns a mutable iterator over the key-value pairs of the map, in their order.

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

Returns an iterator over the keys of the map, in their order.

pub fn into_keys(self) -> IntoKeys<Key, Value>

Returns a consuming iterator over the keys of the map, in their order.

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

Returns an iterator over the values of the map, in their order.

pub fn len(&self) -> usize

Returns the number of key-value pairs in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn clear(&mut self)

Removes all the entries for the map.

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

Removes the entry at the given index.

Returns the key-value pair at the given index (if present).

impl<Key: Eq + Hash, Value, BH: BuildHasher> OrderedHashMap<Key, Value, BH>

pub fn get<Q: ?Sized + Hash + Equivalent<Key>>(&self, key: &Q) -> Option<&Value>

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

Computes in O(1) time (average).

pub fn get_mut<Q: ?Sized + Hash + Equivalent<Key>>( &mut self, key: &Q, ) -> Option<&mut Value>

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

Computes in O(1) time (average).

pub fn entry(&mut self, key: Key) -> Entry<'_, Key, Value>

Gets the given key’s corresponding entry in the map for insertion and/or in-place manipulation.

Computes in O(1) time (amortized average).

pub fn insert(&mut self, key: Key, value: Value) -> Option<Value>

Insert a key-value pair in 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.

Computes in O(1) time (amortized average).

See also entry if you want to insert or modify or if you need to get the index of the corresponding key-value pair.

pub fn extend<I: IntoIterator<Item = (Key, Value)>>(&mut self, iter: I)

Extends the map with the content of the given iterator.

pub fn contains_key<Q: ?Sized + Hash + Equivalent<Key>>(&self, key: &Q) -> bool

Returns true if an equivalent to key exists in the map.

pub fn shift_remove<Q: ?Sized + Hash + Equivalent<Key>>( &mut self, key: &Q, ) -> Option<Value>

Removes the entry for the given key, preserving the order of entries.

Returns the value associated with the key (if present).

pub fn swap_remove<Q: ?Sized + Hash + Equivalent<Key>>( &mut self, key: &Q, ) -> Option<Value>

Removes the entry for the given key by swapping it with the last element. Thus the order of elements is not preserved, but the resulting order is still deterministic.

Returns the value associated with the key (if present).

pub fn retain(&mut self, keep: impl FnMut(&Key, &mut Value) -> bool)

Scan through each key-value pair in the map and keep those where the closure keep returns true.

The elements are visited in order, and remaining elements keep their order.

Computes in O(n) time (average).

pub fn eq_unordered(&self, other: &Self) -> bool

where Value: Eq,

Returns true if the maps are equal, ignoring the order of the entries.

Trait Implementations

impl<Key: Clone, Value: Clone, BH: Clone> Clone for OrderedHashMap<Key, Value, BH>

fn clone(&self) -> OrderedHashMap<Key, Value, BH>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Key: Debug, Value: Debug, BH: Debug> Debug for OrderedHashMap<Key, Value, BH>

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

Formats the value using the given formatter.

impl<Key, Value, BH: Default> Default for OrderedHashMap<Key, Value, BH>

fn default() -> Self

Returns the “default value” for a type.

impl<Key: Hash + Eq, Value, BH: BuildHasher + Default, const N: usize> From<[(Key, Value); N]> for OrderedHashMap<Key, Value, BH>

fn from(init_map: [(Key, Value); N]) -> Self

Converts to this type from the input type.

impl<Key: Hash + Eq, Value, BH: BuildHasher + Default> FromIterator<(Key, Value)> for OrderedHashMap<Key, Value, BH>

fn from_iter<T: IntoIterator<Item = (Key, Value)>>(iter: T) -> Self

Creates a value from an iterator.

impl<Key: Hash, Value: Hash, BH> Hash for OrderedHashMap<Key, Value, BH>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Key, Value, Q, BH> Index<&Q> for OrderedHashMap<Key, Value, BH>

where Q: Hash + Equivalent<Key> + ?Sized, Key: Hash + Eq, BH: BuildHasher,

type Output = Value

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<Key, Value, Q, BH> IndexMut<&Q> for OrderedHashMap<Key, Value, BH>

where Q: Hash + Equivalent<Key> + ?Sized, Key: Hash + Eq, BH: BuildHasher,

fn index_mut(&mut self, index: &Q) -> &mut Value

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

impl<Key, Value, BH> IntoIterator for OrderedHashMap<Key, Value, BH>

type Item = (Key, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter<Key, Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Key: Hash + Eq, Value: HasZero + Clone + Eq, BH: BuildHasher> MergeCollection<Key, Value> for OrderedHashMap<Key, Value, BH>

fn merge_collection( self, other: impl IntoIterator<Item = (Key, Value)>, action: impl Fn(Value, Value) -> Value, ) -> Self

Returns a collection which contains the combination by using action of the values from the given two collections, for each key.

impl<Key: Eq, Value: Eq, BH> PartialEq for OrderedHashMap<Key, Value, BH>

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<Key: Update + Eq + Hash, Value: Update> Update for OrderedHashMap<Key, Value, RandomState>

Available on crate feature salsa only.

unsafe fn maybe_update(old_pointer: *mut Self, new_map: Self) -> bool

Returns

impl<Key: Hash + Eq, Value: Eq, BH: BuildHasher> Eq for OrderedHashMap<Key, Value, BH>