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 with_dir(dir: PathBuf) -> Self

Override the root directory directly. The directory is used verbatim (no schema / workspace subdirectories are appended). Use for tests or when the caller provides an explicit cachePath initializationOption.

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.

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.