Struct DiskHashMap

pub struct DiskHashMap<K, V, BS, S = FxBuildHasher>
where
    BS: ByteStore,
    S: BuildHasher + Default,
{ /* private fields */ }

This is an open address hash map implementation with trait-based encoding/decoding. It takes any types that implement BytesEncode/BytesDecode as key and value. It is designed to be used with a backing store that implements ByteStore trait, allowing for flexible storage options (in-memory with VecStore or persistent with MMapFile). The ByteStore is not used directly; instead we rely on Buffers which is technically a Vec<Box<[u8]>> but backed by a ByteStore trait.

Implementations

impl<K, V, BS, S> DiskHashMap<K, V, BS, S>

where BS: ByteStore, S: BuildHasher + Default,

pub fn with_stores(entry_store: BS, keys_store: BS, values_store: BS) -> Self

Creates a new HashMap with the given backing stores

pub fn len(&self) -> usize

Returns the number of key-value pairs in the map

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements

pub fn capacity(&self) -> usize

Returns the current capacity of the map

pub fn load_factor(&self) -> f64

Returns the load factor of the map (size / capacity)

pub fn stats(&self) -> (u64, u64, u64)

impl<K: for<'a> BytesEncode<'a>, V: for<'a> BytesEncode<'a> + for<'a> BytesDecode<'a>, BS: ByteStore, S: BuildHasher + Default> DiskHashMap<K, V, BS, S>

pub fn insert<'a>( &'a mut self, key: &'a <K as BytesEncode<'a>>::EItem, value: &'a <V as BytesEncode<'a>>::EItem, ) -> Result<Option<<V as BytesDecode<'a>>::DItem>, Box<dyn Error + Sync + Send>>

Insert a key-value pair into the map using the trait-based API

pub fn get<'a>( &self, key: &'a <K as BytesEncode<'a>>::EItem, ) -> Result<Option<<V as BytesDecode<'_>>::DItem>, Box<dyn Error + Sync + Send>>

Get a value by key using the trait-based API

pub fn entry<'a>( &'a mut self, key: &'a <K as BytesEncode<'a>>::EItem, ) -> Result<MapEntry<'a, K, V, BS, S>, Box<dyn Error + Sync + Send>>

where for<'b> K: BytesEncode<'b>, for<'b> V: BytesDecode<'b>,

Get an entry for the given key using trait-based API

impl<K, V> DiskHashMap<K, V, VecStore, FxBuildHasher>

pub fn new() -> Self

Creates a new in-memory HashMap

impl<K, V, S> DiskHashMap<K, V, MMapFile, S>

where S: BuildHasher + Default,

pub fn new_in(path: &Path) -> Result<Self>

pub fn with_capacity( path: impl AsRef<Path>, num_entries: usize, keys_bytes: usize, values_bytes: usize, ) -> Result<Self>

Creates a new HashMap with specified capacities, rounding up to nearest power of 2

pub fn load_from(path: &Path) -> Result<Self>

Trait Implementations

impl<K, V> Default for DiskHashMap<K, V, VecStore, FxBuildHasher>

fn default() -> Self

Returns the “default value” for a type.