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

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 20223

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)),
mode: *mode, mode: *mode,
size: *size, size: *size,
mtime: *mtime, mtime: *mtime,
}, },
) )
}) })
.collect(); .collect();
let non_normal = [ let mut non_normal = [
b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb", b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
] ]
.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!(
(Some(non_normal), Some(other_parent)), (&mut non_normal, &mut other_parent),
(entries.0.to_owned(), entries.1.to_owned()) (entries.0, entries.1)
); );
} }
} }

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)