Struct LinkedHashSet

pub struct LinkedHashSet<T, S = DefaultHashBuilder> { /* private fields */ }

Implementations

impl<T: Hash + Eq> LinkedHashSet<T, DefaultHashBuilder>

pub fn new() -> LinkedHashSet<T, DefaultHashBuilder>

pub fn with_capacity(capacity: usize) -> LinkedHashSet<T, DefaultHashBuilder>

impl<T, S> LinkedHashSet<T, S>

pub fn capacity(&self) -> usize

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn drain(&mut self) -> Drain<'_, T>

pub fn clear(&mut self)

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&T) -> bool,

impl<T, S> LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

pub fn with_hasher(hasher: S) -> LinkedHashSet<T, S>

pub fn with_capacity_and_hasher( capacity: usize, hasher: S, ) -> LinkedHashSet<T, S>

pub fn hasher(&self) -> &S

pub fn reserve(&mut self, additional: usize)

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

pub fn shrink_to_fit(&mut self)

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

pub fn symmetric_difference<'a>( &'a self, other: &'a LinkedHashSet<T, S>, ) -> SymmetricDifference<'a, T, S>

pub fn intersection<'a>( &'a self, other: &'a LinkedHashSet<T, S>, ) -> Intersection<'a, T, S>

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

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

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

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

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

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

pub fn get_or_insert_with<Q, F>(&mut self, value: &Q, f: F) -> &T

where T: Borrow<Q>, Q: Hash + Eq + ?Sized, F: FnOnce(&Q) -> T,

pub fn is_disjoint(&self, other: &LinkedHashSet<T, S>) -> bool

pub fn is_subset(&self, other: &LinkedHashSet<T, S>) -> bool

pub fn is_superset(&self, other: &LinkedHashSet<T, S>) -> bool

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

Inserts the given value into the set.

If the set did not have this value present, inserts it at the back of the internal linked list and returns true, otherwise it moves the existing value to the back of the internal linked list and returns false.

pub fn replace(&mut self, value: T) -> Option<T>

Adds the given value to the set, replacing the existing value.

If a previous value existed, returns the replaced value. In this case, the value’s position in the internal linked list is not changed.

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

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

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

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

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

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

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

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

pub fn to_front<Q>(&mut self, value: &Q) -> bool

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

pub fn to_back<Q>(&mut self, value: &Q) -> bool

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

pub fn retain_with_order<F>(&mut self, f: F)

where F: FnMut(&T) -> bool,

Trait Implementations

impl<'a, 'b, T, S> BitAnd<&'b LinkedHashSet<T, S>> for &'a LinkedHashSet<T, S>

where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = LinkedHashSet<T, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &LinkedHashSet<T, S>) -> LinkedHashSet<T, S>

Performs the & operation.

impl<'a, 'b, T, S> BitOr<&'b LinkedHashSet<T, S>> for &'a LinkedHashSet<T, S>

where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = LinkedHashSet<T, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &LinkedHashSet<T, S>) -> LinkedHashSet<T, S>

Performs the | operation.

impl<'a, 'b, T, S> BitXor<&'b LinkedHashSet<T, S>> for &'a LinkedHashSet<T, S>

where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = LinkedHashSet<T, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &LinkedHashSet<T, S>) -> LinkedHashSet<T, S>

Performs the ^ operation.

impl<T: Hash + Eq + Clone, S: BuildHasher + Clone> Clone for LinkedHashSet<T, S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for LinkedHashSet<T, S>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, S> Default for LinkedHashSet<T, S>

where S: Default,

fn default() -> LinkedHashSet<T, S>

Returns the “default value” for a type.

impl<'a, T, S> Extend<&'a T> for LinkedHashSet<T, S>

where T: 'a + Eq + Hash + Copy, S: BuildHasher,

fn extend<I: IntoIterator<Item = &'a 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, S> Extend<T> for LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

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, S> FromIterator<T> for LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher + Default,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> LinkedHashSet<T, S>

Creates a value from an iterator.

impl<T, S> Hash for LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T, S> IntoIterator for &'a LinkedHashSet<T, S>

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) -> Iter<'a, T>

Creates an iterator from a value.

impl<T, S> IntoIterator for LinkedHashSet<T, S>

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) -> IntoIter<T>

Creates an iterator from a value.

impl<T, S> PartialEq for LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

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, 'b, T, S> Sub<&'b LinkedHashSet<T, S>> for &'a LinkedHashSet<T, S>

where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = LinkedHashSet<T, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &LinkedHashSet<T, S>) -> LinkedHashSet<T, S>

Performs the - operation.

impl<T, S> Eq for LinkedHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,