Struct indigo::sync::ConcurrentHashSet

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

A concurrent hash set provided by the dashmap crate.

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> DashSet<K, RandomState> where
    K: 'a + Eq + Hash, 

A concurrent hash set provided by the dashmap crate.

pub fn new() -> DashSet<K, RandomState>

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) -> DashSet<K, RandomState>

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, S> DashSet<K, S> where
    K: 'a + Eq + Hash,
    S: Clone + BuildHasher, 

A concurrent hash set provided by the dashmap crate.

pub fn with_hasher(hasher: S) -> DashSet<K, S>

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) -> DashSet<K, S>

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>(&self, item: &T) -> usize where
    T: Hash, 

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

pub fn clone(&self) -> DashSet<K, S>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &DashSet<K, S>)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

pub fn default() -> DashSet<K, S>

Returns the "default value" for a type.

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

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

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

pub fn from_iter<I>(iter: I) -> DashSet<K, RandomState> where
    I: IntoIterator<Item = K>, 

Creates a value from an iterator.

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

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?

pub fn into_iter(self) -> <DashSet<K, S> as IntoIterator>::IntoIter

Creates an iterator from a value.