Struct CellMap 

pub struct CellMap<K, V, M = CellMutable>
where
    K: Hash + Eq + CellValue,
    V: CellValue,
{ /* private fields */ }

A reactive HashMap with per-key observability.

Example

use hyphae::{CellMap, Gettable, Watchable, Signal};

let map = CellMap::<String, i32>::new();

// Observe a specific key
let value_cell = map.get(&"counter".to_string());
assert_eq!(value_cell.get(), None);

// Insert triggers update
map.insert("counter".to_string(), 42);
assert_eq!(value_cell.get(), Some(42));

// Observe all entries
let entries = map.entries();
assert_eq!(entries.get().len(), 1);

Implementations

impl<K, V> CellMap<K, V, CellMutable>

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

pub fn new() -> Self

Create a new empty CellMap.

pub fn own(&self, guard: SubscriptionGuard)

Own a subscription guard, keeping it alive as long as this CellMap exists.

pub fn own_guard(&self, guard: SubscriptionGuard)

Own a subscription guard, keeping it alive as long as this CellMap exists.

This enables building custom reactive CellMaps driven by external cells.

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

Insert a key-value pair, returning the old value if present.

pub fn insert_many(&self, entries: Vec<(K, V)>)

Insert multiple key-value pairs and emit a single batch diff.

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

Remove a key, returning the old value if present.

pub fn remove_many(&self, keys: Vec<K>)

Remove multiple keys and emit a single batch diff.

pub fn replace_all(&self, entries: Vec<(K, V)>)

Replace all entries atomically, emitting a single Batch diff.

Removes keys not in entries, inserts/updates keys that are. Skips no-op updates (existing key with equal value). Emits MapDiff::Batch with the actual changes so downstream subscribers see one atomic replacement instead of N individual diffs.

pub fn apply_batch(&self, changes: Vec<MapDiff<K, V>>)

Apply a batch of diffs and emit them as one MapDiff::Batch.

pub fn with_name(self, name: impl Into<Arc<str>>) -> Self

Give this CellMap a name for debugging. Names its internal cells accordingly.

pub fn lock(self) -> CellMap<K, V, CellImmutable>

Lock the map to prevent further mutations.

impl<K, V, M> CellMap<K, V, M>

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

pub fn downgrade(&self) -> WeakCellMap<K, V>

Create a weak handle to this map.

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

Get an observable Cell for a specific key.

Returns a Cell<Option<V>> that updates whenever the key’s value changes. Multiple calls with the same key return the same underlying Cell.

pub fn entries(&self) -> Cell<Vec<(K, V)>, CellImmutable>

Get an observable Cell of all entries.

Returns a derived cell that maintains entries incrementally via diffs. The initial value is computed from the current map state, then updates are applied incrementally as O(1) operations per diff.

pub fn items(&self) -> Cell<Vec<V>, CellImmutable>

Get an observable Cell of all values.

This maintains its own diff-driven projection to avoid forcing an intermediate entries materialization on hot value-only paths.

pub fn keys(&self) -> Cell<Vec<K>, CellImmutable>

Get an observable Cell of all keys.

pub fn size(&self) -> Cell<usize, CellImmutable>

Get an observable Cell of the map size.

This is the preferred reactive count operator because it reuses the internally maintained length cell instead of materializing entries.

pub fn len(&self) -> Cell<usize, CellImmutable>

Get an observable Cell of the map length.

Alias for CellMap::size.

pub fn is_empty(&self) -> bool

Check if map is empty (non-reactive).

pub fn diffs(&self) -> Cell<MapDiff<K, V>, CellImmutable>

Get an observable Cell of diff notifications.

Emits MapDiff updates. Starts with MapDiff::Initial { entries: vec![] }.

pub fn snapshot(&self) -> Vec<(K, V)>

Get a point-in-time snapshot of all entries (non-reactive).

Unlike entries(), this does NOT create a Cell or subscribe to changes. Use this for one-shot reads where you don’t need live updates.

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

Check if key exists (non-reactive).

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

Get current value for key (non-reactive).

pub fn subscribe_diffs<F>(&self, callback: F) -> SubscriptionGuard

where F: Fn(&MapDiff<K, V>) + Send + Sync + 'static,

Subscribe to diffs with an initial snapshot.

The callback is first called with MapDiff::Initial containing all current entries, then called with subsequent diffs as the map changes.

Returns a guard that cancels the subscription when dropped.

impl<K, V, M> CellMap<K, V, M>

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

pub fn nest<PK>( &self, fk: impl Fn(&V) -> PK + Send + Sync + 'static, ) -> NestedMap<PK, K, V>

where PK: Hash + Eq + CellValue,

Create a grouped view of this map, partitioned by a foreign-key extractor.

The returned NestedMap observes this CellMap reactively and maintains a live FK index. It implements ReactiveKeys and ReactiveMap, so it composes with joins exactly like a CellMap.

let orders: CellMap<OrderId, Order> = CellMap::new();
let nested = orders.nest(|order| order.customer_id.clone());
// nested: NestedMap<CustomerId, OrderId, Order>

Trait Implementations

impl<K, V, M: Clone> Clone for CellMap<K, V, M>

where K: Hash + Eq + CellValue + Clone, V: CellValue + Clone,

fn clone(&self) -> CellMap<K, V, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Default for CellMap<K, V, CellMutable>

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

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, M> MapQuery<K, V> for CellMap<K, V, M>

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

fn materialize(self) -> CellMap<K, V, CellImmutable>

No-op materialize: the cell map is already a cached, multicast source. Just flip the marker to CellImmutable and reuse the same Arc<inner>.

impl<K, V, M> ReactiveKeys for CellMap<K, V, M>

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

type Key = K

fn key_set(&self) -> Vec<K>

Snapshot of all current keys. Non-reactive, point-in-time.

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

Does key currently exist? Non-reactive, point-in-time.

fn subscribe_keys( &self, cb: impl Fn(&KeyChange<K>) + Send + Sync + 'static, ) -> SubscriptionGuard

Subscribe to key-set changes.

impl<K, V, M> ReactiveMap for CellMap<K, V, M>

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

type Value = V

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

Point-in-time value lookup by key.

fn snapshot(&self) -> Vec<(K, V)>

Point-in-time snapshot of all entries.

fn subscribe_diffs_reactive( &self, cb: impl Fn(&MapDiff<K, V>) + Send + Sync + 'static, ) -> SubscriptionGuard

Subscribe to diffs with an initial snapshot.