comparison rust/hg-cpython/src/ref_sharing.rs @ 43284:ce6dd1cee4c8

rust-cpython: put leaked reference in PyLeakedRef

The next patch will make PyLeakedRef manage the lifetime of the underlying
object. leak_handle.data.take() will be removed soon.

43283:96eb9ef777a8

    pub fn borrow_mut(&self) -> PyResult<PyRefMut<'a, T>> {
        self.data.borrow_mut(self.py)
    }

    /// Returns a leaked reference and its management object.
    ///
    /// # Safety
    ///
    /// It's up to you to make sure that the management object lives
    /// longer than the leaked reference. Otherwise, you'll get a
    /// dangling reference.
    pub unsafe fn leak_immutable(
        &self,
    ) -> PyResult<(PyLeakedRef, &'static T)> {
        let (static_ref, static_state_ref) = self
            .data
            .py_shared_state
            .leak_immutable(self.py, self.data)?;
        let leak_handle =
            PyLeakedRef::new(self.py, self.owner, static_state_ref);
        Ok((leak_handle, static_ref))
    }
}

/// Holds a mutable reference to data shared between Python and Rust.
pub struct PyRefMut<'a, T> {

/// Manage immutable references to `PyObject` leaked into Python iterators.
///
/// In truth, this does not represent leaked references themselves;
/// it is instead useful alongside them to manage them.
pub struct PyLeakedRef {
    _inner: PyObject,
    py_shared_state: &'static PySharedState,
}

impl PyLeakedRef {
    /// # Safety
    ///
    /// The `py_shared_state` must be owned by the `inner` Python object.
    // Marked as unsafe so client code wouldn't construct PyLeakedRef
    // struct by mistake. Its drop() is unsafe.
    pub unsafe fn new(
        py: Python,
        inner: &PyObject,
        py_shared_state: &'static PySharedState,
    ) -> Self {
        Self {
            _inner: inner.clone_ref(py),
            py_shared_state,
        }
    }
}

impl Drop for PyLeakedRef {
    fn drop(&mut self) {
        // py_shared_state should be alive since we do have
        // a Python reference to the owner object. Taking GIL makes
        // sure that the state is only accessed by this thread.
        let gil = Python::acquire_gil();

///
/// py_class!(pub class MyType |py| {
///     data inner: PySharedRefCell<MyStruct>;
///
///     def __iter__(&self) -> PyResult<MyTypeItemsIterator> {
///         let (leak_handle, leaked_ref) =
///             unsafe { self.inner_shared(py).leak_immutable()? };
///         MyTypeItemsIterator::from_inner(
///             py,
///             leak_handle,
///             leaked_ref.iter(),
///         )

///
/// py_shared_ref!(MyType, MyStruct, inner, MyTypeLeakedRef);
///
/// py_shared_iterator!(
///     MyTypeItemsIterator,
///     PyLeakedRef,
///     HashMap<'static, Vec<u8>, Vec<u8>>,
///     MyType::translate_key_value,
///     Option<(PyBytes, PyBytes)>
/// );
/// ```

43284:ce6dd1cee4c8

    pub fn borrow_mut(&self) -> PyResult<PyRefMut<'a, T>> {
        self.data.borrow_mut(self.py)
    }

    /// Returns a leaked reference temporarily held by its management object.
    ///
    /// # Safety
    ///
    /// It's up to you to make sure that the management object lives
    /// longer than the leaked reference. Otherwise, you'll get a
    /// dangling reference.
    pub unsafe fn leak_immutable(&self) -> PyResult<PyLeakedRef<&'static T>> {
        let (static_ref, static_state_ref) = self
            .data
            .py_shared_state
            .leak_immutable(self.py, self.data)?;
        Ok(PyLeakedRef::new(
            self.py,
            self.owner,
            static_ref,
            static_state_ref,
        ))
    }
}

/// Holds a mutable reference to data shared between Python and Rust.
pub struct PyRefMut<'a, T> {

/// Manage immutable references to `PyObject` leaked into Python iterators.
///
/// In truth, this does not represent leaked references themselves;
/// it is instead useful alongside them to manage them.
pub struct PyLeakedRef<T> {
    _inner: PyObject,
    pub data: Option<T>, // TODO: remove pub
    py_shared_state: &'static PySharedState,
}

impl<T> PyLeakedRef<T> {
    /// # Safety
    ///
    /// The `py_shared_state` must be owned by the `inner` Python object.
    // Marked as unsafe so client code wouldn't construct PyLeakedRef
    // struct by mistake. Its drop() is unsafe.
    pub unsafe fn new(
        py: Python,
        inner: &PyObject,
        data: T,
        py_shared_state: &'static PySharedState,
    ) -> Self {
        Self {
            _inner: inner.clone_ref(py),
            data: Some(data),
            py_shared_state,
        }
    }
}

impl<T> Drop for PyLeakedRef<T> {
    fn drop(&mut self) {
        // py_shared_state should be alive since we do have
        // a Python reference to the owner object. Taking GIL makes
        // sure that the state is only accessed by this thread.
        let gil = Python::acquire_gil();

///
/// py_class!(pub class MyType |py| {
///     data inner: PySharedRefCell<MyStruct>;
///
///     def __iter__(&self) -> PyResult<MyTypeItemsIterator> {
///         let mut leak_handle =
///             unsafe { self.inner_shared(py).leak_immutable()? };
///         let leaked_ref = leak_handle.data.take().unwrap();
///         MyTypeItemsIterator::from_inner(
///             py,
///             leak_handle,
///             leaked_ref.iter(),
///         )

///
/// py_shared_ref!(MyType, MyStruct, inner, MyTypeLeakedRef);
///
/// py_shared_iterator!(
///     MyTypeItemsIterator,
///     PyLeakedRef<&'static MyStruct>,
///     HashMap<'static, Vec<u8>, Vec<u8>>,
///     MyType::translate_key_value,
///     Option<(PyBytes, PyBytes)>
/// );
/// ```