Struct RoleMaskCache 

pub struct RoleMaskCache { /* private fields */ }

Role → resolved mask, valid for exactly one commit sequence.

Resolving a role is a full scan of the label vector, and with a visible_where predicate it is also a property read per candidate node. A scoped reader pays that on every request, and between two writes the answer cannot have changed — so it is paid once and remembered.

Never stale: an entry records the store’s commit_seq at the moment it was built and is served only when that is still the current one. Any write bumps commit_seq and the entry simply stops matching. The cache can be cold, but it cannot be wrong.

commit_seq does not move when a role definition changes — roles.json is a sidecar, not a WAL record — so the owner of the cache installs a fresh one whenever roles are rewritten or the store is reloaded. That also leaves any reader snapshot holding the old Arc with a private cache, so a snapshot frozen against the old definitions can never publish an answer the live handle would read back.

Implementations

impl RoleMaskCache

pub fn new() -> Self

pub fn get_or_build( &self, role: &str, version: u64, build: impl FnOnce() -> Result<NodeMask>, ) -> Result<Arc<NodeMask>>

Return the memoised mask for role at version, building it if the entry is absent or was built against a different commit sequence.

build runs outside the lock: it reads the store, and the cache must never be a lock ordering between two readers.

pub fn clear(&self)

Drop every entry. Correctness never depends on this — a mismatched version is already ignored — but the owner calls it when the role definitions themselves change, which commit_seq does not record.

Trait Implementations

impl Default for RoleMaskCache

fn default() -> RoleMaskCache

Returns the “default value” for a type.