This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6690

rust-dirstate: improve API of `DirsMultiset`
ClosedPublic

Authored by Alphare on Jul 24 2019, 11:22 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG849e744b925d: rust-dirstate: improve API of `DirsMultiset`
rHG4f9dff6f4d7e: rust-dirstate: improve API of `DirsMultiset`
Summary
  • Use opaque Iterator type instead of implementation-specific one from HashMap
  • Make DirsMultiset behave like a set both in Rust and from Python

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.Jul 24 2019, 11:22 AM
Alphare added a commit: rHG4f9dff6f4d7e: rust-dirstate: improve API of `DirsMultiset`.Aug 14 2019, 4:39 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG4f9dff6f4d7e: rust-dirstate: improve API of `DirsMultiset` (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 16199

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

// dirs_multiset.rs // dirs_multiset.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.
//! A multiset of directory names. //! A multiset of directory names.
//! //!
//! Used to counts the references to directories in a manifest or dirstate. //! Used to counts the references to directories in a manifest or dirstate.
use crate::{ use crate::{
dirstate::EntryState, utils::files, DirsIterable, DirstateEntry, dirstate::EntryState, utils::files, DirsIterable, DirstateEntry,
DirstateMapError, DirstateMapError,
}; };
use std::collections::hash_map::{Entry, Iter}; use std::collections::hash_map::Entry;
use std::collections::HashMap; use std::collections::HashMap;
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub struct DirsMultiset { pub struct DirsMultiset {
inner: HashMap<Vec<u8>, u32>, inner: HashMap<Vec<u8>, u32>,
} }
impl DirsMultiset { impl DirsMultiset {
)) ))
} }
}; };
} }
Ok(()) Ok(())
} }
pub fn contains_key(&self, key: &[u8]) -> bool { pub fn contains(&self, key: &[u8]) -> bool {
self.inner.contains_key(key) self.inner.contains_key(key)
} }
pub fn iter(&self) -> Iter<Vec<u8>, u32> { pub fn iter(&self) -> impl Iterator<Item = &Vec<u8>> {
self.inner.iter() self.inner.keys()
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.inner.len() self.inner.len()
} }
} }
#[cfg(test)] #[cfg(test)]

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

// dirs_multiset.rs // dirs_multiset.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 the `hg::dirstate::dirs_multiset` file provided by the //! Bindings for the `hg::dirstate::dirs_multiset` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::RefCell; use std::cell::RefCell;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyObject, PyResult, exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyObject, PyResult,
ToPyObject, PythonObject, ToPyObject,
}; };
use crate::dirstate::extract_dirstate; use crate::dirstate::extract_dirstate;
use hg::{ use hg::{
DirsIterable, DirsMultiset, DirstateMapError, DirstateParseError, DirsIterable, DirsMultiset, DirstateMapError, DirstateParseError,
EntryState, EntryState,
}; };
use std::convert::TryInto; use std::convert::TryInto;
} }
}) })
} }
// This is really inefficient on top of being ugly, but it's an easy way // This is really inefficient on top of being ugly, but it's an easy way
// of having it work to continue working on the rest of the module // of having it work to continue working on the rest of the module
// hopefully bypassing Python entirely pretty soon. // hopefully bypassing Python entirely pretty soon.
def __iter__(&self) -> PyResult<PyObject> { def __iter__(&self) -> PyResult<PyObject> {
let dict = PyDict::new(py); let dirs = self.dirs_map(py).borrow();
let dirs: Vec<_> = dirs
for (key, value) in self.dirs_map(py).borrow().iter() { .iter()
dict.set_item( .map(|d| PyBytes::new(py, d))
py, .collect();
PyBytes::new(py, &key[..]), dirs.to_py_object(py)
value.to_py_object(py), .into_object()
)?; .iter(py)
} .map(|o| o.into_object())
let locals = PyDict::new(py);
locals.set_item(py, "obj", dict)?;
py.eval("iter(obj)", None, Some(&locals))
} }
def __contains__(&self, item: PyObject) -> PyResult<bool> { def __contains__(&self, item: PyObject) -> PyResult<bool> {
Ok(self Ok(self
.dirs_map(py) .dirs_map(py)
.borrow() .borrow()
.contains_key(item.extract::<PyBytes>(py)?.data(py).as_ref())) .contains(item.extract::<PyBytes>(py)?.data(py).as_ref()))
} }
}); });