| pulkit |
| hg-reviewers |
It should behave the same as before. This will enable the next changeset
to run code on the way "down" (in order to removing newly-empty nodes).
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | rust/hg-core/src/dirstate_tree/dirstate_map.rs (69 lines) | |||
| M | rust/hg-core/src/utils/hg_path.rs (10 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | SimonSapin | ||
| Closed | SimonSapin |
| /// Returns a mutable reference to the node at `path` if it exists | /// Returns a mutable reference to the node at `path` if it exists | ||||
| /// | /// | ||||
| /// This takes `root` instead of `&mut self` so that callers can mutate | /// This takes `root` instead of `&mut self` so that callers can mutate | ||||
| /// other fields while the returned borrow is still valid | /// other fields while the returned borrow is still valid | ||||
| fn get_node_mut<'tree>( | fn get_node_mut<'tree>( | ||||
| root: &'tree mut ChildNodes<'on_disk>, | root: &'tree mut ChildNodes<'on_disk>, | ||||
| path: &HgPath, | path: &HgPath, | ||||
| ) -> Option<&'tree mut Node<'on_disk>> { | ) -> Option<&'tree mut Node<'on_disk>> { | ||||
| Self::get_node_mut_tracing_ancestors(root, path, |_| {}) | |||||
| } | |||||
| /// Same as `get_node_mut`, and calls `each_ancestor` for each ancestor of | |||||
| /// the node. | |||||
| /// | |||||
| /// Note that `each_ancestor` may be called (with what would be ancestors) | |||||
| /// even if it turns out there is no node at `path`. | |||||
| fn get_node_mut_tracing_ancestors<'tree>( | |||||
| root: &'tree mut ChildNodes<'on_disk>, | |||||
| path: &HgPath, | |||||
| mut each_ancestor: impl FnMut(&mut Node), | |||||
| ) -> Option<&'tree mut Node<'on_disk>> { | |||||
| let mut children = root; | let mut children = root; | ||||
| let mut components = path.components(); | let mut components = path.components(); | ||||
| let mut component = | let mut component = | ||||
| components.next().expect("expected at least one components"); | components.next().expect("expected at least one components"); | ||||
| loop { | loop { | ||||
| let child = children.get_mut(component)?; | let child = children.get_mut(component)?; | ||||
| if let Some(next_component) = components.next() { | if let Some(next_component) = components.next() { | ||||
| each_ancestor(child); | |||||
| component = next_component; | component = next_component; | ||||
| children = &mut child.children; | children = &mut child.children; | ||||
| } else { | } else { | ||||
| return Some(child); | return Some(child); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| Ok(()) | Ok(()) | ||||
| } | } | ||||
| fn drop_file( | fn drop_file( | ||||
| &mut self, | &mut self, | ||||
| filename: &HgPath, | filename: &HgPath, | ||||
| old_state: EntryState, | old_state: EntryState, | ||||
| ) -> Result<bool, DirstateMapError> { | ) -> Result<bool, DirstateMapError> { | ||||
| let was_tracked = old_state.is_tracked(); | struct Dropped { | ||||
| if let Some(node) = Self::get_node_mut_tracing_ancestors( | was_tracked: bool, | ||||
| &mut self.root, | had_entry: bool, | ||||
| filename, | had_copy_source: bool, | ||||
| |ancestor| { | } | ||||
| if was_tracked { | fn recur(nodes: &mut ChildNodes, path: &HgPath) -> Option<Dropped> { | ||||
| ancestor.tracked_descendants_count -= 1 | let (first_path_component, rest_of_path) = | ||||
| path.split_first_component(); | |||||
| let node = nodes.get_mut(first_path_component)?; | |||||
| let dropped; | |||||
| if let Some(rest) = rest_of_path { | |||||
| dropped = recur(&mut node.children, rest)?; | |||||
| if dropped.was_tracked { | |||||
| node.tracked_descendants_count -= 1; | |||||
| } | } | ||||
| }, | } else { | ||||
| ) { | dropped = Dropped { | ||||
| let had_entry = node.entry.is_some(); | was_tracked: node | ||||
| let had_copy_source = node.copy_source.is_some(); | .entry | ||||
| .as_ref() | |||||
| .map_or(false, |entry| entry.state.is_tracked()), | |||||
| had_entry: node.entry.take().is_some(), | |||||
| had_copy_source: node.copy_source.take().is_some(), | |||||
| }; | |||||
| // TODO: this leaves in the tree a "non-file" node. Should we | // TODO: this leaves in the tree a "non-file" node. Should we | ||||
| // remove the node instead, together with ancestor nodes for | // remove the node instead, together with ancestor nodes for | ||||
| // directories that become empty? | // directories that become empty? | ||||
| node.entry = None; | } | ||||
| node.copy_source = None; | Some(dropped) | ||||
| } | |||||
| if had_entry { | if let Some(dropped) = recur(&mut self.root, filename) { | ||||
| if dropped.had_entry { | |||||
| self.nodes_with_entry_count -= 1 | self.nodes_with_entry_count -= 1 | ||||
| } | } | ||||
| if had_copy_source { | if dropped.had_copy_source { | ||||
| self.nodes_with_copy_source_count -= 1 | self.nodes_with_copy_source_count -= 1 | ||||
| } | } | ||||
| Ok(had_entry) | Ok(dropped.had_entry) | ||||
| } else { | } else { | ||||
| assert!(!was_tracked); | debug_assert!(!old_state.is_tracked()); | ||||
| Ok(false) | Ok(false) | ||||
| } | } | ||||
| } | } | ||||
| fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { | fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { | ||||
| for filename in filenames { | for filename in filenames { | ||||
| if let Some(node) = Self::get_node_mut(&mut self.root, &filename) { | if let Some(node) = Self::get_node_mut(&mut self.root, &filename) { | ||||
| if let Some(entry) = node.entry.as_mut() { | if let Some(entry) = node.entry.as_mut() { | ||||
| // hg_path.rs | // hg_path.rs | ||||
| // | // | ||||
| // Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | // Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | ||||
| // | // | ||||
| // This software may be used and distributed according to the terms of the | // This software may be used and distributed according to the terms of the | ||||
| // GNU General Public License version 2 or any later version. | // GNU General Public License version 2 or any later version. | ||||
| use crate::utils::SliceExt; | |||||
| use std::borrow::Borrow; | use std::borrow::Borrow; | ||||
| use std::borrow::Cow; | use std::borrow::Cow; | ||||
| use std::convert::TryFrom; | use std::convert::TryFrom; | ||||
| use std::ffi::{OsStr, OsString}; | use std::ffi::{OsStr, OsString}; | ||||
| use std::fmt; | use std::fmt; | ||||
| use std::ops::Deref; | use std::ops::Deref; | ||||
| use std::path::{Path, PathBuf}; | use std::path::{Path, PathBuf}; | ||||
| inner.extend(other.as_ref().bytes()); | inner.extend(other.as_ref().bytes()); | ||||
| HgPathBuf::from_bytes(&inner) | HgPathBuf::from_bytes(&inner) | ||||
| } | } | ||||
| pub fn components(&self) -> impl Iterator<Item = &HgPath> { | pub fn components(&self) -> impl Iterator<Item = &HgPath> { | ||||
| self.inner.split(|&byte| byte == b'/').map(HgPath::new) | self.inner.split(|&byte| byte == b'/').map(HgPath::new) | ||||
| } | } | ||||
| /// Returns the first (that is "root-most") slash-separated component of | |||||
| /// the path, and the rest after the first slash if there is one. | |||||
| pub fn split_first_component(&self) -> (&HgPath, Option<&HgPath>) { | |||||
| match self.inner.split_2(b'/') { | |||||
| Some((a, b)) => (HgPath::new(a), Some(HgPath::new(b))), | |||||
| None => (self, None), | |||||
| } | |||||
| } | |||||
| pub fn parent(&self) -> &Self { | pub fn parent(&self) -> &Self { | ||||
| let inner = self.as_bytes(); | let inner = self.as_bytes(); | ||||
| HgPath::new(match inner.iter().rposition(|b| *b == b'/') { | HgPath::new(match inner.iter().rposition(|b| *b == b'/') { | ||||
| Some(pos) => &inner[..pos], | Some(pos) => &inner[..pos], | ||||
| None => &[], | None => &[], | ||||
| }) | }) | ||||
| } | } | ||||
| /// Given a base directory, returns the slice of `self` relative to the | /// Given a base directory, returns the slice of `self` relative to the | ||||