Struct dashmap::DashSet

pub struct DashSet<K, S = RandomState> { /* fields omitted */ }

DashSet is a thin wrapper around DashMap using () as the value type. It uses methods and types which are more convenient to work with on a set.

Implementations

impl<'a, K: 'a + Eq + Hash> DashSet<K, RandomState>

pub fn new() -> Self

Creates a new DashSet with a capacity of 0.

Examples

use dashmap::DashSet;

let games = DashSet::new();
games.insert("Veloren");

pub fn with_capacity(capacity: usize) -> Self

Creates a new DashMap with a specified starting capacity.

Examples

use dashmap::DashSet;

let numbers = DashSet::with_capacity(2);
numbers.insert(2);
numbers.insert(8);

impl<'a, K: 'a + Eq + Hash, S: BuildHasher + Clone> DashSet<K, S>

pub fn with_hasher(hasher: S) -> Self

Creates a new DashMap with a capacity of 0 and the provided hasher.

Examples

use dashmap::DashSet;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let games = DashSet::with_hasher(s);
games.insert("Veloren");

pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> Self

Creates a new DashMap with a specified starting capacity and hasher.

Examples

use dashmap::DashSet;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let numbers = DashSet::with_capacity_and_hasher(2, s);
numbers.insert(2);
numbers.insert(8);

pub fn hash_usize<T: Hash>(&self, item: &T) -> usize

Hash a given item to produce a usize. Uses the provided or default HashBuilder.

pub fn shards(&self) -> &[RwLock<HashMap<K, SharedValue<()>, S>>]

Allows you to peek at the inner shards that store your data. You should probably not use this unless you know what you are doing.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashSet;

let set = DashSet::<()>::new();
println!("Amount of shards: {}", set.shards().len());

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

Finds which shard a certain key is stored in. You should probably not use this unless you know what you are doing. Note that shard selection is dependent on the default or provided HashBuilder.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashSet;

let set = DashSet::new();
set.insert("coca-cola");
println!("coca-cola is stored in shard: {}", set.determine_map("coca-cola"));

pub fn determine_shard(&self, hash: usize) -> usize

Finds which shard a certain hash is stored in.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashSet;

let set: DashSet<i32> = DashSet::new();
let key = "key";
let hash = set.hash_usize(&key);
println!("hash is stored in shard: {}", set.determine_shard(hash));

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

Inserts a key into the set. Returns true if the key was not already in the set.

Examples

use dashmap::DashSet;

let set = DashSet::new();
set.insert("I am the key!");

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

Removes an entry from the map, returning the key if it existed in the map.

Examples

use dashmap::DashSet;

let soccer_team = DashSet::new();
soccer_team.insert("Jack");
assert_eq!(soccer_team.remove("Jack").unwrap(), "Jack");

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

Removes an entry from the set, returning the key if the entry existed and the provided conditional function returned true.

use dashmap::DashSet;

let soccer_team = DashSet::new();
soccer_team.insert("Sam");
soccer_team.remove_if("Sam", |player| player.starts_with("Ja"));
assert!(soccer_team.contains("Sam"));

use dashmap::DashSet;

let soccer_team = DashSet::new();
soccer_team.insert("Sam");
soccer_team.remove_if("Jacob", |player| player.starts_with("Ja"));
assert!(!soccer_team.contains("Jacob"));

pub fn iter(&'a self) -> Iter<'a, K, S, DashMap<K, (), S>>

Creates an iterator over a DashMap yielding immutable references.

Examples

use dashmap::DashSet;

let words = DashSet::new();
words.insert("hello");
assert_eq!(words.iter().count(), 1);

pub fn get<Q: ?Sized>(&'a self, key: &Q) -> Option<Ref<'a, K, S>> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Get a reference to an entry in the set

Examples

use dashmap::DashSet;

let youtubers = DashSet::new();
youtubers.insert("Bosnian Bill");
assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");

pub fn shrink_to_fit(&self)

Remove excess capacity to reduce memory usage.

pub fn retain(&self, f: impl FnMut(&K) -> bool)

Retain elements that whose predicates return true and discard elements whose predicates return false.

Examples

use dashmap::DashSet;

let people = DashSet::new();
people.insert("Albin");
people.insert("Jones");
people.insert("Charlie");
people.retain(|name| name.contains('i'));
assert_eq!(people.len(), 2);

pub fn len(&self) -> usize

Fetches the total number of keys stored in the set.

Examples

use dashmap::DashSet;

let people = DashSet::new();
people.insert("Albin");
people.insert("Jones");
people.insert("Charlie");
assert_eq!(people.len(), 3);

pub fn is_empty(&self) -> bool

Checks if the set is empty or not.

Examples

use dashmap::DashSet;

let map = DashSet::<()>::new();
assert!(map.is_empty());

pub fn clear(&self)

Removes all keys in the set.

Examples

use dashmap::DashSet;

let people = DashSet::new();
people.insert("Albin");
assert!(!people.is_empty());
people.clear();
assert!(people.is_empty());

pub fn capacity(&self) -> usize

Returns how many keys the set can store without reallocating.

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

Checks if the set contains a specific key.

Examples

use dashmap::DashSet;

let people = DashSet::new();
people.insert("Dakota Cherries");
assert!(people.contains("Dakota Cherries"));

Trait Implementations

impl<K: Eq + Hash + Clone, S: Clone> Clone for DashSet<K, S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Eq + Hash + Debug, S: BuildHasher + Clone> Debug for DashSet<K, S>

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

Formats the value using the given formatter.

impl<K, S> Default for DashSet<K, S> where
    K: Eq + Hash,
    S: Default + BuildHasher + Clone, 

fn default() -> Self

Returns the “default value” for a type.

impl<K: Eq + Hash, S: BuildHasher + Clone> Extend<K> for DashSet<K, S>

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

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub 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<K: Eq + Hash> FromIterator<K> for DashSet<K, RandomState>

fn from_iter<I: IntoIterator<Item = K>>(iter: I) -> Self

Creates a value from an iterator.

impl<K, S> FromParallelIterator<K> for DashSet<K, S> where
    K: Send + Sync + Eq + Hash,
    S: Send + Sync + Clone + Default + BuildHasher, 

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = K>, 

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

impl<'a, K: Eq + Hash, S: BuildHasher + Clone> IntoIterator for DashSet<K, S>

type Item = K

The type of the elements being iterated over.

type IntoIter = OwningIter<K, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, S> IntoParallelIterator for DashSet<K, S> where
    K: Send + Eq + Hash,
    S: Send + Clone + BuildHasher, 

type Iter = OwningIter<K, S>

The parallel iterator type that will be created.

type Item = K

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'a, K, S> IntoParallelIterator for &'a DashSet<K, S> where
    K: Send + Sync + Eq + Hash,
    S: Send + Sync + Clone + BuildHasher, 

type Iter = Iter<'a, K, S>

The parallel iterator type that will be created.

type Item = RefMulti<'a, K, S>

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

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

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

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

impl<K, S> ParallelExtend<K> for &DashSet<K, S> where
    K: Send + Sync + Eq + Hash,
    S: Send + Sync + Clone + BuildHasher, 

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

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