comparison rust/hg-cpython/src/dirstate/dirstate_map.rs @ 43285:ffc1fbd7d1f5

rust-cpython: make PyLeakedRef operations relatively safe

This patch encapsulates the access to the leaked reference to make most
leaked-ref operations safe. The only exception is leaked_ref.map(). I
couldn't figure out how to allow arbitrary map operation safely over an
unsafe static reference. See the docstring and inline comment for details.

Now leak_immutable() can be safely implemented as the PyLeakedRef owns
its inner data.

43284:ce6dd1cee4c8

            )),
        }
    }

    def keys(&self) -> PyResult<DirstateMapKeysIterator> {
        let mut leak_handle =
            unsafe { self.inner_shared(py).leak_immutable()? };
        let leaked_ref = leak_handle.data.take().unwrap();
        DirstateMapKeysIterator::from_inner(
            py,
            leak_handle,
            leaked_ref.iter(),
        )
    }

    def items(&self) -> PyResult<DirstateMapItemsIterator> {
        let mut leak_handle =
            unsafe { self.inner_shared(py).leak_immutable()? };
        let leaked_ref = leak_handle.data.take().unwrap();
        DirstateMapItemsIterator::from_inner(
            py,
            leak_handle,
            leaked_ref.iter(),
        )
    }

    def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
        let mut leak_handle =
            unsafe { self.inner_shared(py).leak_immutable()? };
        let leaked_ref = leak_handle.data.take().unwrap();
        DirstateMapKeysIterator::from_inner(
            py,
            leak_handle,
            leaked_ref.iter(),
        )
    }

    def getdirs(&self) -> PyResult<Dirs> {
        // TODO don't copy, share the reference

            None => Ok(default),
        }
    }

    def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
        let mut leak_handle =
            unsafe { self.inner_shared(py).leak_immutable()? };
        let leaked_ref = leak_handle.data.take().unwrap();
        CopyMapKeysIterator::from_inner(
            py,
            leak_handle,
            leaked_ref.copy_map.iter(),
        )
    }

    def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
        let mut leak_handle =
            unsafe { self.inner_shared(py).leak_immutable()? };
        let leaked_ref = leak_handle.data.take().unwrap();
        CopyMapItemsIterator::from_inner(
            py,
            leak_handle,
            leaked_ref.copy_map.iter(),
        )
    }

});

py_shared_ref!(DirstateMap, RustDirstateMap, inner, inner_shared);

py_shared_iterator!(
    DirstateMapKeysIterator,
    PyLeakedRef<&'static RustDirstateMap>,
    StateMapIter<'static>,
    DirstateMap::translate_key,
    Option<PyBytes>
);

py_shared_iterator!(
    DirstateMapItemsIterator,
    PyLeakedRef<&'static RustDirstateMap>,
    StateMapIter<'static>,
    DirstateMap::translate_key_value,
    Option<(PyBytes, PyObject)>
);

fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<[u8; PARENT_SIZE]> {

43285:ffc1fbd7d1f5

            )),
        }
    }

    def keys(&self) -> PyResult<DirstateMapKeysIterator> {
        let leaked_ref = self.inner_shared(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()?;
        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()?;
        DirstateMapKeysIterator::from_inner(
            py,
            unsafe { leaked_ref.map(py, |o| o.iter()) },
        )
    }

    def getdirs(&self) -> PyResult<Dirs> {
        // TODO don't copy, share the reference

            None => Ok(default),
        }
    }

    def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
        let leaked_ref = self.inner_shared(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()?;
        CopyMapItemsIterator::from_inner(
            py,
            unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) },
        )
    }

});

py_shared_ref!(DirstateMap, RustDirstateMap, inner, inner_shared);

py_shared_iterator!(
    DirstateMapKeysIterator,
    PyLeakedRef<StateMapIter<'static>>,
    DirstateMap::translate_key,
    Option<PyBytes>
);

py_shared_iterator!(
    DirstateMapItemsIterator,
    PyLeakedRef<StateMapIter<'static>>,
    DirstateMap::translate_key_value,
    Option<(PyBytes, PyObject)>
);

fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<[u8; PARENT_SIZE]> {