use crate::err::{PyErr, PyResult};
use crate::gil;
use crate::instance;
use crate::internal_tricks::Unsendable;
use crate::object::PyObject;
use crate::objectprotocol::ObjectProtocol;
use crate::type_object::PyTypeCreate;
use crate::type_object::{PyTypeInfo, PyTypeObject};
use crate::types::PyAny;
use crate::{ffi, IntoPy};
use crate::{AsPyPointer, FromPyObject, FromPyPointer, IntoPyPointer, Python, ToPyObject};
use std::marker::PhantomData;
use std::mem;
use std::ops::{Deref, DerefMut};
use std::ptr::NonNull;
pub unsafe trait PyNativeType: Sized {
fn py(&self) -> Python {
unsafe { Python::assume_gil_acquired() }
}
}
#[derive(Debug)]
pub struct PyRef<'a, T: PyTypeInfo>(&'a T, Unsendable);
#[allow(clippy::cast_ptr_alignment)]
fn ref_to_ptr<T>(t: &T) -> *mut ffi::PyObject
where
T: PyTypeInfo,
{
unsafe { (t as *const _ as *mut u8).offset(-T::OFFSET) as *mut _ }
}
impl<'a, T: PyTypeInfo> PyRef<'a, T> {
pub(crate) fn from_ref(r: &'a T) -> Self {
PyRef(r, Unsendable::default())
}
}
impl<'p, T> PyRef<'p, T>
where
T: PyTypeInfo + PyTypeObject + PyTypeCreate,
{
pub fn new(py: Python<'p>, value: T) -> PyResult<PyRef<T>> {
let obj = T::create(py)?;
obj.init(value);
unsafe { Self::from_owned_ptr_or_err(py, obj.into_ptr()) }
}
}
impl<'a, T: PyTypeInfo> AsPyPointer for PyRef<'a, T> {
fn as_ptr(&self) -> *mut ffi::PyObject {
ref_to_ptr(self.0)
}
}
impl<'a, T: PyTypeInfo> ToPyObject for PyRef<'a, T> {
fn to_object(&self, py: Python) -> PyObject {
unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
}
}
impl<'a, T: PyTypeInfo> IntoPy<PyObject> for PyRef<'a, T> {
fn into_py(self, py: Python) -> PyObject {
self.to_object(py)
}
}
impl<'a, T: PyTypeInfo> Deref for PyRef<'a, T> {
type Target = T;
fn deref(&self) -> &T {
self.0
}
}
unsafe impl<'p, T> FromPyPointer<'p> for PyRef<'p, T>
where
T: PyTypeInfo,
{
unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
FromPyPointer::from_owned_ptr_or_opt(py, ptr).map(Self::from_ref)
}
unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
FromPyPointer::from_borrowed_ptr_or_opt(py, ptr).map(Self::from_ref)
}
}
#[derive(Debug)]
pub struct PyRefMut<'a, T: PyTypeInfo>(&'a mut T, Unsendable);
impl<'a, T: PyTypeInfo> PyRefMut<'a, T> {
pub(crate) fn from_mut(t: &'a mut T) -> Self {
PyRefMut(t, Unsendable::default())
}
}
impl<'p, T> PyRefMut<'p, T>
where
T: PyTypeInfo + PyTypeObject + PyTypeCreate,
{
pub fn new(py: Python<'p>, value: T) -> PyResult<PyRefMut<T>> {
let obj = T::create(py)?;
obj.init(value);
unsafe { Self::from_owned_ptr_or_err(py, obj.into_ptr()) }
}
}
impl<'a, T: PyTypeInfo> AsPyPointer for PyRefMut<'a, T> {
fn as_ptr(&self) -> *mut ffi::PyObject {
ref_to_ptr(self.0)
}
}
impl<'a, T: PyTypeInfo> ToPyObject for PyRefMut<'a, T> {
fn to_object(&self, py: Python) -> PyObject {
unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
}
}
impl<'a, T: PyTypeInfo> IntoPy<PyObject> for PyRefMut<'a, T> {
fn into_py(self, py: Python) -> PyObject {
self.to_object(py)
}
}
impl<'a, T: PyTypeInfo> Deref for PyRefMut<'a, T> {
type Target = T;
fn deref(&self) -> &T {
self.0
}
}
impl<'a, T: PyTypeInfo> DerefMut for PyRefMut<'a, T> {
fn deref_mut(&mut self) -> &mut T {
self.0
}
}
unsafe impl<'p, T> FromPyPointer<'p> for PyRefMut<'p, T>
where
T: PyTypeInfo,
{
unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
FromPyPointer::from_owned_ptr_or_opt(py, ptr).map(Self::from_mut)
}
unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<Self> {
FromPyPointer::from_borrowed_ptr_or_opt(py, ptr).map(Self::from_mut)
}
}
pub trait AsPyRef<T: PyTypeInfo>: Sized {
fn as_ref(&self, py: Python) -> PyRef<T>;
fn as_mut(&mut self, py: Python) -> PyRefMut<T>;
fn with<F, R>(&self, f: F) -> R
where
F: FnOnce(Python, PyRef<T>) -> R,
{
let gil = Python::acquire_gil();
let py = gil.python();
f(py, self.as_ref(py))
}
fn with_mut<F, R>(&mut self, f: F) -> R
where
F: FnOnce(Python, PyRefMut<T>) -> R,
{
let gil = Python::acquire_gil();
let py = gil.python();
f(py, self.as_mut(py))
}
fn into_py<F, R>(self, f: F) -> R
where
Self: IntoPyPointer,
F: FnOnce(Python, PyRef<T>) -> R,
{
let gil = Python::acquire_gil();
let py = gil.python();
let result = f(py, self.as_ref(py));
py.xdecref(self);
result
}
fn into_mut_py<F, R>(mut self, f: F) -> R
where
Self: IntoPyPointer,
F: FnOnce(Python, PyRefMut<T>) -> R,
{
let gil = Python::acquire_gil();
let py = gil.python();
let result = f(py, self.as_mut(py));
py.xdecref(self);
result
}
}
#[derive(Debug)]
#[repr(transparent)]
pub struct Py<T>(NonNull<ffi::PyObject>, PhantomData<T>);
unsafe impl<T> Send for Py<T> {}
unsafe impl<T> Sync for Py<T> {}
impl<T> Py<T> {
pub fn new(py: Python, value: T) -> PyResult<Py<T>>
where
T: PyTypeCreate,
{
let ob = T::create(py)?;
ob.init(value);
let ob = unsafe { Py::from_owned_ptr(ob.into_ptr()) };
Ok(ob)
}
#[inline]
pub unsafe fn from_owned_ptr(ptr: *mut ffi::PyObject) -> Py<T> {
debug_assert!(
!ptr.is_null() && ffi::Py_REFCNT(ptr) > 0,
format!("REFCNT: {:?} - {:?}", ptr, ffi::Py_REFCNT(ptr))
);
Py(NonNull::new_unchecked(ptr), PhantomData)
}
#[inline]
pub unsafe fn from_owned_ptr_or_panic(ptr: *mut ffi::PyObject) -> Py<T> {
match NonNull::new(ptr) {
Some(nonnull_ptr) => Py(nonnull_ptr, PhantomData),
None => {
crate::err::panic_after_error();
}
}
}
pub unsafe fn from_owned_ptr_or_err(py: Python, ptr: *mut ffi::PyObject) -> PyResult<Py<T>> {
match NonNull::new(ptr) {
Some(nonnull_ptr) => Ok(Py(nonnull_ptr, PhantomData)),
None => Err(PyErr::fetch(py)),
}
}
#[inline]
pub unsafe fn from_borrowed_ptr(ptr: *mut ffi::PyObject) -> Py<T> {
debug_assert!(
!ptr.is_null() && ffi::Py_REFCNT(ptr) > 0,
format!("REFCNT: {:?} - {:?}", ptr, ffi::Py_REFCNT(ptr))
);
ffi::Py_INCREF(ptr);
Py(NonNull::new_unchecked(ptr), PhantomData)
}
#[inline]
pub fn get_refcnt(&self) -> isize {
unsafe { ffi::Py_REFCNT(self.0.as_ptr()) }
}
#[inline]
pub fn clone_ref(&self, _py: Python) -> Py<T> {
unsafe { Py::from_borrowed_ptr(self.0.as_ptr()) }
}
pub(crate) fn into_non_null(self) -> NonNull<ffi::PyObject> {
let pointer = self.0;
mem::forget(self);
pointer
}
}
trait AsPyRefDispatch<T: PyTypeInfo>: AsPyPointer {
fn as_ref_dispatch(&self, _py: Python) -> &T;
fn as_mut_dispatch(&mut self, _py: Python) -> &mut T;
}
impl<T: PyTypeInfo> AsPyRefDispatch<T> for Py<T> {
default fn as_ref_dispatch(&self, _py: Python) -> &T {
unsafe {
let ptr = (self.as_ptr() as *mut u8).offset(T::OFFSET) as *mut T;
ptr.as_ref().expect("Py has a null pointer")
}
}
default fn as_mut_dispatch(&mut self, _py: Python) -> &mut T {
unsafe {
let ptr = (self.as_ptr() as *mut u8).offset(T::OFFSET) as *mut T;
ptr.as_mut().expect("Py has a null pointer")
}
}
}
impl<T: PyTypeInfo + PyNativeType> AsPyRefDispatch<T> for Py<T> {
fn as_ref_dispatch(&self, _py: Python) -> &T {
unsafe { &*(self as *const instance::Py<T> as *const T) }
}
fn as_mut_dispatch(&mut self, _py: Python) -> &mut T {
unsafe { &mut *(self as *mut _ as *mut T) }
}
}
impl<T> AsPyRef<T> for Py<T>
where
T: PyTypeInfo,
{
#[inline]
fn as_ref(&self, py: Python) -> PyRef<T> {
PyRef::from_ref(self.as_ref_dispatch(py))
}
#[inline]
fn as_mut(&mut self, py: Python) -> PyRefMut<T> {
PyRefMut::from_mut(self.as_mut_dispatch(py))
}
}
impl<T> ToPyObject for Py<T> {
fn to_object(&self, py: Python) -> PyObject {
unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
}
}
impl<T> IntoPy<PyObject> for Py<T> {
#[inline]
fn into_py(self, py: Python) -> PyObject {
unsafe { PyObject::from_owned_ptr(py, self.into_ptr()) }
}
}
impl<T> AsPyPointer for Py<T> {
#[inline]
fn as_ptr(&self) -> *mut ffi::PyObject {
self.0.as_ptr()
}
}
impl<T> IntoPyPointer for Py<T> {
#[inline]
#[must_use]
fn into_ptr(self) -> *mut ffi::PyObject {
let ptr = self.0.as_ptr();
std::mem::forget(self);
ptr
}
}
impl<T> PartialEq for Py<T> {
#[inline]
fn eq(&self, o: &Py<T>) -> bool {
self.0 == o.0
}
}
impl<T> Drop for Py<T> {
fn drop(&mut self) {
unsafe {
gil::register_pointer(self.0);
}
}
}
impl<T> std::convert::From<Py<T>> for PyObject {
#[inline]
fn from(ob: Py<T>) -> Self {
unsafe { PyObject::from_not_null(ob.into_non_null()) }
}
}
impl<'a, T> std::convert::From<PyRef<'a, T>> for Py<T>
where
T: PyTypeInfo,
{
fn from(ob: PyRef<'a, T>) -> Self {
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
}
}
impl<'a, T> std::convert::From<PyRefMut<'a, T>> for Py<T>
where
T: PyTypeInfo,
{
fn from(ob: PyRefMut<'a, T>) -> Self {
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
}
}
impl<'a, T> std::convert::From<&'a T> for PyObject
where
T: AsPyPointer,
{
fn from(ob: &'a T) -> Self {
unsafe { Py::<T>::from_borrowed_ptr(ob.as_ptr()) }.into()
}
}
impl<'a, T> std::convert::From<&'a mut T> for PyObject
where
T: AsPyPointer,
{
fn from(ob: &'a mut T) -> Self {
unsafe { Py::<T>::from_borrowed_ptr(ob.as_ptr()) }.into()
}
}
impl<'a, T> FromPyObject<'a> for Py<T>
where
T: AsPyPointer,
&'a T: 'a + FromPyObject<'a>,
{
fn extract(ob: &'a PyAny) -> PyResult<Self> {
unsafe {
ob.extract::<&T>()
.map(|val| Py::from_borrowed_ptr(val.as_ptr()))
}
}
}
#[repr(transparent)]
pub struct ManagedPyRef<'p, T: ToPyObject + ?Sized> {
data: *mut ffi::PyObject,
data_type: PhantomData<T>,
_py: Python<'p>,
}
impl<'p, T: ToPyObject> ManagedPyRef<'p, T> {
pub fn from_to_pyobject(py: Python<'p>, to_pyobject: &T) -> Self {
to_pyobject.to_managed_py_ref(py)
}
}
impl<'p, T: ToPyObject> AsPyPointer for ManagedPyRef<'p, T> {
fn as_ptr(&self) -> *mut ffi::PyObject {
self.data
}
}
pub trait ManagedPyRefDispatch: ToPyObject {
fn to_managed_py_ref<'p>(&self, py: Python<'p>) -> ManagedPyRef<'p, Self>;
fn drop_impl(borrowed: &mut ManagedPyRef<Self>);
}
impl<T: ToPyObject + ?Sized> ManagedPyRefDispatch for T {
default fn to_managed_py_ref<'p>(&self, py: Python<'p>) -> ManagedPyRef<'p, Self> {
ManagedPyRef {
data: self.to_object(py).into_ptr(),
data_type: PhantomData,
_py: py,
}
}
default fn drop_impl(borrowed: &mut ManagedPyRef<Self>) {
unsafe { ffi::Py_DECREF(borrowed.data) };
}
}
impl<T: ToPyObject + AsPyPointer + ?Sized> ManagedPyRefDispatch for T {
fn to_managed_py_ref<'p>(&self, py: Python<'p>) -> ManagedPyRef<'p, Self> {
ManagedPyRef {
data: self.as_ptr(),
data_type: PhantomData,
_py: py,
}
}
fn drop_impl(_: &mut ManagedPyRef<T>) {}
}
impl<'p, T: ToPyObject + ?Sized> Drop for ManagedPyRef<'p, T> {
fn drop(&mut self) {
ManagedPyRefDispatch::drop_impl(self);
}
}
#[cfg(test)]
mod test {
use crate::ffi;
use crate::types::PyDict;
use crate::{AsPyPointer, ManagedPyRef, Python};
#[test]
fn borrowed_py_ref_with_to_pointer() {
let gil = Python::acquire_gil();
let py = gil.python();
let native = PyDict::new(py);
let ref_count = unsafe { ffi::Py_REFCNT(native.as_ptr()) };
let borrowed = ManagedPyRef::from_to_pyobject(py, native);
assert_eq!(native.as_ptr(), borrowed.data);
assert_eq!(ref_count, unsafe { ffi::Py_REFCNT(borrowed.data) });
drop(borrowed);
assert_eq!(ref_count, unsafe { ffi::Py_REFCNT(native.as_ptr()) });
}
#[test]
fn borrowed_py_ref_with_to_object() {
let gil = Python::acquire_gil();
let py = gil.python();
let convertible = (1, 2, 3);
let borrowed = ManagedPyRef::from_to_pyobject(py, &convertible);
let ptr = borrowed.data;
unsafe {
ffi::Py_INCREF(ptr);
}
assert_eq!(2, unsafe { ffi::Py_REFCNT(ptr) });
drop(borrowed);
assert_eq!(1, unsafe { ffi::Py_REFCNT(ptr) });
unsafe {
ffi::Py_DECREF(ptr);
}
}
}