Struct starlark::collections::SmallSet

pub struct SmallSet<T>(/* private fields */);

An memory-efficient set with deterministic order, based on SmallMap.

Implementations

impl<T> SmallSet<T>

pub const fn new() -> SmallSet<T>

Creates an empty SmallSet.

pub fn with_capacity(n: usize) -> SmallSet<T>

Empty small set with preallocated capacity.

pub fn capacity(&self) -> usize

Current capacity of the set.

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

Iterate the element references.

pub fn iter_hashed(&self) -> IterHashed<'_, T>

Iterate the hashed element references.

pub fn iter_mut_unchecked(&mut self) -> IterMutUnchecked<'_, T>

Iterate the mutable element references.

This operation is memory safe, but otherwise no guarantees if keys are mutated inconsistently (hash or equality changes).

pub fn into_iter_hashed(self) -> IntoIterHashed<T>

Into hashed entries.

pub fn insert(&mut self, key: T) -> bool

where T: Hash + Eq,

Insert the element into the set.

Return true iff the element was inserted.

pub fn insert_unique_unchecked(&mut self, key: T)

where T: Hash,

Insert the element into the set without checking for a duplicate entry.

pub fn insert_hashed(&mut self, key: Hashed<T>) -> bool

where T: Eq,

Insert the element into the set.

Return true iff the element was inserted.

pub fn insert_hashed_unique_unchecked(&mut self, key: Hashed<T>)

Insert an entry into the set without checking for a duplicate key.

pub fn get<Q>(&self, value: &Q) -> Option<&T>

where Q: Hash + Equivalent<T> + ?Sized, T: Eq,

Return a reference to the value stored in the set, if it is present, else None.

Computes in O(1) time (average).

pub fn get_hashed<Q>(&self, value: Hashed<&Q>) -> Option<&T>

where Q: Equivalent<T> + ?Sized, T: Eq,

Query the set by a prehashed value.

pub fn get_index(&self, index: usize) -> Option<&T>

Find an entry by an index.

pub fn get_index_of<Q>(&self, value: &Q) -> Option<usize>

where Q: Hash + Equivalent<T> + ?Sized, T: Eq,

Return item index, if it exists in the set

pub fn get_index_of_hashed<Q>(&self, value: Hashed<&Q>) -> Option<usize>

where Q: Equivalent<T> + ?Sized, T: Eq,

Find the index of the given hashed value.

pub fn get_index_of_hashed_by_value<Q>(&self, value: Hashed<Q>) -> Option<usize>

where Q: Equivalent<T>, T: Eq,

Find the index of the given hashed value.

This operations is similar to get_index_of_hashed, but it takes the key by value, instead of by reference which sometimes generates better code.

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

where Q: Hash + Equivalent<T> + ?Sized, T: Eq,

Remove the element from the set if it is present.

Time complexity of this operation is O(N) where N is the number of entries in the set.

pub fn get_or_insert(&mut self, value: T) -> &T

where T: Hash + Eq,

Insert entry if it doesn’t exist.

Return the resulting entry in the map.

pub fn get_or_insert_owned<Q>(&mut self, value: &Q) -> &T

where Q: Hash + Equivalent<T> + ToOwned<Owned = T> + ?Sized, T: Eq,

Insert entry if it doesn’t exist.

Return the resulting entry in the map.

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

where Q: Hash + Equivalent<T> + ?Sized, T: Eq,

Remove the element from the set if it is present,

and return the removed element.

pub fn pop(&mut self) -> Option<T>

where T: Eq,

Remove the last element from the set.

pub fn is_empty(&self) -> bool

Is the set empty?

pub fn len(&self) -> usize

Number of elements in the set.

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

where Q: Hash + Equivalent<T> + ?Sized, T: Eq,

Check if the set contains an element.

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

where Q: Equivalent<T> + ?Sized, T: Eq,

Check if the set contains an element.

pub fn clear(&mut self)

Remove all elements from the set.

Retain the capacity.

pub fn first(&self) -> Option<&T>

Returns a reference to the first item.

pub fn last(&self) -> Option<&T>

Returns a reference to the last item.

pub fn difference<'a>(&'a self, other: &'a SmallSet<T>) -> Difference<'a, T>

where T: Eq + Hash,

Iterator over elements of this set which are not in the other set.

pub fn union<'a>(&'a self, other: &'a SmallSet<T>) -> Union<'a, T>

where T: Eq + Hash,

Iterator over union of two sets.

Iteration order is: elements of this set followed by elements in the other set not present in this set.

pub fn sort(&mut self)

where T: Ord,

Sort entries.

pub fn eq_ordered(&self, other: &SmallSet<T>) -> bool

where T: PartialEq,

Equal if entries are equal in iteration order.

pub fn hash_ordered<H>(&self, state: &mut H)

where H: Hasher, T: Hash,

Hash entries in iteration order.

Note, entries are not hashed, but previously computed hashes are hashed instead.

pub fn reverse(&mut self)

Reverse the iteration order of the set.

Trait Implementations

impl<T> Allocative for SmallSet<T>

where T: Allocative,

fn visit<'allocative_a, 'allocative_b>( &self, visitor: &'allocative_a mut Visitor<'allocative_b> )

where 'allocative_b: 'allocative_a,

impl<T> Clone for SmallSet<T>

where T: Clone,

fn clone(&self) -> SmallSet<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SmallSet<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for SmallSet<T>

fn default() -> SmallSet<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for SmallSet<T>

where T: Deserialize<'de> + Hash + Eq,

fn deserialize<D>( deserializer: D ) -> Result<SmallSet<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Extend<T> for SmallSet<T>

where T: Eq + Hash,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = 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<T> Freeze for SmallSet<T>

where T: Freeze,

type Frozen = SmallSet<<T as Freeze>::Frozen>

When type is frozen, it is frozen into this type.

fn freeze(self, freezer: &Freezer) -> Result<Self::Frozen>

Freeze a value. The frozen value must be equal to the original, and produce the same hash.

impl<T> FromIterator<T> for SmallSet<T>

where T: Hash + Eq,

fn from_iter<I>(iter: I) -> SmallSet<T>

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'a, T> IntoIterator for &'a SmallSet<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a SmallSet<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for SmallSet<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <SmallSet<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for SmallSet<T>

where T: Eq,

fn eq(&self, other: &SmallSet<T>) -> 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<T> Serialize for SmallSet<T>

where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'v, T: Trace<'v>> Trace<'v> for SmallSet<T>

fn trace(&mut self, tracer: &Tracer<'v>)

Recursively “trace” the value.

impl<T> Eq for SmallSet<T>

where T: Eq,