Struct CacheManager 

pub struct CacheManager { /* private fields */ }

Manages cache directory and cache file operations

Implementations

impl CacheManager

pub fn with_dir(cache_dir: PathBuf) -> Self

Create a new CacheManager for the given app name Create a CacheManager rooted at an explicit directory (primarily for testing).

pub fn new(app_name: &str) -> Result<Self>

Create a CacheManager for the given app name.

DATUI_CACHE_DIR overrides the location. The test suite sets it, because opening a dataset records it as recent — without the override a test run writes its fixtures into the developer’s own recent-files list.

pub fn cache_dir(&self) -> &Path

Get the cache directory path

pub fn cache_file(&self, filename: &str) -> PathBuf

Get path to a specific cache file

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

Ensure the cache directory exists

pub fn clear_file(&self, filename: &str) -> Result<()>

Clear a specific cache file

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

Remove every cache kind’s directory and every line-file list (recents, histories, hidden sources, remembered places).

Nothing else: lock files may be held by another instance, the log is not a cache, and Data Quality’s copies belong to the sessions holding them. Views live in the config directory.

pub fn load_history_file(&self, history_id: &str) -> Result<Vec<String>>

Load history from a history file.

A file that cannot be read is an error, never an empty list: an empty list would be written back by the next push, and every entry would be gone. A line that is not UTF-8 is skipped alone, so one bad byte costs one entry.

pub fn update_history_file<F>( &self, history_id: &str, update: F, ) -> Result<HistoryUpdate>

where F: FnOnce(&mut Vec<String>),

Apply update to a history file, with the whole read-modify-write held under an exclusive lock.

Writing atomically stops two instances producing a corrupt file, but not a lost one: both read [x, y], one writes [a, x, y] and the other [b, x, y], and whichever lands second wins outright. Opening two datasets at once is ordinary — a launcher, a file manager, two terminals — so the read and the write have to be one operation.

The lock is waited for, but only briefly. The critical section is reading and rewriting a fifty-line file, so even a dozen contending instances clear in a few milliseconds; a deadline well beyond that loses nothing in practice while still guaranteeing an interactive action is never held up by a peer that has wedged. Past the deadline the update is dropped — history is a convenience, and it is never worth delaying what the user actually asked for.

Giving up after a couple of quick attempts is not enough: with several opens landing together, some are then dropped, which is the very loss this exists to prevent.

pub fn save_history_file( &self, history_id: &str, history: &[String], ) -> Result<()>

Save history to a history file

impl CacheManager

pub fn load_recents(&self) -> Vec<PathBuf>

Recently opened dataset paths, most recent first.

This is the only thing datui remembers about your data between runs. It is a convenience, not a record: deleting it loses nothing but ordering.

pub fn load_recents_with_visits( &self, ) -> (Vec<PathBuf>, HashMap<PathBuf, Visits>)

Recents, most recent first, and how often and how lately each was opened, by its path as recorded: one read of the list.

pub fn load_folds(&self) -> HashMap<String, bool>

Which home-screen sections the user folded or opened, by title.

One line per section, title<TAB>1 for folded and title<TAB>0 for opened. A section not listed takes its own default.

pub fn save_folds(&self, folds: &HashMap<String, bool>)

Remember the fold state. Failing to write it loses nothing but a preference.

pub fn terminal_mode(&self, terminal: &str) -> Option<ThemeMode>

The mode terminal last said its background was, for the first frame of the next start under theme.mode = "auto". One line per terminal: key<TAB>dark.

pub fn remember_terminal_mode(&self, terminal: &str, mode: ThemeMode)

Remember what terminal answered, when it differs from what is remembered.

pub fn forget_recent(&self, path: &Path)

Forget a single recently opened path.

A recents list you cannot edit is one people stop trusting: an experiment, a file that would not open, something private — all land there, and clearing the whole cache to remove one is too blunt.

pub fn forget_recents(&self, paths: &[PathBuf])

