Struct OrderedHashSet

pub struct OrderedHashSet<Key, BH = RandomState>(/* private fields */);

Implementations

impl<Key, BH> OrderedHashSet<Key, BH>

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

Returns an iterator over the values of the set, in their order.

impl<Key: Hash + Eq, BH> OrderedHashSet<Key, BH>

pub fn len(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

pub fn clear(&mut self)

Remove all elements in the set, while preserving its capacity.

Computes in O(n) time.

impl<Key: Hash + Eq, BH: BuildHasher> OrderedHashSet<Key, BH>

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

Inserts the value into the set.

If an equivalent item already exists in the set, returns false. Otherwise, returns true.

pub fn extend<I: IntoIterator<Item = Key>>(&mut self, iter: I)

Extends the set with the content of the given iterator.

pub fn contains<Q: ?Sized + Hash + Equivalent<Key>>(&self, value: &Q) -> bool

Returns true if an equivalent to value exists in the set.

pub fn shift_remove<Q: ?Sized + Hash + Equivalent<Key>>( &mut self, value: &Q, ) -> bool

Removes the value from the set, preserving the order of elements.

Returns true if the value was present in the set.

pub fn swap_remove<Q: ?Sized + Hash + Equivalent<Key>>( &mut self, value: &Q, ) -> bool

Removes the value by swapping it with the last element, thus the order of elements is not preserved, but the resulting order is still deterministic.

Returns true if the value was present in the set.

pub fn difference<'a, S2>( &'a self, other: &'a OrderedHashSet<Key, S2>, ) -> Difference<'a, Key, S2>

where S2: BuildHasher,

pub fn is_subset<S2: BuildHasher>( &self, other: &OrderedHashSet<Key, S2>, ) -> bool

Returns true if all elements of self are contained in other.

pub fn is_superset<S2: BuildHasher>( &self, other: &OrderedHashSet<Key, S2>, ) -> bool

Returns true if all elements of other are contained in self.

pub fn union<'a, BH2: BuildHasher>( &'a self, other: &'a OrderedHashSet<Key, BH2>, ) -> Union<'a, Key, BH>

Return an iterator over all values that are either in self or other.

Values from self are produced in their original order, followed by values that are unique to other in their original order.

Trait Implementations

impl<Key: Clone, BH: Clone> Clone for OrderedHashSet<Key, BH>

fn clone(&self) -> OrderedHashSet<Key, BH>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Key: Debug, BH: Debug> Debug for OrderedHashSet<Key, BH>

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

Formats the value using the given formatter.

impl<Key, BH: Default> Default for OrderedHashSet<Key, BH>

fn default() -> Self

Returns the “default value” for a type.

impl<Key: Hash + Eq, BH: BuildHasher + Default> FromIterator<Key> for OrderedHashSet<Key, BH>

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

Creates a value from an iterator.

impl<'a, Key, BH> IntoIterator for &'a OrderedHashSet<Key, BH>

type Item = &'a Key

The type of the elements being iterated over.

type IntoIter = <&'a IndexSet<Key, BH> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Key, BH> IntoIterator for OrderedHashSet<Key, BH>

type Item = Key

The type of the elements being iterated over.

type IntoIter = <IndexSet<Key, BH> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Key: Eq, BH> PartialEq for OrderedHashSet<Key, BH>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Key, BH> Sub for &'a OrderedHashSet<Key, BH>

where &'a IndexSet<Key, BH>: Sub<Output = IndexSet<Key, BH>>,

type Output = OrderedHashSet<Key, BH>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<Key: Eq, BH> Eq for OrderedHashSet<Key, BH>