#include <pytypes.h>
Classes | |
struct | borrowed_t |
struct | stolen_t |
Public Member Functions | |
object ()=default | |
PYBIND11_DEPRECATED ("Use reinterpret_borrow<object>() or reinterpret_steal<object>()") object(handle h | |
object (const object &o) | |
Copy constructor; always increases the reference count. More... | |
object (object &&other) noexcept | |
Move constructor; steals the object from other and preserves its reference count. More... | |
~object () | |
Destructor; automatically calls handle::dec_ref() More... | |
handle | release () |
object & | operator= (const object &other) |
object & | operator= (object &&other) noexcept |
template<typename T > | |
T | cast () const & |
template<typename T > | |
T | cast () && |
object (handle h, borrowed_t) | |
object (handle h, stolen_t) | |
template<typename T > | |
T | cast () const & |
template<typename T > | |
T | cast () && |
template<> | |
void | cast () const & |
template<> | |
void | cast () && |
![]() | |
handle ()=default | |
The default constructor creates a handle with a nullptr -valued pointer. More... | |
handle (PyObject *ptr) | |
Creates a handle from the given raw Python object pointer. More... | |
PyObject * | ptr () const |
Return the underlying PyObject * pointer. More... | |
PyObject *& | ptr () |
const handle & | inc_ref () const & |
const handle & | dec_ref () const & |
template<typename T > | |
T | cast () const |
operator bool () const | |
Return true when the handle wraps a valid Python object. More... | |
bool | operator== (const handle &h) const |
bool | operator!= (const handle &h) const |
bool | check () const |
template<> | |
void | cast () const |
Public Attributes | |
bool | is_borrowed: handle(h) { if (is_borrowed) inc_ref() |
Friends | |
template<typename T > | |
T | reinterpret_borrow (handle) |
template<typename T > | |
T | reinterpret_steal (handle) |
Additional Inherited Members | |
![]() | |
PyObject * | m_ptr = nullptr |
\rst Holds a reference to a Python object (with reference counting)
Like handle
, the object
class is a thin wrapper around an arbitrary Python object (i.e. a PyObject *
in Python's C API). In contrast to handle
, it optionally increases the object's reference count upon construction, and it always* decreases the reference count when the object
instance goes out of scope and is destructed. When using object
instances consistently, it is much easier to get reference counting right at the first attempt. \endrst
|
default |
|
inline |
|
inlinenoexcept |
|
inline |
Destructor; automatically calls handle::dec_ref()
|
inline |
T object::cast | ( | ) | && |
T object::cast | ( | ) | const & |
object::PYBIND11_DEPRECATED | ( | "Use reinterpret_borrow<object>() or reinterpret_steal<object>()" | ) |
|
inline |
|
friend |
\rst Declare that a handle
or PyObject *
is a certain type and borrow the reference. The target type T
must be object
or one of its derived classes. The function doesn't do any conversions or checks. It's up to the user to make sure that the target type is correct.
.. code-block:: cpp
PyObject *p = PyList_GetItem(obj, index); py::object o = reinterpret_borrow<py::object>(p);
or py::tuple t = reinterpret_borrow<py::tuple>(p); // <– p
must be already be a tuple
\endrst
|
friend |