( )⚙ 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
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

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

Diff 30233

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);