Mercurial > hg
view rust/hg-cpython/src/ancestors.rs @ 41185:5ac61ca58c3f
rust-cpython: consistency in use of hg-core constructs
While not everybody likes the `CoreLazy` and `CoreIterator`
aliases, it's better not to mix them with direct references.
Note: it's quite possible in the future that these would stop
being exposed at the top of the `hg` crate
Differential Revision: https://phab.mercurial-scm.org/D5547
author | Georges Racinet <georges.racinet@octobus.net> |
---|---|
date | Tue, 08 Jan 2019 13:54:01 +0100 |
parents | dcf818267bc1 |
children | 1b4b94bac8a0 |
line wrap: on
line source
// ancestors.rs // // Copyright 2018 Georges Racinet <gracinet@anybox.fr> // // This software may be used and distributed according to the terms of the // GNU General Public License version 2 or any later version. //! Bindings for the `hg::ancestors` module provided by the //! `hg-core` crate. From Python, this will be seen as `rustext.ancestor` //! and can be used as replacement for the the pure `ancestor` Python module. //! //! # Classes visible from Python: //! - [`LazyAncestors`] is the Rust implementation of //! `mercurial.ancestor.lazyancestors`. //! The only difference is that it is instantiated with a C `parsers.index` //! instance instead of a parents function. //! //! - [`AncestorsIterator`] is the Rust counterpart of the //! `ancestor._lazyancestorsiter` Python generator. //! From Python, instances of this should be mainly obtained by calling //! `iter()` on a [`LazyAncestors`] instance. //! //! [`LazyAncestors`]: struct.LazyAncestors.html //! [`AncestorsIterator`]: struct.AncestorsIterator.html use cindex::Index; use cpython::{ ObjectProtocol, PyClone, PyDict, PyModule, PyObject, PyResult, Python, }; use exceptions::GraphError; use hg::Revision; use hg::{AncestorsIterator as CoreIterator, LazyAncestors as CoreLazy}; use std::cell::RefCell; /// Utility function to convert a Python iterable into a Vec<Revision> /// /// We need this to feed to `AncestorIterators` constructors because /// a `PyErr` can arise at each step of iteration, whereas our inner objects /// expect iterables over `Revision`, not over some `Result<Revision, PyErr>` fn reviter_to_revvec(py: Python, revs: PyObject) -> PyResult<Vec<Revision>> { revs.iter(py)? .map(|r| r.and_then(|o| o.extract::<Revision>(py))) .collect() } py_class!(pub class AncestorsIterator |py| { // TODO RW lock ? data inner: RefCell<Box<CoreIterator<Index>>>; def __next__(&self) -> PyResult<Option<Revision>> { match self.inner(py).borrow_mut().next() { Some(Err(e)) => Err(GraphError::pynew(py, e)), None => Ok(None), Some(Ok(r)) => Ok(Some(r)), } } def __contains__(&self, rev: Revision) -> PyResult<bool> { self.inner(py).borrow_mut().contains(rev).map_err(|e| GraphError::pynew(py, e)) } def __iter__(&self) -> PyResult<Self> { Ok(self.clone_ref(py)) } def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision, inclusive: bool) -> PyResult<AncestorsIterator> { let initvec = reviter_to_revvec(py, initrevs)?; let ait = match CoreIterator::new(Index::new(py, index)?, initvec, stoprev, inclusive) { Ok(ait) => ait, Err(e) => { return Err(GraphError::pynew(py, e)); } }; AncestorsIterator::from_inner(py, ait) } }); impl AncestorsIterator { pub fn from_inner(py: Python, ait: CoreIterator<Index>) -> PyResult<Self> { Self::create_instance(py, RefCell::new(Box::new(ait))) } } py_class!(pub class LazyAncestors |py| { data inner: RefCell<Box<CoreLazy<Index>>>; def __contains__(&self, rev: Revision) -> PyResult<bool> { self.inner(py) .borrow_mut() .contains(rev) .map_err(|e| GraphError::pynew(py, e)) } def __iter__(&self) -> PyResult<AncestorsIterator> { AncestorsIterator::from_inner(py, self.inner(py).borrow().iter()) } def __bool__(&self) -> PyResult<bool> { Ok(!self.inner(py).borrow().is_empty()) } def __new__(_cls, index: PyObject, initrevs: PyObject, stoprev: Revision, inclusive: bool) -> PyResult<Self> { let initvec = reviter_to_revvec(py, initrevs)?; let lazy = CoreLazy::new(Index::new(py, index)?, initvec, stoprev, inclusive) .map_err(|e| GraphError::pynew(py, e))?; Self::create_instance(py, RefCell::new(Box::new(lazy))) } }); /// Create the module, with `__package__` given from parent pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { let dotted_name = &format!("{}.ancestor", package); let m = PyModule::new(py, dotted_name)?; m.add(py, "__package__", package)?; m.add( py, "__doc__", "Generic DAG ancestor algorithms - Rust implementation", )?; m.add_class::<AncestorsIterator>(py)?; m.add_class::<LazyAncestors>(py)?; let sys = PyModule::import(py, "sys")?; let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?; sys_modules.set_item(py, dotted_name, &m)?; // Example C code (see pyexpat.c and import.c) will "give away the // reference", but we won't because it will be consumed once the // Rust PyObject is dropped. Ok(m) }