Struct WorkspaceIndex 

pub struct WorkspaceIndex { /* private fields */ }

Resident workspace file index. Clone-handle via Arc.

The background scanner thread is owned by this handle: dropping the last handle cancels the walk and joins the thread (bounded — the walk checks the cancel flag per entry and the command loop wakes every 250 ms).

Implementations

impl WorkspaceIndex

pub fn start(roots: Vec<PathBuf>) -> Arc<Self>

Start scanning roots in the background with default options.

pub fn start_with(roots: Vec<PathBuf>, opts: IndexOptions) -> Arc<Self>

Like start with explicit options.

Roots are canonicalized; missing/non-dir roots and roots nested inside an earlier root are dropped (they would duplicate entries).

pub fn project_roots(working_dir: &Path) -> Vec<PathBuf>

Roots of the index: [working_dir] plus every directory listed in .whycodes/external_dirs_allowed.

pub fn roots(&self) -> &[PathBuf]

The canonicalized roots being indexed.

pub fn primary_root(&self) -> Option<&Path>

The primary root (working directory). None if no roots were indexed.

pub fn status(&self) -> ScanStatus

Current scan progress.

pub fn is_ready(&self) -> bool

True once the initial walk has finished.

pub fn len(&self) -> usize

Total indexed entries across roots.

pub fn is_empty(&self) -> bool

True when no entries are indexed (yet).

pub fn wait_ready(&self, timeout: Duration) -> bool

Block until the index is ready or timeout elapses. For tests and one-shot CLI paths; the TUI should poll status.

pub fn query_now(&self, pattern: &str, limit: usize) -> Vec<FileMatch>

Non-blocking picker query: point every engine at pattern and read the matches currently available. Never waits on a rematch — fresh results are announced via [take_results_dirty] and picked up with read_matches.

Special forms: an empty pattern browses the top level of the primary root; a pattern ending in / browses that directory (store-backed, always synchronous).

pub fn read_matches(&self, limit: usize) -> Vec<FileMatch>

Non-blocking re-read of current matches (call when take_results_dirty returns true).

pub fn take_results_dirty(&self) -> bool

One-shot check for freshly published matcher results.

pub fn rearm_fuzzy(&self)

Re-issue the last fuzzy query so workers publish a snapshot.

Needed when a tick(0) missed notify and the picker is idle on an empty list. See FuzzyEngine::rearm.

pub fn matching(&self) -> bool

True while any engine is still matching or ingesting (walk running). UIs should keep polling on a short cadence while this holds.

pub fn query(&self, pattern: &str, limit: usize) -> Vec<FileMatch>

Blocking fuzzy query (tests / one-shot callers). UIs should use query_now + the dirty flag instead.

pub fn browse(&self, root: u16, rel_dir: &str) -> Vec<FileMatch>

Depth-1 listing of rel_dir inside root (dirs first, alpha). "" lists the top level. Filesystem-free — reads the store.

pub fn visit(&self, f: &mut dyn FnMut(&Entry) -> bool)

Visit every primary-root entry without cloning (tools hot path). Return false from f to stop early.

pub fn visit_content_candidates( &self, search_root: &Path, pattern: &str, case_insensitive: bool, f: &mut dyn FnMut(&Path, &str, u64) -> bool, ) -> Option<()>

Visit primary-root files under search_root that the content overlay cannot rule out for pattern. None means “do not prune” (regex / too short / Unicode case-fold / overlay not complete / path outside the primary root) — the caller should fall back to [visit].

f receives (abs, rel, size) with rel scoped to search_root, matching [visit] + tools visit_index. Return false to stop.

pub fn entries(&self) -> Vec<Entry>

Clone of all primary-root entries (tools that need owned data).

pub fn resolve(&self, m: &FileMatch) -> PathBuf

Absolute path for a match.

pub fn rescan(&self)

Trigger a full background rescan (e.g. after branch switches).

Trait Implementations

impl Debug for WorkspaceIndex

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

Formats the value using the given formatter.

impl Drop for WorkspaceIndex

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.