2017-05-29 04:19:29 +00:00
|
|
|
// Copyright (c) 2017-present PyO3 Project and Contributors
|
|
|
|
|
2017-06-20 03:55:07 +00:00
|
|
|
use std;
|
2018-11-08 15:09:52 +00:00
|
|
|
use std::ptr::NonNull;
|
2017-05-29 04:19:29 +00:00
|
|
|
|
2018-10-31 10:43:21 +00:00
|
|
|
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;
|
2018-11-11 11:25:53 +00:00
|
|
|
use crate::python::{IntoPyPointer, NonNullPyObject, Python, ToPyPointer};
|
2018-10-31 10:43:21 +00:00
|
|
|
use crate::pythonrun;
|
|
|
|
use crate::typeob::PyTypeCreate;
|
|
|
|
use crate::typeob::{PyTypeInfo, PyTypeObject};
|
|
|
|
use crate::types::PyObjectRef;
|
2017-05-29 04:19:29 +00:00
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Any instance that is managed Python can have access to `gil`.
|
2017-06-20 21:10:12 +00:00
|
|
|
pub trait PyObjectWithToken: Sized {
|
2017-07-14 02:04:00 +00:00
|
|
|
fn py(&self) -> Python;
|
2017-05-29 04:19:29 +00:00
|
|
|
}
|
2017-06-04 00:27:26 +00:00
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
#[doc(hidden)]
|
2017-06-20 21:10:12 +00:00
|
|
|
pub trait PyNativeType: PyObjectWithToken {}
|
|
|
|
|
2018-02-11 21:35:48 +00:00
|
|
|
/// Trait implements object reference extraction from python managed pointer.
|
2017-06-20 21:10:12 +00:00
|
|
|
pub trait AsPyRef<T>: Sized {
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Return reference to object.
|
2017-06-04 00:27:26 +00:00
|
|
|
fn as_ref(&self, py: Python) -> &T;
|
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Return mutable reference to object.
|
2018-08-21 21:51:13 +00:00
|
|
|
fn as_mut(&mut self, py: Python) -> &mut T;
|
2017-06-04 00:27:26 +00:00
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Acquire python gil and call closure with object reference.
|
2018-07-30 21:01:46 +00:00
|
|
|
fn with<F, R>(&self, f: F) -> R
|
|
|
|
where
|
|
|
|
F: FnOnce(Python, &T) -> R,
|
2017-06-06 03:25:00 +00:00
|
|
|
{
|
|
|
|
let gil = Python::acquire_gil();
|
|
|
|
let py = gil.python();
|
|
|
|
|
|
|
|
f(py, self.as_ref(py))
|
|
|
|
}
|
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Acquire python gil and call closure with mutable object reference.
|
2018-08-21 21:51:13 +00:00
|
|
|
fn with_mut<F, R>(&mut self, f: F) -> R
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
F: FnOnce(Python, &mut T) -> R,
|
2017-06-06 03:25:00 +00:00
|
|
|
{
|
|
|
|
let gil = Python::acquire_gil();
|
|
|
|
let py = gil.python();
|
|
|
|
|
|
|
|
f(py, self.as_mut(py))
|
|
|
|
}
|
2017-06-07 02:26:59 +00:00
|
|
|
|
|
|
|
fn into_py<F, R>(self, f: F) -> R
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
Self: IntoPyPointer,
|
|
|
|
F: FnOnce(Python, &T) -> R,
|
2017-06-07 02:26:59 +00:00
|
|
|
{
|
|
|
|
let gil = Python::acquire_gil();
|
|
|
|
let py = gil.python();
|
|
|
|
|
|
|
|
let result = f(py, self.as_ref(py));
|
2018-08-26 19:35:53 +00:00
|
|
|
py.xdecref(self);
|
2017-06-07 02:26:59 +00:00
|
|
|
result
|
|
|
|
}
|
|
|
|
|
2018-08-21 21:51:13 +00:00
|
|
|
fn into_mut_py<F, R>(mut self, f: F) -> R
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
Self: IntoPyPointer,
|
|
|
|
F: FnOnce(Python, &mut T) -> R,
|
2017-06-07 02:26:59 +00:00
|
|
|
{
|
|
|
|
let gil = Python::acquire_gil();
|
|
|
|
let py = gil.python();
|
|
|
|
|
|
|
|
let result = f(py, self.as_mut(py));
|
2018-08-26 19:35:53 +00:00
|
|
|
py.xdecref(self);
|
2017-06-07 02:26:59 +00:00
|
|
|
result
|
|
|
|
}
|
2017-06-04 00:27:26 +00:00
|
|
|
}
|
2017-06-20 03:55:07 +00:00
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Safe wrapper around unsafe `*mut ffi::PyObject` pointer with specified type information.
|
2017-06-20 18:59:07 +00:00
|
|
|
#[derive(Debug)]
|
2018-11-08 15:09:52 +00:00
|
|
|
pub struct Py<T>(NonNullPyObject, std::marker::PhantomData<T>);
|
2017-06-20 03:55:07 +00:00
|
|
|
|
2017-06-22 08:04:37 +00:00
|
|
|
// `Py<T>` is thread-safe, because any python related operations require a Python<'p> token.
|
2017-06-20 06:57:34 +00:00
|
|
|
unsafe impl<T> Send for Py<T> {}
|
|
|
|
unsafe impl<T> Sync for Py<T> {}
|
2017-06-20 03:55:07 +00:00
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> Py<T> {
|
|
|
|
/// Creates a `Py<T>` instance for the given FFI pointer.
|
|
|
|
/// This moves ownership over the pointer into the `Py<T>`.
|
2017-06-20 03:55:07 +00:00
|
|
|
/// Undefined behavior if the pointer is NULL or invalid.
|
|
|
|
#[inline]
|
2017-06-20 06:57:34 +00:00
|
|
|
pub unsafe fn from_owned_ptr(ptr: *mut ffi::PyObject) -> Py<T> {
|
2018-07-30 21:01:46 +00:00
|
|
|
debug_assert!(
|
|
|
|
!ptr.is_null() && ffi::Py_REFCNT(ptr) > 0,
|
|
|
|
format!("REFCNT: {:?} - {:?}", ptr, ffi::Py_REFCNT(ptr))
|
|
|
|
);
|
2018-11-08 15:09:52 +00:00
|
|
|
Py(NonNull::new_unchecked(ptr), std::marker::PhantomData)
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Creates a `Py<T>` instance for the given FFI pointer.
|
|
|
|
/// Panics if the pointer is `null`.
|
|
|
|
/// Undefined behavior if the pointer is invalid.
|
2017-06-20 03:55:07 +00:00
|
|
|
#[inline]
|
2018-07-30 21:01:46 +00:00
|
|
|
pub unsafe fn from_owned_ptr_or_panic(ptr: *mut ffi::PyObject) -> Py<T> {
|
2018-11-08 15:09:52 +00:00
|
|
|
match NonNull::new(ptr) {
|
2018-11-11 11:25:53 +00:00
|
|
|
Some(nonnull_ptr) => Py(nonnull_ptr, std::marker::PhantomData),
|
|
|
|
None => {
|
|
|
|
crate::err::panic_after_error();
|
|
|
|
}
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
/// Construct `Py<T>` from the result of a Python FFI call that
|
2017-06-20 03:55:07 +00:00
|
|
|
/// returns a new reference (owned pointer).
|
|
|
|
/// Returns `Err(PyErr)` if the pointer is `null`.
|
|
|
|
/// Unsafe because the pointer might be invalid.
|
2018-07-30 21:01:46 +00:00
|
|
|
pub unsafe fn from_owned_ptr_or_err(py: Python, ptr: *mut ffi::PyObject) -> PyResult<Py<T>> {
|
2018-11-08 15:09:52 +00:00
|
|
|
match NonNull::new(ptr) {
|
2018-11-11 11:25:53 +00:00
|
|
|
Some(nonnull_ptr) => Ok(Py(nonnull_ptr, std::marker::PhantomData)),
|
|
|
|
None => Err(PyErr::fetch(py)),
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
/// Creates a `Py<T>` instance for the given Python FFI pointer.
|
2017-06-20 03:55:07 +00:00
|
|
|
/// Calls Py_INCREF() on the ptr.
|
|
|
|
/// Undefined behavior if the pointer is NULL or invalid.
|
|
|
|
#[inline]
|
2017-06-20 06:57:34 +00:00
|
|
|
pub unsafe fn from_borrowed_ptr(ptr: *mut ffi::PyObject) -> Py<T> {
|
2018-07-30 21:01:46 +00:00
|
|
|
debug_assert!(
|
|
|
|
!ptr.is_null() && ffi::Py_REFCNT(ptr) > 0,
|
|
|
|
format!("REFCNT: {:?} - {:?}", ptr, ffi::Py_REFCNT(ptr))
|
|
|
|
);
|
2017-06-20 03:55:07 +00:00
|
|
|
ffi::Py_INCREF(ptr);
|
2018-11-08 15:09:52 +00:00
|
|
|
Py(NonNull::new_unchecked(ptr), std::marker::PhantomData)
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets the reference count of the ffi::PyObject pointer.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_refcnt(&self) -> isize {
|
2018-11-08 15:09:52 +00:00
|
|
|
unsafe { ffi::Py_REFCNT(self.0.as_ptr()) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Clone self, Calls Py_INCREF() on the ptr.
|
|
|
|
#[inline]
|
2017-06-20 06:57:34 +00:00
|
|
|
pub fn clone_ref(&self, _py: Python) -> Py<T> {
|
2018-11-08 15:09:52 +00:00
|
|
|
unsafe { Py::from_borrowed_ptr(self.0.as_ptr()) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-30 21:01:46 +00:00
|
|
|
impl<T> Py<T>
|
|
|
|
where
|
|
|
|
T: PyTypeInfo,
|
2017-06-20 03:55:07 +00:00
|
|
|
{
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Create new instance of T and move it under python management
|
2017-06-23 22:15:07 +00:00
|
|
|
/// Returns `Py<T>`.
|
|
|
|
pub fn new<F>(py: Python, f: F) -> PyResult<Py<T>>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
2018-11-12 13:15:11 +00:00
|
|
|
F: FnOnce() -> T,
|
2018-07-30 21:01:46 +00:00
|
|
|
T: PyTypeObject + PyTypeInfo,
|
2017-06-23 22:15:07 +00:00
|
|
|
{
|
2018-10-03 20:12:22 +00:00
|
|
|
let ob = <T as PyTypeCreate>::create(py)?;
|
2017-08-12 03:17:09 +00:00
|
|
|
ob.init(f)?;
|
2017-06-23 22:15:07 +00:00
|
|
|
|
2018-07-30 21:01:46 +00:00
|
|
|
let ob = unsafe { Py::from_owned_ptr(ob.into_ptr()) };
|
2017-06-23 22:15:07 +00:00
|
|
|
Ok(ob)
|
|
|
|
}
|
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Create new instance of `T` and move it under python management.
|
2017-06-23 22:03:52 +00:00
|
|
|
/// Returns references to `T`
|
2017-07-18 11:28:49 +00:00
|
|
|
pub fn new_ref<F>(py: Python, f: F) -> PyResult<&T>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
2018-11-12 13:15:11 +00:00
|
|
|
F: FnOnce() -> T,
|
2018-07-30 21:01:46 +00:00
|
|
|
T: PyTypeObject + PyTypeInfo,
|
2017-06-23 22:03:52 +00:00
|
|
|
{
|
2018-10-03 20:12:22 +00:00
|
|
|
let ob = <T as PyTypeCreate>::create(py)?;
|
2017-08-12 03:17:09 +00:00
|
|
|
ob.init(f)?;
|
2017-06-23 22:03:52 +00:00
|
|
|
|
2018-07-30 21:01:46 +00:00
|
|
|
unsafe { Ok(py.from_owned_ptr(ob.into_ptr())) }
|
2017-06-23 22:03:52 +00:00
|
|
|
}
|
|
|
|
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Create new instance of `T` and move it under python management.
|
2017-06-23 22:03:52 +00:00
|
|
|
/// Returns mutable references to `T`
|
2017-07-18 11:28:49 +00:00
|
|
|
pub fn new_mut<F>(py: Python, f: F) -> PyResult<&mut T>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
2018-11-12 13:15:11 +00:00
|
|
|
F: FnOnce() -> T,
|
2018-07-30 21:01:46 +00:00
|
|
|
T: PyTypeObject + PyTypeInfo,
|
2017-06-23 22:03:52 +00:00
|
|
|
{
|
2018-10-03 20:12:22 +00:00
|
|
|
let ob = <T as PyTypeCreate>::create(py)?;
|
2017-08-12 03:17:09 +00:00
|
|
|
ob.init(f)?;
|
2017-06-23 22:03:52 +00:00
|
|
|
|
2018-07-30 21:01:46 +00:00
|
|
|
unsafe { Ok(py.mut_from_owned_ptr(ob.into_ptr())) }
|
2017-06-23 22:03:52 +00:00
|
|
|
}
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 19:11:08 +00:00
|
|
|
/// Specialization workaround
|
|
|
|
trait AsPyRefDispatch<T: PyTypeInfo>: ToPyPointer {
|
|
|
|
fn as_ref_dispatch(&self, _py: Python) -> &T {
|
2017-06-20 03:55:07 +00:00
|
|
|
unsafe {
|
2017-07-28 02:47:01 +00:00
|
|
|
let ptr = (self.as_ptr() as *mut u8).offset(T::OFFSET) as *mut T;
|
2017-06-20 03:55:07 +00:00
|
|
|
ptr.as_ref().unwrap()
|
|
|
|
}
|
|
|
|
}
|
2018-08-31 19:11:08 +00:00
|
|
|
fn as_mut_dispatch(&mut self, _py: Python) -> &mut T {
|
2017-06-20 03:55:07 +00:00
|
|
|
unsafe {
|
2017-07-28 02:47:01 +00:00
|
|
|
let ptr = (self.as_ptr() as *mut u8).offset(T::OFFSET) as *mut T;
|
2017-06-20 03:55:07 +00:00
|
|
|
ptr.as_mut().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-31 19:11:08 +00:00
|
|
|
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) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-30 21:01:46 +00:00
|
|
|
impl<T> AsPyRef<T> for Py<T>
|
|
|
|
where
|
2018-08-31 19:11:08 +00:00
|
|
|
T: PyTypeInfo,
|
2018-07-30 21:01:46 +00:00
|
|
|
{
|
2018-11-08 15:09:52 +00:00
|
|
|
#[inline]
|
2018-08-31 19:11:08 +00:00
|
|
|
fn as_ref(&self, py: Python) -> &T {
|
|
|
|
self.as_ref_dispatch(py)
|
2017-06-20 18:59:07 +00:00
|
|
|
}
|
2018-11-08 15:09:52 +00:00
|
|
|
#[inline]
|
2018-08-31 19:11:08 +00:00
|
|
|
fn as_mut(&mut self, py: Python) -> &mut T {
|
|
|
|
self.as_mut_dispatch(py)
|
2017-06-20 18:59:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> ToPyObject for Py<T> {
|
2017-07-18 17:13:50 +00:00
|
|
|
/// Converts `Py` instance -> PyObject.
|
2017-06-23 03:56:09 +00:00
|
|
|
fn to_object(&self, py: Python) -> PyObject {
|
2018-07-30 21:01:46 +00:00
|
|
|
unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> IntoPyObject for Py<T> {
|
|
|
|
/// Converts `Py` instance -> PyObject.
|
2017-06-20 03:55:07 +00:00
|
|
|
/// Consumes `self` without calling `Py_DECREF()`
|
|
|
|
#[inline]
|
2017-06-23 03:56:09 +00:00
|
|
|
fn into_object(self, _py: Python) -> PyObject {
|
2017-06-20 03:55:07 +00:00
|
|
|
unsafe { std::mem::transmute(self) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> ToPyPointer for Py<T> {
|
2017-06-20 03:55:07 +00:00
|
|
|
/// Gets the underlying FFI pointer, returns a borrowed pointer.
|
|
|
|
#[inline]
|
|
|
|
fn as_ptr(&self) -> *mut ffi::PyObject {
|
2018-11-08 15:09:52 +00:00
|
|
|
self.0.as_ptr()
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> IntoPyPointer for Py<T> {
|
2017-06-20 03:55:07 +00:00
|
|
|
/// Gets the underlying FFI pointer, returns a owned pointer.
|
|
|
|
#[inline]
|
|
|
|
#[must_use]
|
|
|
|
fn into_ptr(self) -> *mut ffi::PyObject {
|
2018-11-08 15:09:52 +00:00
|
|
|
let ptr = self.0.as_ptr();
|
2017-06-20 03:55:07 +00:00
|
|
|
std::mem::forget(self);
|
|
|
|
ptr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<T> PartialEq for Py<T> {
|
2017-06-20 03:55:07 +00:00
|
|
|
#[inline]
|
2017-06-20 06:57:34 +00:00
|
|
|
fn eq(&self, o: &Py<T>) -> bool {
|
2017-06-20 03:55:07 +00:00
|
|
|
self.0 == o.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
/// Dropping a `Py` instance decrements the reference count on the object by 1.
|
|
|
|
impl<T> Drop for Py<T> {
|
2017-06-20 03:55:07 +00:00
|
|
|
fn drop(&mut self) {
|
2018-07-30 21:01:46 +00:00
|
|
|
unsafe {
|
|
|
|
pythonrun::register_pointer(self.0);
|
|
|
|
}
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-23 03:56:09 +00:00
|
|
|
impl<T> std::convert::From<Py<T>> for PyObject {
|
2017-06-20 18:59:07 +00:00
|
|
|
#[inline]
|
2017-06-20 06:57:34 +00:00
|
|
|
fn from(ob: Py<T>) -> Self {
|
2018-07-30 21:01:46 +00:00
|
|
|
unsafe { std::mem::transmute(ob) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<'a, T> std::convert::From<&'a T> for Py<T>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
T: ToPyPointer,
|
2017-06-20 03:55:07 +00:00
|
|
|
{
|
|
|
|
fn from(ob: &'a T) -> Self {
|
2017-06-20 06:57:34 +00:00
|
|
|
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-20 06:57:34 +00:00
|
|
|
impl<'a, T> std::convert::From<&'a mut T> for Py<T>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
T: ToPyPointer,
|
2017-06-20 03:55:07 +00:00
|
|
|
{
|
|
|
|
fn from(ob: &'a mut T) -> Self {
|
2017-06-20 06:57:34 +00:00
|
|
|
unsafe { Py::from_borrowed_ptr(ob.as_ptr()) }
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-23 03:56:09 +00:00
|
|
|
impl<'a, T> std::convert::From<&'a T> for PyObject
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
T: ToPyPointer,
|
2017-06-20 03:55:07 +00:00
|
|
|
{
|
|
|
|
fn from(ob: &'a T) -> Self {
|
2017-06-20 06:57:34 +00:00
|
|
|
unsafe { Py::<T>::from_borrowed_ptr(ob.as_ptr()) }.into()
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-23 03:56:09 +00:00
|
|
|
impl<'a, T> std::convert::From<&'a mut T> for PyObject
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
T: ToPyPointer,
|
2017-06-20 03:55:07 +00:00
|
|
|
{
|
|
|
|
fn from(ob: &'a mut T) -> Self {
|
2017-06-20 06:57:34 +00:00
|
|
|
unsafe { Py::<T>::from_borrowed_ptr(ob.as_ptr()) }.into()
|
2017-06-20 03:55:07 +00:00
|
|
|
}
|
|
|
|
}
|
2017-06-20 22:09:12 +00:00
|
|
|
|
2018-01-17 16:09:44 +00:00
|
|
|
impl<'a, T> FromPyObject<'a> for Py<T>
|
2018-07-30 21:01:46 +00:00
|
|
|
where
|
|
|
|
T: ToPyPointer,
|
|
|
|
&'a T: 'a + FromPyObject<'a>,
|
2017-06-23 03:56:09 +00:00
|
|
|
{
|
|
|
|
/// Extracts `Self` from the source `PyObject`.
|
2018-07-30 21:01:46 +00:00
|
|
|
fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
|
2017-06-23 03:56:09 +00:00
|
|
|
unsafe {
|
2018-07-30 21:01:46 +00:00
|
|
|
ob.extract::<&T>()
|
|
|
|
.map(|val| Py::from_borrowed_ptr(val.as_ptr()))
|
2017-06-23 03:56:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|