Struct LinkedHashMap 

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

A hash map that preserves insertion order and exposes a [VecDeque]-like API with [insert_back], [insert_front], [pop_front], [pop_back], [front], and [back].

All the usual [HashMap] operations (get, get_mut, remove, contains_key, len, is_empty, clear, …) are also available.

Ordering contract

• [insert_back] and [insert_front] preserve the position of an existing key: only the value is updated in-place. Use [move_to_back] / [move_to_front] to explicitly reorder an entry.

Implementations

impl<K, V> LinkedHashMap<K, V>

pub fn new() -> Self

Creates an empty LinkedHashMap.

pub fn with_capacity(capacity: usize) -> Self

Creates an empty LinkedHashMap with the specified initial capacity.

impl<K, V, S> LinkedHashMap<K, V, S>

pub fn with_hasher(hash_builder: S) -> Self

Creates an empty LinkedHashMap using the supplied hasher builder.

pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self

Creates an empty LinkedHashMap with the given capacity and hasher.

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 key-value pairs.

pub fn capacity(&self) -> usize

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

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

impl<K, V, S> LinkedHashMap<K, V, S>

where K: Hash + Eq, S: BuildHasher,

pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V, S>

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

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

Inserts a key-value pair at the back (most-recently-inserted end).

If the key already exists, the value is replaced in-place and the node’s position in the ordering is preserved (it is not moved). Returns the old value in that case.

To also move the node to the back, call move_to_back after insertion.

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

Inserts a key-value pair at the front (least-recently-inserted end).

If the key already exists, the value is replaced in-place and the node’s position in the ordering is preserved (it is not moved). Returns the old value in that case.

To also move the node to the front, call move_to_front after insertion.

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

Alias for insert_back: matches the HashMap::insert signature.

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

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

Returns a reference to the value associated with key, if present.

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

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

Returns a mutable reference to the value associated with key, if present.

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

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

Returns (&key, &value) for the given key, if present.

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

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

Returns true if the map contains a value for key.

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

Returns references to the front (oldest inserted) key-value pair, or None if the map is empty.

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

Returns a mutable reference to the front key-value pair, or None.

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

Returns references to the back (most recently inserted) key-value pair, or None if the map is empty.

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

Returns a mutable reference to the back key-value pair, or None.

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

Removes and returns the front (oldest) key-value pair, or None.

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

Removes and returns the back (newest) key-value pair, or None.

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

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

Removes the entry for key and returns the value, if present.

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

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

Removes the entry for key and returns (key, value), if present.

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

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

Retains only entries for which f(&key, &mut value) returns true. Elements are visited in insertion order (front → back).

pub fn clear(&mut self)

Removes all key-value pairs from the map.

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

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

Moves the entry for key to the back of the ordering. Returns true if the key was found, false otherwise.

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

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

Moves the entry for key to the front of the ordering. Returns true if the key was found, false otherwise.

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

Removes all elements in insertion order, returning (K, V) pairs via an iterator. The map is empty after this call (even if the iterator is dropped before it is fully consumed).

impl<K, V, S> LinkedHashMap<K, V, S>

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

Returns an iterator over (&K, &V) pairs in insertion order.

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

Returns an iterator over (&K, &mut V) pairs in insertion order.

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

Returns an iterator over keys in insertion order.

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

Returns an iterator over values in insertion order.

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

Returns a mutable iterator over values in insertion order.

Trait Implementations

impl<K: Clone + Hash + Eq, V: Clone, S: BuildHasher + Clone> Clone for LinkedHashMap<K, V, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> Drop for LinkedHashMap<K, V, S>

fn drop(&mut self)

Executes the destructor for this type.

impl<K: Hash + Eq, V, S: BuildHasher> Extend<(K, V)> for LinkedHashMap<K, V, S>

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: Hash + Eq, V> FromIterator<(K, V)> for LinkedHashMap<K, V>

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

Creates a value from an iterator.

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

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

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

Returns a reference to the value for key.

Panics

Panics if key is not present in the map.

type Output = V

The returned type after indexing.

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

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

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

Returns a mutable reference to the value for key.

Panics

Panics if key is not present in the map.

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

Shared-reference iterator: yields (&K, &V) in insertion order.

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) -> Iter<'a, K, V>

Creates an iterator from a value.

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

Mutable-reference iterator: yields (&K, &mut V) in insertion order.

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) -> IterMut<'a, K, V>

Creates an iterator from a value.

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

Consuming iterator: yields all (K, V) pairs in insertion order.

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) -> IntoIter<K, V>

Creates an iterator from a value.

impl<K, V, S1, S2> PartialEq<LinkedHashMap<K, V, S2>> for LinkedHashMap<K, V, S1>

where K: PartialEq, V: PartialEq,

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

Two maps are equal only when they contain the same key-value pairs in the same order.

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: PartialEq + Eq, V: Eq, S> Eq for LinkedHashMap<K, V, S>

impl<K: Send, V: Send, S: Send> Send for LinkedHashMap<K, V, S>

impl<K: Sync, V: Sync, S: Sync> Sync for LinkedHashMap<K, V, S>