Struct ParcodeMapPromise 

pub struct ParcodeMapPromise<'a, K, V> { /* private fields */ }

A promise for a HashMap that supports lazy loading and efficient lookups.

This type wraps a ChunkNode representing a HashMap and provides methods to:

• Load the entire map into memory
• Perform O(1) lookups by key without loading the entire map

Implementations

impl<'a, K, V> ParcodeMapPromise<'a, K, V>

where K: Hash + Eq + DeserializeOwned, V: DeserializeOwned,

pub fn new(node: ChunkNode<'a>) -> Self

Internal constructor.

pub fn load(&self) -> Result<HashMap<K, V>>

Loads the full map by iterating all shards.

This reconstructs the entire HashMap in memory by:

1. Reading the number of shards from the container
2. Iterating over each shard and deserializing its entries
3. Merging all entries into a single HashMap

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

Performs a fast lookup for a single key without loading the entire map.

This method:

1. Computes the hash of the key
2. Determines which shard contains the key (via modulo)
3. Loads only that shard
4. Scans the shard’s hash array for matches
5. Verifies the key on hash collision and returns the value

Performance

• O(1) shard selection
• O(N/S) linear scan within shard (where S = number of shards)
• SIMD-optimized hash comparison on supported platforms

impl<'a, K, V> ParcodeMapPromise<'a, K, V>

where K: Hash + Eq + DeserializeOwned + Send + Sync + 'static, V: ParcodeItem + Send + Sync + ParcodeLazyRef<'a> + 'a,

pub fn get_lazy(&self, key: &K) -> Result<Option<V::Lazy>>

Performs a lazy lookup for a single key.

This returns a Lazy Mirror of the value, allowing access to its local fields without loading its heavy dependencies.

Trait Implementations

impl<'a, K: Debug, V: Debug> Debug for ParcodeMapPromise<'a, K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.