Struct ExHashMap 

pub struct ExHashMap<'a, K, V, C: HashContext<K>> { /* private fields */ }

A high-performance open-addressing hash map with SIMD probing.

Type Parameters

• 'a — Lifetime of the allocator reference.
• K — Key type.
• V — Value type.
• C — HashContext<K> providing hash and equality functions.

Memory Layout

Two separate heap allocations:

1. ctrl — cap + GROUP_WIDTH control bytes. The extra GROUP_WIDTH bytes at the end are mirror copies of the first GROUP_WIDTH control bytes, enabling SIMD group loads at the table boundary without out-of-bounds access.
2. data — cap [Slot<K, V>] entries.

Both allocations are freed on drop.

Implementations

impl<'a, K, V, C: HashContext<K>> ExHashMap<'a, K, V, C>

pub fn new(alloc: &'a dyn Allocator, ctx: C) -> Self

Creates a new, empty map that will allocate through alloc.

No memory is allocated until the first insertion.

Examples found in repository

examples/hash_map.rs (line 8)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

pub fn len(&self) -> usize

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

Examples found in repository

examples/hash_map.rs (line 19)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

pub fn capacity(&self) -> usize

Returns the current table capacity.

Examples found in repository

examples/hash_map.rs (line 19)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

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

Returns a reference to the value associated with key, or None.

Examples found in repository

examples/hash_map.rs (line 13)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

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

Returns a mutable reference to the value associated with key, or None.

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

Returns true if the map contains an entry for key.

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

Inserts key→val, returning the previous value for key if it existed.

Panics

Panics if the allocator fails during table growth.

Examples found in repository

examples/hash_map.rs (line 10)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

pub fn try_insert(&mut self, key: K, val: V) -> Result<Option<V>, (K, V)>

Attempts to insert key→val.

Returns:

• Ok(None) — new entry inserted.
• Ok(Some(old)) — key already existed; old value returned.
• Err((key, val)) — allocation failed; inputs returned to caller.

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

Removes the entry for key and returns its value, or None.

Uses backward-shift deletion to preserve the probing invariant without a tombstone mechanism.

Examples found in repository

examples/hash_map.rs (line 17)

fn main() {
    let alloc = SystemAllocator;
    let ctx = U64HashCtx;
    
    let mut map = ExHashMap::new(&alloc, ctx);

    map.insert(42, 100);
    map.insert(1337, 9000);

    if let Some(val) = map.get(&42) {
        println!("Found: {}", val);
    }

    map.remove(&1337);

    println!("Map len: {}, capacity: {}", map.len(), map.capacity());
}

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

Iterates over all key-value pairs, calling f for each.

The iteration order is unspecified.

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

Iterates over all key-value pairs with mutable access to values.

Trait Implementations

impl<K, V, C: HashContext<K>> Drop for ExHashMap<'_, K, V, C>

fn drop(&mut self)

Drops all live key-value pairs and releases both backing allocations.