Struct scc::hash_set::HashSet

source · [−]

pub struct HashSet<K, H = RandomState> where
    K: 'static + Eq + Hash + Sync,
    H: BuildHasher,  { /* private fields */ }

Expand description

Scalable concurrent hash set data structure.

HashSet is a concurrent hash set based on HashMap. It internally uses a HashMap as its key container, thus sharing all the characteristics of HashMap.

Implementations

source

impl<K, H> HashSet<K, H> where
K: 'static + Eq + Hash + Sync,
H: BuildHasher,

source

pub fn new(capacity: usize, build_hasher: H) -> HashSet<K, H>

Creates an empty HashSet with the given capacity and BuildHasher.

The actual capacity is equal to or greater than the given capacity.

Panics

Panics if memory allocation fails.

Examples

use scc::HashSet;
use std::collections::hash_map::RandomState;

let hashset: HashSet<u64, RandomState> = HashSet::new(1000, RandomState::new());

let result = hashset.capacity();
assert_eq!(result, 1024);

let hashset: HashSet<u64> = HashSet::default();
let result = hashset.capacity();
assert_eq!(result, 64);

source

pub fn reserve(&self, capacity: usize) -> Option<Ticket<'_, K, H>>

Temporarily increases the minimum capacity of the HashSet.

The reserved space is not exclusively owned by the Ticket, thus can be overtaken. Unused space is immediately reclaimed when the Ticket is dropped.

Errors

Returns None if a too large number is given.

Examples

use scc::HashSet;
use std::collections::hash_map::RandomState;

let hashset: HashSet<usize, RandomState> = HashSet::new(1000, RandomState::new());
assert_eq!(hashset.capacity(), 1024);

let ticket = hashset.reserve(10000);
assert!(ticket.is_some());
assert_eq!(hashset.capacity(), 16384);
for i in 0..16 {
    assert!(hashset.insert(i).is_ok());
}
drop(ticket);

assert_eq!(hashset.capacity(), 1024);

source

pub fn insert(&self, key: K) -> Result<(), K>

Inserts a key-value pair into the HashSet.

Errors

Returns an error along with the supplied key if the key exists.

Panics

Panics if memory allocation fails, or the number of entries in the target cell reaches u32::MAX.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert_eq!(hashset.insert(1).unwrap_err(), 1);

source

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

Removes a key-value pair if the key exists.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.remove(&1).is_none());
assert!(hashset.insert(1).is_ok());
assert_eq!(hashset.remove(&1).unwrap(), 1);

source

pub fn remove_if<Q, F: FnOnce() -> bool>(
 &self,
 key_ref: &Q,
 condition: F
) -> Option<K> where
 K: Borrow<Q>,
 Q: Eq + Hash + ?Sized,

Removes a key-value pair if the key exists and the given condition is met.

The key is locked while evaluating the condition.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert!(hashset.remove_if(&1, || false).is_none());
assert_eq!(hashset.remove_if(&1, || true).unwrap(), 1);

source

pub fn read<Q, R, F: FnOnce(&K) -> R>(
 &self,
 key_ref: &Q,
 reader: F
) -> Option<R> where
 K: Borrow<Q>,
 Q: Eq + Hash + ?Sized,

Reads a key.

It returns None if the key does not exist.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.read(&1, |_| true).is_none());
assert!(hashset.insert(1).is_ok());
assert!(hashset.read(&1, |_| true).unwrap());

source

pub fn read_with<'b, Q, R, F: FnOnce(&'b K) -> R>(
 &self,
 key_ref: &Q,
 reader: F,
 barrier: &'b Barrier
) -> Option<R> where
 K: Borrow<Q>,
 Q: Eq + Hash + ?Sized,

Reads a key using the supplied Barrier.

It enables the caller to use the value reference outside the method. It returns None if the key does not exist.

Examples

use scc::ebr::Barrier;
use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());

let barrier = Barrier::new();
let key_ref = hashset.read_with(&1, |k| k, &barrier).unwrap();
assert_eq!(*key_ref, 1);

source

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

Checks if the key exists.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(!hashset.contains(&1));
assert!(hashset.insert(1).is_ok());
assert!(hashset.contains(&1));

source

pub fn for_each<F: FnMut(&K)>(&self, f: F)

