Struct DashSet

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

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 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>(&self, key: &Q) -> Option<K>

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

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>(&self, key: &Q, f: impl FnOnce(&K) -> bool) -> Option<K>

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

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>(&'a self, key: &Q) -> Option<Ref<'a, K>>

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

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>(&self, key: &Q) -> bool

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

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.

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<K: Eq + Hash, S: BuildHasher + Clone + Default> FromIterator<K> for DashSet<K, S>

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

Creates a value from an iterator.

impl<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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.