( )⚙ D11405 rust: Move lazy initialization of `Repo::dirstate_map` into a generic struct

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11405

rust: Move lazy initialization of `Repo::dirstate_map` into a generic struct
ClosedPublic

Authored by SimonSapin on Sep 13 2021, 2:13 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGfc208d6faed3: rust: Move lazy initialization of `Repo::dirstate_map` into a generic struct
Summary

More components of Repo will be added following the same pattern.

Diff Detail

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

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/repo.rs (48 lines)

Diff 30223

rust/hg-core/src/repo.rs

pub struct Repo { pub struct Repo {
working_directory: PathBuf, working_directory: PathBuf,
dot_hg: PathBuf, dot_hg: PathBuf,
store: PathBuf, store: PathBuf,
requirements: HashSet<String>, requirements: HashSet<String>,
config: Config, config: Config,
// None means not known/initialized yet // None means not known/initialized yet
dirstate_parents: Cell<Option<DirstateParents>>, dirstate_parents: Cell<Option<DirstateParents>>,
dirstate_map: RefCell<Option<OwningDirstateMap>>, dirstate_map: LazyCell<OwningDirstateMap, DirstateError>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum RepoError { pub enum RepoError {
NotFound { NotFound {
at: PathBuf, at: PathBuf,
}, },
#[from] #[from]
let repo = Self { let repo = Self {
requirements: reqs, requirements: reqs,
working_directory, working_directory,
store: store_path, store: store_path,
dot_hg, dot_hg,
config: repo_config, config: repo_config,
dirstate_parents: Cell::new(None), dirstate_parents: Cell::new(None),
dirstate_map: RefCell::new(None), dirstate_map: LazyCell::new(Self::new_dirstate_map),
}; };
requirements::check(&repo)?; requirements::check(&repo)?;
Ok(repo) Ok(repo)
} }
pub fn working_directory_path(&self) -> &Path { pub fn working_directory_path(&self) -> &Path {
*placeholder = inner; *placeholder = inner;
Ok(map) Ok(map)
} }
} }
pub fn dirstate_map( pub fn dirstate_map(
&self, &self,
) -> Result<Ref<OwningDirstateMap>, DirstateError> { ) -> Result<Ref<OwningDirstateMap>, DirstateError> {
let mut borrowed = self.dirstate_map.borrow(); self.dirstate_map.get_or_init(self)
}
pub fn dirstate_map_mut(
&self,
) -> Result<RefMut<OwningDirstateMap>, DirstateError> {
self.dirstate_map.get_mut_or_init(self)
}
}
/// Lazily-initialized component of `Repo` with interior mutability
///
/// This differs from `OnceCell` in that the value can still be "deinitialized"
/// later by setting its inner `Option` to `None`.
struct LazyCell<T, E> {
value: RefCell<Option<T>>,
// `Fn`s that don’t capture environment are zero-size, so this box does
// not allocate:
init: Box<dyn Fn(&Repo) -> Result<T, E>>,
}
impl<T, E> LazyCell<T, E> {
fn new(init: impl Fn(&Repo) -> Result<T, E> + 'static) -> Self {
Self {
value: RefCell::new(None),
init: Box::new(init),
}
}
fn get_or_init(&self, repo: &Repo) -> Result<Ref<T>, E> {
let mut borrowed = self.value.borrow();
if borrowed.is_none() { if borrowed.is_none() {
drop(borrowed); drop(borrowed);
// Only use `borrow_mut` if it is really needed to avoid panic in // Only use `borrow_mut` if it is really needed to avoid panic in
// case there is another outstanding borrow but mutation is not // case there is another outstanding borrow but mutation is not
// needed. // needed.
*self.dirstate_map.borrow_mut() = Some(self.new_dirstate_map()?); *self.value.borrow_mut() = Some((self.init)(repo)?);
borrowed = self.dirstate_map.borrow() borrowed = self.value.borrow()
} }
Ok(Ref::map(borrowed, |option| option.as_ref().unwrap())) Ok(Ref::map(borrowed, |option| option.as_ref().unwrap()))
} }
pub fn dirstate_map_mut( pub fn get_mut_or_init(&self, repo: &Repo) -> Result<RefMut<T>, E> {
&self, let mut borrowed = self.value.borrow_mut();
) -> Result<RefMut<OwningDirstateMap>, DirstateError> {
let mut borrowed = self.dirstate_map.borrow_mut();
if borrowed.is_none() { if borrowed.is_none() {
*borrowed = Some(self.new_dirstate_map()?); *borrowed = Some((self.init)(repo)?);
} }
Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap())) Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap()))
} }
} }
// TODO: remove this when https://github.com/RazrFalcon/memmap2-rs/pull/22 is on crates.io // TODO: remove this when https://github.com/RazrFalcon/memmap2-rs/pull/22 is on crates.io
struct MmapWrapper(memmap2::Mmap); struct MmapWrapper(memmap2::Mmap);