Struct ConcurrentHashMap 

pub struct ConcurrentHashMap<K, V> { /* private fields */ }

A concurrent map that can be used to store key-value pairs.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<u32, &'static str> = ConcurrentHashMap::new();

Errors

• ConcurrentCollectionError::Poison: The lock is poisoned

Trait Implementations

impl<K: Debug, V: Debug> Debug for ConcurrentHashMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for ConcurrentHashMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V> Map<K, V> for ConcurrentHashMap<K, V>

where K: Eq + Hash + Send + Sync, V: Copy,

fn new() -> Self

Creates a new empty crate::collections::ConcurrentHashMap

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

fn insert(&self, key: K, value: V) -> Result<(), ConcurrentCollectionError>

Inserts a key-value pair into the map.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

map.insert("key", "value").unwrap();

Errors

• ConcurrentCollectionError::Poison: The lock is poisoned

fn get(&self, key: &K) -> Option<V>

Retrieves a value from the map.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

map.get(&"key").unwrap();

fn remove(&self, key: &K) -> Option<V>

Removes a key-value pair from the map.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

map.insert("key", "value").unwrap();
map.remove(&"key").unwrap();

fn len(&self) -> usize

Returns the number of key-value pairs in the map.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

map.insert("key", "value").unwrap();
assert_eq!(map.len(), 1);

fn is_empty(&self) -> bool

Returns true if the map contains no key-value pairs.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

assert!(map.is_empty());

map.insert("key", "value").unwrap();
assert!(!map.is_empty());

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

Returns true if the map contains the specified key.

Examples

use handy::collections::{ConcurrentHashMap, Map};

let map: ConcurrentHashMap<&'static str, &'static str> = ConcurrentHashMap::new();

map.insert("key", "value").unwrap();
assert!(map.contains_key(&"key"));