Struct CodexMap 

pub struct CodexMap { /* private fields */ }

Type-indexed map storage - multiple values per type, indexed by keys.

CodexMap stores multiple values of type V indexed by keys of type K, similar to how a HashMap stores key-value pairs, but with type-level isolation where different (K, V) type pairs are stored separately.

Useful for sessions, caches, per-user data, etc.

Cloning

CodexMap is cheaply cloneable via Arc. All clones share the same storage:

use magi_codex::CodexMap;

let map = CodexMap::new();
map.insert("user_1", 100u32);

let map2 = map.clone();
assert_eq!(map2.get_cloned::<&str, u32>(&"user_1"), Some(100u32));

Implementations

impl CodexMap

pub fn new() -> Self

Create a new empty map.

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

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static,

Insert or replace a key-value pair.

Example

use magi_codex::CodexMap;

#[derive(Clone)]
struct Session { user_id: String }

let map = CodexMap::new();
map.insert("user_123", Session { user_id: "123".into() });

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

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static, F: FnOnce(&V) -> R,

Access a value immutably via a closure.

The closure runs while holding the lock on the value.

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

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static, F: FnOnce(&mut V) -> R,

Access a value mutably via a closure.

The closure runs while holding the lock on the value.

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

where K: Hash + Eq + Send + Sync + 'static, V: Clone + Send + Sync + 'static,

Clone and return a value (requires Clone).

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

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static,

Remove and return a key-value pair.

pub fn contains<K, V>(&self, key: &K) -> bool

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static,

Returns true if a key exists.

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

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static, F: FnMut(&K, &V),

Iterate over all key-value pairs via a closure.

pub fn len<K, V>(&self) -> usize

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static,

Returns the number of entries for a given type pair.

pub fn is_empty<K, V>(&self) -> bool

where K: Hash + Eq + Send + Sync + 'static, V: Send + Sync + 'static,

Returns true if there are no values of the given type.

pub fn contains2<K, V1, V2>(&self, key: &K) -> bool

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static,

Check if a key has values of two types.

pub fn contains3<K, V1, V2, V3>(&self, key: &K) -> bool

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static,

Check if a key has values of three types.

pub fn contains4<K, V1, V2, V3, V4>(&self, key: &K) -> bool

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static, V4: Send + Sync + 'static,

Check if a key has values of four types.

pub fn with2<K, V1, V2, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, F: FnOnce(&V1, &V2) -> R,

Access two value types for the same key via a closure.

pub fn with3<K, V1, V2, V3, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static, F: FnOnce(&V1, &V2, &V3) -> R,

Access three value types for the same key via a closure.

pub fn with4<K, V1, V2, V3, V4, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static, V4: Send + Sync + 'static, F: FnOnce(&V1, &V2, &V3, &V4) -> R,

Access four value types for the same key via a closure.

pub fn with2_mut<K, V1, V2, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, F: FnOnce(&mut V1, &mut V2) -> R,

Mutably access two value types for the same key via a closure.

pub fn with3_mut<K, V1, V2, V3, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static, F: FnOnce(&mut V1, &mut V2, &mut V3) -> R,

Mutably access three value types for the same key via a closure.

pub fn with4_mut<K, V1, V2, V3, V4, F, R>(&self, key: &K, f: F) -> Option<R>

where K: Hash + Eq + Send + Sync + 'static, V1: Send + Sync + 'static, V2: Send + Sync + 'static, V3: Send + Sync + 'static, V4: Send + Sync + 'static, F: FnOnce(&mut V1, &mut V2, &mut V3, &mut V4) -> R,

Mutably access four value types for the same key via a closure.

pub fn get2_cloned<K, V1, V2>(&self, key: &K) -> Option<(V1, V2)>

where K: Hash + Eq + Send + Sync + 'static, V1: Clone + Send + Sync + 'static, V2: Clone + Send + Sync + 'static,

Clone and return two value types for the same key.

pub fn get3_cloned<K, V1, V2, V3>(&self, key: &K) -> Option<(V1, V2, V3)>

where K: Hash + Eq + Send + Sync + 'static, V1: Clone + Send + Sync + 'static, V2: Clone + Send + Sync + 'static, V3: Clone + Send + Sync + 'static,

Clone and return three value types for the same key.

pub fn get4_cloned<K, V1, V2, V3, V4>( &self, key: &K, ) -> Option<(V1, V2, V3, V4)>

where K: Hash + Eq + Send + Sync + 'static, V1: Clone + Send + Sync + 'static, V2: Clone + Send + Sync + 'static, V3: Clone + Send + Sync + 'static, V4: Clone + Send + Sync + 'static,

Clone and return four value types for the same key.

Trait Implementations

impl Clone for CodexMap

fn clone(&self) -> CodexMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for CodexMap

fn default() -> Self

Returns the “default value” for a type.