Struct hkalbasi_rustc_ap_rustc_data_structures::unord::UnordSet

pub struct UnordSet<V: Eq + Hash> { /* private fields */ }

This is a set 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 set-like collections the keys of which don’t have a semantic ordering.

See MCP 533 for more information.

Implementations

impl<V: Eq + Hash> UnordSet<V>

pub fn new() -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn insert(&mut self, v: V) -> bool

pub fn contains<Q>(&self, v: &Q) -> boolwhere V: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

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

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

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

Returns the items of this set 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 V is expensive (e.g. a DefId -> DefPathHash lookup).

pub fn to_sorted_stable_ord(&self) -> Vec<V>where V: Ord + StableOrd + Copy,

Returns the items of this set in stable sort order (as defined by StableOrd). This method is 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<V>where V: ToStableHashKey<HCX>,

Returns the items of this set 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 V is expensive (e.g. a DefId -> DefPathHash lookup).

pub fn extend_unord<I: Iterator<Item = V>>(&mut self, items: UnordItems<V, I>)

pub fn clear(&mut self)

Trait Implementations

impl<V: Clone + Eq + Hash> Clone for UnordSet<V>

fn clone(&self) -> UnordSet<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug + Eq + Hash> Debug for UnordSet<V>

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

Formats the value using the given formatter.

impl<V, __D: Decoder> Decodable<__D> for UnordSet<V>where V: Decodable<__D> + Eq + Hash,

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

impl<V: Eq + Hash> Default for UnordSet<V>

fn default() -> Self

Returns the “default value” for a type.

impl<V, __E: Encoder> Encodable<__E> for UnordSet<V>where V: Encodable<__E> + Eq + Hash,

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

impl<V: Hash + Eq> Extend<V> for UnordSet<V>

fn extend<T: IntoIterator<Item = 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<V: Hash + Eq> From<HashSet<V, BuildHasherDefault<FxHasher>>> for UnordSet<V>

fn from(value: FxHashSet<V>) -> Self

Converts to this type from the input type.

impl<V: Hash + Eq> FromIterator<V> for UnordSet<V>

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

Creates a value from an iterator.

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

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

impl<V> !IntoIterator for UnordSet<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<V: PartialEq + Eq + Hash> PartialEq<UnordSet<V>> for UnordSet<V>

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

impl<V: Eq + Hash> StructuralEq for UnordSet<V>

impl<V: Eq + Hash> StructuralPartialEq for UnordSet<V>