This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7656

rust-index: make it possible to clone the struct referencing the C index
ClosedPublic

Authored by marmoute on Dec 13 2019, 3:11 PM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHG2728fcb8127c: rust-index: make it possible to clone the struct referencing the C index
Summary

If we are to hand over the C index object to other code, we need to be able to
create a new python reference to it.

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

marmoute created this revision.Dec 13 2019, 3:11 PM
marmoute updated this revision to Diff 18889.Dec 19 2019, 1:10 PM
Alphare accepted this revision.Dec 20 2019, 3:39 AM
indygreg accepted this revision.Dec 23 2019, 1:03 PM
This revision is now accepted and ready to land.Dec 23 2019, 1:03 PM
indygreg requested changes to this revision.Dec 23 2019, 1:05 PM

This patch needs to be rebased on top of D7543 because it can't compile with its changes.

This revision now requires changes to proceed.Dec 23 2019, 1:05 PM
marmoute updated this revision to Diff 18940.Dec 27 2019, 12:12 PM
gracinet added a commit: rHG2728fcb8127c: rust-index: make it possible to clone the struct referencing the C index.Jan 8 2020, 1:10 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG2728fcb8127c: rust-index: make it possible to clone the struct referencing the C index (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 19080

rust/hg-cpython/src/cindex.rs

let guard = Python::acquire_gil(); let guard = Python::acquire_gil();
Index { Index {
index: self.index.clone_ref(guard.python()), index: self.index.clone_ref(guard.python()),
capi: self.capi, capi: self.capi,
} }
} }
} }
impl PyClone for Index {
fn clone_ref(&self, py: Python) -> Self {
Index {
index: self.index.clone_ref(py),
capi: self.capi,
}
}
}
impl Graph for Index { impl Graph for Index {
/// wrap a call to the C extern parents function /// wrap a call to the C extern parents function
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> { fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
if rev == WORKING_DIRECTORY_REVISION { if rev == WORKING_DIRECTORY_REVISION {
return Err(GraphError::WorkingDirectoryUnsupported); return Err(GraphError::WorkingDirectoryUnsupported);
} }
let mut res: [c_int; 2] = [0; 2]; let mut res: [c_int; 2] = [0; 2];
let code = unsafe { let code = unsafe {

rust/hg-cpython/src/revlog.rs

// revlog.rs // revlog.rs
// //
// Copyright 2019 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019 Georges Racinet <georges.racinet@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::cindex; use crate::cindex;
use cpython::{ use cpython::{
ObjectProtocol, PyDict, PyModule, PyObject, PyResult, PyTuple, Python, ObjectProtocol, PyClone, PyDict, PyModule, PyObject, PyResult, PyTuple, Python, PythonObject,
PythonObject, ToPyObject, ToPyObject,
}; };
use hg::Revision; use hg::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, index: PyObject) -> PyResult<cindex::Index> {
py: Python,
index: PyObject,
) -> PyResult<cindex::Index> {
cindex::Index::new(py, index) 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>;
def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> { def __new__(_cls, cindex: PyObject) -> PyResult<MixedIndex> {
Self::create_instance(py, RefCell::new( Self::create_instance(py, RefCell::new(
args: &PyTuple, args: &PyTuple,
kwargs: Option<&PyDict>, kwargs: Option<&PyDict>,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
self.cindex(py) self.cindex(py)
.borrow() .borrow()
.inner() .inner()
.call_method(py, name, args, kwargs) .call_method(py, name, args, kwargs)
} }
pub fn clone_cindex(&self, py: Python) -> cindex::Index {
self.cindex(py).borrow().clone_ref(py)
}
} }
/// Create the module, with __package__ given from parent /// Create the module, with __package__ given from parent
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.revlog", package); let dotted_name = &format!("{}.revlog", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;
m.add(py, "__package__", package)?; m.add(py, "__package__", package)?;
m.add(py, "__doc__", "RevLog - Rust implementations")?; m.add(py, "__doc__", "RevLog - Rust implementations")?;