Struct scc::HashIndex

pub struct HashIndex<K, V, H> where
    K: Clone + Eq + Hash + Sync,
    V: Clone + Sync,
    H: BuildHasher,  { /* fields omitted */ }

A scalable concurrent hash index implementation.

scc::HashIndex is a concurrent hash index data structure that is optimized for read operations.

Implementations

impl<K, V, H> HashIndex<K, V, H> where
    K: Clone + Eq + Hash + Sync,
    V: Clone + Sync,
    H: BuildHasher, 

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

Creates an empty HashIndex instance with the given capacity and build hasher.

The actual capacity is equal to or greater than the given capacity. It is recommended to give a capacity value that is larger than 16 * the number of threads to access the HashMap.

Panics

Panics if memory allocation fails.

Examples

use scc::HashIndex;
use std::collections::hash_map::RandomState;

let hashindex: HashIndex<u64, u32, RandomState> = HashIndex::new(0, RandomState::new());

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

Inserts a key-value pair into the HashIndex.

Returns an error with the given key-value pair attached if the key exists.

Panics

Panics if memory allocation fails, or the number of entries in the target cell reaches u32::MAX.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let result = hashindex.insert(1, 1);
if let Err((key, value)) = result {
    assert_eq!(key, 1);
    assert_eq!(value, 1);
} else {
    assert!(false);
}

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

Removes a key-value pair.

Returns false if the key does not exist.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let result = hashindex.remove(&1);
assert!(result);

pub fn read<R, F: FnOnce(&K, &V) -> R>(&self, key: &K, f: F) -> Option<R>

Reads a key-value pair.

Errors

Returns None if the key does not exist.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let result = hashindex.read(&1, |_, &value| value);
if let Some(result) = result {
    assert_eq!(result, 0);
} else {
    assert!(false);
}

pub fn clear(&self)

Clears all the key-value pairs.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let result = hashindex.len(|capacity| capacity);
assert_eq!(result, 1);

hashindex.clear();

let result = hashindex.len(|capacity| capacity);
assert_eq!(result, 0);

pub fn len<F: FnOnce(usize) -> usize>(&self, f: F) -> usize

Returns an estimated size of the HashIndex.

The given function determines the sampling size. A function returning a fixed number larger than u16::MAX yields around 99% accuracy.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let result = hashindex.len(|capacity| capacity);
assert_eq!(result, 1);

let result = hashindex.len(|capacity| capacity / 2);
assert!(result == 0 || result == 2);

pub fn capacity(&self) -> usize

Returns the capacity of the HashIndex.

Examples

use scc::HashIndex;
use std::collections::hash_map::RandomState;

let hashindex: HashIndex<u64, u32, RandomState> = HashIndex::new(1000000, RandomState::new());

let result = hashindex.capacity();
assert_eq!(result, 1048576);

pub fn hasher(&self) -> &H

Returns a reference to its build hasher.

Examples

use scc::HashIndex;
use std::collections::hash_map::RandomState;

let hashindex: HashIndex<u64, u32, _> = Default::default();
let result: &RandomState = hashindex.hasher();

pub fn iter(&self) -> Visitor<'_, K, V, H>

Returns a Visitor.

It is guaranteed to go through all the key-value pairs pertaining in the HashIndex at the moment, however the same key-value pair can be visited more than once if the HashIndex is being resized.

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

let result = hashindex.insert(1, 0);
assert!(result.is_ok());

let mut iter = hashindex.iter();
assert_eq!(iter.next(), Some((&1, &0)));
assert_eq!(iter.next(), None);

for iter in hashindex.iter() {
    assert_eq!(iter, (&1, &0));
}

Trait Implementations

impl<K, V> Default for HashIndex<K, V, RandomState> where
    K: Clone + Eq + Hash + Sync,
    V: Clone + Sync, 

fn default() -> Self

Creates a HashIndex instance with the default parameters.

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

Panics

Panics if memory allocation fails.

use scc::HashIndex;

let hashindex: HashIndex<u64, u32, _> = Default::default();

impl<K, V, H> Drop for HashIndex<K, V, H> where
    K: Clone + Eq + Hash + Sync,
    V: Clone + Sync,
    H: BuildHasher, 

fn drop(&mut self)

Executes the destructor for this type.