( )⚙ D10558 rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10558

rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs
ClosedPublic

Authored by SimonSapin on May 3 2021, 6:26 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGcd8ca38fccff: rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs
rHGb0d1bb8add3b: rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs
Summary

Getting the former (through Deref) is almost the only useful thing one can
do with the latter anyway. With this changes, API become more flexible for the
"provider" of these paths which may store something else that Deref’s to HgPath,
such as std::borrow::Cow<HgPath>. Using Cow can help reduce memory alloactions
and copying.

Diff Detail

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

Event Timeline

SimonSapin created this revision.May 3 2021, 6:26 AM
Alphare accepted this revision.May 3 2021, 12:23 PM
This revision is now accepted and ready to land.May 3 2021, 12:23 PM
baymax updated this revision to Diff 27634.May 6 2021, 12:04 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 27634

rust/hg-core/src/dirstate.rs

// dirstate module // dirstate module
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::errors::HgError; use crate::errors::HgError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::{utils::hg_path::HgPathBuf, FastHashMap}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::FastHashMap;
use bytes_cast::{unaligned, BytesCast}; use bytes_cast::{unaligned, BytesCast};
use std::convert::TryFrom; use std::convert::TryFrom;
pub mod dirs_multiset; pub mod dirs_multiset;
pub mod dirstate_map; pub mod dirstate_map;
pub mod parsers; pub mod parsers;
pub mod status; pub mod status;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>; pub type StateMap = FastHashMap<HgPathBuf, DirstateEntry>;
pub type StateMapIter<'a> = pub type StateMapIter<'a> =
Box<dyn Iterator<Item = (&'a HgPathBuf, &'a DirstateEntry)> + Send + 'a>; Box<dyn Iterator<Item = (&'a HgPath, &'a DirstateEntry)> + Send + 'a>;
pub type CopyMap = FastHashMap<HgPathBuf, HgPathBuf>; pub type CopyMap = FastHashMap<HgPathBuf, HgPathBuf>;
pub type CopyMapIter<'a> = pub type CopyMapIter<'a> =
Box<dyn Iterator<Item = (&'a HgPathBuf, &'a HgPathBuf)> + Send + 'a>; Box<dyn Iterator<Item = (&'a HgPath, &'a HgPath)> + Send + 'a>;
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum EntryState { pub enum EntryState {
Normal, Normal,
Added, Added,
Removed, Removed,
Merged, Merged,
Unknown, Unknown,

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

pub struct DirsMultiset { pub struct DirsMultiset {
inner: FastHashMap<HgPathBuf, u32>, inner: FastHashMap<HgPathBuf, u32>,
} }
impl DirsMultiset { impl DirsMultiset {
/// Initializes the multiset from a dirstate. /// Initializes the multiset from a dirstate.
/// ///
/// If `skip_state` is provided, skips dirstate entries with equal state. /// If `skip_state` is provided, skips dirstate entries with equal state.
pub fn from_dirstate<'a>( pub fn from_dirstate<'a, I, P>(
dirstate: impl IntoIterator<Item = (&'a HgPathBuf, &'a DirstateEntry)>, dirstate: I,
skip_state: Option<EntryState>, skip_state: Option<EntryState>,
) -> Result<Self, DirstateMapError> { ) -> Result<Self, DirstateMapError>
where
I: IntoIterator<Item = (P, &'a DirstateEntry)>,
P: AsRef<HgPath>,
{
let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
for (filename, DirstateEntry { state, .. }) in dirstate { for (filename, entry) in dirstate {
let filename = filename.as_ref();
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if let Some(skip) = skip_state { if let Some(skip) = skip_state {
if skip != *state { if skip != entry.state {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} else { } else {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} }
Ok(multiset) Ok(multiset)

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

)?); )?);
} }
Ok(()) Ok(())
} }
pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> { pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
if self.dirs.is_none() { if self.dirs.is_none() {
self.dirs = Some(DirsMultiset::from_dirstate( self.dirs = Some(DirsMultiset::from_dirstate(
&self.state_map, self.state_map.iter(),
Some(EntryState::Removed), Some(EntryState::Removed),
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn has_tracked_dir( pub fn has_tracked_dir(
&mut self, &mut self,

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

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::HgPath;
use crate::{ use crate::{
dirstate::{CopyMap, EntryState, RawEntry, StateMap}, dirstate::{CopyMap, EntryState, RawEntry, StateMap},
DirstateEntry, DirstateParents, DirstateEntry, DirstateParents,
}; };
use byteorder::{BigEndian, WriteBytesExt}; use byteorder::{BigEndian, WriteBytesExt};
use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use micro_timer::timed; use micro_timer::timed;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
each_entry(path, &entry, copy_source); each_entry(path, &entry, copy_source);
contents = rest; contents = rest;
} }
Ok(parents) Ok(parents)
} }
fn packed_filename_and_copy_source_size( fn packed_filename_and_copy_source_size(
filename: &HgPathBuf, filename: &HgPath,
copy_source: Option<&HgPathBuf>, copy_source: Option<&HgPath>,
) -> usize { ) -> usize {
filename.len() filename.len()
+ if let Some(source) = copy_source { + if let Some(source) = copy_source {
b"\0".len() + source.len() b"\0".len() + source.len()
} else { } else {
0 0
} }
} }
pub fn packed_entry_size( pub fn packed_entry_size(
filename: &HgPathBuf, filename: &HgPath,
copy_source: Option<&HgPathBuf>, copy_source: Option<&HgPath>,
) -> usize { ) -> usize {
MIN_ENTRY_SIZE MIN_ENTRY_SIZE
+ packed_filename_and_copy_source_size(filename, copy_source) + packed_filename_and_copy_source_size(filename, copy_source)
} }
pub fn pack_entry( pub fn pack_entry(
filename: &HgPathBuf, filename: &HgPath,
entry: &DirstateEntry, entry: &DirstateEntry,
copy_source: Option<&HgPathBuf>, copy_source: Option<&HgPath>,
packed: &mut Vec<u8>, packed: &mut Vec<u8>,
) { ) {
let length = packed_filename_and_copy_source_size(filename, copy_source); let length = packed_filename_and_copy_source_size(filename, copy_source);
// Unwrapping because `impl std::io::Write for Vec<u8>` never errors // Unwrapping because `impl std::io::Write for Vec<u8>` never errors
packed.write_u8(entry.state.into()).unwrap(); packed.write_u8(entry.state.into()).unwrap();
packed.write_i32::<BigEndian>(entry.mode).unwrap(); packed.write_i32::<BigEndian>(entry.mode).unwrap();
packed.write_i32::<BigEndian>(entry.size).unwrap(); packed.write_i32::<BigEndian>(entry.size).unwrap();
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, HgError> { ) -> Result<Vec<u8>, HgError> {
// TODO move away from i32 before 2038. // TODO move away from i32 before 2038.
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let expected_size: usize = state_map let expected_size: usize = state_map
.iter() .iter()
.map(|(filename, _)| { .map(|(filename, _)| {
packed_entry_size(filename, copy_map.get(filename)) packed_entry_size(filename, copy_map.get(filename).map(|p| &**p))
}) })
.sum(); .sum();
let expected_size = expected_size + PARENT_SIZE * 2; let expected_size = expected_size + PARENT_SIZE * 2;
let mut packed = Vec::with_capacity(expected_size); let mut packed = Vec::with_capacity(expected_size);
packed.extend(parents.p1.as_bytes()); packed.extend(parents.p1.as_bytes());
packed.extend(parents.p2.as_bytes()); packed.extend(parents.p2.as_bytes());
for (filename, entry) in state_map.iter_mut() { for (filename, entry) in state_map.iter_mut() {
clear_ambiguous_mtime(entry, now); clear_ambiguous_mtime(entry, now);
pack_entry(filename, entry, copy_map.get(filename), &mut packed) pack_entry(
filename,
entry,
copy_map.get(filename).map(|p| &**p),
&mut packed,
)
} }
if packed.len() != expected_size { if packed.len() != expected_size {
return Err(HgError::CorruptedRepository(format!( return Err(HgError::CorruptedRepository(format!(
"bad dirstate size: {} != {}", "bad dirstate size: {} != {}",
expected_size, expected_size,
packed.len() packed.len()
))); )));

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

impl Node { impl Node {
pub(super) fn state(&self) -> Option<EntryState> { pub(super) fn state(&self) -> Option<EntryState> {
self.entry.as_ref().map(|entry| entry.state) self.entry.as_ref().map(|entry| entry.state)
} }
} }
/// `(full_path, entry, copy_source)` /// `(full_path, entry, copy_source)`
type NodeDataMut<'a> = ( type NodeDataMut<'a> = (
&'a WithBasename<HgPathBuf>, &'a HgPath,
&'a mut Option<DirstateEntry>, &'a mut Option<DirstateEntry>,
&'a mut Option<HgPathBuf>, &'a mut Option<HgPathBuf>,
); );
impl<'on_disk> DirstateMap<'on_disk> { impl<'on_disk> DirstateMap<'on_disk> {
pub fn new( pub fn new(
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<(Self, Option<DirstateParents>), DirstateError> { ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
if node.entry.is_none() { if node.entry.is_none() {
self.nodes_with_entry_count += 1 self.nodes_with_entry_count += 1
} }
node.entry = Some(new_entry) node.entry = Some(new_entry)
} }
fn iter_nodes<'a>( fn iter_nodes<'a>(
&'a self, &'a self,
) -> impl Iterator<Item = (&'a WithBasename<HgPathBuf>, &'a Node)> + 'a ) -> impl Iterator<Item = (&'a HgPath, &'a Node)> + 'a {
{
// Depth first tree traversal. // Depth first tree traversal.
// //
// If we could afford internal iteration and recursion, // If we could afford internal iteration and recursion,
// this would look like: // this would look like:
// //
// ``` // ```
// fn traverse_children( // fn traverse_children(
// children: &ChildNodes, // children: &ChildNodes,
// call stack. Use an explicit stack instead: // call stack. Use an explicit stack instead:
let mut stack = Vec::new(); let mut stack = Vec::new();
let mut iter = self.root.iter(); let mut iter = self.root.iter();
std::iter::from_fn(move || { std::iter::from_fn(move || {
while let Some((key, child_node)) = iter.next() { while let Some((key, child_node)) = iter.next() {
// Pseudo-recursion // Pseudo-recursion
let new_iter = child_node.children.iter(); let new_iter = child_node.children.iter();
let old_iter = std::mem::replace(&mut iter, new_iter); let old_iter = std::mem::replace(&mut iter, new_iter);
let key = &**key.full_path();
stack.push((key, child_node, old_iter)); stack.push((key, child_node, old_iter));
} }
// Found the end of a `children.iter()` iterator. // Found the end of a `children.iter()` iterator.
if let Some((key, child_node, next_iter)) = stack.pop() { if let Some((key, child_node, next_iter)) = stack.pop() {
// "Return" from pseudo-recursion by restoring state from the // "Return" from pseudo-recursion by restoring state from the
// explicit stack // explicit stack
iter = next_iter; iter = next_iter;
&'a mut self, &'a mut self,
) -> impl Iterator<Item = NodeDataMut<'a>> + 'a { ) -> impl Iterator<Item = NodeDataMut<'a>> + 'a {
// Explict stack for pseudo-recursion, see `iter_nodes` above. // Explict stack for pseudo-recursion, see `iter_nodes` above.
let mut stack = Vec::new(); let mut stack = Vec::new();
let mut iter = self.root.iter_mut(); let mut iter = self.root.iter_mut();
std::iter::from_fn(move || { std::iter::from_fn(move || {
while let Some((key, child_node)) = iter.next() { while let Some((key, child_node)) = iter.next() {
// Pseudo-recursion // Pseudo-recursion
let data = let data = (
(key, &mut child_node.entry, &mut child_node.copy_source); &**key.full_path(),
&mut child_node.entry,
&mut child_node.copy_source,
);
let new_iter = child_node.children.iter_mut(); let new_iter = child_node.children.iter_mut();
let old_iter = std::mem::replace(&mut iter, new_iter); let old_iter = std::mem::replace(&mut iter, new_iter);
stack.push((data, old_iter)); stack.push((data, old_iter));
} }
// Found the end of a `children.values_mut()` iterator. // Found the end of a `children.values_mut()` iterator.
if let Some((data, next_iter)) = stack.pop() { if let Some((data, next_iter)) = stack.pop() {
// "Return" from pseudo-recursion by restoring state from the // "Return" from pseudo-recursion by restoring state from the
// explicit stack // explicit stack
fn non_normal_entries_remove(&mut self, _key: &HgPath) { fn non_normal_entries_remove(&mut self, _key: &HgPath) {
// Do nothing, this `DirstateMap` does not have a separate "non normal // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date // entries" set that need to be kept up to date
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + '_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry node.entry
.as_ref() .as_ref()
.filter(|entry| { .filter(|entry| {
entry.is_non_normal() || entry.is_from_other_parent() entry.is_non_normal() || entry.is_from_other_parent()
}) })
.map(|_| path.full_path()) .map(|_| path)
})) }))
} }
fn set_non_normal_other_parent_entries(&mut self, _force: bool) { fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
// Do nothing, this `DirstateMap` does not have a separate "non normal // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" and "from other parent" sets that need to be recomputed // entries" and "from other parent" sets that need to be recomputed
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
self.iter_non_normal_paths_panic() self.iter_non_normal_paths_panic()
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry node.entry
.as_ref() .as_ref()
.filter(|entry| entry.is_non_normal()) .filter(|entry| entry.is_non_normal())
.map(|_| path.full_path()) .map(|_| path)
})) }))
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry node.entry
.as_ref() .as_ref()
.filter(|entry| entry.is_from_other_parent()) .filter(|entry| entry.is_from_other_parent())
.map(|_| path.full_path()) .map(|_| path)
})) }))
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
if let Some(node) = self.get_node(directory) { if let Some(node) = self.get_node(directory) {
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
// Optizimation (to be measured?): pre-compute size to avoid `Vec` // Optizimation (to be measured?): pre-compute size to avoid `Vec`
// reallocations // reallocations
let mut size = parents.as_bytes().len(); let mut size = parents.as_bytes().len();
for (path, node) in self.iter_nodes() { for (path, node) in self.iter_nodes() {
if node.entry.is_some() { if node.entry.is_some() {
size += packed_entry_size( size += packed_entry_size(
path.full_path(), path,
node.copy_source.as_ref(), node.copy_source.as_ref().map(|p| &**p),
) )
} }
} }
let mut packed = Vec::with_capacity(size); let mut packed = Vec::with_capacity(size);
packed.extend(parents.as_bytes()); packed.extend(parents.as_bytes());
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
for (path, opt_entry, copy_source) in self.iter_node_data_mut() { for (path, opt_entry, copy_source) in self.iter_node_data_mut() {
if let Some(entry) = opt_entry { if let Some(entry) = opt_entry {
clear_ambiguous_mtime(entry, now); clear_ambiguous_mtime(entry, now);
pack_entry( pack_entry(
path.full_path(), path,
entry, entry,
copy_source.as_ref(), copy_source.as_ref().map(|p| &**p),
&mut packed, &mut packed,
); );
} }
} }
Ok(packed) Ok(packed)
} }
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> {
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.nodes_with_copy_source_count self.nodes_with_copy_source_count
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.copy_source node.copy_source
.as_ref() .as_ref()
.map(|copy_source| (path.full_path(), copy_source)) .map(|copy_source| (path, &**copy_source))
})) }))
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(&self, key: &HgPath) -> bool {
if let Some(node) = self.get_node(key) { if let Some(node) = self.get_node(key) {
node.copy_source.is_some() node.copy_source.is_some()
} else { } else {
false false
} }
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPathBuf> { fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> {
self.get_node(key)?.copy_source.as_ref() self.get_node(key)?.copy_source.as_ref().map(|p| &**p)
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> {
let count = &mut self.nodes_with_copy_source_count; let count = &mut self.nodes_with_copy_source_count;
Self::get_node_mut(&mut self.root, key).and_then(|node| { Self::get_node_mut(&mut self.root, key).and_then(|node| {
if node.copy_source.is_some() { if node.copy_source.is_some() {
*count -= 1 *count -= 1
} }
} }
fn get(&self, key: &HgPath) -> Option<&DirstateEntry> { fn get(&self, key: &HgPath) -> Option<&DirstateEntry> {
self.get_node(key)?.entry.as_ref() self.get_node(key)?.entry.as_ref()
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {
node.entry.as_ref().map(|entry| (path.full_path(), entry)) node.entry.as_ref().map(|entry| (path, entry))
})) }))
} }
} }

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

fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32); fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32);
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool; fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool;
fn non_normal_entries_remove(&mut self, key: &HgPath); fn non_normal_entries_remove(&mut self, key: &HgPath);
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_>; ) -> Box<dyn Iterator<Item = &HgPath> + '_>;
fn set_non_normal_other_parent_entries(&mut self, force: bool); fn set_non_normal_other_parent_entries(&mut self, force: bool);
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>; ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>;
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>; ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>;
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>; ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_>;
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateMapError>;
fn has_dir( fn has_dir(
&mut self, &mut self,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>; ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
fn copy_map_len(&self) -> usize; fn copy_map_len(&self) -> usize;
fn copy_map_iter(&self) -> CopyMapIter<'_>; fn copy_map_iter(&self) -> CopyMapIter<'_>;
fn copy_map_contains_key(&self, key: &HgPath) -> bool; fn copy_map_contains_key(&self, key: &HgPath) -> bool;
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPathBuf>; fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath>;
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf>; fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf>;
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Option<HgPathBuf>; ) -> Option<HgPathBuf>;
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) {
self.non_normal_entries_remove(key) self.non_normal_entries_remove(key)
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + '_> {
let (non_normal, other_parent) = let (non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(non_normal.union(other_parent)) Box::new(non_normal.union(other_parent).map(|p| &**p))
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.set_non_normal_other_parent_entries(force) self.set_non_normal_other_parent_entries(force)
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(non_normal.iter()) Box::new(non_normal.iter().map(|p| &**p))
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries_panic(); self.get_non_normal_other_parent_entries_panic();
Box::new(non_normal.iter()) Box::new(non_normal.iter().map(|p| &**p))
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
let (_non_normal, other_parent) = let (_non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(other_parent.iter()) Box::new(other_parent.iter().map(|p| &**p))
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
self.has_tracked_dir(directory) self.has_tracked_dir(directory)
} }
crate::status(self, matcher, root_dir, ignore_files, options) crate::status(self, matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.copy_map.len() self.copy_map.len()
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(self.copy_map.iter()) Box::new(self.copy_map.iter().map(|(key, value)| (&**key, &**value)))
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(&self, key: &HgPath) -> bool {
self.copy_map.contains_key(key) self.copy_map.contains_key(key)
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPathBuf> { fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> {
self.copy_map.get(key) self.copy_map.get(key).map(|p| &**p)
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> {
self.copy_map.remove(key) self.copy_map.remove(key)
} }
fn copy_map_insert( fn copy_map_insert(
&mut self, &mut self,
(&**self).contains_key(key) (&**self).contains_key(key)
} }
fn get(&self, key: &HgPath) -> Option<&DirstateEntry> { fn get(&self, key: &HgPath) -> Option<&DirstateEntry> {
(&**self).get(key) (&**self).get(key)
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new((&**self).iter()) Box::new((&**self).iter().map(|(key, value)| (&**key, value)))
} }
} }

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

// copymap.rs // copymap.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for `hg::dirstate::dirstate_map::CopyMap` provided by the //! Bindings for `hg::dirstate::dirstate_map::CopyMap` provided by the
//! `hg-core` package. //! `hg-core` package.
use cpython::{ use cpython::{
PyBytes, PyClone, PyDict, PyObject, PyResult, Python, UnsafePyLeaked, PyBytes, PyClone, PyDict, PyObject, PyResult, Python, UnsafePyLeaked,
}; };
use std::cell::RefCell; use std::cell::RefCell;
use crate::dirstate::dirstate_map::DirstateMap; use crate::dirstate::dirstate_map::DirstateMap;
use hg::{utils::hg_path::HgPathBuf, CopyMapIter}; use hg::utils::hg_path::HgPath;
use hg::CopyMapIter;
py_class!(pub class CopyMap |py| { py_class!(pub class CopyMap |py| {
data dirstate_map: DirstateMap; data dirstate_map: DirstateMap;
def __getitem__(&self, key: PyObject) -> PyResult<PyBytes> { def __getitem__(&self, key: PyObject) -> PyResult<PyBytes> {
(*self.dirstate_map(py)).copymapgetitem(py, key) (*self.dirstate_map(py)).copymapgetitem(py, key)
} }
}); });
impl CopyMap { impl CopyMap {
pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> { pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> {
Self::create_instance(py, dm) Self::create_instance(py, dm)
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPathBuf, &HgPathBuf), res: (&HgPath, &HgPath),
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_bytes()))) Ok(Some(PyBytes::new(py, res.0.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPathBuf, &HgPathBuf), res: (&HgPath, &HgPath),
) -> PyResult<Option<(PyBytes, PyBytes)>> { ) -> PyResult<Option<(PyBytes, PyBytes)>> {
let (k, v) = res; let (k, v) = res;
Ok(Some(( Ok(Some((
PyBytes::new(py, k.as_bytes()), PyBytes::new(py, k.as_bytes()),
PyBytes::new(py, v.as_bytes()), PyBytes::new(py, v.as_bytes()),
))) )))
} }
} }

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

pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPathBuf, &DirstateEntry), res: (&HgPath, &DirstateEntry),
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_bytes()))) Ok(Some(PyBytes::new(py, res.0.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: (&HgPathBuf, &DirstateEntry), res: (&HgPath, &DirstateEntry),
) -> PyResult<Option<(PyBytes, PyObject)>> { ) -> PyResult<Option<(PyBytes, PyObject)>> {
let (f, entry) = res; let (f, entry) = res;
Ok(Some(( Ok(Some((
PyBytes::new(py, f.as_bytes()), PyBytes::new(py, f.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_tuple(py, &entry)?,
))) )))
} }
} }

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

} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) {
self.get_mut().non_normal_entries_remove(key) self.get_mut().non_normal_entries_remove(key)
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + '_> {
self.get_mut().non_normal_or_other_parent_paths() self.get_mut().non_normal_or_other_parent_paths()
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.get_mut().set_non_normal_other_parent_entries(force) self.get_mut().set_non_normal_other_parent_entries(force)
} }
fn iter_non_normal_paths( fn iter_non_normal_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
self.get_mut().iter_non_normal_paths() self.get_mut().iter_non_normal_paths()
} }
fn iter_non_normal_paths_panic( fn iter_non_normal_paths_panic(
&self, &self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
self.get().iter_non_normal_paths_panic() self.get().iter_non_normal_paths_panic()
} }
fn iter_other_parent_paths( fn iter_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> { ) -> Box<dyn Iterator<Item = &HgPath> + Send + '_> {
self.get_mut().iter_other_parent_paths() self.get_mut().iter_other_parent_paths()
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
self.get_mut().has_tracked_dir(directory) self.get_mut().has_tracked_dir(directory)
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
self.get().copy_map_iter() self.get().copy_map_iter()
} }
fn copy_map_contains_key(&self, key: &HgPath) -> bool { fn copy_map_contains_key(&self, key: &HgPath) -> bool {
self.get().copy_map_contains_key(key) self.get().copy_map_contains_key(key)
} }
fn copy_map_get(&self, key: &HgPath) -> Option<&HgPathBuf> { fn copy_map_get(&self, key: &HgPath) -> Option<&HgPath> {
self.get().copy_map_get(key) self.get().copy_map_get(key)
} }
fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> { fn copy_map_remove(&mut self, key: &HgPath) -> Option<HgPathBuf> {
self.get_mut().copy_map_remove(key) self.get_mut().copy_map_remove(key)
} }
fn copy_map_insert( fn copy_map_insert(

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

// non_normal_other_parent_entries.rs // non_normal_other_parent_entries.rs
// //
// Copyright 2020 Raphaël Gomès <rgomes@octobus.net> // Copyright 2020 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use cpython::{ use cpython::{
exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone, exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,
PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject, PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::dirstate::DirstateMap; use crate::dirstate::DirstateMap;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPath;
use std::cell::RefCell; use std::cell::RefCell;
py_class!(pub class NonNormalEntries |py| { py_class!(pub class NonNormalEntries |py| {
data dmap: DirstateMap; data dmap: DirstateMap;
def __contains__(&self, key: PyObject) -> PyResult<bool> { def __contains__(&self, key: PyObject) -> PyResult<bool> {
self.dmap(py).non_normal_entries_contains(py, key) self.dmap(py).non_normal_entries_contains(py, key)
} }
for item in other.iter(py)? { for item in other.iter(py)? {
if !self.dmap(py).non_normal_entries_contains(py, item?)? { if !self.dmap(py).non_normal_entries_contains(py, item?)? {
return Ok(false); return Ok(false);
} }
} }
Ok(true) Ok(true)
} }
fn translate_key( fn translate_key(py: Python, key: &HgPath) -> PyResult<Option<PyBytes>> {
py: Python,
key: &HgPathBuf,
) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, key.as_bytes()))) Ok(Some(PyBytes::new(py, key.as_bytes())))
} }
} }
type NonNormalEntriesIter<'a> = type NonNormalEntriesIter<'a> =
Box<dyn Iterator<Item = &'a HgPathBuf> + Send + 'a>; Box<dyn Iterator<Item = &'a HgPath> + Send + 'a>;
py_shared_iterator!( py_shared_iterator!(
NonNormalEntriesIterator, NonNormalEntriesIterator,
UnsafePyLeaked<NonNormalEntriesIter<'static>>, UnsafePyLeaked<NonNormalEntriesIter<'static>>,
NonNormalEntries::translate_key, NonNormalEntries::translate_key,
Option<PyBytes> Option<PyBytes>
); );