Iterates over all the keys in the HashSet.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert!(hashset.insert(2).is_ok());

let mut acc = 0;
hashset.for_each(|k| { acc += *k; });
assert_eq!(acc, 3);

source

pub fn retain<F: FnMut(&K) -> bool>(&self, filter: F) -> (usize, usize )

Retains keys that satisfy the given predicate.

It returns the number of keys remaining and removed.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert!(hashset.insert(2).is_ok());
assert!(hashset.insert(3).is_ok());

assert_eq!(hashset.retain(|k| *k == 1), (1, 2));

source

pub fn clear(&self) -> usize

Clears all the keys.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert_eq!(hashset.clear(), 1);

source

pub fn len(&self) -> usize

Returns the number of entries in the HashSet.

It scans the entire array to calculate the number of valid entries, making its time complexity O(N).

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.insert(1).is_ok());
assert_eq!(hashset.len(), 1);

source

pub fn is_empty(&self) -> bool

Returns true if the HashSet is empty.

It scans the entire array to calculate the number of valid entries, making its time complexity O(N).

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

assert!(hashset.is_empty());

Panics

Panics if memory allocation fails.

Examples

use scc::HashSet;

let hashset: HashSet<u64> = HashSet::default();

let result = hashset.capacity();
assert_eq!(result, 64);

Auto Trait Implementations

impl<K, H> RefUnwindSafe for HashSet<K, H> where
H: RefUnwindSafe,

impl<K, H> Send for HashSet<K, H> where
H: Send,

impl<K, H> Sync for HashSet<K, H> where
H: Sync,

impl<K, H> Unpin for HashSet<K, H> where
H: Unpin,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct scc::hash_set::HashSet

Implementations

impl<K, H> HashSet<K, H> where K: 'static + Eq + Hash + Sync, H: BuildHasher,

pub fn new(capacity: usize, build_hasher: H) -> HashSet<K, H>

pub fn reserve(&self, capacity: usize) -> Option<Ticket<'_, K, H>>

pub fn insert(&self, key: K) -> Result<(), K>

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

pub fn remove_if<Q, F: FnOnce() -> bool>( &self, key_ref: &Q, condition: F) -> Option<K> where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

pub fn read<Q, R, F: FnOnce(&K) -> R>( &self, key_ref: &Q, reader: F) -> Option<R> where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

pub fn read_with<'b, Q, R, F: FnOnce(&'b K) -> R>( &self, key_ref: &Q, reader: F, barrier: &'b Barrier) -> Option<R> where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

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

pub fn for_each<F: FnMut(&K)>(&self, f: F)

pub fn retain<F: FnMut(&K) -> bool>(&self, filter: F) -> (usize, usize)

pub fn clear(&self) -> usize

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

Trait Implementations

impl<K: 'static + Eq + Hash + Sync> Default for HashSet<K, RandomState>

fn default() -> Self

Auto Trait Implementations

impl<K, H> RefUnwindSafe for HashSet<K, H> where H: RefUnwindSafe,

impl<K, H> Send for HashSet<K, H> where H: Send,

impl<K, H> Sync for HashSet<K, H> where H: Sync,

impl<K, H> Unpin for HashSet<K, H> where H: Unpin,

impl<K, H = RandomState> !UnwindSafe for HashSet<K, H>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<K, H> HashSet<K, H> where
K: 'static + Eq + Hash + Sync,
H: BuildHasher,

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

pub fn remove_if<Q, F: FnOnce() -> bool>(
&self,
key_ref: &Q,
condition: F
) -> Option<K> where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,

pub fn read<Q, R, F: FnOnce(&K) -> R>(
&self,
key_ref: &Q,
reader: F
) -> Option<R> where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,

pub fn read_with<'b, Q, R, F: FnOnce(&'b K) -> R>(
&self,
key_ref: &Q,
reader: F,
barrier: &'b Barrier
) -> Option<R> where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,

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

pub fn retain<F: FnMut(&K) -> bool>(&self, filter: F) -> (usize, usize )

impl<K, H> RefUnwindSafe for HashSet<K, H> where
H: RefUnwindSafe,

impl<K, H> Send for HashSet<K, H> where
H: Send,

impl<K, H> Sync for HashSet<K, H> where
H: Sync,

impl<K, H> Unpin for HashSet<K, H> where
H: Unpin,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,