Forget several recently opened paths at once: every recent under one place.

pub fn clear_recents(&self)

Forget every recently opened path, leaving other caches alone.

pub fn push_recent(&self, path: &Path) -> HistoryUpdate

Record a path as most recently opened, de-duplicating and capping the list.

Failures are ignored: not being able to write a convenience list must never interfere with opening data. The return value distinguishes a write from a contended skip for callers and tests that care; the normal caller does not.

pub fn load_visits(&self) -> HashMap<PathBuf, Visits>

How often and how lately each recent was opened, by its path as recorded.

impl CacheManager

pub fn dataset_shapes_kept(&self) -> usize

How many dataset shapes are kept.

pub fn dataset_shape( &self, path: &str, fingerprint: &str, ) -> Option<DatasetShape>

What datui remembers about one dataset, if the fingerprint still matches.

Taking the fingerprint as an argument rather than returning the entry and letting the caller check is deliberate: an entry whose fingerprint has moved on describes a dataset that no longer exists, and there is no use for it that is not a mistake. A hit counts as use, so the datasets that never change, with the most to gain, are not the first to age out.

pub fn has_dataset_shape(&self, path: &str) -> bool

Whether a shape is kept for path at all, whatever it was taken against: one stat, so a caller can tell whether listing the dataset could find it.

pub fn save_dataset_shape(&self, path: &str, shape: DatasetShape)

Remember one dataset’s shape, keeping the others while they fit the budget.

pub fn file_footers(&self, path: &str) -> Option<FileFooters>

The footers counts of the dataset at path have read, by file.

pub fn save_file_footers(&self, path: &str, footers: &FileFooters)

Remember the footers a count of the dataset at path read, by file.

pub fn cloud_listing(&self, id: &str, fingerprint: &str) -> Option<CloudListing>

The last listing of cloud source id, if it was taken at fingerprint.

pub fn load_cloud_listings(&self) -> HashMap<String, CloudListing>

Every source’s last listing, by source ID.

pub fn save_cloud_listing(&self, id: &str, listing: CloudListing)

Record one source’s listing, keeping the others.

pub fn load_hidden_cloud_sources(&self) -> Vec<String>

Source IDs hidden from the home screen with Delete.

pub fn hide_cloud_source(&self, id: &str)

Hide a source from the home screen until the cache is cleared.

pub fn examples_hidden(&self) -> bool

Whether Delete on its heading hid the Example datasets that come with datui. Only the bundled catalog: a user’s own examples.toml still shows.

pub fn hide_examples(&self)

Hide the bundled Example datasets from the home screen until the cache is cleared.

pub fn load_remembered_places(&self) -> Vec<PathBuf>

The directories Ctrl+D kept here before 0.4.0, which keeps them in catalog.toml, in the order they were added.

pub fn clear_remembered_places(&self)

Drop the list Self::load_remembered_places reads, once it is moved.

pub fn save_remembered_places(&self, places: &[PathBuf]) -> Result<()>

Write places where Ctrl+D kept them before 0.4.0, for the migration’s tests.

impl CacheManager

pub fn load_dataset_facts(&self) -> HashMap<PathBuf, DatasetFacts>

Everything datui knows about datasets it has measured before, without counting any of it as use. Unreadable records are absent: this is a cache, and failing to read it must never be worse than not having it.

pub fn dataset_facts(&self, path: &Path) -> Option<DatasetFacts>

What datui knows about one dataset, counted as use.

pub fn touch_dataset_facts<'a>(&self, paths: impl IntoIterator<Item = &'a Path>)

Count these datasets’ records as used: shown on the home screen, say. The least recently used go first once the records pass their budget.

pub fn record_dataset_facts(&self, facts: &[(PathBuf, DatasetFacts)])

Record newly measured datasets, one file each. A path that is not UTF-8 is not recorded.

Trait Implementations

impl Clone for CacheManager

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheManager

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

Formats the value using the given formatter.