Struct scc::awaitable::hash_map::HashMap

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

Scalable concurrent hash map data structure for asynchronous code.

The data structure is almost identical to HashMap except that most methods return future thereby allowing the data structures to be used in asynchronous code without blocking execution.

Implementations

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

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

Creates an empty HashMap 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::awaitable::HashMap;
use std::collections::hash_map::RandomState;

let hashmap: HashMap<u64, u32, RandomState> = HashMap::new(1000, RandomState::new());

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

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

Inserts a key-value pair into the HashMap.

Errors

Returns an error along with the supplied key-value pair.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
let future_insert = hashmap.insert(11, 17);

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

Reads a key-value pair.

It returns None if the key does not exist.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
let future_insert = hashmap.insert(11, 17);
let future_read = hashmap.read(&11, |_, v| *v);

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

Removes a key-value pair if the key exists.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
let future_insert = hashmap.insert(11, 17);
let future_remove = hashmap.remove(&11);

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

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

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
let future_insert = hashmap.insert(11, 17);
let future_remove = hashmap.remove_if(&11, |_| true);

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

Iterates over all the entries in the HashMap.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

let future_insert = hashmap.insert(1, 0);
let future_for_each = hashmap.for_each(|k, v| println!("{} {}", k, v));

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

Retains key-value pairs that satisfy the given predicate.

It returns the number of entries remaining and removed.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

let future_insert = hashmap.insert(1, 0);
let future_retain = hashmap.retain(|k, v| *k == 1);

pub async fn clear(&self) -> usize

Clears all the key-value pairs.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

let future_insert = hashmap.insert(1, 0);
let future_clear = hashmap.clear();

pub fn len(&self) -> usize

Returns the number of entries in the HashMap.

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

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

assert_eq!(hashmap.len(), 0);

pub fn is_empty(&self) -> bool

Returns true if the HashMap is empty.

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

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

assert!(hashmap.is_empty());

pub fn capacity(&self) -> usize

Returns the capacity of the HashMap.

Examples

use scc::awaitable::HashMap;
use std::collections::hash_map::RandomState;

let hashmap: HashMap<u64, u32, RandomState> = HashMap::new(1000000, RandomState::new());
assert_eq!(hashmap.capacity(), 1048576);

Trait Implementations

impl<K, V> Default for HashMap<K, V, RandomState> where
    K: 'static + Eq + Hash + Sync,
    V: 'static + Sync, 

fn default() -> Self

Creates a HashMap with the default parameters.

The default hash builder is RandomState, and the default capacity is 64.

Panics

Panics if memory allocation fails.

Examples

use scc::awaitable::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();