Struct FilePicker 

pub struct FilePicker {
    pub mode: FfsMode,
    pub base_path: PathBuf,
    /* private fields */
}

Fields

mode: FfsMode

base_path: PathBuf

Implementations

impl FilePicker

pub fn base_path(&self) -> &Path

pub fn has_mmap_cache(&self) -> bool

pub fn has_content_indexing(&self) -> bool

pub fn has_watcher(&self) -> bool

pub fn mode(&self) -> FfsMode

pub fn cache_budget(&self) -> &ContentCacheBudget

pub fn bigram_index(&self) -> Option<&BigramFilter>

pub fn bigram_overlay(&self) -> Option<&RwLock<BigramOverlay>>

pub fn get_file_mut(&mut self, index: usize) -> Option<&mut FileItem>

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

Absolute path to the repository root if the indexed tree lives inside a git working directory. None for non-git bases.

pub fn has_explicit_cache_budget(&self) -> bool

pub fn set_cache_budget(&mut self, budget: ContentCacheBudget)

pub fn get_files(&self) -> &[FileItem]

Get all indexed files sorted by path. Note: Files are stored sorted by PATH for efficient insert/remove. For frecency-sorted results, use search() which sorts matched results.

pub fn get_overflow_files(&self) -> &[FileItem]

pub fn get_dirs(&self) -> &[DirItem]

Get the directory table (sorted by path).

pub fn arena_bytes(&self) -> (usize, usize, usize)

Actual heap bytes used: (chunked_path_store, 0, 0). The second element is 0 because leaked overflow stores aren’t tracked.

pub fn new(options: FilePickerOptions) -> Result<Self, Error>

Create a new FilePicker from options. Always prefer new_with_shared_state for the consumer application, use this only if you know what you are doing. This won’t spawn the backgraound watcher and won’t walk the file tree.

pub fn new_with_shared_state( shared_picker: SharedFilePicker, shared_frecency: SharedFrecency, options: FilePickerOptions, ) -> Result<(), Error>

Create a picker, place it into the shared handle, and spawn background indexing + file-system watcher. This is the default entry point.

pub fn collect_files(&mut self) -> Result<(), Error>

Synchronous filesystem scan — populates self with indexed files.

Use this when you need direct access to the picker without shared state:

let mut picker = FilePicker::new(options)?;
picker.collect_files()?;
// picker.get_files() is now populated

pub fn spawn_background_watcher( &mut self, shared_picker: &SharedFilePicker, shared_frecency: &SharedFrecency, ) -> Result<(), Error>

Start the background file-system watcher.

The picker must already be placed into shared_picker (the watcher needs the shared handle to apply live updates). Call after collect_files or after an initial scan.

pub fn fuzzy_search<'q>( &self, query: &'q FfsQuery<'q>, query_tracker: Option<&QueryTracker>, options: FuzzySearchOptions<'q>, ) -> SearchResult<'_>

Perform fuzzy search on files with a pre-parsed query.

The query should be parsed using FfsQuery::parse() before calling this function. If a QueryTracker is provided, the search will automatically look up the last selected file for this query and boost it

pub fn fuzzy_search_directories<'q>( &self, query: &'q FfsQuery<'q>, options: FuzzySearchOptions<'q>, ) -> DirSearchResult<'_>

Perform fuzzy search on indexed directories.

Returns directories ranked by fuzzy match quality + frecency.

pub fn fuzzy_search_mixed<'q>( &self, query: &'q FfsQuery<'q>, query_tracker: Option<&QueryTracker>, options: FuzzySearchOptions<'q>, ) -> MixedSearchResult<'_>

Perform a mixed fuzzy search across both files and directories.

Returns a single flat list where files and directories are interleaved by total score in descending order.

If the raw query ends with a path separator (/), only directories are searched — files are skipped entirely. The caller should parse the query with DirSearchConfig so that trailing / is kept as fuzzy text instead of becoming a PathSegment constraint.

pub fn grep( &self, query: &FfsQuery<'_>, options: &GrepSearchOptions, ) -> GrepResult<'_>

Perform a live grep search across indexed files.

If options.abort_signal is set it overrides the picker’s internal cancellation flag, giving the caller full control over when to stop.

pub fn multi_grep( &self, patterns: &[&str], constraints: &[Constraint<'_>], options: &GrepSearchOptions, ) -> GrepResult<'_>

Multi-pattern grep search across indexed files.

pub fn get_scan_progress(&self) -> ScanProgress

pub fn update_single_file_frecency( &mut self, file_path: impl AsRef<Path>, frecency_tracker: &FrecencyTracker, ) -> Result<(), Error>

pub fn get_file_by_path(&self, path: impl AsRef<Path>) -> Option<&FileItem>

pub fn get_mut_file_by_path( &mut self, path: impl AsRef<Path>, ) -> Option<&mut FileItem>

pub fn handle_create_or_modify( &mut self, path: impl AsRef<Path> + Debug, ) -> Option<&FileItem>

Handle the event of certain file being modified or adds a neww file if it is not added If this function returns None it means that picker is in the invalid state, or the capacity of index is exhausted and a new rescan needs to be triggered.

pub fn add_new_file(&mut self, path: &Path) -> Option<&FileItem>

Adds a new file to picker, if the file can not be added returns None which indicates that it’s time to trigger a new sync

pub fn remove_file_by_path(&mut self, path: impl AsRef<Path>) -> bool

Tombstone a file instead of removing it, keeping base indices stable.

pub fn remove_all_files_in_dir(&mut self, dir: impl AsRef<Path>) -> usize

pub fn cancel(&self)

Use this to prevent any substantial background threads from acquiring the locks

pub fn stop_background_monitor(&mut self)

Stop the background filesystem watcher. Non-blocking.

pub fn is_scan_active(&self) -> bool

Quick way to check if scan is going without acquiring a lock for Self::get_scan_progress

pub fn watcher_signal(&self) -> Arc<AtomicBool>

Return a clone of the watcher-ready flag so callers can poll it without holding a lock on the picker.

Trait Implementations

impl Debug for FilePicker

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

Formats the value using the given formatter.

impl FfsStringStorage for &FilePicker

fn arena_for(&self, file: &FileItem) -> ArenaPtr

Resolve the arena for a FileItem (handles base vs overflow split).

fn base_arena(&self) -> ArenaPtr

The base arena (scan-time paths).

fn overflow_arena(&self) -> ArenaPtr

The overflow arena (paths added after the last full scan).