( )⚙ D8159 rust-nodemap: add binding for `nodemap_data_incremental`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8159

rust-nodemap: add binding for `nodemap_data_incremental`
ClosedPublic

Authored by Alphare on Feb 26 2020, 12:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5bbf887275b0: rust-nodemap: add binding for `nodemap_data_incremental`

Diff Detail

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

Event Timeline

Alphare created this revision.Feb 26 2020, 12:36 PM
marmoute updated this revision to Diff 20378.Feb 28 2020, 1:53 PM
Alphare updated this revision to Diff 20658.Mar 10 2020, 6:52 AM
gracinet added a commit: rHG5bbf887275b0: rust-nodemap: add binding for `nodemap_data_incremental`.Mar 11 2020, 11:42 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG5bbf887275b0: rust-nodemap: add binding for `nodemap_data_incremental` (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-cpython/src/revlog.rs (29 lines)

Diff 20334

rust/hg-cpython/src/revlog.rs

utils::{node_from_py_bytes, node_from_py_object}, utils::{node_from_py_bytes, node_from_py_object},
}; };
use cpython::{ use cpython::{
exc::{IndexError, ValueError}, exc::{IndexError, ValueError},
ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject,
PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
nodemap::{NodeMapError, NodeTree}, nodemap::{Block, NodeMapError, NodeTree},
revlog::{nodemap::NodeMap, RevlogIndex}, revlog::{nodemap::NodeMap, RevlogIndex},
NodeError, Revision, NodeError, Revision,
}; };
use std::cell::RefCell; use std::cell::RefCell;
/// Return a Struct implementing the Graph trait /// Return a Struct implementing the Graph trait
pub(crate) fn pyindex_to_graph( pub(crate) fn pyindex_to_graph(
py: Python, py: Python,
index: PyObject, index: PyObject,
) -> PyResult<cindex::Index> { ) -> PyResult<cindex::Index> {
match index.extract::<MixedIndex>(py) { match index.extract::<MixedIndex>(py) {
Ok(midx) => Ok(midx.clone_cindex(py)), Ok(midx) => Ok(midx.clone_cindex(py)),
Err(_) => cindex::Index::new(py, index), Err(_) => cindex::Index::new(py, index),
} }
} }
py_class!(pub class MixedIndex |py| { py_class!(pub class MixedIndex |py| {
data cindex: RefCell<cindex::Index>; data cindex: RefCell<cindex::Index>;
data nt: RefCell<Option<NodeTree>>; data nt: RefCell<Option<NodeTree>>;
data docket: RefCell<Option<PyObject>>;
def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> { def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> {
Self::new(py, cindex) Self::new(py, cindex)
} }
/// Compatibility layer used for Python consumers needing access to the C index /// Compatibility layer used for Python consumers needing access to the C index
/// ///
/// Only use case so far is `scmutil.shortesthexnodeidprefix`, /// Only use case so far is `scmutil.shortesthexnodeidprefix`,
} }
} }
} }
def nodemap_data_all(&self) -> PyResult<PyBytes> { def nodemap_data_all(&self) -> PyResult<PyBytes> {
self.inner_nodemap_data_all(py) self.inner_nodemap_data_all(py)
} }
def nodemap_data_incremental(&self) -> PyResult<PyObject> {
self.inner_nodemap_data_incremental(py)
}
}); });
impl MixedIndex { impl MixedIndex {
fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> { fn new(py: Python, cindex: PyObject) -> PyResult<MixedIndex> {
Self::create_instance( Self::create_instance(
py, py,
RefCell::new(cindex::Index::new(py, cindex)?), RefCell::new(cindex::Index::new(py, cindex)?),
RefCell::new(None), RefCell::new(None),
RefCell::new(None),
) )
} }
/// This is scaffolding at this point, but it could also become /// This is scaffolding at this point, but it could also become
/// a way to start a persistent nodemap or perform a /// a way to start a persistent nodemap or perform a
/// vacuum / repack operation /// vacuum / repack operation
fn fill_nodemap( fn fill_nodemap(
&self, &self,
bytes bytes
} else { } else {
bytes bytes
}; };
let bytes = PyBytes::new(py, &bytes); let bytes = PyBytes::new(py, &bytes);
Ok(bytes) Ok(bytes)
} }
/// Returns the last saved docket along with the size of any changed data
/// (in number of blocks), and said data as bytes.
fn inner_nodemap_data_incremental(
&self,
py: Python,
) -> PyResult<PyObject> {
let docket = self.docket(py).borrow();
let docket = match docket.as_ref() {
Some(d) => d,
None => return Ok(py.None()),
};
let node_tree = self.get_nodetree(py)?.borrow_mut().take().unwrap();
let masked_blocks = node_tree.masked_readonly_blocks();
let (_, data) = node_tree.into_readonly_and_added_bytes();
let changed = masked_blocks * std::mem::size_of::<Block>();
Ok((docket, changed, PyBytes::new(py, &data))
.to_py_object(py)
.into_object())
}
} }
fn revlog_error(py: Python) -> PyErr { fn revlog_error(py: Python) -> PyErr {
match py match py
.import("mercurial.error") .import("mercurial.error")
.and_then(|m| m.get(py, "RevlogError")) .and_then(|m| m.get(py, "RevlogError"))
{ {
Err(e) => e, Err(e) => e,