This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8121

rust-dirstatemap: directly return `non_normal` and `other_entries`
ClosedPublic

Authored by Alphare on Feb 14 2020, 9:03 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGc089a0947f3e: rust-dirstatemap: directly return `non_normal` and `other_entries`
Summary

This cleans up the interface which I previously thought needed to be uglier
than in reality. No performance difference, simple refactoring.

Diff Detail

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

Event Timeline

Alphare created this revision.Feb 14 2020, 9:03 AM
Alphare updated this revision to Diff 20222.Feb 14 2020, 9:05 AM
Alphare added a commit: rHGc089a0947f3e: rust-dirstatemap: directly return `non_normal` and `other_entries`.Feb 14 2020, 11:48 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGc089a0947f3e: rust-dirstatemap: directly return `non_normal` and `other_entries` (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20221

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

all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
self.state_map.insert(filename.to_owned(), entry.to_owned()); self.state_map.insert(filename.to_owned(), entry.to_owned());
if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET { if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
if entry.size == SIZE_FROM_OTHER_PARENT { if entry.size == SIZE_FROM_OTHER_PARENT {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.1 .1
.as_mut()
.unwrap()
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
Ok(()) Ok(())
} }
/// Mark a file as removed in the dirstate. /// Mark a file as removed in the dirstate.
/// ///
/// The `size` parameter is used to store sentinel values that indicate /// The `size` parameter is used to store sentinel values that indicate
state: EntryState::Removed, state: EntryState::Removed,
mode: 0, mode: 0,
size, size,
mtime: 0, mtime: 0,
}, },
); );
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.insert(filename.to_owned()); .insert(filename.to_owned());
Ok(()) Ok(())
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_file( pub fn drop_file(
&mut self, &mut self,
all_dirs.delete_path(filename)?; all_dirs.delete_path(filename)?;
} }
} }
if let Some(ref mut file_fold_map) = self.file_fold_map { if let Some(ref mut file_fold_map) = self.file_fold_map {
file_fold_map.remove(&normalize_case(filename)); file_fold_map.remove(&normalize_case(filename));
} }
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.remove(filename); .remove(filename);
Ok(exists) Ok(exists)
} }
pub fn clear_ambiguous_times( pub fn clear_ambiguous_times(
&mut self, &mut self,
filenames: Vec<HgPathBuf>, filenames: Vec<HgPathBuf>,
mtime: MTIME_UNSET, mtime: MTIME_UNSET,
..*entry ..*entry
}; };
} }
}); });
if changed { if changed {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
} }
} }
pub fn non_normal_entries_remove( pub fn non_normal_entries_remove(
&mut self, &mut self,
key: impl AsRef<HgPath>, key: impl AsRef<HgPath>,
) -> bool { ) -> bool {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.remove(key.as_ref()) .remove(key.as_ref())
} }
pub fn non_normal_entries_union( pub fn non_normal_entries_union(
&mut self, &mut self,
other: HashSet<HgPathBuf>, other: HashSet<HgPathBuf>,
) -> Vec<HgPathBuf> { ) -> Vec<HgPathBuf> {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.as_mut()
.unwrap()
.union(&other) .union(&other)
.map(|e| e.to_owned()) .map(|e| e.to_owned())
.collect() .collect()
} }
pub fn get_non_normal_other_parent_entries( pub fn get_non_normal_other_parent_entries(
&mut self, &mut self,
) -> ( ) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {
&mut Option<HashSet<HgPathBuf>>,
&mut Option<HashSet<HgPathBuf>>,
) {
self.set_non_normal_other_parent_entries(false); self.set_non_normal_other_parent_entries(false);
(&mut self.non_normal_set, &mut self.other_parent_set) (
self.non_normal_set.as_mut().unwrap(),
self.other_parent_set.as_mut().unwrap(),
)
} }
pub fn set_non_normal_other_parent_entries(&mut self, force: bool) { pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
if !force if !force
&& self.non_normal_set.is_some() && self.non_normal_set.is_some()
&& self.other_parent_set.is_some() && self.other_parent_set.is_some()
{ {
return; return;
mode: 1337, mode: 1337,
mtime: 1337, mtime: 1337,
size: 1337, size: 1337,
}, },
) )
.unwrap(); .unwrap();
assert_eq!(1, map.len()); assert_eq!(1, map.len());
assert_eq!( assert_eq!(0, map.get_non_normal_other_parent_entries().0.len());
0, assert_eq!(0, map.get_non_normal_other_parent_entries().1.len());
map.get_non_normal_other_parent_entries()
.0
.as_ref()
.unwrap()
.len()
);
assert_eq!(
0,
map.get_non_normal_other_parent_entries()
.1
.as_ref()
.unwrap()
.len()
);
} }
#[test] #[test]
fn test_non_normal_other_parent_entries() { fn test_non_normal_other_parent_entries() {
let mut map: DirstateMap = [ let mut map: DirstateMap = [
(b"f1", (EntryState::Removed, 1337, 1337, 1337)), (b"f1", (EntryState::Removed, 1337, 1337, 1337)),
(b"f2", (EntryState::Normal, 1337, 1337, -1)), (b"f2", (EntryState::Normal, 1337, 1337, -1)),
(b"f3", (EntryState::Normal, 1337, 1337, 1337)), (b"f3", (EntryState::Normal, 1337, 1337, 1337)),
.iter() .iter()
.map(|x| HgPathBuf::from_bytes(x.as_ref())) .map(|x| HgPathBuf::from_bytes(x.as_ref()))
.collect(); .collect();
let mut other_parent = HashSet::new(); let mut other_parent = HashSet::new();
other_parent.insert(HgPathBuf::from_bytes(b"f4")); other_parent.insert(HgPathBuf::from_bytes(b"f4"));
let entries = map.get_non_normal_other_parent_entries(); let entries = map.get_non_normal_other_parent_entries();
assert_eq!( assert_eq!((non_normal, other_parent), (entries.0, entries.1));
(Some(non_normal), Some(other_parent)),
(entries.0.to_owned(), entries.1.to_owned())
);
} }
} }

