Struct LinkedHashMap

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

Implementations

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

pub fn with_hasher(hasher: S) -> LinkedHashMap<K, V, S>

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

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

where K: Hash + Eq,

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

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

pub fn push_front_and_return(&mut self, key: K, value: V) -> (&K, &V)

like [push_front], but return the put element instead of the replaced element

pub fn pop_front_node(&mut self) -> Option<Box<Node<K, V>>>

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

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

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

pub fn push_back_and_return(&mut self, key: K, value: V) -> (&K, &V)

like [push_back], but return the put element instead of the replaced element

pub fn pop_back_node(&mut self) -> Option<Box<Node<K, V>>>

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

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

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn insert_and_return(&mut self, key: K, value: V) -> (&K, &V)

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

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

pub fn is_empty(&self) -> bool

pub fn position(&self, pos: usize) -> Option<(&K, &V)>

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

pub fn clear(&mut self)

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

pub fn _into_iter(self) -> IntoIter<K, V>

Trait Implementations

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

where K: Clone + Hash + Eq, V: Clone,

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> Debug for LinkedHashMap<K, V>

where K: Debug + Hash + Eq, V: Debug,

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

Formats the value using the given formatter.

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

where S: Default,

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, V> Extend<(K, V)> for LinkedHashMap<K, V>

where K: Hash + Eq,

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

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> Hash for LinkedHashMap<K, V>

where K: Hash + Eq, V: Hash,

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

where K: Hash + Eq,

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

where K: Hash + Eq,

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, V> PartialEq for LinkedHashMap<K, V>

where K: Hash + Eq, V: PartialEq,

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> Eq for LinkedHashMap<K, V>

where K: Hash + Eq, V: Eq,

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

where K: Send, V: Send,

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

where K: Sync, V: Sync,