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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 27641

rust/hg-core/src/dirstate/parsers.rs

contents: &[u8], contents: &[u8],
) -> Result<&DirstateParents, HgError> { ) -> Result<&DirstateParents, HgError> {
let (parents, _rest) = DirstateParents::from_bytes(contents) let (parents, _rest) = DirstateParents::from_bytes(contents)
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; .map_err(|_| HgError::corrupted("Too little data for dirstate."))?;
Ok(parents) Ok(parents)
} }
#[timed] #[timed]
pub fn parse_dirstate(mut contents: &[u8]) -> Result<ParseResult, HgError> { pub fn parse_dirstate(contents: &[u8]) -> Result<ParseResult, HgError> {
let mut copies = Vec::new(); let mut copies = Vec::new();
let mut entries = Vec::new(); let mut entries = Vec::new();
let parents =
parse_dirstate_entries(contents, |path, entry, copy_source| {
if let Some(source) = copy_source {
copies.push((path, source));
}
entries.push((path, *entry));
})?;
Ok((parents, entries, copies))
}
pub fn parse_dirstate_entries<'a>(
mut contents: &'a [u8],
mut each_entry: impl FnMut(&'a HgPath, &DirstateEntry, Option<&'a HgPath>),
) -> Result<&'a DirstateParents, HgError> {
let (parents, rest) = DirstateParents::from_bytes(contents) let (parents, rest) = DirstateParents::from_bytes(contents)
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; .map_err(|_| HgError::corrupted("Too little data for dirstate."))?;
contents = rest; contents = rest;
while !contents.is_empty() { while !contents.is_empty() {
let (raw_entry, rest) = RawEntry::from_bytes(contents) let (raw_entry, rest) = RawEntry::from_bytes(contents)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
let entry = DirstateEntry { let entry = DirstateEntry {
state: EntryState::try_from(raw_entry.state)?, state: EntryState::try_from(raw_entry.state)?,
mode: raw_entry.mode.get(), mode: raw_entry.mode.get(),
mtime: raw_entry.mtime.get(), mtime: raw_entry.mtime.get(),
size: raw_entry.size.get(), size: raw_entry.size.get(),
}; };
let (paths, rest) = let (paths, rest) =
u8::slice_from_bytes(rest, raw_entry.length.get() as usize) u8::slice_from_bytes(rest, raw_entry.length.get() as usize)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
// `paths` is either a single path, or two paths separated by a NULL // `paths` is either a single path, or two paths separated by a NULL
// byte // byte
let mut iter = paths.splitn(2, |&byte| byte == b'\0'); let mut iter = paths.splitn(2, |&byte| byte == b'\0');
let path = HgPath::new( let path = HgPath::new(
iter.next().expect("splitn always yields at least one item"), iter.next().expect("splitn always yields at least one item"),
); );
if let Some(copy_source) = iter.next() { let copy_source = iter.next().map(HgPath::new);
copies.push((path, HgPath::new(copy_source))); each_entry(path, &entry, copy_source);
}
entries.push((path, entry));
contents = rest; contents = rest;
} }
Ok((parents, entries, copies)) Ok(parents)
} }
/// `now` is the duration in seconds since the Unix epoch /// `now` is the duration in seconds since the Unix epoch
pub fn pack_dirstate( pub fn pack_dirstate(
state_map: &mut StateMap, state_map: &mut StateMap,
copy_map: &CopyMap, copy_map: &CopyMap,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Duration,

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_entries;
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_entries(
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!()