rust/hg-cpython/src/dirstate/dirstate_map.rs

let mut inner_shared = self.inner(py).borrow_mut(); let mut inner_shared = self.inner(py).borrow_mut();
let (_, other_parent) = let (_, other_parent) =
inner_shared.get_non_normal_other_parent_entries(); inner_shared.get_non_normal_other_parent_entries();
let locals = PyDict::new(py); let locals = PyDict::new(py);
locals.set_item( locals.set_item(
py, py,
"other_parent", "other_parent",
other_parent.as_ref() other_parent
.unwrap()
.iter() .iter()
.map(|v| PyBytes::new(py, v.as_ref())) .map(|v| PyBytes::new(py, v.as_ref()))
.collect::<Vec<PyBytes>>() .collect::<Vec<PyBytes>>()
.to_py_object(py), .to_py_object(py),
)?; )?;
py.eval("set(other_parent)", None, Some(&locals)) py.eval("set(other_parent)", None, Some(&locals))
} }
def non_normal_entries(&self) -> PyResult<NonNormalEntries> { def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
NonNormalEntries::from_inner(py, self.clone_ref(py)) NonNormalEntries::from_inner(py, self.clone_ref(py))
} }
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> { def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
Ok(self Ok(self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.get_non_normal_other_parent_entries().0 .get_non_normal_other_parent_entries().0
.as_ref()
.unwrap()
.contains(HgPath::new(key.data(py)))) .contains(HgPath::new(key.data(py))))
} }
def non_normal_entries_display(&self) -> PyResult<PyString> { def non_normal_entries_display(&self) -> PyResult<PyString> {
Ok( Ok(
PyString::new( PyString::new(
py, py,
&format!( &format!(
"NonNormalEntries: {:?}", "NonNormalEntries: {:?}",
self self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.get_non_normal_other_parent_entries().0 .get_non_normal_other_parent_entries().0
.as_ref() .iter().map(|o| o))
.unwrap().iter().map(|o| o))
) )
) )
} }
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> { def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
self self
.inner(py) .inner(py)