Struct contrie::clonemap::CloneConMap

pub struct CloneConMap<K, V, S = RandomState> where
    K: Clone + Hash + Eq + 'static,
    V: Clone + 'static,  { /* fields omitted */ }

A concurrent map that clones its elements.

This flavour stores the data as (K, V) tuples; it clones independently both the elements (to be intended as the key and the value) of the tuple. The return values of its functions are clones of the stored values. This makes this data structure suitable for types cheap to clone.

Iteration returns cloned copies of its elements. The FromIterator and Extend traits accept tuples as arguments. Furthermore, the Extend is also implemented for shared references (to allow extending the same map concurrently from multiple threads).

Examples

use contrie::CloneConMap;
use crossbeam_utils::thread;

let map = CloneConMap::new();

thread::scope(|s| {
    s.spawn(|_| {
        map.insert("hello", 1);
    });
    s.spawn(|_| {
        map.insert("world", 2);
    });
}).unwrap();
assert_eq!(1, map.get("hello").unwrap().1);
assert_eq!(2, map.get("world").unwrap().1);

use contrie::clonemap::{CloneConMap};

let map_1: CloneConMap<usize, Vec<usize>> = CloneConMap::new();

map_1.insert(42, vec![1, 2, 3]);
map_1.insert(43, vec![1, 2, 3, 4]);

assert_eq!(3, map_1.get(&42).unwrap().1.len());
assert_eq!(4, map_1.get(&43).unwrap().1.len());
assert_eq!(None, map_1.get(&44));

let map_2 = CloneConMap::new();
map_2.insert(44, map_1.get(&43).unwrap().1);
assert_eq!(4, map_2.get(&44).unwrap().1.len());

Methods

impl<K, V> CloneConMap<K, V> where
    K: Clone + Hash + Eq + 'static,
    V: Clone + 'static, 

pub fn new() -> Self

Creates a new empty map.

impl<K, V, S> CloneConMap<K, V, S> where
    K: Clone + Hash + Eq + 'static,
    V: Clone + 'static,
    S: BuildHasher, 

pub fn insert(&self, key: K, value: V) -> Option<(K, V)>

Inserts a new element as a tuple (key, value).

Any previous element with the same key is replaced and returned.

pub fn get_or_insert(&self, key: K, value: V) -> ExistingOrNew<(K, V)>

Looks up or inserts an element as a tuple (key, value).

It looks up an element. If it isn't present, the provided one is inserted instead. Either way, an element is returned.

pub fn get_or_insert_with<F>(&self, key: K, create: F) -> ExistingOrNew<(K, V)> where
    F: FnOnce() -> V, 

Looks up or inserts a newly created element.

It looks up an element. If it isn't present, the provided closure is used to create a new one insert it. Either way, an element is returned.

Quirks

Due to races in case of concurrent accesses, the closure may be called even if the value is not subsequently inserted and an existing element is returned. This should be relatively rare (another thread must insert the new element between this method observes an empty slot and manages to insert the new element).

pub fn get_or_insert_default(&self, key: K) -> ExistingOrNew<(K, V)> where
    V: Default, 

Looks up or inserts a default value of an element.

This is like get_or_insert_with, but a default value is used instead of manually providing a closure.

impl<K, V, S> CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone,
    S: BuildHasher, 

pub fn with_hasher(hasher: S) -> Self

Creates a new empty map, but with the provided hasher implementation.

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

Looks up an element.

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

Removes an element identified by the given key, returning it.

impl<K, V, S> CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone, 

pub fn is_empty(&self) -> bool

Checks if the map is currently empty.

Note that due to the nature of concurrent map, this is inherently racy ‒ another thread may add or remove elements between you call this method and act based on the result.

Important traits for Iter<'a, K, V, S>

impl<'a, K, V, S> Iterator for Iter<'a, K, V, S> where
    K: Clone + Hash + Eq + 'static,
    V: Clone + 'static,  type Item = (K, V);

pub fn iter(&self) -> Iter<K, V, S>

Returns an iterator through the elements of the map.

Trait Implementations

impl<K, V, S> Clone for CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone,
    S: Clone + BuildHasher, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Default for CloneConMap<K, V> where
    K: Clone + Hash + Eq,
    V: Clone, 

fn default() -> Self

Returns the "default value" for a type.

impl<'a, K, V, S> IntoIterator for &'a CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone, 

type Item = (K, V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, S> Extend<(K, V)> for &'a CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone,
    S: BuildHasher, 

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

Extends a collection with the contents of an iterator.

impl<K, V, S> Extend<(K, V)> for CloneConMap<K, V, S> where
    K: Clone + Hash + Eq,
    V: Clone,
    S: BuildHasher, 

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

Extends a collection with the contents of an iterator.

impl<K, V, S> Debug for CloneConMap<K, V, S> where
    K: Debug + Clone + Hash + Eq,
    V: Debug + Clone, 

fn fmt(&self, fmt: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<K, V> FromIterator<(K, V)> for CloneConMap<K, V> where
    K: Clone + Hash + Eq,
    V: Clone, 

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = (K, V)>, 

Creates a value from an iterator.

impl<K, V> FromParallelIterator<(K, V)> for CloneConMap<K, V> where
    K: Clone + Hash + Eq + Send + Sync,
    V: Clone + Send + Sync, 

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

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

impl<K, V, S> ParallelExtend<(K, V)> for CloneConMap<K, V, S> where
    K: Clone + Hash + Eq + Send + Sync,
    S: BuildHasher + Sync,
    V: Clone + Send + Sync, 

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

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

impl<'a, K, V, S> ParallelExtend<(K, V)> for &'a CloneConMap<K, V, S> where
    K: Clone + Hash + Eq + Send + Sync,
    S: BuildHasher + Sync,
    V: Clone + Send + Sync, 

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

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