This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12529

rust-dirstatemap: add `each_ancestor` argument to `get_node_mut`
Needs ReviewPublic

Authored by Alphare on Tue, Apr 12, 12:05 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

This forces the callers to think about if the counters in the ancestors
need to be adjusted.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 33092

rust/hg-core/src/dirstate_tree/dirstate_map.rs

return Ok(None); return Ok(None);
} }
} }
} }
/// 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.
///
/// `each_ancestor` is a callback that is called for each ancestor node
/// when descending the tree. It is used to keep the different counters
/// of the `DirstateMap` up-to-date.
fn get_node_mut<'tree>( fn get_node_mut<'tree>(
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
unreachable_bytes: &mut u32, unreachable_bytes: &mut u32,
root: &'tree mut ChildNodes<'on_disk>, root: &'tree mut ChildNodes<'on_disk>,
path: &HgPath, path: &HgPath,
mut each_ancestor: impl FnMut(&mut Node),
) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> { ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
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 {
if let Some(child) = children if let Some(child) = children
.make_mut(on_disk, unreachable_bytes)? .make_mut(on_disk, unreachable_bytes)?
.get_mut(component) .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 Ok(Some(child)); return Ok(Some(child));
} }
} else { } else {
return Ok(None); return Ok(None);
} }
&mut self, &mut self,
path: &HgPath, path: &HgPath,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let node = match DirstateMap::get_node_mut( let node = match DirstateMap::get_node_mut(
self.on_disk, self.on_disk,
&mut self.unreachable_bytes, &mut self.unreachable_bytes,
&mut self.root, &mut self.root,
path, path,
|_ancestor| {},
)? { )? {
Some(node) => node, Some(node) => node,
None => return Ok(()), None => return Ok(()),
}; };
if let NodeData::CachedDirectory { .. } = &node.data { if let NodeData::CachedDirectory { .. } = &node.data {
node.data = NodeData::None node.data = NodeData::None
} }
Ok(()) Ok(())
} }
/// Sets the cached mtime for the (potential) folder at `path`. /// Sets the cached mtime for the (potential) folder at `path`.
pub(super) fn set_cached_mtime( pub(super) fn set_cached_mtime(
&mut self, &mut self,
path: &HgPath, path: &HgPath,
mtime: TruncatedTimestamp, mtime: TruncatedTimestamp,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let node = match DirstateMap::get_node_mut( let node = match DirstateMap::get_node_mut(
self.on_disk, self.on_disk,
&mut self.unreachable_bytes, &mut self.unreachable_bytes,
&mut self.root, &mut self.root,
path, path,
|_ancestor| {},
)? { )? {
Some(node) => node, Some(node) => node,
None => return Ok(()), None => return Ok(()),
}; };
match &node.data { match &node.data {
NodeData::Entry(_) => {} // Don’t overwrite an entry NodeData::Entry(_) => {} // Don’t overwrite an entry
NodeData::CachedDirectory { .. } | NodeData::None => { NodeData::CachedDirectory { .. } | NodeData::None => {
node.data = NodeData::CachedDirectory { mtime } node.data = NodeData::CachedDirectory { mtime }
self.with_dmap_mut(|map| { self.with_dmap_mut(|map| {
let count = &mut map.nodes_with_copy_source_count; let count = &mut map.nodes_with_copy_source_count;
let unreachable_bytes = &mut map.unreachable_bytes; let unreachable_bytes = &mut map.unreachable_bytes;
Ok(DirstateMap::get_node_mut( Ok(DirstateMap::get_node_mut(
map.on_disk, map.on_disk,
unreachable_bytes, unreachable_bytes,
&mut map.root, &mut map.root,
key, key,
|_ancestor| {},
)? )?
.and_then(|node| { .and_then(|node| {
if let Some(source) = &node.copy_source { if let Some(source) = &node.copy_source {
*count -= 1; *count -= 1;
DirstateMap::count_dropped_path(unreachable_bytes, source); DirstateMap::count_dropped_path(unreachable_bytes, source);
} }
node.copy_source.take().map(Cow::into_owned) node.copy_source.take().map(Cow::into_owned)
})) }))