( )⚙ D10367 dirstate-tree: Implement DirstateMap::read

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10367

dirstate-tree: Implement DirstateMap::read
ClosedPublic

Authored by SimonSapin on Apr 12 2021, 8:23 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGe66ea29e2b1a: dirstate-tree: Implement DirstateMap::read
rHG9148c9d5163b: dirstate-tree: Implement DirstateMap::read
Summary

This reads the on-disk dirstate in its current format (a flat sequence of
entries) and creates a tree in memory.

Diff Detail

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

Revision Contents
Changeset List

Diff 26820

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

use std::collections::BTreeMap;
use std::path::PathBuf; use std::path::PathBuf;
use std::time::Duration; use std::time::Duration;
use super::path_with_basename::WithBasename;
use crate::dirstate::parsers::parse_dirstate;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::revlog::node::NULL_NODE;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateMapError; use crate::DirstateMapError;
use crate::DirstateParents; use crate::DirstateParents;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::FastHashMap; use crate::FastHashMap;
use crate::HgPathCow; use crate::HgPathCow;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StateMapIter; use crate::StateMapIter;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
pub struct DirstateMap { pub struct DirstateMap {
// TODO parents: Option<DirstateParents>,
dirty_parents: bool,
root: ChildNodes,
}
/// Using a plain `HgPathBuf` of the full path from the repository root as a
/// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base
/// names. However `BTreeMap` would waste time always re-comparing the same
/// string prefix.
type ChildNodes = BTreeMap<WithBasename<HgPathBuf>, Node>;
#[derive(Default)]
struct Node {
entry: Option<DirstateEntry>,
copy_source: Option<HgPathBuf>,
children: ChildNodes,
} }
impl DirstateMap { impl DirstateMap {
pub fn new() -> Self { pub fn new() -> Self {
todo!() Self {
parents: None,
dirty_parents: false,
root: ChildNodes::new(),
}
}
fn get_or_insert_node(&mut self, path: &HgPath) -> &mut Node {
let mut child_nodes = &mut self.root;
let mut inclusive_ancestor_paths =
WithBasename::inclusive_ancestors_of(path);
let mut ancestor_path = inclusive_ancestor_paths
.next()
.expect("expected at least one inclusive ancestor");
loop {
// TODO: can we avoid double lookup in all cases without allocating
// an owned key in cases where the map already contains that key?
let child_node =
if child_nodes.contains_key(ancestor_path.base_name()) {
child_nodes.get_mut(ancestor_path.base_name()).unwrap()
} else {
// This is always a vacant entry, using `.entry()` lets us
// return a `&mut Node` of the newly-inserted node without
// yet another lookup. `BTreeMap::insert` doesn’t do this.
child_nodes.entry(ancestor_path.to_owned()).or_default()
};
if let Some(next) = inclusive_ancestor_paths.next() {
ancestor_path = next;
child_nodes = &mut child_node.children;
} else {
return child_node;
}
}
} }
} }
impl super::dispatch::DirstateMapMethods for DirstateMap { impl super::dispatch::DirstateMapMethods for DirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
todo!() self.set_parents(&DirstateParents {
p1: NULL_NODE,
p2: NULL_NODE,
});
self.root.clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
_filename: &HgPath, _filename: &HgPath,
_old_state: EntryState, _old_state: EntryState,
_entry: DirstateEntry, _entry: DirstateEntry,
) -> Result<(), DirstateMapError> { ) -> Result<(), DirstateMapError> {
fn parents( fn parents(
&mut self, &mut self,
_file_contents: &[u8], _file_contents: &[u8],
) -> Result<&DirstateParents, DirstateError> { ) -> Result<&DirstateParents, DirstateError> {
todo!() todo!()
} }
fn set_parents(&mut self, _parents: &DirstateParents) { fn set_parents(&mut self, parents: &DirstateParents) {
todo!() self.parents = Some(parents.clone());
self.dirty_parents = true;
} }
fn read<'a>( fn read<'a>(
&mut self, &mut self,
_file_contents: &'a [u8], file_contents: &'a [u8],
) -> Result<Option<&'a DirstateParents>, DirstateError> { ) -> Result<Option<&'a DirstateParents>, DirstateError> {
todo!() if file_contents.is_empty() {
return Ok(None);
}
let parents =
parse_dirstate(file_contents, |path, entry, copy_source| {
let node = self.get_or_insert_node(path);
node.entry = Some(*entry);
node.copy_source = copy_source.map(HgPath::to_owned);
})?;
if !self.dirty_parents {
self.set_parents(parents);
}
Ok(Some(parents))
} }
fn pack( fn pack(
&mut self, &mut self,
_parents: DirstateParents, _parents: DirstateParents,
_now: Duration, _now: Duration,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
todo!() todo!()