comparison rust/hg-core/src/dirstate/dirstate_map.rs @ 46890:441024b279a6

rust: Remove the compile-time 'dirstate-tree' feature flag

This code has compiler errors since it is not built on CI and nobody has been
working on it for some time.

We (Octobus) are still pursuing status optimizations based on a tree data
structure for the dirstate, but upcoming patches will use a run-time opt-in
instead of compile-time, so that at least corresponding Rust code keeps
compiling when other changes are made.

Differential Revision: https://phab.mercurial-scm.org/D10329

46889:8759e22f1649

            self.non_normal_set.as_ref().unwrap(),
            self.other_parent_set.as_ref().unwrap(),
        )
    }

    #[cfg(not(feature = "dirstate-tree"))]
    pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
        if !force
            && self.non_normal_set.is_some()
            && self.other_parent_set.is_some()
        {

            if *state != EntryState::Normal || *mtime == MTIME_UNSET {
                non_normal.insert(filename.to_owned());
            }
            if *state == EntryState::Normal && *size == SIZE_FROM_OTHER_PARENT
            {
                other_parent.insert(filename.to_owned());
            }
        }
        self.non_normal_set = Some(non_normal);
        self.other_parent_set = Some(other_parent);
    }
    #[cfg(feature = "dirstate-tree")]
    pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
        if !force
            && self.non_normal_set.is_some()
            && self.other_parent_set.is_some()
        {
            return;
        }
        let mut non_normal = HashSet::new();
        let mut other_parent = HashSet::new();

        for (
            filename,
            DirstateEntry {
                state, size, mtime, ..
            },
        ) in self.state_map.iter()
        {
            if state != EntryState::Normal || mtime == MTIME_UNSET {
                non_normal.insert(filename.to_owned());
            }
            if state == EntryState::Normal && size == SIZE_FROM_OTHER_PARENT {
                other_parent.insert(filename.to_owned());
            }
        }
        self.non_normal_set = Some(non_normal);
        self.other_parent_set = Some(other_parent);

        self.dirty_parents = false;

        self.set_non_normal_other_parent_entries(true);
        Ok(packed)
    }
    #[cfg(not(feature = "dirstate-tree"))]
    pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
        if let Some(ref file_fold_map) = self.file_fold_map {
            return file_fold_map;
        }
        let mut new_file_fold_map = FileFoldMap::default();

        for (filename, DirstateEntry { state, .. }) in self.state_map.iter() {
            if *state != EntryState::Removed {
                new_file_fold_map
                    .insert(normalize_case(&filename), filename.to_owned());
            }
        }
        self.file_fold_map = Some(new_file_fold_map);
        self.file_fold_map.as_ref().unwrap()
    }
    #[cfg(feature = "dirstate-tree")]
    pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
        if let Some(ref file_fold_map) = self.file_fold_map {
            return file_fold_map;
        }
        let mut new_file_fold_map = FileFoldMap::default();

        for (filename, DirstateEntry { state, .. }) in self.state_map.iter() {
            if state != EntryState::Removed {
                new_file_fold_map
                    .insert(normalize_case(&filename), filename.to_owned());
            }
        }
        self.file_fold_map = Some(new_file_fold_map);

46890:441024b279a6

            self.non_normal_set.as_ref().unwrap(),
            self.other_parent_set.as_ref().unwrap(),
        )
    }

    pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
        if !force
            && self.non_normal_set.is_some()
            && self.other_parent_set.is_some()
        {

            if *state != EntryState::Normal || *mtime == MTIME_UNSET {
                non_normal.insert(filename.to_owned());
            }
            if *state == EntryState::Normal && *size == SIZE_FROM_OTHER_PARENT
            {
                other_parent.insert(filename.to_owned());
            }
        }
        self.non_normal_set = Some(non_normal);
        self.other_parent_set = Some(other_parent);

        self.dirty_parents = false;

        self.set_non_normal_other_parent_entries(true);
        Ok(packed)
    }
    pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
        if let Some(ref file_fold_map) = self.file_fold_map {
            return file_fold_map;
        }
        let mut new_file_fold_map = FileFoldMap::default();

        for (filename, DirstateEntry { state, .. }) in self.state_map.iter() {
            if *state != EntryState::Removed {
                new_file_fold_map
                    .insert(normalize_case(&filename), filename.to_owned());
            }
        }
        self.file_fold_map = Some(new_file_fold_map);