use patricia_tree::GenericPatriciaMap;

    // TODO: use a trie
    pub states: HashMap<Utf8PathBuf, PathState>,

    states: GenericPatriciaMap<String, PathState>,

        let mut untracked_states = HashMap::new();

        let mut untracked_states = GenericPatriciaMap::new();

                untracked_states.insert(utf8_path, PathState::Untracked);

                untracked_states.insert(utf8_path.into_string(), PathState::Untracked);

        let mut updated_states = HashMap::new();

            let entry = self.states.entry(Utf8PathBuf::from(globalized_hunk.path()));

            let entry = updated_states.entry(globalized_hunk.path().to_string());

        // Overwrite the previous path states that were affected, and clear any previous paths
        // that no longer have an active state
        let mut paths_to_remove = Vec::new();
        for (path, existing_state) in self.states.iter_prefix_mut(prefix) {
            match updated_states.remove(&path) {
                Some(updated_state) => {
                    // Update an existing state
                    *existing_state = updated_state;
                }
                None => {
                    // There is currently no state attached to this path, so remove it
                    paths_to_remove.push(path);
                }
            }
        }
        // Actually clear the paths that no longer have an active state (and aren't untracked)
        let read_transaction = transaction.read();
        for outdated_path in paths_to_remove {
            if read_transaction.is_tracked(&outdated_path)? {
                self.states.remove(outdated_path);
            } else {
                self.states.insert(outdated_path, PathState::Untracked);
            }
        }
        // Insert any new paths that remain
        for (path, updated_state) in updated_states {
            self.states.insert(path, updated_state);
        }

        self.states.get(path).copied()

        self.states.get(path.as_str()).copied()
    }
    pub fn iter_path_states(&self) -> impl Iterator<Item = (Utf8PathBuf, PathState)> {
        self.states
            .iter()
            .map(|(path, state)| (Utf8PathBuf::from(path), *state))

            self.states.insert(path, PathState::Untracked);

            self.states.insert(path.into_string(), PathState::Untracked);

    pub fn iter_path_states(&self) -> impl Iterator<Item = (&Utf8Path, PathState)> {
        self.path_states
            .states
            .iter()
            .map(|(path, state)| (path.as_path(), *state))

    pub fn iter_path_states(&self) -> impl Iterator<Item = (Utf8PathBuf, PathState)> {
        self.path_states.iter_path_states()

patricia_tree.workspace = true

patricia_tree = "0.10"

name = "patricia_tree"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4df0e43512f12f23a6b08c7b893192b7d6ec937b95ee03af040847907fe5cef7"
[[package]]

 "patricia_tree",