upstream/mercurial-mirror Commit - r44702:281642cd

rust-cpython: rename inner_shared() to inner()...

Yuya Nishihara -

r44702:281642cd default

parent child

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

0 +6 -6

             };
             py_class!(pub class Dirs |py| {
-                data inner: PySharedRefCell<DirsMultiset>;
+                data inner_: PySharedRefCell<DirsMultiset>;
                 // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
                 // a `list`)
                 }
                 def addpath(&self, path: PyObject) -> PyResult<PyObject> {
-                    self.inner_shared(py).borrow_mut().add_path(
+                    self.inner(py).borrow_mut().add_path(
                         HgPath::new(path.extract::<PyBytes>(py)?.data(py)),
                     ).and(Ok(py.None())).or_else(|e| {
                         match e {
                 }
                 def delpath(&self, path: PyObject) -> PyResult<PyObject> {
-                    self.inner_shared(py).borrow_mut().delete_path(
+                    self.inner(py).borrow_mut().delete_path(
                         HgPath::new(path.extract::<PyBytes>(py)?.data(py)),
                     )
                         .and(Ok(py.None()))
                         })
                 }
                 def __iter__(&self) -> PyResult<DirsMultisetKeysIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     DirsMultisetKeysIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.iter()) },
                 }
                 def __contains__(&self, item: PyObject) -> PyResult<bool> {
-                    Ok(self.inner_shared(py).borrow().contains(HgPath::new(
+                    Ok(self.inner(py).borrow().contains(HgPath::new(
                         item.extract::<PyBytes>(py)?.data(py).as_ref(),
                     )))
                 }
             });
-            py_shared_ref!(Dirs, DirsMultiset, inner, inner_shared);
+            py_shared_ref!(Dirs, DirsMultiset, inner_, inner);
             impl Dirs {
                 pub fn from_inner(py: Python, d: DirsMultiset) -> PyResult<Self> {

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

0 +36 -36

             //     All attributes also have to have a separate refcount data attribute for
             //     leaks, with all methods that go along for reference sharing.
             py_class!(pub class DirstateMap |py| {
-                data inner: PySharedRefCell<RustDirstateMap>;
+                data inner_: PySharedRefCell<RustDirstateMap>;
                 def __new__(_cls, _root: PyObject) -> PyResult<Self> {
                     let inner = RustDirstateMap::default();
                 }
                 def clear(&self) -> PyResult<PyObject> {
-                    self.inner_shared(py).borrow_mut().clear();
+                    self.inner(py).borrow_mut().clear();
                     Ok(py.None())
                 }
                     default: Option<PyObject> = None
                 ) -> PyResult<Option<PyObject>> {
                     let key = key.extract::<PyBytes>(py)?;
-                    match self.inner_shared(py).borrow().get(HgPath::new(key.data(py))) {
+                    match self.inner(py).borrow().get(HgPath::new(key.data(py))) {
                         Some(entry) => {
                             Ok(Some(make_dirstate_tuple(py, entry)?))
                         },
                     size: PyObject,
                     mtime: PyObject
                 ) -> PyResult<PyObject> {
-                    self.inner_shared(py).borrow_mut().add_file(
+                    self.inner(py).borrow_mut().add_file(
                         HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
                         oldstate.extract::<PyBytes>(py)?.data(py)[0]
                             .try_into()
                     oldstate: PyObject,
                     size: PyObject
                 ) -> PyResult<PyObject> {
-                    self.inner_shared(py).borrow_mut()
+                    self.inner(py).borrow_mut()
                         .remove_file(
                             HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
                             oldstate.extract::<PyBytes>(py)?.data(py)[0]
                     f: PyObject,
                     oldstate: PyObject
                 ) -> PyResult<PyBool> {
-                    self.inner_shared(py).borrow_mut()
+                    self.inner(py).borrow_mut()
                         .drop_file(
                             HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
                             oldstate.extract::<PyBytes>(py)?.data(py)[0]
                             ))
                         })
                         .collect();
-                    self.inner_shared(py).borrow_mut()
+                    self.inner(py).borrow_mut()
                         .clear_ambiguous_times(files?, now.extract(py)?);
                     Ok(py.None())
                 }
                 // TODO share the reference
                 def nonnormalentries(&self) -> PyResult<PyObject> {
                     let (non_normal, other_parent) =
-                        self.inner_shared(py).borrow().non_normal_other_parent_entries();
+                        self.inner(py).borrow().non_normal_other_parent_entries();
                     let locals = PyDict::new(py);
                     locals.set_item(
                 def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
                     let d = d.extract::<PyBytes>(py)?;
-                    Ok(self.inner_shared(py).borrow_mut()
+                    Ok(self.inner(py).borrow_mut()
                         .has_tracked_dir(HgPath::new(d.data(py)))
                         .map_err(|e| {
                             PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 def hasdir(&self, d: PyObject) -> PyResult<PyBool> {
                     let d = d.extract::<PyBytes>(py)?;
-                    Ok(self.inner_shared(py).borrow_mut()
+                    Ok(self.inner(py).borrow_mut()
                         .has_dir(HgPath::new(d.data(py)))
                         .map_err(|e| {
                             PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 }
                 def parents(&self, st: PyObject) -> PyResult<PyTuple> {
-                    self.inner_shared(py).borrow_mut()
+                    self.inner(py).borrow_mut()
                         .parents(st.extract::<PyBytes>(py)?.data(py))
                         .and_then(|d| {
                             Ok((PyBytes::new(py, &d.p1), PyBytes::new(py, &d.p2))
                     let p1 = extract_node_id(py, &p1)?;
                     let p2 = extract_node_id(py, &p2)?;
-                    self.inner_shared(py).borrow_mut()
+                    self.inner(py).borrow_mut()
                         .set_parents(&DirstateParents { p1, p2 });
                     Ok(py.None())
                 }
                 def read(&self, st: PyObject) -> PyResult<Option<PyObject>> {
-                    match self.inner_shared(py).borrow_mut()
+                    match self.inner(py).borrow_mut()
                         .read(st.extract::<PyBytes>(py)?.data(py))
                     {
                         Ok(Some(parents)) => Ok(Some(
                         p2: extract_node_id(py, &p2)?,
                     };
-                    match self.inner_shared(py).borrow_mut().pack(parents, now) {
+                    match self.inner(py).borrow_mut().pack(parents, now) {
                         Ok(packed) => Ok(PyBytes::new(py, &packed)),
                         Err(_) => Err(PyErr::new::<exc::OSError, _>(
                             py,
                 def filefoldmapasdict(&self) -> PyResult<PyDict> {
                     let dict = PyDict::new(py);
                     for (key, value) in
-                        self.inner_shared(py).borrow_mut().build_file_fold_map().iter()
+                        self.inner(py).borrow_mut().build_file_fold_map().iter()
                     {
                         dict.set_item(py, key.as_ref().to_vec(), value.as_ref().to_vec())?;
                     }
                 }
                 def __len__(&self) -> PyResult<usize> {
-                    Ok(self.inner_shared(py).borrow().len())
+                    Ok(self.inner(py).borrow().len())
                 }
                 def __contains__(&self, key: PyObject) -> PyResult<bool> {
                     let key = key.extract::<PyBytes>(py)?;
-                    Ok(self.inner_shared(py).borrow().contains_key(HgPath::new(key.data(py))))
+                    Ok(self.inner(py).borrow().contains_key(HgPath::new(key.data(py))))
                 }
                 def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
                     let key = key.extract::<PyBytes>(py)?;
                     let key = HgPath::new(key.data(py));
-                    match self.inner_shared(py).borrow().get(key) {
+                    match self.inner(py).borrow().get(key) {
                         Some(entry) => {
                             Ok(make_dirstate_tuple(py, entry)?)
                         },
                 }
                 def keys(&self) -> PyResult<DirstateMapKeysIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     DirstateMapKeysIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.iter()) },
                 }
                 def items(&self) -> PyResult<DirstateMapItemsIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     DirstateMapItemsIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.iter()) },
                 }
                 def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     DirstateMapKeysIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.iter()) },
                 def getdirs(&self) -> PyResult<Dirs> {
                     // TODO don't copy, share the reference
-                    self.inner_shared(py).borrow_mut().set_dirs()
+                    self.inner(py).borrow_mut().set_dirs()
                         .map_err(|e| {
                             PyErr::new::<exc::ValueError, _>(py, e.to_string())
                         })?;
                     Dirs::from_inner(
                         py,
                         DirsMultiset::from_dirstate(
-                            &self.inner_shared(py).borrow(),
+                            &self.inner(py).borrow(),
                             Some(EntryState::Removed),
                         )
                         .map_err(|e| {
                 }
                 def getalldirs(&self) -> PyResult<Dirs> {
                     // TODO don't copy, share the reference
-                    self.inner_shared(py).borrow_mut().set_all_dirs()
+                    self.inner(py).borrow_mut().set_all_dirs()
                         .map_err(|e| {
                             PyErr::new::<exc::ValueError, _>(py, e.to_string())
                         })?;
                     Dirs::from_inner(
                         py,
                         DirsMultiset::from_dirstate(
-                            &self.inner_shared(py).borrow(),
+                            &self.inner(py).borrow(),
                             None,
                         ).map_err(|e| {
                             PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 // TODO all copymap* methods, see docstring above
                 def copymapcopy(&self) -> PyResult<PyDict> {
                     let dict = PyDict::new(py);
-                    for (key, value) in self.inner_shared(py).borrow().copy_map.iter() {
+                    for (key, value) in self.inner(py).borrow().copy_map.iter() {
                         dict.set_item(
                             py,
                             PyBytes::new(py, key.as_ref()),
                 def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
                     let key = key.extract::<PyBytes>(py)?;
-                    match self.inner_shared(py).borrow().copy_map.get(HgPath::new(key.data(py))) {
+                    match self.inner(py).borrow().copy_map.get(HgPath::new(key.data(py))) {
                         Some(copy) => Ok(PyBytes::new(py, copy.as_ref())),
                         None => Err(PyErr::new::<exc::KeyError, _>(
                             py,
                 }
                 def copymaplen(&self) -> PyResult<usize> {
-                    Ok(self.inner_shared(py).borrow().copy_map.len())
+                    Ok(self.inner(py).borrow().copy_map.len())
                 }
                 def copymapcontains(&self, key: PyObject) -> PyResult<bool> {
                     let key = key.extract::<PyBytes>(py)?;
                     Ok(self
-                        .inner_shared(py)
+                        .inner(py)
                         .borrow()
                         .copy_map
                         .contains_key(HgPath::new(key.data(py))))
                 ) -> PyResult<Option<PyObject>> {
                     let key = key.extract::<PyBytes>(py)?;
                     match self
-                        .inner_shared(py)
+                        .inner(py)
                         .borrow()
                         .copy_map
                         .get(HgPath::new(key.data(py)))
                 ) -> PyResult<PyObject> {
                     let key = key.extract::<PyBytes>(py)?;
                     let value = value.extract::<PyBytes>(py)?;
-                    self.inner_shared(py).borrow_mut().copy_map.insert(
+                    self.inner(py).borrow_mut().copy_map.insert(
                         HgPathBuf::from_bytes(key.data(py)),
                         HgPathBuf::from_bytes(value.data(py)),
                     );
                 ) -> PyResult<Option<PyObject>> {
                     let key = key.extract::<PyBytes>(py)?;
                     match self
-                        .inner_shared(py)
+                        .inner(py)
                         .borrow_mut()
                         .copy_map
                         .remove(HgPath::new(key.data(py)))
                 }
                 def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     CopyMapKeysIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) },
                 }
                 def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
-                    let leaked_ref = self.inner_shared(py).leak_immutable();
+                    let leaked_ref = self.inner(py).leak_immutable();
                     CopyMapItemsIterator::from_inner(
                         py,
                         unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) },
                     &'a self,
                     py: Python<'a>,
                 ) -> Ref<'a, RustDirstateMap> {
-                    self.inner_shared(py).borrow()
+                    self.inner(py).borrow()
                 }
                 fn translate_key(
                     py: Python,
                 }
             }
-            py_shared_ref!(DirstateMap, RustDirstateMap, inner, inner_shared);
+            py_shared_ref!(DirstateMap, RustDirstateMap, inner_, inner);
             py_shared_iterator!(
                 DirstateMapKeysIterator,

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages