Struct HomeState 

pub struct HomeState {

    pub sections: Vec<Section>,
    pub filter: String,
    pub filter_selected: bool,
    pub search_limit: usize,
    pub hide_unreadable: bool,
    pub formats: Arc<Registry>,
    pub lake_here: Option<(PathBuf, &'static str)>,
    pub selected: usize,
    pub scroll: usize,
    pub view_height: usize,
    pub path_input_active: bool,
    pub path_input: String,
    pub path_listing: Option<PathListing>,
    pub path_pick: Option<usize>,
    pub browsing: Option<PathBuf>,
    pub browse_start: Option<PathBuf>,
    pub status: Option<String>,
    pub network_check: fn(&Path) -> bool,
    pub visits: HashMap<PathBuf, Visits>,
    pub newest_recent: Option<PathBuf>,
    pub probes: Probes,
    pub narrowed: Option<Narrowed>,
    pub cloud_kinds: HashMap<PathBuf, (EntryKind, Holds)>,
    pub sort: SortMode,
    pub listing_in_flight: bool,
    pub measure_in_flight: bool,
    pub classifying: HashSet<PathBuf>,
    pub peeking: HashSet<PathBuf>,
    pub peek_failed: HashSet<PathBuf>,
    pub enriched: HashMap<PathBuf, Measured>,
    pub stated: HashMap<PathBuf, Stated>,
    pub stat_epoch: u64,
    pub stale: HashSet<PathBuf>,
    pub unapplied: HashSet<PathBuf>,
    pub folds: HashMap<String, bool>,
    pub folds_owed: bool,
    pub search: SearchState,
    pub known: Known,
    pub cloud: Vec<CloudSource>,
    pub catalogs: Vec<ShownCatalog>,
    pub sized: HashSet<PathBuf>,
    pub web_gone: HashMap<PathBuf, HttpGone>,
    pub missing: HashSet<PathBuf>,
    pub waiting_since: Option<Instant>,
    pub recent_expanded: bool,
    pub shown_whole: HashSet<PathBuf>,
    pub trail: Vec<Mark>,
    pub returning: Option<RowKey>,
    pub returning_line: Option<usize>,
    pub landing: bool,
    pub resting: bool,
    pub rows_cache: RowsCache,
    pub catalog_places: CatalogPlaces,
}

Home screen state.

Fields

sections: Vec<Section>

filter: String

Fuzzy filter over every row in every section.

filter_selected: bool

The filter kept from before a dataset opened, shown selected: the next character replaces it and ~ opens the path prompt. Any other key keeps it.

search_limit: usize

The most search matches listed under Found: [home.search] max_results.

hide_unreadable: bool

Hide files datui has no reader for (default); Ctrl+A flips it.

formats: Arc<Registry>

The format specs on the search path: files one names by glob list as data under its name.

lake_here: Option<(PathBuf, &'static str)>

The lake table being browsed and its format, said on its heading for the whole browse.

selected: usize

Index into the flattened list of currently visible rows.

scroll: usize

First row of the last frame, as an index into HomeState::visible. Written by the renderer (which knows the list’s height) and read by HomeState::unclassified_visible, so what is looked into is what is on screen. Zero until the first frame.

view_height: usize

How many rows the last frame had room for. See HomeState::scroll.

path_input_active: bool

True while the user is typing a path directly.

path_input: String

path_listing: Option<PathListing>

What the ~ prompt lists: the directory being typed and the names in it.

path_pick: Option<usize>

The name ↑↓ put the cursor on, among those the last segment matches.

browsing: Option<PathBuf>

Directory the user has descended into, if any. None means the root listing.

browse_start: Option<PathBuf>

Where the browse began (entered from the root listing or jumped to). Esc climbs back to here, then to the listing, never above. None: browsing is the start.

status: Option<String>

Transient message (e.g. a path that does not exist).

network_check: fn(&Path) -> bool

How a path is judged network-backed; swappable so the never-touch-remote rule is testable without a remote.

visits: HashMap<PathBuf, Visits>

How often and how lately each recent was opened, ranking matches. Set with HomeState::set_visits, which relists.

newest_recent: Option<PathBuf>

The recent opened last: the cursor lands here, one Enter from the last file.

probes: Probes

Where the listing of each network root and remote directory is.

narrowed: Option<Narrowed>

The names a filter asked the server for, in a cloud directory cut short.

cloud_kinds: HashMap<PathBuf, (EntryKind, Holds)>

What peeked cloud directories hold (hive, multi), kept for the session so each is peeked once.

sort: SortMode

How rows are ordered inside each section.

listing_in_flight: bool

A listing is being built on a worker; the previous one stays on screen.

measure_in_flight: bool

True while a measurement batch is out, so only one is in flight at a time.

classifying: HashSet<PathBuf>

The filesystems (by mount point) with a classification pass out. One pass per filesystem, each chosen from the viewport then, so fast paging does not queue every row it passed and a share that stopped answering stops only its own rows.

peeking: HashSet<PathBuf>

Cloud directories with a peek out, kept apart from Self::cloud_kinds so no answer is claimed before the request returns.

peek_failed: HashSet<PathBuf>

Cloud directories whose peek failed: not asked again until Ctrl+R, labeled ? (not dir, which would claim no data inside).

enriched: HashMap<PathBuf, Measured>

Row and column counts already read, by path, so each dataset is measured once a session.

stated: HashMap<PathBuf, Stated>

Each row’s latest stat this session, and the refresh it was taken in: a stat-only answer lands here and not in enriched.

stat_epoch: u64

Which refresh the stats are of: Ctrl+R moves it, and the rows shown are stat’ed again, their counts dropped where the file changed.

stale: HashSet<PathBuf>

Rows whose counts went stale: the file changed since they were measured.

unapplied: HashSet<PathBuf>

Paths recorded in enriched since the rows last took them in.

folds: HashMap<String, bool>

Sections folded (true) or opened by the user, by title so it survives rebuilds that renumber sections, and cached across restarts. Unlisted sections take their default. Use HomeState::toggle_collapsed and HomeState::set_collapsed.

folds_owed: bool

The saved folds are to be read again with the next listing, arriving with the rows they fold.

search: SearchState

Datasets found by walking below the working directory.

known: Known

What earlier runs measured, by path: the index the listing was annotated from, kept so search results fill in the same way (the filter matches columns). Read once a session; what this session measures is in Self::enriched.

cloud: Vec<CloudSource>

Cloud sources found on this machine or in the config, with their buckets. Empty without cloud credentials, which is normal.

catalogs: Vec<ShownCatalog>

The catalogs shown, a section each. Set with HomeState::set_catalogs, which indexes their places.

sized: HashSet<PathBuf>

HTTP(S) catalog files whose size was asked for this session (a HEAD).

web_gone: HashMap<PathBuf, HttpGone>

HTTP(S) catalog files a HEAD showed unavailable (missing, no server); retried on Ctrl+R.

missing: HashSet<PathBuf>

Local datasets of a catalog that the last listing found missing.

waiting_since: Option<Instant>

When the current wait for a remote listing began, for the elapsed time on screen.

recent_expanded: bool

RECENT shows every place, for the session: Enter on its … N more row.

shown_whole: HashSet<PathBuf>

Directory sections shown whole rather than cut, by directory, for the session. See HomeState::show_all.

trail: Vec<Mark>

The listings entered from, outermost first, to restore the cursor on the way out. See HomeState::leave_mark.

returning: Option<RowKey>

The row the cursor returns to once the returned-to listing lands; held across listings while rows arrive, dropped when the user moves.

returning_line: Option<usize>

How far down the returned-to row was, so it comes back on the same line.

landing: bool

The cursor is where HomeState::select_first_entry put it and has not moved: a door the footers later turn down sends it to the first row.

resting: bool

No row is picked: datui opened here and nothing has been chosen. The cursor’s place is kept (where Enter and the first ↑ or ↓ go), but no row is marked and nothing is read for one, so opening datui starts no reader.

rows_cache: RowsCache

The rows as last listed. See RowsCache.

catalog_places: CatalogPlaces

The catalogs’ places. See HomeState::set_catalogs.

Implementations

impl HomeState

pub const SEARCH_SECTION: &'static str = "Found"

Title of the section of recursive search results; fold state is keyed by title.

pub const CLOUD_SECTION: &'static str = "Cloud"

Title of the section listing cloud sources.

pub const RECENT_SECTION: &'static str = "Recent"

Title of the section listing what has been opened, grouped by place.

pub fn roots(desktop_dirs: &[PathBuf]) -> Vec<Root>

Roots from the working directory, then the desktop’s data directories; duplicates collapse to the first. Recents’ places are RECENT rows, not roots.

pub fn roots_with( desktop_dirs: &[PathBuf], is_network: fn(&Path) -> bool, ) -> Vec<Root>

As HomeState::roots, with the network test injected.

pub fn rebuild(&mut self, recents: &[PathBuf])

Build the home listing: recents first (on a mount, the dataset you want was usually opened before), then roots scanned one level deep.

pub fn rebuild_with(&mut self, recents: &[PathBuf], desktop_dirs: &[PathBuf])

As HomeState::rebuild, plus directories derived from the desktop’s own recently-used list.

pub fn apply_listing(&mut self, listing: Listing)

Install a listing built elsewhere, keeping the cursor on whatever it was on.

pub fn relist_remote(&mut self, root: &Path)

Build again, from its probe alone, the section showing the remote place root: the browsed directory or a network root. Pages of a listing land several times a second; this touches no file and leaves every other section as it is.

pub fn set_cloud(&mut self, cloud: Vec<CloudSource>)

Show cloud as the cloud sources: the Cloud section, or the browsed source’s buckets, built again in place. Nothing else changes, so nothing is read.

pub fn leave_mark(&mut self)

Remember the cursor before going inside something, so leaving returns to it. Call before browsing changes.

pub fn come_back(&mut self, from: Option<PathBuf>)

Return to the place now browsed, from from: its filter, search, and the cursor on its row once the listing lands. Call after browsing is set. A place never entered from (Backspace above the browse start) puts the cursor on the place just left.

pub fn selected_key(&self) -> Option<RowKey>

What the cursor is on, picked or resting, as something that survives the rows changing: where it is put back after a listing, a resize or a fold.

pub fn reselect(&mut self, key: Option<RowKey>) -> bool

Put the cursor back on the row key names, if still listed; true if placed. A row the cap now hides counts as placed on its more row. Otherwise the cursor is clamped so it never sits past the end.

pub fn set_view_height(&mut self, height: usize)

Tell the listing the list’s height, keeping the cursor on its row: RECENT’s cap is a share of the height. Called every frame; only a change does work.

pub fn is_collapsed(&self, section: usize) -> bool

Whether a section is collapsed.

pub fn toggle_collapsed(&mut self, section: usize)

Collapse or expand a section.

pub fn set_collapsed(&mut self, section: usize, collapsed: bool)

Fold or unfold section, remembered by title. Nothing is remembered while browsing: the browsed listing never folds, and its path is also a root section’s title.

pub fn jump_section(&mut self, delta: isize)

Move the cursor to the next (delta > 0) or previous section header, wrapping.

pub fn has_any_dataset(&self) -> bool

Whether the listing holds anywhere to go, folded or not: datasets, lake tables (not readable as tables, but places), and rows not yet looked into, which may be datasets. Hence EntryKind::is_dataset, not EntryKind::is_known_dataset.

pub fn cloud_source_of(&self, path: &Path) -> Option<&CloudSource>

The source a place belongs to: cloud://<id> itself, a bucket named with a source (s3://<id>@bucket), or a bucket some source listed.

pub fn parent_of(&self, path: &Path) -> Option<PathBuf>

One level up from path. A bucket’s parent is its source, so Backspace from a bucket returns to the source.

pub fn catalog_dataset( &self, path: &Path, ) -> Option<(&ShownCatalog, &ShownDataset)>

The catalog dataset listed at path itself.

pub fn bookmark(&self, path: &Path) -> Option<(&ShownDataset, &str)>

The dataset a bookmark is listed under, and the bookmark’s name.

pub fn size_hint(&self, path: &Path) -> Option<u64>

What a catalog says an unmeasured HTTP(S) file weighs, shown as ~33 MB.

pub fn cloud_look(&self, entry: &Entry) -> Option<CloudLook>

How far an object-store directory is in being looked into, while its row has no label. None once labeled, or for other rows.

pub fn place_kind(&self, path: &Path) -> Option<&'static str>

What a source or catalog calls a place: a catalog’s remote dataset, or missing for an absent local one.

pub fn place_details(&self, path: &Path) -> Option<&[(String, String)]>

Details-pane lines for a place a cloud source listed or a catalog names, when it has any.

pub fn location_label(&self, path: &Path) -> String

The location as the title bar names it; cloud places read as a trail through the source’s label.

pub fn sync_search_section(&mut self)

Put the search results into sections, or take them out, after every rebuild and batch. Only while there is a filter: unfiltered, everything matches.

pub fn search_batch(&mut self, root: &Path, found: Vec<Entry>, scanned: usize)

Fold a batch of search results in, keeping the list free of duplicates.

pub fn score_job(&mut self) -> Option<ScoreJob>

The scoring a worker should do next, if owed (the filter changed, or files arrived). One at a time; the next is asked when it answers.

pub fn search_scored(&mut self, epoch: u64, scored: Matches)

A worker’s scoring is in.

pub fn search_finished( &mut self, root: &Path, scanned: usize, limited: Option<String>, )

Record that the walk under root has finished.

pub fn visible(&self) -> Vec<Row<'_>>

Lines on screen: a header per non-empty section, then its matching rows unless folded. Results stay grouped while filtering, to show where a dataset lives.

pub fn list_lines(&self, spaced: bool) -> ListLines

Where each row of HomeState::visible falls in the list, spaced with a blank line before every header but the first; from the headers alone, so a frame costs the rows it shows, not the rows listed.

pub fn matched(&self) -> usize

How many rows the filter matches: the sum of the section headers’ counts.

pub fn position(&self, wanted: impl FnMut(&Row<'_>) -> bool) -> Option<usize>

The first row of HomeState::visible that wanted picks, without building the rest.

pub fn row_count(&self) -> usize

How many rows HomeState::visible lists.

pub fn row_at(&self, index: usize) -> Option<Row<'_>>

Row index of HomeState::visible.

pub fn rows_built(&self) -> usize

How many times the rows were built, for the test that a frame builds them at most once.

pub fn set_catalogs(&mut self, catalogs: Vec<ShownCatalog>)

Show these catalogs.

pub fn set_visits(&mut self, visits: HashMap<PathBuf, Visits>)

How often and how lately each recent was opened, which ranks matches.

pub fn show_all(&mut self, section: usize)

Show the whole of the section the more row at section cuts.

pub fn cut_again(&mut self, section: usize) -> bool

With the cursor on a row the cut would hide in a section shown whole, cut it back, the cursor on the row standing for the rest. Whether it did.

pub fn sections_mut(&mut self) -> &mut Vec<Section>

The sections, to change in place; rows are relisted on the next read.

pub fn path_candidates(&self) -> Vec<&PathName>

The names the ~ prompt offers: those in the typed directory matching its last segment, best first; hidden names only after a typed dot.

pub fn pick_first_path(&mut self)

Put the ~ prompt’s pick on the first match, or none, so the list always shows what Enter and Tab take. ↑ from the first takes the typed path as is.

pub fn picked_path(&self) -> Option<String>

The path the picked candidate names, with its separator when it is a directory.

pub fn path_completion(&self) -> Option<String>

What Tab makes of the typed path: the sole candidate, or the candidates’ longest common start. None when it adds nothing.

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

Every URL the screen knows (catalogs, buckets, listings, the index): what s3:// completes from.

pub fn selected_row(&self) -> Option<Row<'_>>

The highlighted row, whatever it is.

pub fn cursor_row(&self) -> Option<Row<'_>>

The row Enter and the first ↑ or ↓ take, picked or not.

pub fn selected_entry(&self) -> Option<&Entry>

The highlighted row when it is a dataset, door included (it can be opened; it is Row::Door only to stay out of path-keyed maps).

pub fn selection_is_the_door(&self) -> bool

Whether the cursor is on the door rather than on something in the directory.

pub fn recents_in(&self, place: &Path) -> Vec<PathBuf>

The recents that live in place: what Delete on its row forgets.

pub fn selected_section(&self) -> Option<usize>

The section the highlighted row belongs to.

pub fn selected_catalog(&self) -> Option<&ShownCatalog>

The catalog whose section heading is selected, if the selection is one.

pub fn selection_is_header(&self) -> bool

Whether the highlighted row is a section header.

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

Remote roots that have neither answered nor been written off, for the caller to probe off the UI thread.

pub fn below_browse_start(&self) -> bool

Whether the browsed directory is below the browse start, so Esc has a level to climb before the listing.

pub fn sections_waiting(&self) -> bool

Whether any section on screen is still waiting for its rows.

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

The remote location being browsed, while its listing has not come back.

pub fn probe_ready(&mut self, root: PathBuf, rows: Vec<Entry>, cut_short: bool)

Record what a probe found. An empty listing is still an answer.

pub fn take_cloud_kinds(&mut self)

Label every listed row a peek answered, in place: the probes’ rows, then the sections showing them (a remote place’s built again from its probe, Recent’s rows directly). No listing is read again.

pub fn apply_cloud_kinds(&mut self, root: &Path)

Label the rows of a cloud listing with what peeking inside them found.

pub fn cloud_directories_to_peek(&self, limit: usize) -> Vec<PathBuf>

Cloud directories on or near the screen not yet peeked into, at most limit, the highlighted first. The cloud twin of Self::unclassified_visible: a peek is a request, worth spending on rows someone is looking at.

pub fn probe_failed(&mut self, root: PathBuf, why: Option<String>)

Record that a probe could not read the root, and why when the service said.

pub fn measure_now(&mut self, limit: usize) -> bool

Measure a batch of rows on the calling thread, for tests and library callers with safe paths. The app never calls this: footer reads can block, so the UI thread only picks rows (HomeState::unmeasured_visible) and a worker reads.

pub fn unmeasured_visible(&self, limit: usize) -> Vec<Entry>

Rows not yet measured, up to limit: the screen and a little either side of it (see HomeState::entries_on_screen), the highlighted row first. Nothing off screen is read for a keystroke, so a filter typed over thousands of files costs what it shows; a column name matches the rows whose columns are known, read here or remembered from an earlier run. Sorted by rows, the order needs every count, so then every row listed and those a cut hides: the sort asked for them.

pub fn unstated_for_sort(&self, limit: usize) -> Vec<Entry>

Rows that need a stat and nothing read, up to limit: those on screen stat’ed before the last Ctrl+R, then, sorted by size or time, every row listed and those a cut hides. Each goes with its stat cleared, so it is taken again.

pub fn classify_now(&mut self, limit: usize) -> bool

Look into a batch of rows on the calling thread; for tests and library callers, like HomeState::measure_now.

pub fn unclassified_visible(&self, limit: usize) -> Vec<Entry>

Rows on or near the screen not yet looked into, up to limit. Unlike HomeState::unmeasured_visible, which walks from the top, this asks the viewport plus a screen either side (thousands of partitions would take seconds to reach the cursor): the highlighted row first (about to be acted on), then the screen, the screen below, the screen above.

pub fn unclassified_visible_where( &self, limit: usize, keep: impl Fn(&Entry) -> bool, ) -> Vec<Entry>

HomeState::unclassified_visible, of the rows keep takes.

pub fn record_measurement(&mut self, path: PathBuf, measured: Measured)

Record what measuring path found, for HomeState::apply_new_measurements to fold into its rows.

pub fn record_size(&mut self, path: PathBuf, measured: Measured)

Record a size alone: a measurement that landed meanwhile keeps the rest.

pub fn apply_measurements(&mut self)

Fold every known measurement into the rows currently listed, as a new listing needs.

pub fn apply_new_measurements(&mut self)

Fold the measurements recorded since the last fold into their rows. Only those rows change and are scored again: measurements land a file at a time while the user types, over listings of thousands.

pub fn select_first_entry(&mut self)

Put the cursor on the first dataset rather than the first header, so the preview pane has something to show without a keypress.

Inside a directory that is the door when the door opens the directory as one dataset (see door_lands), and the first thing in it otherwise.

pub fn clamp_selection(&mut self)

pub fn select(&mut self, index: usize)

Put the selection on row index of what is listed, as a click does.

pub fn move_selection(&mut self, delta: isize)

pub fn page_selection(&mut self, delta: isize)

Move the selection delta rows, stopping at the ends rather than wrapping (a wrapped page jump lands somewhere unexpected; single steps wrap).

Trait Implementations

impl Debug for HomeState

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

Formats the value using the given formatter.

impl Default for HomeState

fn default() -> Self

Returns the “default value” for a type.