Struct WorkspaceCache 

pub struct WorkspaceCache { /* private fields */ }

Handle to the cache directory for a single workspace. Construction is cheap (creates directories on demand); the same handle can be shared across threads via Arc — it holds no mutable state.

Implementations

impl WorkspaceCache

pub fn new(root: &Path) -> Option<Self>

Create (or re-open) the cache directory for a workspace rooted at root. Returns None when the system has no usable home/cache directory — callers should treat that as “cache disabled” and proceed without persistence.

If the existing cache directory exceeds CACHE_SIZE_CAP, it is cleared before the handle is returned. That’s a coarse knob — K3 could refine to LRU-by-mtime — but crossing 512 MiB at startup indicates the workspace has churned through many content hashes and the rebuild cost is bounded to one full re-scan.

pub fn cache_dir(&self) -> &Path

The filesystem path of this workspace’s cache directory.

pub fn size_bytes(&self) -> Result<u64>

Total bytes consumed by .bin entries in this workspace’s cache directory. Cheap (one read_dir pass, no recursion into subdirectories because the layout is flat).

pub fn key_for(uri: &str, content: &str) -> CacheKey

Build a cache key from file content. Combines uri and content so that two files with identical content but different URIs get different keys. Used in tests and legacy code paths.

pub fn key_for_stat(uri: &str, mtime_secs: u64, size: u64) -> CacheKey

Build a cache key from file metadata instead of content.

Hashing the full file content costs ~1 ms/file CPU on warm starts, nearly cancelling the parse savings. An mtime+size key is O(constant) per file and is invalidated automatically when the file changes.

Tradeoffs vs content hash: touch without an edit invalidates the entry (safe cache miss, re-parses once) and clock skew on network mounts can in theory produce a stale hit. Both are acceptable for a developer tool where a spurious miss is safe.

pub fn read<T: DeserializeOwned>(&self, key: &CacheKey) -> Option<T>

Deserialize a previously-cached value. Returns None on any I/O or decode failure — a corrupted entry should look identical to a missing one so callers fall through to the recompute path.

pub fn write<T: Serialize>(&self, key: &CacheKey, value: &T) -> Result<()>

Atomically publish an entry to the cache. Writes to a sibling temp file then renames, so readers never see a half-written payload even if the process dies mid-write.

No fsync: the cache is advisory-only — a crash that loses a write just produces a cache miss on the next startup, which safely falls back to re-parsing. Skipping sync_all() avoids 5–15 ms per file on macOS, which on a 1,500-file project accounts for most of the cold indexing time.

pub fn clear(&self) -> Result<()>

Drop every entry in this workspace’s cache. Safe to call while other threads are reading — individual read calls that race with a clear will see None rather than garbage, and the next write recreates the entry.

Trait Implementations

impl Clone for WorkspaceCache

fn clone(&self) -> WorkspaceCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkspaceCache

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

Formats the value using the given formatter.