Struct contrie::set::ConSet

pub struct ConSet<T, S = RandomState> where
    T: Clone + Hash + Eq + 'static,  { /* fields omitted */ }

A concurrent lock-free set.

Note that due to the limitations described in the crate level docs, values returned by looking up (or misplacing or removing) are always copied using the Clone trait. Therefore, the set is more suitable for types that are cheap to copy (eg. u64 or IpAddr).

If you intend to store types that are more expensive to make copies of or are not Clone, you can wrap them in an Arc (eg. Arc<str>).

use contrie::ConSet;
use crossbeam_utils::thread;

let set = ConSet::new();

thread::scope(|s| {
    s.spawn(|_| {
        set.insert("hello");
    });
    s.spawn(|_| {
        set.insert("world");
    });
}).unwrap();

assert_eq!(Some("hello"), set.get("hello"));
assert_eq!(Some("world"), set.get("world"));
assert_eq!(None, set.get("universe"));
set.remove("world");
assert_eq!(None, set.get("world"));

use contrie::set::{ConSet};
let set: ConSet<usize> = ConSet::new();

set.insert(0);
set.insert(1);

assert!(set.contains(&1));

set.remove(&1);
assert!(!set.contains(&1));

set.remove(&0);
assert!(set.is_empty());

Methods

impl<T> ConSet<T, RandomState> where
    T: Clone + Hash + Eq + 'static, 

pub fn new() -> Self

Creates a new empty set.

impl<T, S> ConSet<T, S> where
    T: Clone + Hash + Eq + 'static,
    S: BuildHasher, 

pub fn with_hasher(hasher: S) -> Self

Creates a new empty set with the given hasher.

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

Inserts a new value into the set.

It returns the previous value, if any was present.

pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<T> where
    Q: Eq + Hash,
    T: Borrow<Q>, 

Looks up a value in the set.

This creates a copy of the original value.

pub fn contains<Q: ?Sized>(&self, key: &Q) -> bool where
    Q: Eq + Hash,
    T: Borrow<Q>, 

Checks if a value identified by the given key is present in the set.

Note that by the time you can act on it, the presence of the value can change (eg. other thread can add or remove it in the meantime).

pub fn remove<Q: ?Sized>(&self, key: &Q) -> Option<T> where
    Q: Eq + Hash,
    T: Borrow<Q>, 

Removes an element identified by the given key, returning it.

pub fn is_empty(&self) -> bool

Checks if the set is currently empty.

Note that due to being concurrent, the use-case of this method is mostly for debugging purposes, because the state can change between reading the value and acting on it.

impl<T, S> ConSet<T, S> where
    T: Clone + Hash + Eq + 'static, 

Important traits for Iter<'a, T, S>

impl<'a, T, S> Iterator for Iter<'a, T, S> where
    T: Clone + Hash + Eq + 'static,  type Item = T;

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

Returns an iterator through the elements of the set.

Trait Implementations

impl<T> Default for ConSet<T, RandomState> where
    T: Clone + Hash + Eq + 'static, 

fn default() -> Self

Returns the "default value" for a type.

impl<'a, T, S> IntoIterator for &'a ConSet<T, S> where
    T: Clone + Hash + Eq + 'static, 

type Item = T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, S> Extend<T> for &'a ConSet<T, S> where
    T: Clone + Hash + Eq + 'static,
    S: BuildHasher, 

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

Extends a collection with the contents of an iterator.

impl<T, S> Extend<T> for ConSet<T, S> where
    T: Clone + Hash + Eq + 'static,
    S: BuildHasher, 

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

Extends a collection with the contents of an iterator.

impl<T, S> Debug for ConSet<T, S> where
    T: Debug + Clone + Hash + Eq + 'static, 

fn fmt(&self, fmt: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<T> FromIterator<T> for ConSet<T> where
    T: Clone + Hash + Eq + 'static, 

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

Creates a value from an iterator.

impl<T> FromParallelIterator<T> for ConSet<T> where
    T: Clone + Hash + Eq + Send + Sync, 

fn from_par_iter<I>(iter: I) -> Self where
    I: IntoParallelIterator<Item = T>, 

Creates an instance of the collection from the parallel iterator par_iter.

impl<'a, T, S> ParallelExtend<T> for &'a ConSet<T, S> where
    T: Clone + Hash + Eq + Send + Sync,
    S: BuildHasher + Sync, 

fn par_extend<I>(&mut self, par_iter: I) where
    I: IntoParallelIterator<Item = T>, 

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

impl<T, S> ParallelExtend<T> for ConSet<T, S> where
    T: Clone + Hash + Eq + Send + Sync,
    S: BuildHasher + Sync, 

fn par_extend<I>(&mut self, par_iter: I) where
    I: IntoParallelIterator<Item = T>, 

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.