Struct InMemoryIndex 

pub struct InMemoryIndex { /* private fields */ }

A simple in-memory registry — for tests and ephemeral workspaces. No tombstones: an unregistered ID is forgotten entirely.

Implementations

impl InMemoryIndex

pub fn new() -> InMemoryIndex

An empty registry.

pub fn len(&self) -> usize

The number of registered IDs.

pub fn is_empty(&self) -> bool

Whether the registry is empty.

Trait Implementations

impl Clone for InMemoryIndex

fn clone(&self) -> InMemoryIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InMemoryIndex

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

Formats the value using the given formatter.

impl Default for InMemoryIndex

fn default() -> InMemoryIndex

Returns the “default value” for a type.

impl IdIndex for InMemoryIndex

fn resolve(&self, id: &Id) -> Option<PathBuf>

Resolve an ID to its current path. None for unknown and tombstoned IDs — use is_known to tell them apart.

fn id_for_path(&self, path: &Path) -> Option<Id>

The ID currently assigned to path, if any.

fn is_known(&self, id: &Id) -> bool

Whether id has ever been issued — live or tombstoned. This is the mint-with-rejection predicate: a fresh ID must be !is_known.

impl IndexStore for InMemoryIndex

fn register(&mut self, id: &Id, path: &Path)

Displacing an existing registration must not leave the other map pointing at the old counterpart — set_path delegates here for exactly this care. Without it a collision leaves the registry claiming two paths for one id (or two ids for one path), which nothing downstream can make sense of.

Eviction is the last line of defence, not the intended path: callers that register (or move, via set_path) an id they did not just mint should ask prov’s Workspace::registration_conflict or prov’s Workspace::move_conflict first and refuse, because the document being displaced still spells the id in its own frontmatter. What this guarantees is only that the index stays consistent when something slips through.

fn set_path(&mut self, id: &Id, new_path: &Path)

Moving an id onto a path is the same bijection-safe upsert as registering it there fresh — displacing in either direction must not leave the other map pointing at the old counterpart — so this is register, not a near-duplicate of it. Before this delegated, a displacement in the new-path direction went unevicted: new_path’s previous id kept a forward entry pointing at a path it no longer owned, the exact two-ids-one-path break register was fixed against in 11abd38.

fn committed(&mut self, _persisted: bool)

Nothing here is ever persisted, so persisted is irrelevant — but the checkpoint must still be dropped on every success.

fn unregister(&mut self, id: &Id)

Retire an ID (e.g. after a delete). A store with tombstones keeps the ID on record so it is never reissued; a plain store may forget it.

fn checkpoint(&mut self)

Snapshot the store, so a mutation that fails can put it back. Called before an op touches the index; paired with exactly one rollback or committed.

fn rollback(&mut self)

Restore the last checkpoint — the mutation failed and its writes were unwound, so the in-memory store must forget it too, or it would claim a move that never happened.

fn rebase(&mut self, cs: &dyn Rebase) -> Result<(), Error>

Follow the mutation’s change set to wherever it leaves this store’s home.

fn pending_write(&mut self) -> Result<Option<(PathBuf, String)>, Error>

The write that would persist this store, as (path, full new text) — staged into the mutation’s change set and applied with it.