Struct starlark_map::small_set::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() -> Self

Creates an empty SmallSet.

pub fn with_capacity(n: usize) -> Self

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: ?Sized + Hash + Equivalent<T>, 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: ?Sized + Hash + Equivalent<T>, 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 Self) -> 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 Self) -> 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: &Self) -> bool

where T: PartialEq,

Equal if entries are equal in iteration order.

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

where 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> Allocative for SmallSet<T>

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

impl<T: Clone> Clone for SmallSet<T>

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> Debug for SmallSet<T>

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

Formats the value using the given formatter.

impl<T> Default for SmallSet<T>

fn default() -> Self

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<Self, D::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: IntoIterator<Item = T>>(&mut self, iter: I)

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> From<SmallSet<T>> for OrderedSet<T>

fn from(set: SmallSet<T>) -> OrderedSet<T>

Converts to this type from the input type.

impl<T> From<SmallSet<T>> for SortedSet<T>

where T: Eq + Ord + Hash,

fn from(inner: SmallSet<T>) -> SortedSet<T>

Converts to this type from the input type.

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

where T: Hash + Eq,

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

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) -> Self::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) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for SmallSet<T>

where T: Eq,

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Eq for SmallSet<T>

where T: Eq,