Struct lockfree::set::Set

pub struct Set<T, H = RandomState> { /* private fields */ }

A lock-free set. This is currently implemented on top of Map. To check more details about it, please see Map docs.

Implementations

impl<T> Set<T>

pub fn new() -> Self

Creates a Set with the default hasher builder.

pub fn with_incin(incin: SharedIncin<T>) -> Self

Creates the Set using the given shared incinerator.

impl<T, H> Set<T, H>

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

Creates an iterator over guarded references to the elements.

impl<T, H> Set<T, H>where
    H: BuildHasher,

pub fn with_hasher(builder: H) -> Self

Creates a Set with the given hasher builder.

pub fn with_hasher_and_incin(builder: H, incin: SharedIncin<T>) -> Self

Creates the Set using the given hasher builder and shared incinerator.

pub fn incin(&self) -> SharedIncin<T>

The shared incinerator used by this Map.

pub fn hasher(&self) -> &H

Returns the hasher builder used by this Set.

pub fn optimize_space(&mut self)

Tries to optimize space by removing unnecessary tables without removing any element. This method cannot be performed in a shared context.

pub fn clear(&mut self)

Removes all elements. This method cannot be performed in a shared context.

pub fn contains<U>(&self, elem: &U) -> boolwhere
    U: Hash + Ord,
    T: Borrow<U>,

Tests if the given element is present on the Set. The method accepts a type resulted from borrowing the stored element. This method will only work correctly if Hash and Ord are implemented in the same way for the borrowed type and the stored type.

pub fn get<'set, U>(&'set self, elem: &U) -> Option<ReadGuard<'set, T>>where
    U: Hash + Ord,
    T: Borrow<U>,

Returns a guarded reference to the given element in the Set. This may be useful for types with additional metadata. The method accepts a type resulted from borrowing the stored element. This method will only work correctly if Hash and Ord are implemented in the same way for the borrowed type and the stored type. If the element is not found, None is obviously returned.

pub fn insert(&self, elem: T) -> Result<(), T>where
    T: Hash + Ord,

Inserts the element into the Set. If the element was already present, Err(the_passed_value) is returned.

pub fn insert_with<F>(&self, elem: T, interactive: F) -> Insertion<T, T>where
    F: FnMut(&T, Option<&T>) -> bool,
    T: Hash + Ord,

Inserts interactively the element into the Set. A passed closure tests if the insertion should proceed. The first argument of the closure is the element passed to insert_with and the second is the stored found element, if any. The closure returns whether the insertion should go on. This method is useful for types with metadata.

pub fn reinsert(&self, elem: Removed<T>) -> Result<(), Removed<T>>where
    T: Hash + Ord,

Tries to reinsert a previously removed element. The element must have been either:

1. Removed from this very Set.
2. Removed from an already dead Set.
3. Removed from a Set which has no sensitive reads active.

If the removed element does not fit any category, the insertion will fail. Otherwise, insertion cannot fail.

pub fn reinsert_with<F>(
    &self,
    elem: Removed<T>,
    interactive: F
) -> Insertion<T, Removed<T>>where
    F: FnMut(&T, Option<&T>) -> bool,
    T: Hash + Ord,

Tries to reinsert interactively a previously removed element. A closure is passed to test if the reinsertion should proceed The first argument to the closure is a reference to the given element and the second is a reference to the found stored element, if any. The closure returns whether the reinsertion should go on. The removed element must have been either:

1. Removed from this very Set.
2. Removed from an already dead Set.
3. Removed from a Set which has no sensitive reads active.

If the removed element does not fit any category, the insertion will fail. Otherwise, insertion cannot fail.

pub fn remove<U>(&self, elem: &U) -> Option<Removed<T>>where
    U: Hash + Ord,
    T: Borrow<U>,

Removes the given element inconditionally. The method accepts a type resulted from borrowing the stored element. This method will only work correctly if Hash and Ord are implemented in the same way for the borrowed type and the stored type.

pub fn remove_with<U, F>(&self, elem: &U, interactive: F) -> Option<Removed<T>>where
    U: Hash + Ord,
    T: Borrow<U>,
    F: FnMut(&T) -> bool,

Removes interactively the given element. A closure is passed to validate the removal. The only argument passed to the closure is a reference to the found stored element. The return value is whether the removal should happen or not. The method accepts a type resulted from borrowing the stored element. This method will only work correctly if Hash and Ord are implemented in the same way for the borrowed type and the stored type.

pub fn extend<I>(&self, iterable: I)where
    I: IntoIterator<Item = T>,
    T: Hash + Ord,

Acts just like Extend::extend but does not require mutability.

Trait Implementations

impl<T, H> Debug for Set<T, H>where
    H: Debug,

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

Formats the value using the given formatter.

impl<T, H> Default for Set<T, H>where
    H: BuildHasher + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, H> Extend<T> for Set<T, H>where
    H: BuildHasher,
    T: Hash + Ord,

fn extend<I>(&mut self, iterable: 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, H> FromIterator<T> for Set<T, H>where
    H: BuildHasher + Default,
    T: Hash + Ord,

fn from_iter<I>(iterable: I) -> Selfwhere
    I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'set, T, H> IntoIterator for &'set Set<T, H>

type Item = ReadGuard<'set, T>

The type of the elements being iterated over.

type IntoIter = Iter<'set, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, H> IntoIterator for Set<T, H>

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.