Function broot::git::get_tree_status

pub fn get_tree_status(
    root_path: &Path,
    dam: &mut Dam
) -> ComputationResult<TreeGitStatus>

try to get the result of the computation of the tree git status. This may be immediate if a previous computation was finished. This may wait for the result of a new computation or of a previously launched one. In any case:

• this function returns as soon as the dam asks for it (ie when there’s an event)
• computations are never dropped unless the program ends: they continue in background and the result may be available for following queries

Examples found in repository

src/browser/browser_state.rs (line 696)

    fn do_pending_task(
        &mut self,
        app_state: &mut AppState,
        screen: Screen,
        con: &AppContext,
        dam: &mut Dam,
    ) -> Result<(), ProgramError> {
        if let Some(pending_task) = self.pending_task.take() {
            match pending_task {
                BrowserTask::Search { pattern, total } => {
                    let pattern_str = pattern.raw.clone();
                    let mut options = self.tree.options.clone();
                    options.pattern = pattern;
                    let root = self.tree.root().clone();
                    let page_height = BrowserState::page_height(screen) as usize;
                    let builder = TreeBuilder::from(root, options, page_height, con)?;
                    let filtered_tree = time!(
                        Info,
                        "tree filtering",
                        &pattern_str,
                        builder.build_tree(total, dam),
                    );
                    if let Ok(mut ft) = filtered_tree {
                        ft.try_select_best_match();
                        ft.make_selection_visible(BrowserState::page_height(screen));
                        self.filtered_tree = Some(ft);
                    }
                }
                BrowserTask::StageAll(pattern) => {
                    let tree = self.displayed_tree();
                    let root = tree.root().clone();
                    let mut options = tree.options.clone();
                    let total_search = true;
                    options.pattern = pattern; // should be the same
                    let builder = TreeBuilder::from(root, options, con.max_staged_count, con);
                    let mut paths = builder
                        .and_then(|mut builder| {
                            builder.matches_max = Some(con.max_staged_count);
                            time!(builder.build_paths(
                                total_search,
                                dam,
                                |line| line.file_type.is_file(),
                            ))
                        })?;
                    for path in paths.drain(..) {
                        app_state.stage.add(path);
                    }
                }
            }
        } else if self.displayed_tree().is_missing_git_status_computation() {
            let root_path = self.displayed_tree().root();
            let git_status = git::get_tree_status(root_path, dam);
            self.displayed_tree_mut().git_status = git_status;
        } else {
            self.displayed_tree_mut().fetch_some_missing_dir_sum(dam, con);
        }
        Ok(())
    }