Struct ra_ap_rustc_data_structures::unord::UnordMap

pub struct UnordMap<K: Eq + Hash, V> { /* private fields */ }

This is a map collection type that tries very hard to not expose any internal iteration. This is a useful property when trying to uphold the determinism invariants imposed by the query system.

This collection type is a good choice for map-like collections the keys of which don’t have a semantic ordering.

See MCP 533 for more information.

Implementations

impl<K: Eq + Hash, V> UnordMap<K, V>

pub fn with_capacity(capacity: usize) -> Self

pub fn len(&self) -> usize

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

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

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

pub fn is_empty(&self) -> bool

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

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

where 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 remove<Q>(&mut self, k: &Q) -> Option<V>

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

pub fn items(&self) -> UnordItems<(&K, &V), impl Iterator<Item = (&K, &V)>>

pub fn into_items(self) -> UnordItems<(K, V), impl Iterator<Item = (K, V)>>

pub fn to_sorted<HCX>(&self, hcx: &HCX, cache_sort_key: bool) -> Vec<(&K, &V)>

where K: ToStableHashKey<HCX>,

Returns the entries of this map in stable sort order (as defined by ToStableHashKey).

The cache_sort_key parameter controls if slice::sort_by_cached_key or slice::sort_unstable_by_key will be used for sorting the vec. Use cache_sort_key when the ToStableHashKey::to_stable_hash_key implementation for K is expensive (e.g. a DefId -> DefPathHash lookup).

pub fn to_sorted_stable_ord(&self) -> Vec<(K, &V)>

where K: Ord + StableOrd + Copy,

Returns the entries of this map in stable sort order (as defined by StableOrd). This method can be much more efficient than into_sorted because it does not need to transform keys to their ToStableHashKey equivalent.

pub fn into_sorted<HCX>(self, hcx: &HCX, cache_sort_key: bool) -> Vec<(K, V)>

where K: ToStableHashKey<HCX>,

Returns the entries of this map in stable sort order (as defined by ToStableHashKey).

The cache_sort_key parameter controls if slice::sort_by_cached_key or slice::sort_unstable_by_key will be used for sorting the vec. Use cache_sort_key when the ToStableHashKey::to_stable_hash_key implementation for K is expensive (e.g. a DefId -> DefPathHash lookup).

pub fn values_sorted<HCX>( &self, hcx: &HCX, cache_sort_key: bool ) -> impl Iterator<Item = &V>

where K: ToStableHashKey<HCX>,

Returns the values of this map in stable sort order (as defined by K’s ToStableHashKey implementation).

The cache_sort_key parameter controls if slice::sort_by_cached_key or slice::sort_unstable_by_key will be used for sorting the vec. Use cache_sort_key when the ToStableHashKey::to_stable_hash_key implementation for K is expensive (e.g. a DefId -> DefPathHash lookup).

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for UnordMap<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + Hash, V: Debug> Debug for UnordMap<K, V>

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

Formats the value using the given formatter.

impl<K, V, __D: Decoder> Decodable<__D> for UnordMap<K, V>

where K: Decodable<__D> + Eq + Hash, V: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<K: Eq + Hash, V> Default for UnordMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, __E: Encoder> Encodable<__E> for UnordMap<K, V>

where K: Encodable<__E> + Eq + Hash, V: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<K: Hash + Eq, V> Extend<(K, V)> for UnordMap<K, V>

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: Hash + Eq, V, I: Iterator<Item = (K, V)>> From<UnordItems<(K, V), I>> for UnordMap<K, V>

fn from(items: UnordItems<(K, V), I>) -> Self

Converts to this type from the input type.

impl<K: Hash + Eq, V> FromIterator<(K, V)> for UnordMap<K, V>

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

Creates a value from an iterator.

impl<HCX, K: Hash + Eq + HashStable<HCX>, V: HashStable<HCX>> HashStable<HCX> for UnordMap<K, V>

fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher)

impl<K, Q, V> Index<&Q> for UnordMap<K, V>

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

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V> !IntoIterator for UnordMap<K, V>

type Item

The type of the elements being iterated over.

type IntoIter: Iterator<Item = Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq + Eq + Hash, V: PartialEq> PartialEq for UnordMap<K, V>

fn eq(&self, other: &UnordMap<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: Eq + Eq + Hash, V: Eq> Eq for UnordMap<K, V>

impl<K: Eq + Hash, V> StructuralEq for UnordMap<K, V>

impl<K: Eq + Hash, V> StructuralPartialEq for UnordMap<K, V>