Struct fdg_sim::force::LinkedHashMap

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

A version of HashMap that has a user controllable order for its entries.

It achieves this by keeping its entries in an internal linked list and using a HashMap to point at nodes in this linked list.

The order of entries defaults to “insertion order”, but the user can also modify the order of existing entries by manually moving them to the front or back.

There are two kinds of methods that modify the order of the internal list:

• Methods that have names like to_front and to_back will unsurprisingly move an existing entry to the front or back
• Methods that have the word insert will insert a new entry ot the back of the list, and if that method might replace an entry, that method will also move that existing entry to the back.

Implementations

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

pub fn new() -> LinkedHashMap<K, V, RandomState>

pub fn with_capacity(capacity: usize) -> LinkedHashMap<K, V, RandomState>

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

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

pub fn with_capacity_and_hasher(
    capacity: usize,
    hash_builder: S
) -> LinkedHashMap<K, V, S>

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

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

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

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

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

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

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

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

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

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

pub fn retain<F>(&mut self, f: F)where
    F: FnMut(&K, &mut V) -> bool,

pub fn hasher(&self) -> &S

pub fn capacity(&self) -> usize

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

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

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

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

pub fn contains_key<Q>(&self, k: &Q) -> boolwhere
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

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

Inserts the given key / value pair at the back of the internal linked list.

Returns the previously set value, if one existed prior to this call. After this call, calling LinkedHashMap::back will return a reference to this key / value pair.

pub fn replace(&mut self, k: K, v: V) -> Option<V>

If the given key is not in this map, inserts the key / value pair at the back of the internal linked list and returns None, otherwise, replaces the existing value with the given value without moving the entry in the internal linked list and returns the previous value.

pub fn remove<Q>(&mut self, k: &Q) -> Option<V>where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

pub fn remove_entry<Q>(&mut self, k: &Q) -> Option<(K, V)>where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

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

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

pub fn to_front<Q>(&mut self, k: &Q) -> Option<&mut V>where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

If an entry with this key exists, move it to the front of the list and return a reference to the value.

pub fn to_back<Q>(&mut self, k: &Q) -> Option<&mut V>where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,

If an entry with this key exists, move it to the back of the list and return a reference to the value.

pub fn shrink_to_fit(&mut self)

pub fn retain_with_order<F>(&mut self, f: F)where
    F: FnMut(&K, &mut V) -> bool,

impl<K, V, S> LinkedHashMap<K, V, S>where
    S: BuildHasher,

pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, S>

pub fn raw_entry_mut(&mut self) -> RawEntryBuilderMut<'_, K, V, S>

Trait Implementations

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

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

Returns a copy 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<(), Error>

Formats the value using the given formatter.

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

fn default() -> LinkedHashMap<K, V, S>

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<'a, K, V, S> Extend<(&'a K, &'a V)> for LinkedHashMap<K, V, S>where
    K: 'a + Hash + Eq + Copy,
    V: 'a + Copy,
    S: BuildHasher,

fn extend<I>(&mut self, iter: I)where
    I: 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, S> Extend<(K, V)> for LinkedHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher,

fn extend<I>(&mut self, iter: I)where
    I: 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, S> FromIterator<(K, V)> for LinkedHashMap<K, V, S>where
    K: Hash + Eq,
    S: BuildHasher + Default,

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

Creates a value from an iterator.

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

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

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, S, Q> Index<&'a Q> for LinkedHashMap<K, V, S>where
    K: Hash + Eq + Borrow<Q>,
    S: BuildHasher,
    Q: Eq + Hash + ?Sized,

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, K, V, S, Q> IndexMut<&'a Q> for LinkedHashMap<K, V, S>where
    K: Hash + Eq + Borrow<Q>,
    S: BuildHasher,
    Q: Eq + Hash + ?Sized,

fn index_mut(&mut self, index: &'a Q) -> &mut V

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

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

Creates an iterator from a value.

impl<'a, K, V, S> IntoIterator for &'a mut LinkedHashMap<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) -> IterMut<'a, K, V>

Creates an iterator from a value.

impl<K, V, S> IntoIterator for LinkedHashMap<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) -> IntoIter<K, V>

Creates an iterator from a value.

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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

fn eq(&self, other: &LinkedHashMap<K, V, S>) -> 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, V, S> PartialOrd<LinkedHashMap<K, V, S>> for LinkedHashMap<K, V, S>where
    K: Hash + Eq + PartialOrd<K>,
    V: PartialOrd<V>,
    S: BuildHasher,

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

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

fn lt(&self, other: &LinkedHashMap<K, V, S>) -> bool

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

fn le(&self, other: &LinkedHashMap<K, V, S>) -> bool

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

fn ge(&self, other: &LinkedHashMap<K, V, S>) -> bool

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

fn gt(&self, other: &LinkedHashMap<K, V, S>) -> bool

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

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

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

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