111986Sandreas.sandberg@arm.com/* 212391Sjason@lowepower.com pybind11/pytypes.h: Convenience wrapper classes for basic Python types 311986Sandreas.sandberg@arm.com 411986Sandreas.sandberg@arm.com Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 511986Sandreas.sandberg@arm.com 611986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 711986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 811986Sandreas.sandberg@arm.com*/ 911986Sandreas.sandberg@arm.com 1011986Sandreas.sandberg@arm.com#pragma once 1111986Sandreas.sandberg@arm.com 1212391Sjason@lowepower.com#include "detail/common.h" 1312391Sjason@lowepower.com#include "buffer_info.h" 1411986Sandreas.sandberg@arm.com#include <utility> 1511986Sandreas.sandberg@arm.com#include <type_traits> 1611986Sandreas.sandberg@arm.com 1712391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE) 1811986Sandreas.sandberg@arm.com 1911986Sandreas.sandberg@arm.com/* A few forward declarations */ 2011986Sandreas.sandberg@arm.comclass handle; class object; 2111986Sandreas.sandberg@arm.comclass str; class iterator; 2211986Sandreas.sandberg@arm.comstruct arg; struct arg_v; 2311986Sandreas.sandberg@arm.com 2411986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 2511986Sandreas.sandberg@arm.comclass args_proxy; 2611986Sandreas.sandberg@arm.cominline bool isinstance_generic(handle obj, const std::type_info &tp); 2711986Sandreas.sandberg@arm.com 2811986Sandreas.sandberg@arm.com// Accessor forward declarations 2911986Sandreas.sandberg@arm.comtemplate <typename Policy> class accessor; 3011986Sandreas.sandberg@arm.comnamespace accessor_policies { 3111986Sandreas.sandberg@arm.com struct obj_attr; 3211986Sandreas.sandberg@arm.com struct str_attr; 3311986Sandreas.sandberg@arm.com struct generic_item; 3411986Sandreas.sandberg@arm.com struct sequence_item; 3511986Sandreas.sandberg@arm.com struct list_item; 3611986Sandreas.sandberg@arm.com struct tuple_item; 3711986Sandreas.sandberg@arm.com} 3811986Sandreas.sandberg@arm.comusing obj_attr_accessor = accessor<accessor_policies::obj_attr>; 3911986Sandreas.sandberg@arm.comusing str_attr_accessor = accessor<accessor_policies::str_attr>; 4011986Sandreas.sandberg@arm.comusing item_accessor = accessor<accessor_policies::generic_item>; 4111986Sandreas.sandberg@arm.comusing sequence_accessor = accessor<accessor_policies::sequence_item>; 4211986Sandreas.sandberg@arm.comusing list_accessor = accessor<accessor_policies::list_item>; 4311986Sandreas.sandberg@arm.comusing tuple_accessor = accessor<accessor_policies::tuple_item>; 4411986Sandreas.sandberg@arm.com 4511986Sandreas.sandberg@arm.com/// Tag and check to identify a class which implements the Python object API 4611986Sandreas.sandberg@arm.comclass pyobject_tag { }; 4712391Sjason@lowepower.comtemplate <typename T> using is_pyobject = std::is_base_of<pyobject_tag, remove_reference_t<T>>; 4811986Sandreas.sandberg@arm.com 4912037Sandreas.sandberg@arm.com/** \rst 5012037Sandreas.sandberg@arm.com A mixin class which adds common functions to `handle`, `object` and various accessors. 5112037Sandreas.sandberg@arm.com The only requirement for `Derived` is to implement ``PyObject *Derived::ptr() const``. 5212037Sandreas.sandberg@arm.com\endrst */ 5311986Sandreas.sandberg@arm.comtemplate <typename Derived> 5411986Sandreas.sandberg@arm.comclass object_api : public pyobject_tag { 5511986Sandreas.sandberg@arm.com const Derived &derived() const { return static_cast<const Derived &>(*this); } 5611986Sandreas.sandberg@arm.com 5711986Sandreas.sandberg@arm.compublic: 5812037Sandreas.sandberg@arm.com /** \rst 5912037Sandreas.sandberg@arm.com Return an iterator equivalent to calling ``iter()`` in Python. The object 6012037Sandreas.sandberg@arm.com must be a collection which supports the iteration protocol. 6112037Sandreas.sandberg@arm.com \endrst */ 6211986Sandreas.sandberg@arm.com iterator begin() const; 6312037Sandreas.sandberg@arm.com /// Return a sentinel which ends iteration. 6411986Sandreas.sandberg@arm.com iterator end() const; 6512037Sandreas.sandberg@arm.com 6612037Sandreas.sandberg@arm.com /** \rst 6712037Sandreas.sandberg@arm.com Return an internal functor to invoke the object's sequence protocol. Casting 6812037Sandreas.sandberg@arm.com the returned ``detail::item_accessor`` instance to a `handle` or `object` 6912037Sandreas.sandberg@arm.com subclass causes a corresponding call to ``__getitem__``. Assigning a `handle` 7012037Sandreas.sandberg@arm.com or `object` subclass causes a call to ``__setitem__``. 7112037Sandreas.sandberg@arm.com \endrst */ 7211986Sandreas.sandberg@arm.com item_accessor operator[](handle key) const; 7312037Sandreas.sandberg@arm.com /// See above (the only difference is that they key is provided as a string literal) 7411986Sandreas.sandberg@arm.com item_accessor operator[](const char *key) const; 7512037Sandreas.sandberg@arm.com 7612037Sandreas.sandberg@arm.com /** \rst 7712037Sandreas.sandberg@arm.com Return an internal functor to access the object's attributes. Casting the 7812037Sandreas.sandberg@arm.com returned ``detail::obj_attr_accessor`` instance to a `handle` or `object` 7912037Sandreas.sandberg@arm.com subclass causes a corresponding call to ``getattr``. Assigning a `handle` 8012037Sandreas.sandberg@arm.com or `object` subclass causes a call to ``setattr``. 8112037Sandreas.sandberg@arm.com \endrst */ 8211986Sandreas.sandberg@arm.com obj_attr_accessor attr(handle key) const; 8312037Sandreas.sandberg@arm.com /// See above (the only difference is that they key is provided as a string literal) 8411986Sandreas.sandberg@arm.com str_attr_accessor attr(const char *key) const; 8512037Sandreas.sandberg@arm.com 8612037Sandreas.sandberg@arm.com /** \rst 8712037Sandreas.sandberg@arm.com Matches * unpacking in Python, e.g. to unpack arguments out of a ``tuple`` 8812037Sandreas.sandberg@arm.com or ``list`` for a function call. Applying another * to the result yields 8912037Sandreas.sandberg@arm.com ** unpacking, e.g. to unpack a dict as function keyword arguments. 9012037Sandreas.sandberg@arm.com See :ref:`calling_python_functions`. 9112037Sandreas.sandberg@arm.com \endrst */ 9211986Sandreas.sandberg@arm.com args_proxy operator*() const; 9311986Sandreas.sandberg@arm.com 9412037Sandreas.sandberg@arm.com /// Check if the given item is contained within this object, i.e. ``item in obj``. 9512037Sandreas.sandberg@arm.com template <typename T> bool contains(T &&item) const; 9612037Sandreas.sandberg@arm.com 9712037Sandreas.sandberg@arm.com /** \rst 9812037Sandreas.sandberg@arm.com Assuming the Python object is a function or implements the ``__call__`` 9912037Sandreas.sandberg@arm.com protocol, ``operator()`` invokes the underlying function, passing an 10012037Sandreas.sandberg@arm.com arbitrary set of parameters. The result is returned as a `object` and 10112037Sandreas.sandberg@arm.com may need to be converted back into a Python object using `handle::cast()`. 10212037Sandreas.sandberg@arm.com 10312037Sandreas.sandberg@arm.com When some of the arguments cannot be converted to Python objects, the 10412037Sandreas.sandberg@arm.com function will throw a `cast_error` exception. When the Python function 10512037Sandreas.sandberg@arm.com call fails, a `error_already_set` exception is thrown. 10612037Sandreas.sandberg@arm.com \endrst */ 10711986Sandreas.sandberg@arm.com template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args> 10811986Sandreas.sandberg@arm.com object operator()(Args &&...args) const; 10911986Sandreas.sandberg@arm.com template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args> 11011986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("call(...) was deprecated in favor of operator()(...)") 11111986Sandreas.sandberg@arm.com object call(Args&&... args) const; 11211986Sandreas.sandberg@arm.com 11312391Sjason@lowepower.com /// Equivalent to ``obj is other`` in Python. 11412391Sjason@lowepower.com bool is(object_api const& other) const { return derived().ptr() == other.derived().ptr(); } 11512037Sandreas.sandberg@arm.com /// Equivalent to ``obj is None`` in Python. 11611986Sandreas.sandberg@arm.com bool is_none() const { return derived().ptr() == Py_None; } 11714299Sbbruce@ucdavis.edu /// Equivalent to obj == other in Python 11814299Sbbruce@ucdavis.edu bool equal(object_api const &other) const { return rich_compare(other, Py_EQ); } 11914299Sbbruce@ucdavis.edu bool not_equal(object_api const &other) const { return rich_compare(other, Py_NE); } 12014299Sbbruce@ucdavis.edu bool operator<(object_api const &other) const { return rich_compare(other, Py_LT); } 12114299Sbbruce@ucdavis.edu bool operator<=(object_api const &other) const { return rich_compare(other, Py_LE); } 12214299Sbbruce@ucdavis.edu bool operator>(object_api const &other) const { return rich_compare(other, Py_GT); } 12314299Sbbruce@ucdavis.edu bool operator>=(object_api const &other) const { return rich_compare(other, Py_GE); } 12414299Sbbruce@ucdavis.edu 12514299Sbbruce@ucdavis.edu object operator-() const; 12614299Sbbruce@ucdavis.edu object operator~() const; 12714299Sbbruce@ucdavis.edu object operator+(object_api const &other) const; 12814299Sbbruce@ucdavis.edu object operator+=(object_api const &other) const; 12914299Sbbruce@ucdavis.edu object operator-(object_api const &other) const; 13014299Sbbruce@ucdavis.edu object operator-=(object_api const &other) const; 13114299Sbbruce@ucdavis.edu object operator*(object_api const &other) const; 13214299Sbbruce@ucdavis.edu object operator*=(object_api const &other) const; 13314299Sbbruce@ucdavis.edu object operator/(object_api const &other) const; 13414299Sbbruce@ucdavis.edu object operator/=(object_api const &other) const; 13514299Sbbruce@ucdavis.edu object operator|(object_api const &other) const; 13614299Sbbruce@ucdavis.edu object operator|=(object_api const &other) const; 13714299Sbbruce@ucdavis.edu object operator&(object_api const &other) const; 13814299Sbbruce@ucdavis.edu object operator&=(object_api const &other) const; 13914299Sbbruce@ucdavis.edu object operator^(object_api const &other) const; 14014299Sbbruce@ucdavis.edu object operator^=(object_api const &other) const; 14114299Sbbruce@ucdavis.edu object operator<<(object_api const &other) const; 14214299Sbbruce@ucdavis.edu object operator<<=(object_api const &other) const; 14314299Sbbruce@ucdavis.edu object operator>>(object_api const &other) const; 14414299Sbbruce@ucdavis.edu object operator>>=(object_api const &other) const; 14514299Sbbruce@ucdavis.edu 14612037Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use py::str(obj) instead") 14711986Sandreas.sandberg@arm.com pybind11::str str() const; 14811986Sandreas.sandberg@arm.com 14912391Sjason@lowepower.com /// Get or set the object's docstring, i.e. ``obj.__doc__``. 15012391Sjason@lowepower.com str_attr_accessor doc() const; 15112391Sjason@lowepower.com 15212037Sandreas.sandberg@arm.com /// Return the object's current reference count 15311986Sandreas.sandberg@arm.com int ref_count() const { return static_cast<int>(Py_REFCNT(derived().ptr())); } 15412037Sandreas.sandberg@arm.com /// Return a handle to the Python type object underlying the instance 15511986Sandreas.sandberg@arm.com handle get_type() const; 15614299Sbbruce@ucdavis.edu 15714299Sbbruce@ucdavis.eduprivate: 15814299Sbbruce@ucdavis.edu bool rich_compare(object_api const &other, int value) const; 15911986Sandreas.sandberg@arm.com}; 16011986Sandreas.sandberg@arm.com 16111986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 16211986Sandreas.sandberg@arm.com 16312037Sandreas.sandberg@arm.com/** \rst 16412037Sandreas.sandberg@arm.com Holds a reference to a Python object (no reference counting) 16512037Sandreas.sandberg@arm.com 16612037Sandreas.sandberg@arm.com The `handle` class is a thin wrapper around an arbitrary Python object (i.e. a 16712037Sandreas.sandberg@arm.com ``PyObject *`` in Python's C API). It does not perform any automatic reference 16812037Sandreas.sandberg@arm.com counting and merely provides a basic C++ interface to various Python API functions. 16912037Sandreas.sandberg@arm.com 17012037Sandreas.sandberg@arm.com .. seealso:: 17112037Sandreas.sandberg@arm.com The `object` class inherits from `handle` and adds automatic reference 17212037Sandreas.sandberg@arm.com counting features. 17312037Sandreas.sandberg@arm.com\endrst */ 17411986Sandreas.sandberg@arm.comclass handle : public detail::object_api<handle> { 17511986Sandreas.sandberg@arm.compublic: 17612037Sandreas.sandberg@arm.com /// The default constructor creates a handle with a ``nullptr``-valued pointer 17711986Sandreas.sandberg@arm.com handle() = default; 17812037Sandreas.sandberg@arm.com /// Creates a ``handle`` from the given raw Python object pointer 17911986Sandreas.sandberg@arm.com handle(PyObject *ptr) : m_ptr(ptr) { } // Allow implicit conversion from PyObject* 18011986Sandreas.sandberg@arm.com 18112037Sandreas.sandberg@arm.com /// Return the underlying ``PyObject *`` pointer 18211986Sandreas.sandberg@arm.com PyObject *ptr() const { return m_ptr; } 18311986Sandreas.sandberg@arm.com PyObject *&ptr() { return m_ptr; } 18411986Sandreas.sandberg@arm.com 18512037Sandreas.sandberg@arm.com /** \rst 18612037Sandreas.sandberg@arm.com Manually increase the reference count of the Python object. Usually, it is 18712037Sandreas.sandberg@arm.com preferable to use the `object` class which derives from `handle` and calls 18812037Sandreas.sandberg@arm.com this function automatically. Returns a reference to itself. 18912037Sandreas.sandberg@arm.com \endrst */ 19012037Sandreas.sandberg@arm.com const handle& inc_ref() const & { Py_XINCREF(m_ptr); return *this; } 19112037Sandreas.sandberg@arm.com 19212037Sandreas.sandberg@arm.com /** \rst 19312037Sandreas.sandberg@arm.com Manually decrease the reference count of the Python object. Usually, it is 19412037Sandreas.sandberg@arm.com preferable to use the `object` class which derives from `handle` and calls 19512037Sandreas.sandberg@arm.com this function automatically. Returns a reference to itself. 19612037Sandreas.sandberg@arm.com \endrst */ 19712037Sandreas.sandberg@arm.com const handle& dec_ref() const & { Py_XDECREF(m_ptr); return *this; } 19812037Sandreas.sandberg@arm.com 19912037Sandreas.sandberg@arm.com /** \rst 20012037Sandreas.sandberg@arm.com Attempt to cast the Python object into the given C++ type. A `cast_error` 20112037Sandreas.sandberg@arm.com will be throw upon failure. 20212037Sandreas.sandberg@arm.com \endrst */ 20311986Sandreas.sandberg@arm.com template <typename T> T cast() const; 20412037Sandreas.sandberg@arm.com /// Return ``true`` when the `handle` wraps a valid Python object 20511986Sandreas.sandberg@arm.com explicit operator bool() const { return m_ptr != nullptr; } 20612037Sandreas.sandberg@arm.com /** \rst 20712391Sjason@lowepower.com Deprecated: Check that the underlying pointers are the same. 20812037Sandreas.sandberg@arm.com Equivalent to ``obj1 is obj2`` in Python. 20912037Sandreas.sandberg@arm.com \endrst */ 21012391Sjason@lowepower.com PYBIND11_DEPRECATED("Use obj1.is(obj2) instead") 21111986Sandreas.sandberg@arm.com bool operator==(const handle &h) const { return m_ptr == h.m_ptr; } 21212391Sjason@lowepower.com PYBIND11_DEPRECATED("Use !obj1.is(obj2) instead") 21311986Sandreas.sandberg@arm.com bool operator!=(const handle &h) const { return m_ptr != h.m_ptr; } 21411986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use handle::operator bool() instead") 21511986Sandreas.sandberg@arm.com bool check() const { return m_ptr != nullptr; } 21611986Sandreas.sandberg@arm.comprotected: 21711986Sandreas.sandberg@arm.com PyObject *m_ptr = nullptr; 21811986Sandreas.sandberg@arm.com}; 21911986Sandreas.sandberg@arm.com 22012037Sandreas.sandberg@arm.com/** \rst 22112037Sandreas.sandberg@arm.com Holds a reference to a Python object (with reference counting) 22212037Sandreas.sandberg@arm.com 22312037Sandreas.sandberg@arm.com Like `handle`, the `object` class is a thin wrapper around an arbitrary Python 22412037Sandreas.sandberg@arm.com object (i.e. a ``PyObject *`` in Python's C API). In contrast to `handle`, it 22512037Sandreas.sandberg@arm.com optionally increases the object's reference count upon construction, and it 22612037Sandreas.sandberg@arm.com *always* decreases the reference count when the `object` instance goes out of 22712037Sandreas.sandberg@arm.com scope and is destructed. When using `object` instances consistently, it is much 22812037Sandreas.sandberg@arm.com easier to get reference counting right at the first attempt. 22912037Sandreas.sandberg@arm.com\endrst */ 23011986Sandreas.sandberg@arm.comclass object : public handle { 23111986Sandreas.sandberg@arm.compublic: 23211986Sandreas.sandberg@arm.com object() = default; 23311986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use reinterpret_borrow<object>() or reinterpret_steal<object>()") 23411986Sandreas.sandberg@arm.com object(handle h, bool is_borrowed) : handle(h) { if (is_borrowed) inc_ref(); } 23512037Sandreas.sandberg@arm.com /// Copy constructor; always increases the reference count 23611986Sandreas.sandberg@arm.com object(const object &o) : handle(o) { inc_ref(); } 23712037Sandreas.sandberg@arm.com /// Move constructor; steals the object from ``other`` and preserves its reference count 23811986Sandreas.sandberg@arm.com object(object &&other) noexcept { m_ptr = other.m_ptr; other.m_ptr = nullptr; } 23912037Sandreas.sandberg@arm.com /// Destructor; automatically calls `handle::dec_ref()` 24011986Sandreas.sandberg@arm.com ~object() { dec_ref(); } 24111986Sandreas.sandberg@arm.com 24212037Sandreas.sandberg@arm.com /** \rst 24312037Sandreas.sandberg@arm.com Resets the internal pointer to ``nullptr`` without without decreasing the 24412037Sandreas.sandberg@arm.com object's reference count. The function returns a raw handle to the original 24512037Sandreas.sandberg@arm.com Python object. 24612037Sandreas.sandberg@arm.com \endrst */ 24711986Sandreas.sandberg@arm.com handle release() { 24811986Sandreas.sandberg@arm.com PyObject *tmp = m_ptr; 24911986Sandreas.sandberg@arm.com m_ptr = nullptr; 25011986Sandreas.sandberg@arm.com return handle(tmp); 25111986Sandreas.sandberg@arm.com } 25211986Sandreas.sandberg@arm.com 25311986Sandreas.sandberg@arm.com object& operator=(const object &other) { 25411986Sandreas.sandberg@arm.com other.inc_ref(); 25511986Sandreas.sandberg@arm.com dec_ref(); 25611986Sandreas.sandberg@arm.com m_ptr = other.m_ptr; 25711986Sandreas.sandberg@arm.com return *this; 25811986Sandreas.sandberg@arm.com } 25911986Sandreas.sandberg@arm.com 26011986Sandreas.sandberg@arm.com object& operator=(object &&other) noexcept { 26111986Sandreas.sandberg@arm.com if (this != &other) { 26211986Sandreas.sandberg@arm.com handle temp(m_ptr); 26311986Sandreas.sandberg@arm.com m_ptr = other.m_ptr; 26411986Sandreas.sandberg@arm.com other.m_ptr = nullptr; 26511986Sandreas.sandberg@arm.com temp.dec_ref(); 26611986Sandreas.sandberg@arm.com } 26711986Sandreas.sandberg@arm.com return *this; 26811986Sandreas.sandberg@arm.com } 26911986Sandreas.sandberg@arm.com 27011986Sandreas.sandberg@arm.com // Calling cast() on an object lvalue just copies (via handle::cast) 27111986Sandreas.sandberg@arm.com template <typename T> T cast() const &; 27211986Sandreas.sandberg@arm.com // Calling on an object rvalue does a move, if needed and/or possible 27311986Sandreas.sandberg@arm.com template <typename T> T cast() &&; 27411986Sandreas.sandberg@arm.com 27511986Sandreas.sandberg@arm.comprotected: 27611986Sandreas.sandberg@arm.com // Tags for choosing constructors from raw PyObject * 27712391Sjason@lowepower.com struct borrowed_t { }; 27812391Sjason@lowepower.com struct stolen_t { }; 27911986Sandreas.sandberg@arm.com 28011986Sandreas.sandberg@arm.com template <typename T> friend T reinterpret_borrow(handle); 28111986Sandreas.sandberg@arm.com template <typename T> friend T reinterpret_steal(handle); 28211986Sandreas.sandberg@arm.com 28311986Sandreas.sandberg@arm.compublic: 28411986Sandreas.sandberg@arm.com // Only accessible from derived classes and the reinterpret_* functions 28511986Sandreas.sandberg@arm.com object(handle h, borrowed_t) : handle(h) { inc_ref(); } 28611986Sandreas.sandberg@arm.com object(handle h, stolen_t) : handle(h) { } 28711986Sandreas.sandberg@arm.com}; 28811986Sandreas.sandberg@arm.com 28912037Sandreas.sandberg@arm.com/** \rst 29012037Sandreas.sandberg@arm.com Declare that a `handle` or ``PyObject *`` is a certain type and borrow the reference. 29112037Sandreas.sandberg@arm.com The target type ``T`` must be `object` or one of its derived classes. The function 29212037Sandreas.sandberg@arm.com doesn't do any conversions or checks. It's up to the user to make sure that the 29312037Sandreas.sandberg@arm.com target type is correct. 29412037Sandreas.sandberg@arm.com 29512037Sandreas.sandberg@arm.com .. code-block:: cpp 29612037Sandreas.sandberg@arm.com 29712037Sandreas.sandberg@arm.com PyObject *p = PyList_GetItem(obj, index); 29812037Sandreas.sandberg@arm.com py::object o = reinterpret_borrow<py::object>(p); 29912037Sandreas.sandberg@arm.com // or 30012037Sandreas.sandberg@arm.com py::tuple t = reinterpret_borrow<py::tuple>(p); // <-- `p` must be already be a `tuple` 30112037Sandreas.sandberg@arm.com\endrst */ 30212391Sjason@lowepower.comtemplate <typename T> T reinterpret_borrow(handle h) { return {h, object::borrowed_t{}}; } 30312037Sandreas.sandberg@arm.com 30412037Sandreas.sandberg@arm.com/** \rst 30512037Sandreas.sandberg@arm.com Like `reinterpret_borrow`, but steals the reference. 30612037Sandreas.sandberg@arm.com 30712037Sandreas.sandberg@arm.com .. code-block:: cpp 30812037Sandreas.sandberg@arm.com 30912037Sandreas.sandberg@arm.com PyObject *p = PyObject_Str(obj); 31012037Sandreas.sandberg@arm.com py::str s = reinterpret_steal<py::str>(p); // <-- `p` must be already be a `str` 31112037Sandreas.sandberg@arm.com\endrst */ 31212391Sjason@lowepower.comtemplate <typename T> T reinterpret_steal(handle h) { return {h, object::stolen_t{}}; } 31312391Sjason@lowepower.com 31412391Sjason@lowepower.comNAMESPACE_BEGIN(detail) 31512391Sjason@lowepower.cominline std::string error_string(); 31612391Sjason@lowepower.comNAMESPACE_END(detail) 31712391Sjason@lowepower.com 31812391Sjason@lowepower.com/// Fetch and hold an error which was already set in Python. An instance of this is typically 31912391Sjason@lowepower.com/// thrown to propagate python-side errors back through C++ which can either be caught manually or 32012391Sjason@lowepower.com/// else falls back to the function dispatcher (which then raises the captured error back to 32112391Sjason@lowepower.com/// python). 32212391Sjason@lowepower.comclass error_already_set : public std::runtime_error { 32312391Sjason@lowepower.compublic: 32412391Sjason@lowepower.com /// Constructs a new exception from the current Python error indicator, if any. The current 32512391Sjason@lowepower.com /// Python error indicator will be cleared. 32612391Sjason@lowepower.com error_already_set() : std::runtime_error(detail::error_string()) { 32714299Sbbruce@ucdavis.edu PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr()); 32812391Sjason@lowepower.com } 32912391Sjason@lowepower.com 33014299Sbbruce@ucdavis.edu error_already_set(const error_already_set &) = default; 33114299Sbbruce@ucdavis.edu error_already_set(error_already_set &&) = default; 33214299Sbbruce@ucdavis.edu 33312391Sjason@lowepower.com inline ~error_already_set(); 33412391Sjason@lowepower.com 33512391Sjason@lowepower.com /// Give the currently-held error back to Python, if any. If there is currently a Python error 33612391Sjason@lowepower.com /// already set it is cleared first. After this call, the current object no longer stores the 33712391Sjason@lowepower.com /// error variables (but the `.what()` string is still available). 33814299Sbbruce@ucdavis.edu void restore() { PyErr_Restore(m_type.release().ptr(), m_value.release().ptr(), m_trace.release().ptr()); } 33912391Sjason@lowepower.com 34012391Sjason@lowepower.com // Does nothing; provided for backwards compatibility. 34112391Sjason@lowepower.com PYBIND11_DEPRECATED("Use of error_already_set.clear() is deprecated") 34212391Sjason@lowepower.com void clear() {} 34312391Sjason@lowepower.com 34412391Sjason@lowepower.com /// Check if the currently trapped error type matches the given Python exception class (or a 34512391Sjason@lowepower.com /// subclass thereof). May also be passed a tuple to search for any exception class matches in 34612391Sjason@lowepower.com /// the given tuple. 34714299Sbbruce@ucdavis.edu bool matches(handle exc) const { return PyErr_GivenExceptionMatches(m_type.ptr(), exc.ptr()); } 34814299Sbbruce@ucdavis.edu 34914299Sbbruce@ucdavis.edu const object& type() const { return m_type; } 35014299Sbbruce@ucdavis.edu const object& value() const { return m_value; } 35114299Sbbruce@ucdavis.edu const object& trace() const { return m_trace; } 35212391Sjason@lowepower.com 35312391Sjason@lowepower.comprivate: 35414299Sbbruce@ucdavis.edu object m_type, m_value, m_trace; 35512391Sjason@lowepower.com}; 35611986Sandreas.sandberg@arm.com 35712037Sandreas.sandberg@arm.com/** \defgroup python_builtins _ 35812037Sandreas.sandberg@arm.com Unless stated otherwise, the following C++ functions behave the same 35912037Sandreas.sandberg@arm.com as their Python counterparts. 36012037Sandreas.sandberg@arm.com */ 36112037Sandreas.sandberg@arm.com 36212037Sandreas.sandberg@arm.com/** \ingroup python_builtins 36312037Sandreas.sandberg@arm.com \rst 36412037Sandreas.sandberg@arm.com Return true if ``obj`` is an instance of ``T``. Type ``T`` must be a subclass of 36512037Sandreas.sandberg@arm.com `object` or a class which was exposed to Python as ``py::class_<T>``. 36612037Sandreas.sandberg@arm.com\endrst */ 36711986Sandreas.sandberg@arm.comtemplate <typename T, detail::enable_if_t<std::is_base_of<object, T>::value, int> = 0> 36812037Sandreas.sandberg@arm.combool isinstance(handle obj) { return T::check_(obj); } 36911986Sandreas.sandberg@arm.com 37011986Sandreas.sandberg@arm.comtemplate <typename T, detail::enable_if_t<!std::is_base_of<object, T>::value, int> = 0> 37111986Sandreas.sandberg@arm.combool isinstance(handle obj) { return detail::isinstance_generic(obj, typeid(T)); } 37211986Sandreas.sandberg@arm.com 37311986Sandreas.sandberg@arm.comtemplate <> inline bool isinstance<handle>(handle obj) = delete; 37411986Sandreas.sandberg@arm.comtemplate <> inline bool isinstance<object>(handle obj) { return obj.ptr() != nullptr; } 37511986Sandreas.sandberg@arm.com 37612037Sandreas.sandberg@arm.com/// \ingroup python_builtins 37712037Sandreas.sandberg@arm.com/// Return true if ``obj`` is an instance of the ``type``. 37812037Sandreas.sandberg@arm.cominline bool isinstance(handle obj, handle type) { 37912037Sandreas.sandberg@arm.com const auto result = PyObject_IsInstance(obj.ptr(), type.ptr()); 38012037Sandreas.sandberg@arm.com if (result == -1) 38112037Sandreas.sandberg@arm.com throw error_already_set(); 38212037Sandreas.sandberg@arm.com return result != 0; 38312037Sandreas.sandberg@arm.com} 38412037Sandreas.sandberg@arm.com 38512037Sandreas.sandberg@arm.com/// \addtogroup python_builtins 38612037Sandreas.sandberg@arm.com/// @{ 38711986Sandreas.sandberg@arm.cominline bool hasattr(handle obj, handle name) { 38811986Sandreas.sandberg@arm.com return PyObject_HasAttr(obj.ptr(), name.ptr()) == 1; 38911986Sandreas.sandberg@arm.com} 39011986Sandreas.sandberg@arm.com 39111986Sandreas.sandberg@arm.cominline bool hasattr(handle obj, const char *name) { 39211986Sandreas.sandberg@arm.com return PyObject_HasAttrString(obj.ptr(), name) == 1; 39311986Sandreas.sandberg@arm.com} 39411986Sandreas.sandberg@arm.com 39514299Sbbruce@ucdavis.eduinline void delattr(handle obj, handle name) { 39614299Sbbruce@ucdavis.edu if (PyObject_DelAttr(obj.ptr(), name.ptr()) != 0) { throw error_already_set(); } 39714299Sbbruce@ucdavis.edu} 39814299Sbbruce@ucdavis.edu 39914299Sbbruce@ucdavis.eduinline void delattr(handle obj, const char *name) { 40014299Sbbruce@ucdavis.edu if (PyObject_DelAttrString(obj.ptr(), name) != 0) { throw error_already_set(); } 40114299Sbbruce@ucdavis.edu} 40214299Sbbruce@ucdavis.edu 40311986Sandreas.sandberg@arm.cominline object getattr(handle obj, handle name) { 40411986Sandreas.sandberg@arm.com PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr()); 40511986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 40611986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 40711986Sandreas.sandberg@arm.com} 40811986Sandreas.sandberg@arm.com 40911986Sandreas.sandberg@arm.cominline object getattr(handle obj, const char *name) { 41011986Sandreas.sandberg@arm.com PyObject *result = PyObject_GetAttrString(obj.ptr(), name); 41111986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 41211986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 41311986Sandreas.sandberg@arm.com} 41411986Sandreas.sandberg@arm.com 41511986Sandreas.sandberg@arm.cominline object getattr(handle obj, handle name, handle default_) { 41611986Sandreas.sandberg@arm.com if (PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr())) { 41711986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 41811986Sandreas.sandberg@arm.com } else { 41911986Sandreas.sandberg@arm.com PyErr_Clear(); 42011986Sandreas.sandberg@arm.com return reinterpret_borrow<object>(default_); 42111986Sandreas.sandberg@arm.com } 42211986Sandreas.sandberg@arm.com} 42311986Sandreas.sandberg@arm.com 42411986Sandreas.sandberg@arm.cominline object getattr(handle obj, const char *name, handle default_) { 42511986Sandreas.sandberg@arm.com if (PyObject *result = PyObject_GetAttrString(obj.ptr(), name)) { 42611986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 42711986Sandreas.sandberg@arm.com } else { 42811986Sandreas.sandberg@arm.com PyErr_Clear(); 42911986Sandreas.sandberg@arm.com return reinterpret_borrow<object>(default_); 43011986Sandreas.sandberg@arm.com } 43111986Sandreas.sandberg@arm.com} 43211986Sandreas.sandberg@arm.com 43311986Sandreas.sandberg@arm.cominline void setattr(handle obj, handle name, handle value) { 43411986Sandreas.sandberg@arm.com if (PyObject_SetAttr(obj.ptr(), name.ptr(), value.ptr()) != 0) { throw error_already_set(); } 43511986Sandreas.sandberg@arm.com} 43611986Sandreas.sandberg@arm.com 43711986Sandreas.sandberg@arm.cominline void setattr(handle obj, const char *name, handle value) { 43811986Sandreas.sandberg@arm.com if (PyObject_SetAttrString(obj.ptr(), name, value.ptr()) != 0) { throw error_already_set(); } 43911986Sandreas.sandberg@arm.com} 44012391Sjason@lowepower.com 44112391Sjason@lowepower.cominline ssize_t hash(handle obj) { 44212391Sjason@lowepower.com auto h = PyObject_Hash(obj.ptr()); 44312391Sjason@lowepower.com if (h == -1) { throw error_already_set(); } 44412391Sjason@lowepower.com return h; 44512391Sjason@lowepower.com} 44612391Sjason@lowepower.com 44712037Sandreas.sandberg@arm.com/// @} python_builtins 44811986Sandreas.sandberg@arm.com 44911986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 45011986Sandreas.sandberg@arm.cominline handle get_function(handle value) { 45111986Sandreas.sandberg@arm.com if (value) { 45211986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION >= 3 45311986Sandreas.sandberg@arm.com if (PyInstanceMethod_Check(value.ptr())) 45411986Sandreas.sandberg@arm.com value = PyInstanceMethod_GET_FUNCTION(value.ptr()); 45512391Sjason@lowepower.com else 45611986Sandreas.sandberg@arm.com#endif 45711986Sandreas.sandberg@arm.com if (PyMethod_Check(value.ptr())) 45811986Sandreas.sandberg@arm.com value = PyMethod_GET_FUNCTION(value.ptr()); 45911986Sandreas.sandberg@arm.com } 46011986Sandreas.sandberg@arm.com return value; 46111986Sandreas.sandberg@arm.com} 46211986Sandreas.sandberg@arm.com 46311986Sandreas.sandberg@arm.com// Helper aliases/functions to support implicit casting of values given to python accessors/methods. 46411986Sandreas.sandberg@arm.com// When given a pyobject, this simply returns the pyobject as-is; for other C++ type, the value goes 46511986Sandreas.sandberg@arm.com// through pybind11::cast(obj) to convert it to an `object`. 46611986Sandreas.sandberg@arm.comtemplate <typename T, enable_if_t<is_pyobject<T>::value, int> = 0> 46711986Sandreas.sandberg@arm.comauto object_or_cast(T &&o) -> decltype(std::forward<T>(o)) { return std::forward<T>(o); } 46811986Sandreas.sandberg@arm.com// The following casting version is implemented in cast.h: 46911986Sandreas.sandberg@arm.comtemplate <typename T, enable_if_t<!is_pyobject<T>::value, int> = 0> 47011986Sandreas.sandberg@arm.comobject object_or_cast(T &&o); 47111986Sandreas.sandberg@arm.com// Match a PyObject*, which we want to convert directly to handle via its converting constructor 47211986Sandreas.sandberg@arm.cominline handle object_or_cast(PyObject *ptr) { return ptr; } 47311986Sandreas.sandberg@arm.com 47411986Sandreas.sandberg@arm.comtemplate <typename Policy> 47511986Sandreas.sandberg@arm.comclass accessor : public object_api<accessor<Policy>> { 47611986Sandreas.sandberg@arm.com using key_type = typename Policy::key_type; 47711986Sandreas.sandberg@arm.com 47811986Sandreas.sandberg@arm.compublic: 47911986Sandreas.sandberg@arm.com accessor(handle obj, key_type key) : obj(obj), key(std::move(key)) { } 48012391Sjason@lowepower.com accessor(const accessor &) = default; 48112391Sjason@lowepower.com accessor(accessor &&) = default; 48211986Sandreas.sandberg@arm.com 48311986Sandreas.sandberg@arm.com // accessor overload required to override default assignment operator (templates are not allowed 48411986Sandreas.sandberg@arm.com // to replace default compiler-generated assignments). 48511986Sandreas.sandberg@arm.com void operator=(const accessor &a) && { std::move(*this).operator=(handle(a)); } 48611986Sandreas.sandberg@arm.com void operator=(const accessor &a) & { operator=(handle(a)); } 48711986Sandreas.sandberg@arm.com 48811986Sandreas.sandberg@arm.com template <typename T> void operator=(T &&value) && { 48911986Sandreas.sandberg@arm.com Policy::set(obj, key, object_or_cast(std::forward<T>(value))); 49011986Sandreas.sandberg@arm.com } 49111986Sandreas.sandberg@arm.com template <typename T> void operator=(T &&value) & { 49211986Sandreas.sandberg@arm.com get_cache() = reinterpret_borrow<object>(object_or_cast(std::forward<T>(value))); 49311986Sandreas.sandberg@arm.com } 49411986Sandreas.sandberg@arm.com 49511986Sandreas.sandberg@arm.com template <typename T = Policy> 49611986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)") 49711986Sandreas.sandberg@arm.com explicit operator enable_if_t<std::is_same<T, accessor_policies::str_attr>::value || 49811986Sandreas.sandberg@arm.com std::is_same<T, accessor_policies::obj_attr>::value, bool>() const { 49911986Sandreas.sandberg@arm.com return hasattr(obj, key); 50011986Sandreas.sandberg@arm.com } 50111986Sandreas.sandberg@arm.com template <typename T = Policy> 50211986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use of obj[key] as bool is deprecated in favor of obj.contains(key)") 50311986Sandreas.sandberg@arm.com explicit operator enable_if_t<std::is_same<T, accessor_policies::generic_item>::value, bool>() const { 50411986Sandreas.sandberg@arm.com return obj.contains(key); 50511986Sandreas.sandberg@arm.com } 50611986Sandreas.sandberg@arm.com 50711986Sandreas.sandberg@arm.com operator object() const { return get_cache(); } 50811986Sandreas.sandberg@arm.com PyObject *ptr() const { return get_cache().ptr(); } 50911986Sandreas.sandberg@arm.com template <typename T> T cast() const { return get_cache().template cast<T>(); } 51011986Sandreas.sandberg@arm.com 51111986Sandreas.sandberg@arm.comprivate: 51211986Sandreas.sandberg@arm.com object &get_cache() const { 51311986Sandreas.sandberg@arm.com if (!cache) { cache = Policy::get(obj, key); } 51411986Sandreas.sandberg@arm.com return cache; 51511986Sandreas.sandberg@arm.com } 51611986Sandreas.sandberg@arm.com 51711986Sandreas.sandberg@arm.comprivate: 51811986Sandreas.sandberg@arm.com handle obj; 51911986Sandreas.sandberg@arm.com key_type key; 52011986Sandreas.sandberg@arm.com mutable object cache; 52111986Sandreas.sandberg@arm.com}; 52211986Sandreas.sandberg@arm.com 52311986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(accessor_policies) 52411986Sandreas.sandberg@arm.comstruct obj_attr { 52511986Sandreas.sandberg@arm.com using key_type = object; 52611986Sandreas.sandberg@arm.com static object get(handle obj, handle key) { return getattr(obj, key); } 52711986Sandreas.sandberg@arm.com static void set(handle obj, handle key, handle val) { setattr(obj, key, val); } 52811986Sandreas.sandberg@arm.com}; 52911986Sandreas.sandberg@arm.com 53011986Sandreas.sandberg@arm.comstruct str_attr { 53111986Sandreas.sandberg@arm.com using key_type = const char *; 53211986Sandreas.sandberg@arm.com static object get(handle obj, const char *key) { return getattr(obj, key); } 53311986Sandreas.sandberg@arm.com static void set(handle obj, const char *key, handle val) { setattr(obj, key, val); } 53411986Sandreas.sandberg@arm.com}; 53511986Sandreas.sandberg@arm.com 53611986Sandreas.sandberg@arm.comstruct generic_item { 53711986Sandreas.sandberg@arm.com using key_type = object; 53811986Sandreas.sandberg@arm.com 53911986Sandreas.sandberg@arm.com static object get(handle obj, handle key) { 54011986Sandreas.sandberg@arm.com PyObject *result = PyObject_GetItem(obj.ptr(), key.ptr()); 54111986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 54211986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 54311986Sandreas.sandberg@arm.com } 54411986Sandreas.sandberg@arm.com 54511986Sandreas.sandberg@arm.com static void set(handle obj, handle key, handle val) { 54611986Sandreas.sandberg@arm.com if (PyObject_SetItem(obj.ptr(), key.ptr(), val.ptr()) != 0) { throw error_already_set(); } 54711986Sandreas.sandberg@arm.com } 54811986Sandreas.sandberg@arm.com}; 54911986Sandreas.sandberg@arm.com 55011986Sandreas.sandberg@arm.comstruct sequence_item { 55111986Sandreas.sandberg@arm.com using key_type = size_t; 55211986Sandreas.sandberg@arm.com 55311986Sandreas.sandberg@arm.com static object get(handle obj, size_t index) { 55411986Sandreas.sandberg@arm.com PyObject *result = PySequence_GetItem(obj.ptr(), static_cast<ssize_t>(index)); 55511986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 55612037Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 55711986Sandreas.sandberg@arm.com } 55811986Sandreas.sandberg@arm.com 55911986Sandreas.sandberg@arm.com static void set(handle obj, size_t index, handle val) { 56011986Sandreas.sandberg@arm.com // PySequence_SetItem does not steal a reference to 'val' 56111986Sandreas.sandberg@arm.com if (PySequence_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.ptr()) != 0) { 56211986Sandreas.sandberg@arm.com throw error_already_set(); 56311986Sandreas.sandberg@arm.com } 56411986Sandreas.sandberg@arm.com } 56511986Sandreas.sandberg@arm.com}; 56611986Sandreas.sandberg@arm.com 56711986Sandreas.sandberg@arm.comstruct list_item { 56811986Sandreas.sandberg@arm.com using key_type = size_t; 56911986Sandreas.sandberg@arm.com 57011986Sandreas.sandberg@arm.com static object get(handle obj, size_t index) { 57111986Sandreas.sandberg@arm.com PyObject *result = PyList_GetItem(obj.ptr(), static_cast<ssize_t>(index)); 57211986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 57311986Sandreas.sandberg@arm.com return reinterpret_borrow<object>(result); 57411986Sandreas.sandberg@arm.com } 57511986Sandreas.sandberg@arm.com 57611986Sandreas.sandberg@arm.com static void set(handle obj, size_t index, handle val) { 57711986Sandreas.sandberg@arm.com // PyList_SetItem steals a reference to 'val' 57811986Sandreas.sandberg@arm.com if (PyList_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.inc_ref().ptr()) != 0) { 57911986Sandreas.sandberg@arm.com throw error_already_set(); 58011986Sandreas.sandberg@arm.com } 58111986Sandreas.sandberg@arm.com } 58211986Sandreas.sandberg@arm.com}; 58311986Sandreas.sandberg@arm.com 58411986Sandreas.sandberg@arm.comstruct tuple_item { 58511986Sandreas.sandberg@arm.com using key_type = size_t; 58611986Sandreas.sandberg@arm.com 58711986Sandreas.sandberg@arm.com static object get(handle obj, size_t index) { 58811986Sandreas.sandberg@arm.com PyObject *result = PyTuple_GetItem(obj.ptr(), static_cast<ssize_t>(index)); 58911986Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 59011986Sandreas.sandberg@arm.com return reinterpret_borrow<object>(result); 59111986Sandreas.sandberg@arm.com } 59211986Sandreas.sandberg@arm.com 59311986Sandreas.sandberg@arm.com static void set(handle obj, size_t index, handle val) { 59411986Sandreas.sandberg@arm.com // PyTuple_SetItem steals a reference to 'val' 59511986Sandreas.sandberg@arm.com if (PyTuple_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.inc_ref().ptr()) != 0) { 59611986Sandreas.sandberg@arm.com throw error_already_set(); 59711986Sandreas.sandberg@arm.com } 59811986Sandreas.sandberg@arm.com } 59911986Sandreas.sandberg@arm.com}; 60011986Sandreas.sandberg@arm.comNAMESPACE_END(accessor_policies) 60111986Sandreas.sandberg@arm.com 60212037Sandreas.sandberg@arm.com/// STL iterator template used for tuple, list, sequence and dict 60312037Sandreas.sandberg@arm.comtemplate <typename Policy> 60412037Sandreas.sandberg@arm.comclass generic_iterator : public Policy { 60512037Sandreas.sandberg@arm.com using It = generic_iterator; 60612037Sandreas.sandberg@arm.com 60711986Sandreas.sandberg@arm.compublic: 60812037Sandreas.sandberg@arm.com using difference_type = ssize_t; 60912037Sandreas.sandberg@arm.com using iterator_category = typename Policy::iterator_category; 61012037Sandreas.sandberg@arm.com using value_type = typename Policy::value_type; 61112037Sandreas.sandberg@arm.com using reference = typename Policy::reference; 61212037Sandreas.sandberg@arm.com using pointer = typename Policy::pointer; 61312037Sandreas.sandberg@arm.com 61412037Sandreas.sandberg@arm.com generic_iterator() = default; 61512037Sandreas.sandberg@arm.com generic_iterator(handle seq, ssize_t index) : Policy(seq, index) { } 61612037Sandreas.sandberg@arm.com 61712037Sandreas.sandberg@arm.com reference operator*() const { return Policy::dereference(); } 61812037Sandreas.sandberg@arm.com reference operator[](difference_type n) const { return *(*this + n); } 61912037Sandreas.sandberg@arm.com pointer operator->() const { return **this; } 62012037Sandreas.sandberg@arm.com 62112037Sandreas.sandberg@arm.com It &operator++() { Policy::increment(); return *this; } 62212037Sandreas.sandberg@arm.com It operator++(int) { auto copy = *this; Policy::increment(); return copy; } 62312037Sandreas.sandberg@arm.com It &operator--() { Policy::decrement(); return *this; } 62412037Sandreas.sandberg@arm.com It operator--(int) { auto copy = *this; Policy::decrement(); return copy; } 62512037Sandreas.sandberg@arm.com It &operator+=(difference_type n) { Policy::advance(n); return *this; } 62612037Sandreas.sandberg@arm.com It &operator-=(difference_type n) { Policy::advance(-n); return *this; } 62712037Sandreas.sandberg@arm.com 62812037Sandreas.sandberg@arm.com friend It operator+(const It &a, difference_type n) { auto copy = a; return copy += n; } 62912037Sandreas.sandberg@arm.com friend It operator+(difference_type n, const It &b) { return b + n; } 63012037Sandreas.sandberg@arm.com friend It operator-(const It &a, difference_type n) { auto copy = a; return copy -= n; } 63112037Sandreas.sandberg@arm.com friend difference_type operator-(const It &a, const It &b) { return a.distance_to(b); } 63212037Sandreas.sandberg@arm.com 63312037Sandreas.sandberg@arm.com friend bool operator==(const It &a, const It &b) { return a.equal(b); } 63412037Sandreas.sandberg@arm.com friend bool operator!=(const It &a, const It &b) { return !(a == b); } 63512037Sandreas.sandberg@arm.com friend bool operator< (const It &a, const It &b) { return b - a > 0; } 63612037Sandreas.sandberg@arm.com friend bool operator> (const It &a, const It &b) { return b < a; } 63712037Sandreas.sandberg@arm.com friend bool operator>=(const It &a, const It &b) { return !(a < b); } 63812037Sandreas.sandberg@arm.com friend bool operator<=(const It &a, const It &b) { return !(a > b); } 63912037Sandreas.sandberg@arm.com}; 64012037Sandreas.sandberg@arm.com 64112037Sandreas.sandberg@arm.comNAMESPACE_BEGIN(iterator_policies) 64212037Sandreas.sandberg@arm.com/// Quick proxy class needed to implement ``operator->`` for iterators which can't return pointers 64312037Sandreas.sandberg@arm.comtemplate <typename T> 64412037Sandreas.sandberg@arm.comstruct arrow_proxy { 64512037Sandreas.sandberg@arm.com T value; 64612037Sandreas.sandberg@arm.com 64712037Sandreas.sandberg@arm.com arrow_proxy(T &&value) : value(std::move(value)) { } 64812037Sandreas.sandberg@arm.com T *operator->() const { return &value; } 64912037Sandreas.sandberg@arm.com}; 65012037Sandreas.sandberg@arm.com 65112037Sandreas.sandberg@arm.com/// Lightweight iterator policy using just a simple pointer: see ``PySequence_Fast_ITEMS`` 65212037Sandreas.sandberg@arm.comclass sequence_fast_readonly { 65312037Sandreas.sandberg@arm.comprotected: 65412037Sandreas.sandberg@arm.com using iterator_category = std::random_access_iterator_tag; 65512037Sandreas.sandberg@arm.com using value_type = handle; 65612037Sandreas.sandberg@arm.com using reference = const handle; 65712037Sandreas.sandberg@arm.com using pointer = arrow_proxy<const handle>; 65812037Sandreas.sandberg@arm.com 65912037Sandreas.sandberg@arm.com sequence_fast_readonly(handle obj, ssize_t n) : ptr(PySequence_Fast_ITEMS(obj.ptr()) + n) { } 66012037Sandreas.sandberg@arm.com 66112037Sandreas.sandberg@arm.com reference dereference() const { return *ptr; } 66212037Sandreas.sandberg@arm.com void increment() { ++ptr; } 66312037Sandreas.sandberg@arm.com void decrement() { --ptr; } 66412037Sandreas.sandberg@arm.com void advance(ssize_t n) { ptr += n; } 66512037Sandreas.sandberg@arm.com bool equal(const sequence_fast_readonly &b) const { return ptr == b.ptr; } 66612037Sandreas.sandberg@arm.com ssize_t distance_to(const sequence_fast_readonly &b) const { return ptr - b.ptr; } 66712037Sandreas.sandberg@arm.com 66811986Sandreas.sandberg@arm.comprivate: 66912037Sandreas.sandberg@arm.com PyObject **ptr; 67011986Sandreas.sandberg@arm.com}; 67111986Sandreas.sandberg@arm.com 67212037Sandreas.sandberg@arm.com/// Full read and write access using the sequence protocol: see ``detail::sequence_accessor`` 67312037Sandreas.sandberg@arm.comclass sequence_slow_readwrite { 67412037Sandreas.sandberg@arm.comprotected: 67512037Sandreas.sandberg@arm.com using iterator_category = std::random_access_iterator_tag; 67612037Sandreas.sandberg@arm.com using value_type = object; 67712037Sandreas.sandberg@arm.com using reference = sequence_accessor; 67812037Sandreas.sandberg@arm.com using pointer = arrow_proxy<const sequence_accessor>; 67912037Sandreas.sandberg@arm.com 68012037Sandreas.sandberg@arm.com sequence_slow_readwrite(handle obj, ssize_t index) : obj(obj), index(index) { } 68112037Sandreas.sandberg@arm.com 68212037Sandreas.sandberg@arm.com reference dereference() const { return {obj, static_cast<size_t>(index)}; } 68312037Sandreas.sandberg@arm.com void increment() { ++index; } 68412037Sandreas.sandberg@arm.com void decrement() { --index; } 68512037Sandreas.sandberg@arm.com void advance(ssize_t n) { index += n; } 68612037Sandreas.sandberg@arm.com bool equal(const sequence_slow_readwrite &b) const { return index == b.index; } 68712037Sandreas.sandberg@arm.com ssize_t distance_to(const sequence_slow_readwrite &b) const { return index - b.index; } 68812037Sandreas.sandberg@arm.com 68912037Sandreas.sandberg@arm.comprivate: 69012037Sandreas.sandberg@arm.com handle obj; 69112037Sandreas.sandberg@arm.com ssize_t index; 69212037Sandreas.sandberg@arm.com}; 69312037Sandreas.sandberg@arm.com 69412037Sandreas.sandberg@arm.com/// Python's dictionary protocol permits this to be a forward iterator 69512037Sandreas.sandberg@arm.comclass dict_readonly { 69612037Sandreas.sandberg@arm.comprotected: 69712037Sandreas.sandberg@arm.com using iterator_category = std::forward_iterator_tag; 69812037Sandreas.sandberg@arm.com using value_type = std::pair<handle, handle>; 69912037Sandreas.sandberg@arm.com using reference = const value_type; 70012037Sandreas.sandberg@arm.com using pointer = arrow_proxy<const value_type>; 70112037Sandreas.sandberg@arm.com 70212037Sandreas.sandberg@arm.com dict_readonly() = default; 70312037Sandreas.sandberg@arm.com dict_readonly(handle obj, ssize_t pos) : obj(obj), pos(pos) { increment(); } 70412037Sandreas.sandberg@arm.com 70512037Sandreas.sandberg@arm.com reference dereference() const { return {key, value}; } 70612037Sandreas.sandberg@arm.com void increment() { if (!PyDict_Next(obj.ptr(), &pos, &key, &value)) { pos = -1; } } 70712037Sandreas.sandberg@arm.com bool equal(const dict_readonly &b) const { return pos == b.pos; } 70812037Sandreas.sandberg@arm.com 70912037Sandreas.sandberg@arm.comprivate: 71012037Sandreas.sandberg@arm.com handle obj; 71114299Sbbruce@ucdavis.edu PyObject *key = nullptr, *value = nullptr; 71212037Sandreas.sandberg@arm.com ssize_t pos = -1; 71312037Sandreas.sandberg@arm.com}; 71412037Sandreas.sandberg@arm.comNAMESPACE_END(iterator_policies) 71512037Sandreas.sandberg@arm.com 71612037Sandreas.sandberg@arm.com#if !defined(PYPY_VERSION) 71712037Sandreas.sandberg@arm.comusing tuple_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>; 71812037Sandreas.sandberg@arm.comusing list_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>; 71912037Sandreas.sandberg@arm.com#else 72012037Sandreas.sandberg@arm.comusing tuple_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>; 72112037Sandreas.sandberg@arm.comusing list_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>; 72212037Sandreas.sandberg@arm.com#endif 72312037Sandreas.sandberg@arm.com 72412037Sandreas.sandberg@arm.comusing sequence_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>; 72512037Sandreas.sandberg@arm.comusing dict_iterator = generic_iterator<iterator_policies::dict_readonly>; 72612037Sandreas.sandberg@arm.com 72711986Sandreas.sandberg@arm.cominline bool PyIterable_Check(PyObject *obj) { 72811986Sandreas.sandberg@arm.com PyObject *iter = PyObject_GetIter(obj); 72911986Sandreas.sandberg@arm.com if (iter) { 73011986Sandreas.sandberg@arm.com Py_DECREF(iter); 73111986Sandreas.sandberg@arm.com return true; 73211986Sandreas.sandberg@arm.com } else { 73311986Sandreas.sandberg@arm.com PyErr_Clear(); 73411986Sandreas.sandberg@arm.com return false; 73511986Sandreas.sandberg@arm.com } 73611986Sandreas.sandberg@arm.com} 73711986Sandreas.sandberg@arm.com 73811986Sandreas.sandberg@arm.cominline bool PyNone_Check(PyObject *o) { return o == Py_None; } 73914299Sbbruce@ucdavis.edu#if PY_MAJOR_VERSION >= 3 74014299Sbbruce@ucdavis.eduinline bool PyEllipsis_Check(PyObject *o) { return o == Py_Ellipsis; } 74114299Sbbruce@ucdavis.edu#endif 74211986Sandreas.sandberg@arm.com 74311986Sandreas.sandberg@arm.cominline bool PyUnicode_Check_Permissive(PyObject *o) { return PyUnicode_Check(o) || PYBIND11_BYTES_CHECK(o); } 74411986Sandreas.sandberg@arm.com 74514299Sbbruce@ucdavis.eduinline bool PyStaticMethod_Check(PyObject *o) { return o->ob_type == &PyStaticMethod_Type; } 74614299Sbbruce@ucdavis.edu 74711986Sandreas.sandberg@arm.comclass kwargs_proxy : public handle { 74811986Sandreas.sandberg@arm.compublic: 74911986Sandreas.sandberg@arm.com explicit kwargs_proxy(handle h) : handle(h) { } 75011986Sandreas.sandberg@arm.com}; 75111986Sandreas.sandberg@arm.com 75211986Sandreas.sandberg@arm.comclass args_proxy : public handle { 75311986Sandreas.sandberg@arm.compublic: 75411986Sandreas.sandberg@arm.com explicit args_proxy(handle h) : handle(h) { } 75511986Sandreas.sandberg@arm.com kwargs_proxy operator*() const { return kwargs_proxy(*this); } 75611986Sandreas.sandberg@arm.com}; 75711986Sandreas.sandberg@arm.com 75811986Sandreas.sandberg@arm.com/// Python argument categories (using PEP 448 terms) 75911986Sandreas.sandberg@arm.comtemplate <typename T> using is_keyword = std::is_base_of<arg, T>; 76011986Sandreas.sandberg@arm.comtemplate <typename T> using is_s_unpacking = std::is_same<args_proxy, T>; // * unpacking 76111986Sandreas.sandberg@arm.comtemplate <typename T> using is_ds_unpacking = std::is_same<kwargs_proxy, T>; // ** unpacking 76212037Sandreas.sandberg@arm.comtemplate <typename T> using is_positional = satisfies_none_of<T, 76312037Sandreas.sandberg@arm.com is_keyword, is_s_unpacking, is_ds_unpacking 76411986Sandreas.sandberg@arm.com>; 76512037Sandreas.sandberg@arm.comtemplate <typename T> using is_keyword_or_ds = satisfies_any_of<T, is_keyword, is_ds_unpacking>; 76611986Sandreas.sandberg@arm.com 76711986Sandreas.sandberg@arm.com// Call argument collector forward declarations 76811986Sandreas.sandberg@arm.comtemplate <return_value_policy policy = return_value_policy::automatic_reference> 76911986Sandreas.sandberg@arm.comclass simple_collector; 77011986Sandreas.sandberg@arm.comtemplate <return_value_policy policy = return_value_policy::automatic_reference> 77111986Sandreas.sandberg@arm.comclass unpacking_collector; 77211986Sandreas.sandberg@arm.com 77311986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 77411986Sandreas.sandberg@arm.com 77511986Sandreas.sandberg@arm.com// TODO: After the deprecated constructors are removed, this macro can be simplified by 77611986Sandreas.sandberg@arm.com// inheriting ctors: `using Parent::Parent`. It's not an option right now because 77711986Sandreas.sandberg@arm.com// the `using` statement triggers the parent deprecation warning even if the ctor 77811986Sandreas.sandberg@arm.com// isn't even used. 77911986Sandreas.sandberg@arm.com#define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 78011986Sandreas.sandberg@arm.com public: \ 78111986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use reinterpret_borrow<"#Name">() or reinterpret_steal<"#Name">()") \ 78212391Sjason@lowepower.com Name(handle h, bool is_borrowed) : Parent(is_borrowed ? Parent(h, borrowed_t{}) : Parent(h, stolen_t{})) { } \ 78312391Sjason@lowepower.com Name(handle h, borrowed_t) : Parent(h, borrowed_t{}) { } \ 78412391Sjason@lowepower.com Name(handle h, stolen_t) : Parent(h, stolen_t{}) { } \ 78511986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use py::isinstance<py::python_type>(obj) instead") \ 78611986Sandreas.sandberg@arm.com bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } \ 78712037Sandreas.sandberg@arm.com static bool check_(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); } 78811986Sandreas.sandberg@arm.com 78911986Sandreas.sandberg@arm.com#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun) \ 79011986Sandreas.sandberg@arm.com PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 79111986Sandreas.sandberg@arm.com /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \ 79212391Sjason@lowepower.com Name(const object &o) \ 79312391Sjason@lowepower.com : Parent(check_(o) ? o.inc_ref().ptr() : ConvertFun(o.ptr()), stolen_t{}) \ 79412391Sjason@lowepower.com { if (!m_ptr) throw error_already_set(); } \ 79512391Sjason@lowepower.com Name(object &&o) \ 79612391Sjason@lowepower.com : Parent(check_(o) ? o.release().ptr() : ConvertFun(o.ptr()), stolen_t{}) \ 79712391Sjason@lowepower.com { if (!m_ptr) throw error_already_set(); } \ 79812391Sjason@lowepower.com template <typename Policy_> \ 79912391Sjason@lowepower.com Name(const ::pybind11::detail::accessor<Policy_> &a) : Name(object(a)) { } 80011986Sandreas.sandberg@arm.com 80111986Sandreas.sandberg@arm.com#define PYBIND11_OBJECT(Name, Parent, CheckFun) \ 80211986Sandreas.sandberg@arm.com PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ 80311986Sandreas.sandberg@arm.com /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \ 80411986Sandreas.sandberg@arm.com Name(const object &o) : Parent(o) { } \ 80511986Sandreas.sandberg@arm.com Name(object &&o) : Parent(std::move(o)) { } 80611986Sandreas.sandberg@arm.com 80711986Sandreas.sandberg@arm.com#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \ 80811986Sandreas.sandberg@arm.com PYBIND11_OBJECT(Name, Parent, CheckFun) \ 80911986Sandreas.sandberg@arm.com Name() : Parent() { } 81011986Sandreas.sandberg@arm.com 81112037Sandreas.sandberg@arm.com/// \addtogroup pytypes 81212037Sandreas.sandberg@arm.com/// @{ 81312037Sandreas.sandberg@arm.com 81412037Sandreas.sandberg@arm.com/** \rst 81512037Sandreas.sandberg@arm.com Wraps a Python iterator so that it can also be used as a C++ input iterator 81612037Sandreas.sandberg@arm.com 81712037Sandreas.sandberg@arm.com Caveat: copying an iterator does not (and cannot) clone the internal 81812037Sandreas.sandberg@arm.com state of the Python iterable. This also applies to the post-increment 81912037Sandreas.sandberg@arm.com operator. This iterator should only be used to retrieve the current 82012037Sandreas.sandberg@arm.com value using ``operator*()``. 82112037Sandreas.sandberg@arm.com\endrst */ 82211986Sandreas.sandberg@arm.comclass iterator : public object { 82311986Sandreas.sandberg@arm.compublic: 82412037Sandreas.sandberg@arm.com using iterator_category = std::input_iterator_tag; 82512037Sandreas.sandberg@arm.com using difference_type = ssize_t; 82612037Sandreas.sandberg@arm.com using value_type = handle; 82712037Sandreas.sandberg@arm.com using reference = const handle; 82812037Sandreas.sandberg@arm.com using pointer = const handle *; 82912037Sandreas.sandberg@arm.com 83011986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(iterator, object, PyIter_Check) 83111986Sandreas.sandberg@arm.com 83211986Sandreas.sandberg@arm.com iterator& operator++() { 83312037Sandreas.sandberg@arm.com advance(); 83411986Sandreas.sandberg@arm.com return *this; 83511986Sandreas.sandberg@arm.com } 83611986Sandreas.sandberg@arm.com 83711986Sandreas.sandberg@arm.com iterator operator++(int) { 83812037Sandreas.sandberg@arm.com auto rv = *this; 83912037Sandreas.sandberg@arm.com advance(); 84011986Sandreas.sandberg@arm.com return rv; 84111986Sandreas.sandberg@arm.com } 84211986Sandreas.sandberg@arm.com 84312037Sandreas.sandberg@arm.com reference operator*() const { 84412037Sandreas.sandberg@arm.com if (m_ptr && !value.ptr()) { 84511986Sandreas.sandberg@arm.com auto& self = const_cast<iterator &>(*this); 84611986Sandreas.sandberg@arm.com self.advance(); 84711986Sandreas.sandberg@arm.com } 84811986Sandreas.sandberg@arm.com return value; 84911986Sandreas.sandberg@arm.com } 85011986Sandreas.sandberg@arm.com 85112037Sandreas.sandberg@arm.com pointer operator->() const { operator*(); return &value; } 85212037Sandreas.sandberg@arm.com 85312037Sandreas.sandberg@arm.com /** \rst 85412037Sandreas.sandberg@arm.com The value which marks the end of the iteration. ``it == iterator::sentinel()`` 85512037Sandreas.sandberg@arm.com is equivalent to catching ``StopIteration`` in Python. 85612037Sandreas.sandberg@arm.com 85712037Sandreas.sandberg@arm.com .. code-block:: cpp 85812037Sandreas.sandberg@arm.com 85912037Sandreas.sandberg@arm.com void foo(py::iterator it) { 86012037Sandreas.sandberg@arm.com while (it != py::iterator::sentinel()) { 86112037Sandreas.sandberg@arm.com // use `*it` 86212037Sandreas.sandberg@arm.com ++it; 86312037Sandreas.sandberg@arm.com } 86412037Sandreas.sandberg@arm.com } 86512037Sandreas.sandberg@arm.com \endrst */ 86612037Sandreas.sandberg@arm.com static iterator sentinel() { return {}; } 86712037Sandreas.sandberg@arm.com 86812037Sandreas.sandberg@arm.com friend bool operator==(const iterator &a, const iterator &b) { return a->ptr() == b->ptr(); } 86912037Sandreas.sandberg@arm.com friend bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); } 87012037Sandreas.sandberg@arm.com 87111986Sandreas.sandberg@arm.comprivate: 87212037Sandreas.sandberg@arm.com void advance() { 87312037Sandreas.sandberg@arm.com value = reinterpret_steal<object>(PyIter_Next(m_ptr)); 87412037Sandreas.sandberg@arm.com if (PyErr_Occurred()) { throw error_already_set(); } 87512037Sandreas.sandberg@arm.com } 87611986Sandreas.sandberg@arm.com 87711986Sandreas.sandberg@arm.comprivate: 87811986Sandreas.sandberg@arm.com object value = {}; 87911986Sandreas.sandberg@arm.com}; 88011986Sandreas.sandberg@arm.com 88111986Sandreas.sandberg@arm.comclass iterable : public object { 88211986Sandreas.sandberg@arm.compublic: 88311986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(iterable, object, detail::PyIterable_Check) 88411986Sandreas.sandberg@arm.com}; 88511986Sandreas.sandberg@arm.com 88611986Sandreas.sandberg@arm.comclass bytes; 88711986Sandreas.sandberg@arm.com 88811986Sandreas.sandberg@arm.comclass str : public object { 88911986Sandreas.sandberg@arm.compublic: 89011986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(str, object, detail::PyUnicode_Check_Permissive, raw_str) 89111986Sandreas.sandberg@arm.com 89211986Sandreas.sandberg@arm.com str(const char *c, size_t n) 89312391Sjason@lowepower.com : object(PyUnicode_FromStringAndSize(c, (ssize_t) n), stolen_t{}) { 89411986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate string object!"); 89511986Sandreas.sandberg@arm.com } 89611986Sandreas.sandberg@arm.com 89711986Sandreas.sandberg@arm.com // 'explicit' is explicitly omitted from the following constructors to allow implicit conversion to py::str from C++ string-like objects 89811986Sandreas.sandberg@arm.com str(const char *c = "") 89912391Sjason@lowepower.com : object(PyUnicode_FromString(c), stolen_t{}) { 90011986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate string object!"); 90111986Sandreas.sandberg@arm.com } 90211986Sandreas.sandberg@arm.com 90311986Sandreas.sandberg@arm.com str(const std::string &s) : str(s.data(), s.size()) { } 90411986Sandreas.sandberg@arm.com 90511986Sandreas.sandberg@arm.com explicit str(const bytes &b); 90611986Sandreas.sandberg@arm.com 90712037Sandreas.sandberg@arm.com /** \rst 90812037Sandreas.sandberg@arm.com Return a string representation of the object. This is analogous to 90912037Sandreas.sandberg@arm.com the ``str()`` function in Python. 91012037Sandreas.sandberg@arm.com \endrst */ 91112391Sjason@lowepower.com explicit str(handle h) : object(raw_str(h.ptr()), stolen_t{}) { } 91211986Sandreas.sandberg@arm.com 91311986Sandreas.sandberg@arm.com operator std::string() const { 91411986Sandreas.sandberg@arm.com object temp = *this; 91511986Sandreas.sandberg@arm.com if (PyUnicode_Check(m_ptr)) { 91611986Sandreas.sandberg@arm.com temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(m_ptr)); 91711986Sandreas.sandberg@arm.com if (!temp) 91811986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract string contents! (encoding issue)"); 91911986Sandreas.sandberg@arm.com } 92011986Sandreas.sandberg@arm.com char *buffer; 92111986Sandreas.sandberg@arm.com ssize_t length; 92211986Sandreas.sandberg@arm.com if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length)) 92311986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract string contents! (invalid type)"); 92411986Sandreas.sandberg@arm.com return std::string(buffer, (size_t) length); 92511986Sandreas.sandberg@arm.com } 92611986Sandreas.sandberg@arm.com 92711986Sandreas.sandberg@arm.com template <typename... Args> 92811986Sandreas.sandberg@arm.com str format(Args &&...args) const { 92911986Sandreas.sandberg@arm.com return attr("format")(std::forward<Args>(args)...); 93011986Sandreas.sandberg@arm.com } 93111986Sandreas.sandberg@arm.com 93211986Sandreas.sandberg@arm.comprivate: 93311986Sandreas.sandberg@arm.com /// Return string representation -- always returns a new reference, even if already a str 93411986Sandreas.sandberg@arm.com static PyObject *raw_str(PyObject *op) { 93511986Sandreas.sandberg@arm.com PyObject *str_value = PyObject_Str(op); 93611986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION < 3 93711986Sandreas.sandberg@arm.com if (!str_value) throw error_already_set(); 93811986Sandreas.sandberg@arm.com PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr); 93911986Sandreas.sandberg@arm.com Py_XDECREF(str_value); str_value = unicode; 94011986Sandreas.sandberg@arm.com#endif 94111986Sandreas.sandberg@arm.com return str_value; 94211986Sandreas.sandberg@arm.com } 94311986Sandreas.sandberg@arm.com}; 94412037Sandreas.sandberg@arm.com/// @} pytypes 94511986Sandreas.sandberg@arm.com 94611986Sandreas.sandberg@arm.cominline namespace literals { 94712037Sandreas.sandberg@arm.com/** \rst 94812037Sandreas.sandberg@arm.com String literal version of `str` 94912037Sandreas.sandberg@arm.com \endrst */ 95011986Sandreas.sandberg@arm.cominline str operator"" _s(const char *s, size_t size) { return {s, size}; } 95111986Sandreas.sandberg@arm.com} 95211986Sandreas.sandberg@arm.com 95312037Sandreas.sandberg@arm.com/// \addtogroup pytypes 95412037Sandreas.sandberg@arm.com/// @{ 95511986Sandreas.sandberg@arm.comclass bytes : public object { 95611986Sandreas.sandberg@arm.compublic: 95711986Sandreas.sandberg@arm.com PYBIND11_OBJECT(bytes, object, PYBIND11_BYTES_CHECK) 95811986Sandreas.sandberg@arm.com 95911986Sandreas.sandberg@arm.com // Allow implicit conversion: 96011986Sandreas.sandberg@arm.com bytes(const char *c = "") 96112391Sjason@lowepower.com : object(PYBIND11_BYTES_FROM_STRING(c), stolen_t{}) { 96211986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate bytes object!"); 96311986Sandreas.sandberg@arm.com } 96411986Sandreas.sandberg@arm.com 96511986Sandreas.sandberg@arm.com bytes(const char *c, size_t n) 96612391Sjason@lowepower.com : object(PYBIND11_BYTES_FROM_STRING_AND_SIZE(c, (ssize_t) n), stolen_t{}) { 96711986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate bytes object!"); 96811986Sandreas.sandberg@arm.com } 96911986Sandreas.sandberg@arm.com 97011986Sandreas.sandberg@arm.com // Allow implicit conversion: 97111986Sandreas.sandberg@arm.com bytes(const std::string &s) : bytes(s.data(), s.size()) { } 97211986Sandreas.sandberg@arm.com 97311986Sandreas.sandberg@arm.com explicit bytes(const pybind11::str &s); 97411986Sandreas.sandberg@arm.com 97511986Sandreas.sandberg@arm.com operator std::string() const { 97611986Sandreas.sandberg@arm.com char *buffer; 97711986Sandreas.sandberg@arm.com ssize_t length; 97811986Sandreas.sandberg@arm.com if (PYBIND11_BYTES_AS_STRING_AND_SIZE(m_ptr, &buffer, &length)) 97911986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract bytes contents!"); 98011986Sandreas.sandberg@arm.com return std::string(buffer, (size_t) length); 98111986Sandreas.sandberg@arm.com } 98211986Sandreas.sandberg@arm.com}; 98311986Sandreas.sandberg@arm.com 98411986Sandreas.sandberg@arm.cominline bytes::bytes(const pybind11::str &s) { 98511986Sandreas.sandberg@arm.com object temp = s; 98611986Sandreas.sandberg@arm.com if (PyUnicode_Check(s.ptr())) { 98711986Sandreas.sandberg@arm.com temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(s.ptr())); 98811986Sandreas.sandberg@arm.com if (!temp) 98911986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract string contents! (encoding issue)"); 99011986Sandreas.sandberg@arm.com } 99111986Sandreas.sandberg@arm.com char *buffer; 99211986Sandreas.sandberg@arm.com ssize_t length; 99311986Sandreas.sandberg@arm.com if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length)) 99411986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract string contents! (invalid type)"); 99511986Sandreas.sandberg@arm.com auto obj = reinterpret_steal<object>(PYBIND11_BYTES_FROM_STRING_AND_SIZE(buffer, length)); 99611986Sandreas.sandberg@arm.com if (!obj) 99711986Sandreas.sandberg@arm.com pybind11_fail("Could not allocate bytes object!"); 99811986Sandreas.sandberg@arm.com m_ptr = obj.release().ptr(); 99911986Sandreas.sandberg@arm.com} 100011986Sandreas.sandberg@arm.com 100111986Sandreas.sandberg@arm.cominline str::str(const bytes& b) { 100211986Sandreas.sandberg@arm.com char *buffer; 100311986Sandreas.sandberg@arm.com ssize_t length; 100411986Sandreas.sandberg@arm.com if (PYBIND11_BYTES_AS_STRING_AND_SIZE(b.ptr(), &buffer, &length)) 100511986Sandreas.sandberg@arm.com pybind11_fail("Unable to extract bytes contents!"); 100611986Sandreas.sandberg@arm.com auto obj = reinterpret_steal<object>(PyUnicode_FromStringAndSize(buffer, (ssize_t) length)); 100711986Sandreas.sandberg@arm.com if (!obj) 100811986Sandreas.sandberg@arm.com pybind11_fail("Could not allocate string object!"); 100911986Sandreas.sandberg@arm.com m_ptr = obj.release().ptr(); 101011986Sandreas.sandberg@arm.com} 101111986Sandreas.sandberg@arm.com 101211986Sandreas.sandberg@arm.comclass none : public object { 101311986Sandreas.sandberg@arm.compublic: 101411986Sandreas.sandberg@arm.com PYBIND11_OBJECT(none, object, detail::PyNone_Check) 101512391Sjason@lowepower.com none() : object(Py_None, borrowed_t{}) { } 101611986Sandreas.sandberg@arm.com}; 101711986Sandreas.sandberg@arm.com 101814299Sbbruce@ucdavis.edu#if PY_MAJOR_VERSION >= 3 101914299Sbbruce@ucdavis.educlass ellipsis : public object { 102014299Sbbruce@ucdavis.edupublic: 102114299Sbbruce@ucdavis.edu PYBIND11_OBJECT(ellipsis, object, detail::PyEllipsis_Check) 102214299Sbbruce@ucdavis.edu ellipsis() : object(Py_Ellipsis, borrowed_t{}) { } 102314299Sbbruce@ucdavis.edu}; 102414299Sbbruce@ucdavis.edu#endif 102514299Sbbruce@ucdavis.edu 102611986Sandreas.sandberg@arm.comclass bool_ : public object { 102711986Sandreas.sandberg@arm.compublic: 102811986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(bool_, object, PyBool_Check, raw_bool) 102912391Sjason@lowepower.com bool_() : object(Py_False, borrowed_t{}) { } 103011986Sandreas.sandberg@arm.com // Allow implicit conversion from and to `bool`: 103112391Sjason@lowepower.com bool_(bool value) : object(value ? Py_True : Py_False, borrowed_t{}) { } 103211986Sandreas.sandberg@arm.com operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; } 103311986Sandreas.sandberg@arm.com 103411986Sandreas.sandberg@arm.comprivate: 103511986Sandreas.sandberg@arm.com /// Return the truth value of an object -- always returns a new reference 103611986Sandreas.sandberg@arm.com static PyObject *raw_bool(PyObject *op) { 103711986Sandreas.sandberg@arm.com const auto value = PyObject_IsTrue(op); 103811986Sandreas.sandberg@arm.com if (value == -1) return nullptr; 103911986Sandreas.sandberg@arm.com return handle(value ? Py_True : Py_False).inc_ref().ptr(); 104011986Sandreas.sandberg@arm.com } 104111986Sandreas.sandberg@arm.com}; 104211986Sandreas.sandberg@arm.com 104312391Sjason@lowepower.comNAMESPACE_BEGIN(detail) 104412391Sjason@lowepower.com// Converts a value to the given unsigned type. If an error occurs, you get back (Unsigned) -1; 104512391Sjason@lowepower.com// otherwise you get back the unsigned long or unsigned long long value cast to (Unsigned). 104612391Sjason@lowepower.com// (The distinction is critically important when casting a returned -1 error value to some other 104712391Sjason@lowepower.com// unsigned type: (A)-1 != (B)-1 when A and B are unsigned types of different sizes). 104812391Sjason@lowepower.comtemplate <typename Unsigned> 104912391Sjason@lowepower.comUnsigned as_unsigned(PyObject *o) { 105012391Sjason@lowepower.com if (sizeof(Unsigned) <= sizeof(unsigned long) 105112391Sjason@lowepower.com#if PY_VERSION_HEX < 0x03000000 105212391Sjason@lowepower.com || PyInt_Check(o) 105312391Sjason@lowepower.com#endif 105412391Sjason@lowepower.com ) { 105512391Sjason@lowepower.com unsigned long v = PyLong_AsUnsignedLong(o); 105612391Sjason@lowepower.com return v == (unsigned long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v; 105712391Sjason@lowepower.com } 105812391Sjason@lowepower.com else { 105912391Sjason@lowepower.com unsigned long long v = PyLong_AsUnsignedLongLong(o); 106012391Sjason@lowepower.com return v == (unsigned long long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v; 106112391Sjason@lowepower.com } 106212391Sjason@lowepower.com} 106312391Sjason@lowepower.comNAMESPACE_END(detail) 106412391Sjason@lowepower.com 106511986Sandreas.sandberg@arm.comclass int_ : public object { 106611986Sandreas.sandberg@arm.compublic: 106711986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(int_, object, PYBIND11_LONG_CHECK, PyNumber_Long) 106812391Sjason@lowepower.com int_() : object(PyLong_FromLong(0), stolen_t{}) { } 106911986Sandreas.sandberg@arm.com // Allow implicit conversion from C++ integral types: 107011986Sandreas.sandberg@arm.com template <typename T, 107111986Sandreas.sandberg@arm.com detail::enable_if_t<std::is_integral<T>::value, int> = 0> 107211986Sandreas.sandberg@arm.com int_(T value) { 107311986Sandreas.sandberg@arm.com if (sizeof(T) <= sizeof(long)) { 107411986Sandreas.sandberg@arm.com if (std::is_signed<T>::value) 107511986Sandreas.sandberg@arm.com m_ptr = PyLong_FromLong((long) value); 107611986Sandreas.sandberg@arm.com else 107711986Sandreas.sandberg@arm.com m_ptr = PyLong_FromUnsignedLong((unsigned long) value); 107811986Sandreas.sandberg@arm.com } else { 107911986Sandreas.sandberg@arm.com if (std::is_signed<T>::value) 108011986Sandreas.sandberg@arm.com m_ptr = PyLong_FromLongLong((long long) value); 108111986Sandreas.sandberg@arm.com else 108211986Sandreas.sandberg@arm.com m_ptr = PyLong_FromUnsignedLongLong((unsigned long long) value); 108311986Sandreas.sandberg@arm.com } 108411986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate int object!"); 108511986Sandreas.sandberg@arm.com } 108611986Sandreas.sandberg@arm.com 108711986Sandreas.sandberg@arm.com template <typename T, 108811986Sandreas.sandberg@arm.com detail::enable_if_t<std::is_integral<T>::value, int> = 0> 108911986Sandreas.sandberg@arm.com operator T() const { 109012391Sjason@lowepower.com return std::is_unsigned<T>::value 109112391Sjason@lowepower.com ? detail::as_unsigned<T>(m_ptr) 109212391Sjason@lowepower.com : sizeof(T) <= sizeof(long) 109312391Sjason@lowepower.com ? (T) PyLong_AsLong(m_ptr) 109412391Sjason@lowepower.com : (T) PYBIND11_LONG_AS_LONGLONG(m_ptr); 109511986Sandreas.sandberg@arm.com } 109611986Sandreas.sandberg@arm.com}; 109711986Sandreas.sandberg@arm.com 109811986Sandreas.sandberg@arm.comclass float_ : public object { 109911986Sandreas.sandberg@arm.compublic: 110011986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(float_, object, PyFloat_Check, PyNumber_Float) 110111986Sandreas.sandberg@arm.com // Allow implicit conversion from float/double: 110212391Sjason@lowepower.com float_(float value) : object(PyFloat_FromDouble((double) value), stolen_t{}) { 110311986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate float object!"); 110411986Sandreas.sandberg@arm.com } 110512391Sjason@lowepower.com float_(double value = .0) : object(PyFloat_FromDouble((double) value), stolen_t{}) { 110611986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate float object!"); 110711986Sandreas.sandberg@arm.com } 110811986Sandreas.sandberg@arm.com operator float() const { return (float) PyFloat_AsDouble(m_ptr); } 110911986Sandreas.sandberg@arm.com operator double() const { return (double) PyFloat_AsDouble(m_ptr); } 111011986Sandreas.sandberg@arm.com}; 111111986Sandreas.sandberg@arm.com 111211986Sandreas.sandberg@arm.comclass weakref : public object { 111311986Sandreas.sandberg@arm.compublic: 111411986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(weakref, object, PyWeakref_Check) 111511986Sandreas.sandberg@arm.com explicit weakref(handle obj, handle callback = {}) 111612391Sjason@lowepower.com : object(PyWeakref_NewRef(obj.ptr(), callback.ptr()), stolen_t{}) { 111711986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate weak reference!"); 111811986Sandreas.sandberg@arm.com } 111911986Sandreas.sandberg@arm.com}; 112011986Sandreas.sandberg@arm.com 112111986Sandreas.sandberg@arm.comclass slice : public object { 112211986Sandreas.sandberg@arm.compublic: 112311986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(slice, object, PySlice_Check) 112411986Sandreas.sandberg@arm.com slice(ssize_t start_, ssize_t stop_, ssize_t step_) { 112511986Sandreas.sandberg@arm.com int_ start(start_), stop(stop_), step(step_); 112611986Sandreas.sandberg@arm.com m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr()); 112711986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate slice object!"); 112811986Sandreas.sandberg@arm.com } 112911986Sandreas.sandberg@arm.com bool compute(size_t length, size_t *start, size_t *stop, size_t *step, 113011986Sandreas.sandberg@arm.com size_t *slicelength) const { 113111986Sandreas.sandberg@arm.com return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr, 113211986Sandreas.sandberg@arm.com (ssize_t) length, (ssize_t *) start, 113311986Sandreas.sandberg@arm.com (ssize_t *) stop, (ssize_t *) step, 113411986Sandreas.sandberg@arm.com (ssize_t *) slicelength) == 0; 113511986Sandreas.sandberg@arm.com } 113614299Sbbruce@ucdavis.edu bool compute(ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, 113714299Sbbruce@ucdavis.edu ssize_t *slicelength) const { 113814299Sbbruce@ucdavis.edu return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr, 113914299Sbbruce@ucdavis.edu length, start, 114014299Sbbruce@ucdavis.edu stop, step, 114114299Sbbruce@ucdavis.edu slicelength) == 0; 114214299Sbbruce@ucdavis.edu } 114311986Sandreas.sandberg@arm.com}; 114411986Sandreas.sandberg@arm.com 114511986Sandreas.sandberg@arm.comclass capsule : public object { 114611986Sandreas.sandberg@arm.compublic: 114711986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact) 114811986Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Use reinterpret_borrow<capsule>() or reinterpret_steal<capsule>()") 114912391Sjason@lowepower.com capsule(PyObject *ptr, bool is_borrowed) : object(is_borrowed ? object(ptr, borrowed_t{}) : object(ptr, stolen_t{})) { } 115012037Sandreas.sandberg@arm.com 115112391Sjason@lowepower.com explicit capsule(const void *value, const char *name = nullptr, void (*destructor)(PyObject *) = nullptr) 115212391Sjason@lowepower.com : object(PyCapsule_New(const_cast<void *>(value), name, destructor), stolen_t{}) { 115312037Sandreas.sandberg@arm.com if (!m_ptr) 115412037Sandreas.sandberg@arm.com pybind11_fail("Could not allocate capsule object!"); 115512037Sandreas.sandberg@arm.com } 115612037Sandreas.sandberg@arm.com 115712037Sandreas.sandberg@arm.com PYBIND11_DEPRECATED("Please pass a destructor that takes a void pointer as input") 115812037Sandreas.sandberg@arm.com capsule(const void *value, void (*destruct)(PyObject *)) 115912391Sjason@lowepower.com : object(PyCapsule_New(const_cast<void*>(value), nullptr, destruct), stolen_t{}) { 116012037Sandreas.sandberg@arm.com if (!m_ptr) 116112037Sandreas.sandberg@arm.com pybind11_fail("Could not allocate capsule object!"); 116211986Sandreas.sandberg@arm.com } 116312037Sandreas.sandberg@arm.com 116412037Sandreas.sandberg@arm.com capsule(const void *value, void (*destructor)(void *)) { 116512037Sandreas.sandberg@arm.com m_ptr = PyCapsule_New(const_cast<void *>(value), nullptr, [](PyObject *o) { 116612037Sandreas.sandberg@arm.com auto destructor = reinterpret_cast<void (*)(void *)>(PyCapsule_GetContext(o)); 116712037Sandreas.sandberg@arm.com void *ptr = PyCapsule_GetPointer(o, nullptr); 116812037Sandreas.sandberg@arm.com destructor(ptr); 116912037Sandreas.sandberg@arm.com }); 117012037Sandreas.sandberg@arm.com 117112037Sandreas.sandberg@arm.com if (!m_ptr) 117212037Sandreas.sandberg@arm.com pybind11_fail("Could not allocate capsule object!"); 117312037Sandreas.sandberg@arm.com 117412037Sandreas.sandberg@arm.com if (PyCapsule_SetContext(m_ptr, (void *) destructor) != 0) 117512037Sandreas.sandberg@arm.com pybind11_fail("Could not set capsule context!"); 117612037Sandreas.sandberg@arm.com } 117712037Sandreas.sandberg@arm.com 117812037Sandreas.sandberg@arm.com capsule(void (*destructor)()) { 117912037Sandreas.sandberg@arm.com m_ptr = PyCapsule_New(reinterpret_cast<void *>(destructor), nullptr, [](PyObject *o) { 118012037Sandreas.sandberg@arm.com auto destructor = reinterpret_cast<void (*)()>(PyCapsule_GetPointer(o, nullptr)); 118112037Sandreas.sandberg@arm.com destructor(); 118212037Sandreas.sandberg@arm.com }); 118312037Sandreas.sandberg@arm.com 118412037Sandreas.sandberg@arm.com if (!m_ptr) 118512037Sandreas.sandberg@arm.com pybind11_fail("Could not allocate capsule object!"); 118612037Sandreas.sandberg@arm.com } 118712037Sandreas.sandberg@arm.com 118811986Sandreas.sandberg@arm.com template <typename T> operator T *() const { 118912391Sjason@lowepower.com auto name = this->name(); 119012391Sjason@lowepower.com T * result = static_cast<T *>(PyCapsule_GetPointer(m_ptr, name)); 119111986Sandreas.sandberg@arm.com if (!result) pybind11_fail("Unable to extract capsule contents!"); 119211986Sandreas.sandberg@arm.com return result; 119311986Sandreas.sandberg@arm.com } 119412391Sjason@lowepower.com 119512391Sjason@lowepower.com const char *name() const { return PyCapsule_GetName(m_ptr); } 119611986Sandreas.sandberg@arm.com}; 119711986Sandreas.sandberg@arm.com 119811986Sandreas.sandberg@arm.comclass tuple : public object { 119911986Sandreas.sandberg@arm.compublic: 120011986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(tuple, object, PyTuple_Check, PySequence_Tuple) 120112391Sjason@lowepower.com explicit tuple(size_t size = 0) : object(PyTuple_New((ssize_t) size), stolen_t{}) { 120211986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate tuple object!"); 120311986Sandreas.sandberg@arm.com } 120411986Sandreas.sandberg@arm.com size_t size() const { return (size_t) PyTuple_Size(m_ptr); } 120514299Sbbruce@ucdavis.edu bool empty() const { return size() == 0; } 120611986Sandreas.sandberg@arm.com detail::tuple_accessor operator[](size_t index) const { return {*this, index}; } 120714299Sbbruce@ucdavis.edu detail::item_accessor operator[](handle h) const { return object::operator[](h); } 120812037Sandreas.sandberg@arm.com detail::tuple_iterator begin() const { return {*this, 0}; } 120912037Sandreas.sandberg@arm.com detail::tuple_iterator end() const { return {*this, PyTuple_GET_SIZE(m_ptr)}; } 121011986Sandreas.sandberg@arm.com}; 121111986Sandreas.sandberg@arm.com 121211986Sandreas.sandberg@arm.comclass dict : public object { 121311986Sandreas.sandberg@arm.compublic: 121411986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(dict, object, PyDict_Check, raw_dict) 121512391Sjason@lowepower.com dict() : object(PyDict_New(), stolen_t{}) { 121611986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate dict object!"); 121711986Sandreas.sandberg@arm.com } 121811986Sandreas.sandberg@arm.com template <typename... Args, 121912037Sandreas.sandberg@arm.com typename = detail::enable_if_t<detail::all_of<detail::is_keyword_or_ds<Args>...>::value>, 122011986Sandreas.sandberg@arm.com // MSVC workaround: it can't compile an out-of-line definition, so defer the collector 122111986Sandreas.sandberg@arm.com typename collector = detail::deferred_t<detail::unpacking_collector<>, Args...>> 122211986Sandreas.sandberg@arm.com explicit dict(Args &&...args) : dict(collector(std::forward<Args>(args)...).kwargs()) { } 122311986Sandreas.sandberg@arm.com 122411986Sandreas.sandberg@arm.com size_t size() const { return (size_t) PyDict_Size(m_ptr); } 122514299Sbbruce@ucdavis.edu bool empty() const { return size() == 0; } 122612037Sandreas.sandberg@arm.com detail::dict_iterator begin() const { return {*this, 0}; } 122712037Sandreas.sandberg@arm.com detail::dict_iterator end() const { return {}; } 122811986Sandreas.sandberg@arm.com void clear() const { PyDict_Clear(ptr()); } 122914299Sbbruce@ucdavis.edu template <typename T> bool contains(T &&key) const { 123014299Sbbruce@ucdavis.edu return PyDict_Contains(m_ptr, detail::object_or_cast(std::forward<T>(key)).ptr()) == 1; 123114299Sbbruce@ucdavis.edu } 123211986Sandreas.sandberg@arm.com 123311986Sandreas.sandberg@arm.comprivate: 123411986Sandreas.sandberg@arm.com /// Call the `dict` Python type -- always returns a new reference 123511986Sandreas.sandberg@arm.com static PyObject *raw_dict(PyObject *op) { 123611986Sandreas.sandberg@arm.com if (PyDict_Check(op)) 123711986Sandreas.sandberg@arm.com return handle(op).inc_ref().ptr(); 123811986Sandreas.sandberg@arm.com return PyObject_CallFunctionObjArgs((PyObject *) &PyDict_Type, op, nullptr); 123911986Sandreas.sandberg@arm.com } 124011986Sandreas.sandberg@arm.com}; 124111986Sandreas.sandberg@arm.com 124211986Sandreas.sandberg@arm.comclass sequence : public object { 124311986Sandreas.sandberg@arm.compublic: 124412037Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(sequence, object, PySequence_Check) 124511986Sandreas.sandberg@arm.com size_t size() const { return (size_t) PySequence_Size(m_ptr); } 124614299Sbbruce@ucdavis.edu bool empty() const { return size() == 0; } 124711986Sandreas.sandberg@arm.com detail::sequence_accessor operator[](size_t index) const { return {*this, index}; } 124814299Sbbruce@ucdavis.edu detail::item_accessor operator[](handle h) const { return object::operator[](h); } 124912037Sandreas.sandberg@arm.com detail::sequence_iterator begin() const { return {*this, 0}; } 125012037Sandreas.sandberg@arm.com detail::sequence_iterator end() const { return {*this, PySequence_Size(m_ptr)}; } 125111986Sandreas.sandberg@arm.com}; 125211986Sandreas.sandberg@arm.com 125311986Sandreas.sandberg@arm.comclass list : public object { 125411986Sandreas.sandberg@arm.compublic: 125511986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(list, object, PyList_Check, PySequence_List) 125612391Sjason@lowepower.com explicit list(size_t size = 0) : object(PyList_New((ssize_t) size), stolen_t{}) { 125711986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate list object!"); 125811986Sandreas.sandberg@arm.com } 125911986Sandreas.sandberg@arm.com size_t size() const { return (size_t) PyList_Size(m_ptr); } 126014299Sbbruce@ucdavis.edu bool empty() const { return size() == 0; } 126111986Sandreas.sandberg@arm.com detail::list_accessor operator[](size_t index) const { return {*this, index}; } 126214299Sbbruce@ucdavis.edu detail::item_accessor operator[](handle h) const { return object::operator[](h); } 126312037Sandreas.sandberg@arm.com detail::list_iterator begin() const { return {*this, 0}; } 126412037Sandreas.sandberg@arm.com detail::list_iterator end() const { return {*this, PyList_GET_SIZE(m_ptr)}; } 126511986Sandreas.sandberg@arm.com template <typename T> void append(T &&val) const { 126611986Sandreas.sandberg@arm.com PyList_Append(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()); 126711986Sandreas.sandberg@arm.com } 126814299Sbbruce@ucdavis.edu template <typename T> void insert(size_t index, T &&val) const { 126914299Sbbruce@ucdavis.edu PyList_Insert(m_ptr, static_cast<ssize_t>(index), 127014299Sbbruce@ucdavis.edu detail::object_or_cast(std::forward<T>(val)).ptr()); 127114299Sbbruce@ucdavis.edu } 127211986Sandreas.sandberg@arm.com}; 127311986Sandreas.sandberg@arm.com 127411986Sandreas.sandberg@arm.comclass args : public tuple { PYBIND11_OBJECT_DEFAULT(args, tuple, PyTuple_Check) }; 127511986Sandreas.sandberg@arm.comclass kwargs : public dict { PYBIND11_OBJECT_DEFAULT(kwargs, dict, PyDict_Check) }; 127611986Sandreas.sandberg@arm.com 127711986Sandreas.sandberg@arm.comclass set : public object { 127811986Sandreas.sandberg@arm.compublic: 127911986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(set, object, PySet_Check, PySet_New) 128012391Sjason@lowepower.com set() : object(PySet_New(nullptr), stolen_t{}) { 128111986Sandreas.sandberg@arm.com if (!m_ptr) pybind11_fail("Could not allocate set object!"); 128211986Sandreas.sandberg@arm.com } 128311986Sandreas.sandberg@arm.com size_t size() const { return (size_t) PySet_Size(m_ptr); } 128414299Sbbruce@ucdavis.edu bool empty() const { return size() == 0; } 128511986Sandreas.sandberg@arm.com template <typename T> bool add(T &&val) const { 128611986Sandreas.sandberg@arm.com return PySet_Add(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()) == 0; 128711986Sandreas.sandberg@arm.com } 128811986Sandreas.sandberg@arm.com void clear() const { PySet_Clear(m_ptr); } 128914299Sbbruce@ucdavis.edu template <typename T> bool contains(T &&val) const { 129014299Sbbruce@ucdavis.edu return PySet_Contains(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()) == 1; 129114299Sbbruce@ucdavis.edu } 129211986Sandreas.sandberg@arm.com}; 129311986Sandreas.sandberg@arm.com 129411986Sandreas.sandberg@arm.comclass function : public object { 129511986Sandreas.sandberg@arm.compublic: 129611986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(function, object, PyCallable_Check) 129712391Sjason@lowepower.com handle cpp_function() const { 129811986Sandreas.sandberg@arm.com handle fun = detail::get_function(m_ptr); 129912391Sjason@lowepower.com if (fun && PyCFunction_Check(fun.ptr())) 130012391Sjason@lowepower.com return fun; 130112391Sjason@lowepower.com return handle(); 130211986Sandreas.sandberg@arm.com } 130312391Sjason@lowepower.com bool is_cpp_function() const { return (bool) cpp_function(); } 130411986Sandreas.sandberg@arm.com}; 130511986Sandreas.sandberg@arm.com 130614299Sbbruce@ucdavis.educlass staticmethod : public object { 130714299Sbbruce@ucdavis.edupublic: 130814299Sbbruce@ucdavis.edu PYBIND11_OBJECT_CVT(staticmethod, object, detail::PyStaticMethod_Check, PyStaticMethod_New) 130914299Sbbruce@ucdavis.edu}; 131014299Sbbruce@ucdavis.edu 131111986Sandreas.sandberg@arm.comclass buffer : public object { 131211986Sandreas.sandberg@arm.compublic: 131311986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer) 131411986Sandreas.sandberg@arm.com 131514299Sbbruce@ucdavis.edu buffer_info request(bool writable = false) const { 131611986Sandreas.sandberg@arm.com int flags = PyBUF_STRIDES | PyBUF_FORMAT; 131711986Sandreas.sandberg@arm.com if (writable) flags |= PyBUF_WRITABLE; 131811986Sandreas.sandberg@arm.com Py_buffer *view = new Py_buffer(); 131912391Sjason@lowepower.com if (PyObject_GetBuffer(m_ptr, view, flags) != 0) { 132012391Sjason@lowepower.com delete view; 132111986Sandreas.sandberg@arm.com throw error_already_set(); 132212391Sjason@lowepower.com } 132311986Sandreas.sandberg@arm.com return buffer_info(view); 132411986Sandreas.sandberg@arm.com } 132511986Sandreas.sandberg@arm.com}; 132611986Sandreas.sandberg@arm.com 132711986Sandreas.sandberg@arm.comclass memoryview : public object { 132811986Sandreas.sandberg@arm.compublic: 132911986Sandreas.sandberg@arm.com explicit memoryview(const buffer_info& info) { 133011986Sandreas.sandberg@arm.com static Py_buffer buf { }; 133111986Sandreas.sandberg@arm.com // Py_buffer uses signed sizes, strides and shape!.. 133211986Sandreas.sandberg@arm.com static std::vector<Py_ssize_t> py_strides { }; 133311986Sandreas.sandberg@arm.com static std::vector<Py_ssize_t> py_shape { }; 133411986Sandreas.sandberg@arm.com buf.buf = info.ptr; 133512391Sjason@lowepower.com buf.itemsize = info.itemsize; 133611986Sandreas.sandberg@arm.com buf.format = const_cast<char *>(info.format.c_str()); 133711986Sandreas.sandberg@arm.com buf.ndim = (int) info.ndim; 133812391Sjason@lowepower.com buf.len = info.size; 133911986Sandreas.sandberg@arm.com py_strides.clear(); 134011986Sandreas.sandberg@arm.com py_shape.clear(); 134112391Sjason@lowepower.com for (size_t i = 0; i < (size_t) info.ndim; ++i) { 134212391Sjason@lowepower.com py_strides.push_back(info.strides[i]); 134312391Sjason@lowepower.com py_shape.push_back(info.shape[i]); 134411986Sandreas.sandberg@arm.com } 134511986Sandreas.sandberg@arm.com buf.strides = py_strides.data(); 134611986Sandreas.sandberg@arm.com buf.shape = py_shape.data(); 134711986Sandreas.sandberg@arm.com buf.suboffsets = nullptr; 134811986Sandreas.sandberg@arm.com buf.readonly = false; 134911986Sandreas.sandberg@arm.com buf.internal = nullptr; 135011986Sandreas.sandberg@arm.com 135111986Sandreas.sandberg@arm.com m_ptr = PyMemoryView_FromBuffer(&buf); 135211986Sandreas.sandberg@arm.com if (!m_ptr) 135311986Sandreas.sandberg@arm.com pybind11_fail("Unable to create memoryview from buffer descriptor"); 135411986Sandreas.sandberg@arm.com } 135511986Sandreas.sandberg@arm.com 135611986Sandreas.sandberg@arm.com PYBIND11_OBJECT_CVT(memoryview, object, PyMemoryView_Check, PyMemoryView_FromObject) 135711986Sandreas.sandberg@arm.com}; 135812037Sandreas.sandberg@arm.com/// @} pytypes 135911986Sandreas.sandberg@arm.com 136012037Sandreas.sandberg@arm.com/// \addtogroup python_builtins 136112037Sandreas.sandberg@arm.com/// @{ 136211986Sandreas.sandberg@arm.cominline size_t len(handle h) { 136311986Sandreas.sandberg@arm.com ssize_t result = PyObject_Length(h.ptr()); 136411986Sandreas.sandberg@arm.com if (result < 0) 136511986Sandreas.sandberg@arm.com pybind11_fail("Unable to compute length of object"); 136611986Sandreas.sandberg@arm.com return (size_t) result; 136711986Sandreas.sandberg@arm.com} 136811986Sandreas.sandberg@arm.com 136914299Sbbruce@ucdavis.eduinline size_t len_hint(handle h) { 137014299Sbbruce@ucdavis.edu#if PY_VERSION_HEX >= 0x03040000 137114299Sbbruce@ucdavis.edu ssize_t result = PyObject_LengthHint(h.ptr(), 0); 137214299Sbbruce@ucdavis.edu#else 137314299Sbbruce@ucdavis.edu ssize_t result = PyObject_Length(h.ptr()); 137414299Sbbruce@ucdavis.edu#endif 137514299Sbbruce@ucdavis.edu if (result < 0) { 137614299Sbbruce@ucdavis.edu // Sometimes a length can't be determined at all (eg generators) 137714299Sbbruce@ucdavis.edu // In which case simply return 0 137814299Sbbruce@ucdavis.edu PyErr_Clear(); 137914299Sbbruce@ucdavis.edu return 0; 138014299Sbbruce@ucdavis.edu } 138114299Sbbruce@ucdavis.edu return (size_t) result; 138214299Sbbruce@ucdavis.edu} 138314299Sbbruce@ucdavis.edu 138411986Sandreas.sandberg@arm.cominline str repr(handle h) { 138511986Sandreas.sandberg@arm.com PyObject *str_value = PyObject_Repr(h.ptr()); 138611986Sandreas.sandberg@arm.com if (!str_value) throw error_already_set(); 138711986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION < 3 138811986Sandreas.sandberg@arm.com PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr); 138911986Sandreas.sandberg@arm.com Py_XDECREF(str_value); str_value = unicode; 139011986Sandreas.sandberg@arm.com if (!str_value) throw error_already_set(); 139111986Sandreas.sandberg@arm.com#endif 139211986Sandreas.sandberg@arm.com return reinterpret_steal<str>(str_value); 139311986Sandreas.sandberg@arm.com} 139411986Sandreas.sandberg@arm.com 139512037Sandreas.sandberg@arm.cominline iterator iter(handle obj) { 139612037Sandreas.sandberg@arm.com PyObject *result = PyObject_GetIter(obj.ptr()); 139712037Sandreas.sandberg@arm.com if (!result) { throw error_already_set(); } 139812037Sandreas.sandberg@arm.com return reinterpret_steal<iterator>(result); 139912037Sandreas.sandberg@arm.com} 140012037Sandreas.sandberg@arm.com/// @} python_builtins 140112037Sandreas.sandberg@arm.com 140211986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 140312037Sandreas.sandberg@arm.comtemplate <typename D> iterator object_api<D>::begin() const { return iter(derived()); } 140412037Sandreas.sandberg@arm.comtemplate <typename D> iterator object_api<D>::end() const { return iterator::sentinel(); } 140511986Sandreas.sandberg@arm.comtemplate <typename D> item_accessor object_api<D>::operator[](handle key) const { 140611986Sandreas.sandberg@arm.com return {derived(), reinterpret_borrow<object>(key)}; 140711986Sandreas.sandberg@arm.com} 140811986Sandreas.sandberg@arm.comtemplate <typename D> item_accessor object_api<D>::operator[](const char *key) const { 140911986Sandreas.sandberg@arm.com return {derived(), pybind11::str(key)}; 141011986Sandreas.sandberg@arm.com} 141111986Sandreas.sandberg@arm.comtemplate <typename D> obj_attr_accessor object_api<D>::attr(handle key) const { 141211986Sandreas.sandberg@arm.com return {derived(), reinterpret_borrow<object>(key)}; 141311986Sandreas.sandberg@arm.com} 141411986Sandreas.sandberg@arm.comtemplate <typename D> str_attr_accessor object_api<D>::attr(const char *key) const { 141511986Sandreas.sandberg@arm.com return {derived(), key}; 141611986Sandreas.sandberg@arm.com} 141711986Sandreas.sandberg@arm.comtemplate <typename D> args_proxy object_api<D>::operator*() const { 141811986Sandreas.sandberg@arm.com return args_proxy(derived().ptr()); 141911986Sandreas.sandberg@arm.com} 142012037Sandreas.sandberg@arm.comtemplate <typename D> template <typename T> bool object_api<D>::contains(T &&item) const { 142112037Sandreas.sandberg@arm.com return attr("__contains__")(std::forward<T>(item)).template cast<bool>(); 142211986Sandreas.sandberg@arm.com} 142311986Sandreas.sandberg@arm.com 142411986Sandreas.sandberg@arm.comtemplate <typename D> 142511986Sandreas.sandberg@arm.compybind11::str object_api<D>::str() const { return pybind11::str(derived()); } 142611986Sandreas.sandberg@arm.com 142711986Sandreas.sandberg@arm.comtemplate <typename D> 142812391Sjason@lowepower.comstr_attr_accessor object_api<D>::doc() const { return attr("__doc__"); } 142912391Sjason@lowepower.com 143012391Sjason@lowepower.comtemplate <typename D> 143111986Sandreas.sandberg@arm.comhandle object_api<D>::get_type() const { return (PyObject *) Py_TYPE(derived().ptr()); } 143211986Sandreas.sandberg@arm.com 143314299Sbbruce@ucdavis.edutemplate <typename D> 143414299Sbbruce@ucdavis.edubool object_api<D>::rich_compare(object_api const &other, int value) const { 143514299Sbbruce@ucdavis.edu int rv = PyObject_RichCompareBool(derived().ptr(), other.derived().ptr(), value); 143614299Sbbruce@ucdavis.edu if (rv == -1) 143714299Sbbruce@ucdavis.edu throw error_already_set(); 143814299Sbbruce@ucdavis.edu return rv == 1; 143914299Sbbruce@ucdavis.edu} 144014299Sbbruce@ucdavis.edu 144114299Sbbruce@ucdavis.edu#define PYBIND11_MATH_OPERATOR_UNARY(op, fn) \ 144214299Sbbruce@ucdavis.edu template <typename D> object object_api<D>::op() const { \ 144314299Sbbruce@ucdavis.edu object result = reinterpret_steal<object>(fn(derived().ptr())); \ 144414299Sbbruce@ucdavis.edu if (!result.ptr()) \ 144514299Sbbruce@ucdavis.edu throw error_already_set(); \ 144614299Sbbruce@ucdavis.edu return result; \ 144714299Sbbruce@ucdavis.edu } 144814299Sbbruce@ucdavis.edu 144914299Sbbruce@ucdavis.edu#define PYBIND11_MATH_OPERATOR_BINARY(op, fn) \ 145014299Sbbruce@ucdavis.edu template <typename D> \ 145114299Sbbruce@ucdavis.edu object object_api<D>::op(object_api const &other) const { \ 145214299Sbbruce@ucdavis.edu object result = reinterpret_steal<object>( \ 145314299Sbbruce@ucdavis.edu fn(derived().ptr(), other.derived().ptr())); \ 145414299Sbbruce@ucdavis.edu if (!result.ptr()) \ 145514299Sbbruce@ucdavis.edu throw error_already_set(); \ 145614299Sbbruce@ucdavis.edu return result; \ 145714299Sbbruce@ucdavis.edu } 145814299Sbbruce@ucdavis.edu 145914299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_UNARY (operator~, PyNumber_Invert) 146014299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_UNARY (operator-, PyNumber_Negative) 146114299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator+, PyNumber_Add) 146214299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator+=, PyNumber_InPlaceAdd) 146314299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator-, PyNumber_Subtract) 146414299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator-=, PyNumber_InPlaceSubtract) 146514299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator*, PyNumber_Multiply) 146614299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator*=, PyNumber_InPlaceMultiply) 146714299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator/, PyNumber_TrueDivide) 146814299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator/=, PyNumber_InPlaceTrueDivide) 146914299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator|, PyNumber_Or) 147014299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator|=, PyNumber_InPlaceOr) 147114299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator&, PyNumber_And) 147214299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator&=, PyNumber_InPlaceAnd) 147314299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator^, PyNumber_Xor) 147414299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator^=, PyNumber_InPlaceXor) 147514299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator<<, PyNumber_Lshift) 147614299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator<<=, PyNumber_InPlaceLshift) 147714299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator>>, PyNumber_Rshift) 147814299Sbbruce@ucdavis.eduPYBIND11_MATH_OPERATOR_BINARY(operator>>=, PyNumber_InPlaceRshift) 147914299Sbbruce@ucdavis.edu 148014299Sbbruce@ucdavis.edu#undef PYBIND11_MATH_OPERATOR_UNARY 148114299Sbbruce@ucdavis.edu#undef PYBIND11_MATH_OPERATOR_BINARY 148214299Sbbruce@ucdavis.edu 148311986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 148412391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE) 1485