use std;
use std::marker::PhantomData;
use std::rc::Rc;
use crate::conversion::{FromPyObject, IntoPyObject, ToPyObject};
use crate::err::{PyErr, PyResult};
use crate::ffi;
use crate::instance;
use crate::object::PyObject;
use crate::objectprotocol::ObjectProtocol;
use crate::python::{IntoPyPointer, Python, ToPyPointer};
use crate::pythonrun;
use crate::typeob::PyTypeCreate;
use crate::typeob::{PyTypeInfo, PyTypeObject};
use crate::types::PyObjectRef;
pub struct PyToken(PhantomData<Rc<()>>);
impl PyToken {
pub(crate) fn new() -> PyToken {
PyToken(PhantomData)
}
#[inline]
pub fn py(&self) -> Python {
unsafe { Python::assume_gil_acquired() }
}
}
pub trait PyObjectWithToken: Sized {
fn py(&self) -> Python;
}
#[doc(hidden)]
pub trait PyNativeType: PyObjectWithToken {}
pub trait AsPyRef<T>: Sized {
fn as_ref(&self, py: Python) -> &T;
fn as_mut(&mut self, py: Python) -> &mut T;
fn with<F, R>(&self, f: F) -> R
where
F: FnOnce(Python, &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, &mut 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, &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, &mut 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)]
pub struct Py<T>(pub *mut ffi::PyObject, std::marker::PhantomData<T>);
unsafe impl<T> Send for Py<T> {}
unsafe impl<T> Sync for Py<T> {}
impl<T> Py<T> {
#[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(ptr, std::marker::PhantomData)
}
#[inline]
pub unsafe fn from_owned_ptr_or_panic(ptr: *mut ffi::PyObject) -> Py<T> {
if ptr.is_null() {
crate::err::panic_after_error();
} else {
Py::from_owned_ptr(ptr)
}
}
pub unsafe fn from_owned_ptr_or_err(py: Python, ptr: *mut ffi::PyObject) -> PyResult<Py<T>> {
if ptr.is_null() {
Err(PyErr::fetch(py))
} else {
Ok(Py::from_owned_ptr(ptr))
}
}
#[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::from_owned_ptr(ptr)
}
#[inline]
pub fn get_refcnt(&self) -> isize {
unsafe { ffi::Py_REFCNT(self.0) }
}
#[inline]
pub fn clone_ref(&self, _py: Python) -> Py<T> {
unsafe { Py::from_borrowed_ptr(self.0) }
}
}
impl<T> Py<T>
where
T: PyTypeInfo,
{
pub fn new<F>(py: Python, f: F) -> PyResult<Py<T>>
where
F: FnOnce(crate::PyToken) -> T,
T: PyTypeObject + PyTypeInfo,
{
let ob = <T as PyTypeCreate>::create(py)?;
ob.init(f)?;
let ob = unsafe { Py::from_owned_ptr(ob.into_ptr()) };
Ok(ob)
}
pub fn new_ref<F>(py: Python, f: F) -> PyResult<&T>
where
F: FnOnce(crate::PyToken) -> T,
T: PyTypeObject + PyTypeInfo,
{
let ob = <T as PyTypeCreate>::create(py)?;
ob.init(f)?;
unsafe { Ok(py.from_owned_ptr(ob.into_ptr())) }
}
pub fn new_mut<F>(py: Python, f: F) -> PyResult<&mut T>
where
F: FnOnce(crate::PyToken) -> T,
T: PyTypeObject + PyTypeInfo,
{
let ob = <T as PyTypeCreate>::create(py)?;
ob.init(f)?;
unsafe { Ok(py.mut_from_owned_ptr(ob.into_ptr())) }
}
}
trait AsPyRefDispatch<T: PyTypeInfo>: ToPyPointer {
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().unwrap()
}
}
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().unwrap()
}
}
}
impl<T: PyTypeInfo> AsPyRefDispatch<T> for Py<T> {}
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 *const _ as *mut T) }
}
}
impl<T> AsPyRef<T> for Py<T>
where
T: PyTypeInfo,
{
fn as_ref(&self, py: Python) -> &T {
self.as_ref_dispatch(py)
}
fn as_mut(&mut self, py: Python) -> &mut T {
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> IntoPyObject for Py<T> {
#[inline]
fn into_object(self, _py: Python) -> PyObject {
unsafe { std::mem::transmute(self) }
}
}
impl<T> ToPyPointer for Py<T> {
#[inline]
fn as_ptr(&self) -> *mut ffi::PyObject {
self.0
}
}
impl<T> IntoPyPointer for Py<T> {
#[inline]
#[must_use]
fn into_ptr(self) -> *mut ffi::PyObject {
let ptr = self.0;
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 {
pythonrun::register_pointer(self.0);
}
}
}
impl<T> std::convert::From<Py<T>> for PyObject {
#[inline]
fn from(ob: Py<T>) -> Self {
unsafe { std::mem::transmute(ob) }
}
}
impl<'a, T> std::convert::From<&'a T> for Py<T>
where
T: ToPyPointer,
{
fn from(ob: &'a T) -> Self {
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
}
}
impl<'a, T> std::convert::From<&'a mut T> for Py<T>
where
T: ToPyPointer,
{
fn from(ob: &'a mut T) -> Self {
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
}
}
impl<'a, T> std::convert::From<&'a T> for PyObject
where
T: ToPyPointer,
{
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: ToPyPointer,
{
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: ToPyPointer,
&'a T: 'a + FromPyObject<'a>,
{
fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
unsafe {
ob.extract::<&T>()
.map(|val| Py::from_borrowed_ptr(val.as_ptr()))
}
}
}