Struct SeqMap

pub struct SeqMap<K: Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Copy + Clone + Send + Sync + 'static, H: Hasher + Default = DefaultHasher> { /* private fields */ }

A concurrent, lock-free hash map implementation that can sustain rapid expansion and high contention on every key, while allowing for concurrent reads and writes.

Based on the interior mutability provided by SeqArray, this map uses open addressing with linear probing to provide a highly concurrent map interface, and can be safely shared and passed between threads. without issue.

use seqmap::SeqMap;

let map = SeqMap::<u64, u8>::new();

map.insert(1, 42);
map.insert(2, 43);

std::thread::scope(|s| {
   s.spawn(|| {
       assert_eq!(map.get(1), Some(42));
       map.insert(3, 100);
   });
   s.spawn(|| {
      assert_eq!(map.get(2), Some(43));
      map.insert(4, 101);
   });
});

assert_eq!(map.get(1), Some(42));
assert_eq!(map.get(2), Some(43));
assert_eq!(map.get(3), Some(100));
assert_eq!(map.get(4), Some(101));

Implementations

impl<K: Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Copy + Clone + Send + Sync + 'static, H: Hasher + Default> SeqMap<K, V, H>

pub fn new() -> Self

Creates a new SeqMap with an initial capacity of 10.

pub fn with_capacity(size: usize) -> Self

Creates a new SeqMap with the specified initial capacity.

pub fn insert(&self, key: K, value: V)

where K: Debug, V: Debug + PartialEq,

Inserts a key-value pair into the map, resizing if necessary.

If a resize or snapshot (i.e. Clone) is already in progress, it will block until the resize or snapshot is complete.

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

Retrieves a value by key from the map.

If a resize is in progress, it will block until the resize is complete.

Trait Implementations

impl<K: Clone + Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Clone + Copy + Clone + Send + Sync + 'static, H: Clone + Hasher + Default> Clone for SeqMap<K, V, H>

fn clone(&self) -> SeqMap<K, V, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Default + Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Default + Copy + Clone + Send + Sync + 'static, H: Default + Hasher + Default> Default for SeqMap<K, V, H>

fn default() -> SeqMap<K, V, H>

Returns the “default value” for a type.

impl<K: PartialEq + Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: PartialEq + Copy + Clone + Send + Sync + 'static, H: PartialEq + Hasher + Default> PartialEq for SeqMap<K, V, H>

fn eq(&self, other: &SeqMap<K, V, H>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Eq + Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Eq + Copy + Clone + Send + Sync + 'static, H: Eq + Hasher + Default> Eq for SeqMap<K, V, H>

impl<K: Hash + PartialEq + Eq + Copy + Clone + Send + Sync + 'static, V: Copy + Clone + Send + Sync + 'static, H: Hasher + Default> StructuralPartialEq for SeqMap<K, V, H>