111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com pybind11/cast.h: Partial template specializations to cast between 311986Sandreas.sandberg@arm.com C++ and Python types 411986Sandreas.sandberg@arm.com 511986Sandreas.sandberg@arm.com Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 611986Sandreas.sandberg@arm.com 711986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 811986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 911986Sandreas.sandberg@arm.com*/ 1011986Sandreas.sandberg@arm.com 1111986Sandreas.sandberg@arm.com#pragma once 1211986Sandreas.sandberg@arm.com 1311986Sandreas.sandberg@arm.com#include "pytypes.h" 1412391Sjason@lowepower.com#include "detail/typeid.h" 1512391Sjason@lowepower.com#include "detail/descr.h" 1612391Sjason@lowepower.com#include "detail/internals.h" 1711986Sandreas.sandberg@arm.com#include <array> 1811986Sandreas.sandberg@arm.com#include <limits> 1912391Sjason@lowepower.com#include <tuple> 2014299Sbbruce@ucdavis.edu#include <type_traits> 2111986Sandreas.sandberg@arm.com 2212391Sjason@lowepower.com#if defined(PYBIND11_CPP17) 2312391Sjason@lowepower.com# if defined(__has_include) 2412391Sjason@lowepower.com# if __has_include(<string_view>) 2512391Sjason@lowepower.com# define PYBIND11_HAS_STRING_VIEW 2612391Sjason@lowepower.com# endif 2712391Sjason@lowepower.com# elif defined(_MSC_VER) 2812391Sjason@lowepower.com# define PYBIND11_HAS_STRING_VIEW 2912391Sjason@lowepower.com# endif 3012391Sjason@lowepower.com#endif 3112391Sjason@lowepower.com#ifdef PYBIND11_HAS_STRING_VIEW 3212391Sjason@lowepower.com#include <string_view> 3312391Sjason@lowepower.com#endif 3412391Sjason@lowepower.com 3512391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE) 3611986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 3711986Sandreas.sandberg@arm.com 3812391Sjason@lowepower.com/// A life support system for temporary objects created by `type_caster::load()`. 3912391Sjason@lowepower.com/// Adding a patient will keep it alive up until the enclosing function returns. 4012391Sjason@lowepower.comclass loader_life_support { 4112391Sjason@lowepower.compublic: 4212391Sjason@lowepower.com /// A new patient frame is created when a function is entered 4312391Sjason@lowepower.com loader_life_support() { 4412391Sjason@lowepower.com get_internals().loader_patient_stack.push_back(nullptr); 4512391Sjason@lowepower.com } 4612391Sjason@lowepower.com 4712391Sjason@lowepower.com /// ... and destroyed after it returns 4812391Sjason@lowepower.com ~loader_life_support() { 4912391Sjason@lowepower.com auto &stack = get_internals().loader_patient_stack; 5012391Sjason@lowepower.com if (stack.empty()) 5112391Sjason@lowepower.com pybind11_fail("loader_life_support: internal error"); 5212391Sjason@lowepower.com 5312391Sjason@lowepower.com auto ptr = stack.back(); 5412391Sjason@lowepower.com stack.pop_back(); 5512391Sjason@lowepower.com Py_CLEAR(ptr); 5612391Sjason@lowepower.com 5712391Sjason@lowepower.com // A heuristic to reduce the stack's capacity (e.g. after long recursive calls) 5812391Sjason@lowepower.com if (stack.capacity() > 16 && stack.size() != 0 && stack.capacity() / stack.size() > 2) 5912391Sjason@lowepower.com stack.shrink_to_fit(); 6012391Sjason@lowepower.com } 6112391Sjason@lowepower.com 6212391Sjason@lowepower.com /// This can only be used inside a pybind11-bound function, either by `argument_loader` 6312391Sjason@lowepower.com /// at argument preparation time or by `py::cast()` at execution time. 6412391Sjason@lowepower.com PYBIND11_NOINLINE static void add_patient(handle h) { 6512391Sjason@lowepower.com auto &stack = get_internals().loader_patient_stack; 6612391Sjason@lowepower.com if (stack.empty()) 6712391Sjason@lowepower.com throw cast_error("When called outside a bound function, py::cast() cannot " 6812391Sjason@lowepower.com "do Python -> C++ conversions which require the creation " 6912391Sjason@lowepower.com "of temporary values"); 7012391Sjason@lowepower.com 7112391Sjason@lowepower.com auto &list_ptr = stack.back(); 7212391Sjason@lowepower.com if (list_ptr == nullptr) { 7312391Sjason@lowepower.com list_ptr = PyList_New(1); 7412391Sjason@lowepower.com if (!list_ptr) 7512391Sjason@lowepower.com pybind11_fail("loader_life_support: error allocating list"); 7612391Sjason@lowepower.com PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr()); 7712391Sjason@lowepower.com } else { 7812391Sjason@lowepower.com auto result = PyList_Append(list_ptr, h.ptr()); 7912391Sjason@lowepower.com if (result == -1) 8012391Sjason@lowepower.com pybind11_fail("loader_life_support: error adding patient"); 8112391Sjason@lowepower.com } 8212391Sjason@lowepower.com } 8311986Sandreas.sandberg@arm.com}; 8411986Sandreas.sandberg@arm.com 8512391Sjason@lowepower.com// Gets the cache entry for the given type, creating it if necessary. The return value is the pair 8612391Sjason@lowepower.com// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was 8712391Sjason@lowepower.com// just created. 8812391Sjason@lowepower.cominline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type); 8912391Sjason@lowepower.com 9012391Sjason@lowepower.com// Populates a just-created cache entry. 9112391Sjason@lowepower.comPYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) { 9212391Sjason@lowepower.com std::vector<PyTypeObject *> check; 9312391Sjason@lowepower.com for (handle parent : reinterpret_borrow<tuple>(t->tp_bases)) 9412391Sjason@lowepower.com check.push_back((PyTypeObject *) parent.ptr()); 9512391Sjason@lowepower.com 9612391Sjason@lowepower.com auto const &type_dict = get_internals().registered_types_py; 9712391Sjason@lowepower.com for (size_t i = 0; i < check.size(); i++) { 9812391Sjason@lowepower.com auto type = check[i]; 9912391Sjason@lowepower.com // Ignore Python2 old-style class super type: 10012391Sjason@lowepower.com if (!PyType_Check((PyObject *) type)) continue; 10112391Sjason@lowepower.com 10212391Sjason@lowepower.com // Check `type` in the current set of registered python types: 10312391Sjason@lowepower.com auto it = type_dict.find(type); 10412391Sjason@lowepower.com if (it != type_dict.end()) { 10512391Sjason@lowepower.com // We found a cache entry for it, so it's either pybind-registered or has pre-computed 10612391Sjason@lowepower.com // pybind bases, but we have to make sure we haven't already seen the type(s) before: we 10712391Sjason@lowepower.com // want to follow Python/virtual C++ rules that there should only be one instance of a 10812391Sjason@lowepower.com // common base. 10912391Sjason@lowepower.com for (auto *tinfo : it->second) { 11012391Sjason@lowepower.com // NB: Could use a second set here, rather than doing a linear search, but since 11112391Sjason@lowepower.com // having a large number of immediate pybind11-registered types seems fairly 11212391Sjason@lowepower.com // unlikely, that probably isn't worthwhile. 11312391Sjason@lowepower.com bool found = false; 11412391Sjason@lowepower.com for (auto *known : bases) { 11512391Sjason@lowepower.com if (known == tinfo) { found = true; break; } 11611986Sandreas.sandberg@arm.com } 11712391Sjason@lowepower.com if (!found) bases.push_back(tinfo); 11811986Sandreas.sandberg@arm.com } 11912391Sjason@lowepower.com } 12012391Sjason@lowepower.com else if (type->tp_bases) { 12112391Sjason@lowepower.com // It's some python type, so keep follow its bases classes to look for one or more 12212391Sjason@lowepower.com // registered types 12312391Sjason@lowepower.com if (i + 1 == check.size()) { 12412391Sjason@lowepower.com // When we're at the end, we can pop off the current element to avoid growing 12512391Sjason@lowepower.com // `check` when adding just one base (which is typical--i.e. when there is no 12612391Sjason@lowepower.com // multiple inheritance) 12712391Sjason@lowepower.com check.pop_back(); 12812391Sjason@lowepower.com i--; 12912391Sjason@lowepower.com } 13012391Sjason@lowepower.com for (handle parent : reinterpret_borrow<tuple>(type->tp_bases)) 13112391Sjason@lowepower.com check.push_back((PyTypeObject *) parent.ptr()); 13212391Sjason@lowepower.com } 13311986Sandreas.sandberg@arm.com } 13411986Sandreas.sandberg@arm.com} 13511986Sandreas.sandberg@arm.com 13612391Sjason@lowepower.com/** 13712391Sjason@lowepower.com * Extracts vector of type_info pointers of pybind-registered roots of the given Python type. Will 13812391Sjason@lowepower.com * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side 13912391Sjason@lowepower.com * derived class that uses single inheritance. Will contain as many types as required for a Python 14012391Sjason@lowepower.com * class that uses multiple inheritance to inherit (directly or indirectly) from multiple 14112391Sjason@lowepower.com * pybind-registered classes. Will be empty if neither the type nor any base classes are 14212391Sjason@lowepower.com * pybind-registered. 14312391Sjason@lowepower.com * 14412391Sjason@lowepower.com * The value is cached for the lifetime of the Python type. 14512391Sjason@lowepower.com */ 14612391Sjason@lowepower.cominline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) { 14712391Sjason@lowepower.com auto ins = all_type_info_get_cache(type); 14812391Sjason@lowepower.com if (ins.second) 14912391Sjason@lowepower.com // New cache entry: populate it 15012391Sjason@lowepower.com all_type_info_populate(type, ins.first->second); 15112391Sjason@lowepower.com 15212391Sjason@lowepower.com return ins.first->second; 15311986Sandreas.sandberg@arm.com} 15411986Sandreas.sandberg@arm.com 15512391Sjason@lowepower.com/** 15612391Sjason@lowepower.com * Gets a single pybind11 type info for a python type. Returns nullptr if neither the type nor any 15712391Sjason@lowepower.com * ancestors are pybind11-registered. Throws an exception if there are multiple bases--use 15812391Sjason@lowepower.com * `all_type_info` instead if you want to support multiple bases. 15912391Sjason@lowepower.com */ 16012391Sjason@lowepower.comPYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) { 16112391Sjason@lowepower.com auto &bases = all_type_info(type); 16212391Sjason@lowepower.com if (bases.size() == 0) 16312391Sjason@lowepower.com return nullptr; 16412391Sjason@lowepower.com if (bases.size() > 1) 16512391Sjason@lowepower.com pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases"); 16612391Sjason@lowepower.com return bases.front(); 16712391Sjason@lowepower.com} 16812391Sjason@lowepower.com 16912391Sjason@lowepower.cominline detail::type_info *get_local_type_info(const std::type_index &tp) { 17012391Sjason@lowepower.com auto &locals = registered_local_types_cpp(); 17112391Sjason@lowepower.com auto it = locals.find(tp); 17212391Sjason@lowepower.com if (it != locals.end()) 17312391Sjason@lowepower.com return it->second; 17412391Sjason@lowepower.com return nullptr; 17512391Sjason@lowepower.com} 17612391Sjason@lowepower.com 17712391Sjason@lowepower.cominline detail::type_info *get_global_type_info(const std::type_index &tp) { 17812391Sjason@lowepower.com auto &types = get_internals().registered_types_cpp; 17912391Sjason@lowepower.com auto it = types.find(tp); 18012391Sjason@lowepower.com if (it != types.end()) 18112391Sjason@lowepower.com return it->second; 18212391Sjason@lowepower.com return nullptr; 18312391Sjason@lowepower.com} 18412391Sjason@lowepower.com 18512391Sjason@lowepower.com/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr. 18612391Sjason@lowepower.comPYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp, 18711986Sandreas.sandberg@arm.com bool throw_if_missing = false) { 18812391Sjason@lowepower.com if (auto ltype = get_local_type_info(tp)) 18912391Sjason@lowepower.com return ltype; 19012391Sjason@lowepower.com if (auto gtype = get_global_type_info(tp)) 19112391Sjason@lowepower.com return gtype; 19211986Sandreas.sandberg@arm.com 19311986Sandreas.sandberg@arm.com if (throw_if_missing) { 19411986Sandreas.sandberg@arm.com std::string tname = tp.name(); 19511986Sandreas.sandberg@arm.com detail::clean_type_id(tname); 19611986Sandreas.sandberg@arm.com pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\""); 19711986Sandreas.sandberg@arm.com } 19811986Sandreas.sandberg@arm.com return nullptr; 19911986Sandreas.sandberg@arm.com} 20011986Sandreas.sandberg@arm.com 20111986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) { 20211986Sandreas.sandberg@arm.com detail::type_info *type_info = get_type_info(tp, throw_if_missing); 20311986Sandreas.sandberg@arm.com return handle(type_info ? ((PyObject *) type_info->type) : nullptr); 20411986Sandreas.sandberg@arm.com} 20511986Sandreas.sandberg@arm.com 20612391Sjason@lowepower.comstruct value_and_holder { 20714299Sbbruce@ucdavis.edu instance *inst = nullptr; 20814299Sbbruce@ucdavis.edu size_t index = 0u; 20914299Sbbruce@ucdavis.edu const detail::type_info *type = nullptr; 21014299Sbbruce@ucdavis.edu void **vh = nullptr; 21112391Sjason@lowepower.com 21212391Sjason@lowepower.com // Main constructor for a found value/holder: 21312391Sjason@lowepower.com value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) : 21412391Sjason@lowepower.com inst{i}, index{index}, type{type}, 21512391Sjason@lowepower.com vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]} 21612391Sjason@lowepower.com {} 21712391Sjason@lowepower.com 21812391Sjason@lowepower.com // Default constructor (used to signal a value-and-holder not found by get_value_and_holder()) 21914299Sbbruce@ucdavis.edu value_and_holder() {} 22012391Sjason@lowepower.com 22112391Sjason@lowepower.com // Used for past-the-end iterator 22212391Sjason@lowepower.com value_and_holder(size_t index) : index{index} {} 22312391Sjason@lowepower.com 22412391Sjason@lowepower.com template <typename V = void> V *&value_ptr() const { 22512391Sjason@lowepower.com return reinterpret_cast<V *&>(vh[0]); 22612391Sjason@lowepower.com } 22712391Sjason@lowepower.com // True if this `value_and_holder` has a non-null value pointer 22812391Sjason@lowepower.com explicit operator bool() const { return value_ptr(); } 22912391Sjason@lowepower.com 23012391Sjason@lowepower.com template <typename H> H &holder() const { 23112391Sjason@lowepower.com return reinterpret_cast<H &>(vh[1]); 23212391Sjason@lowepower.com } 23312391Sjason@lowepower.com bool holder_constructed() const { 23412391Sjason@lowepower.com return inst->simple_layout 23512391Sjason@lowepower.com ? inst->simple_holder_constructed 23612391Sjason@lowepower.com : inst->nonsimple.status[index] & instance::status_holder_constructed; 23712391Sjason@lowepower.com } 23812391Sjason@lowepower.com void set_holder_constructed(bool v = true) { 23912391Sjason@lowepower.com if (inst->simple_layout) 24012391Sjason@lowepower.com inst->simple_holder_constructed = v; 24112391Sjason@lowepower.com else if (v) 24212391Sjason@lowepower.com inst->nonsimple.status[index] |= instance::status_holder_constructed; 24312391Sjason@lowepower.com else 24412391Sjason@lowepower.com inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed; 24512391Sjason@lowepower.com } 24612391Sjason@lowepower.com bool instance_registered() const { 24712391Sjason@lowepower.com return inst->simple_layout 24812391Sjason@lowepower.com ? inst->simple_instance_registered 24912391Sjason@lowepower.com : inst->nonsimple.status[index] & instance::status_instance_registered; 25012391Sjason@lowepower.com } 25112391Sjason@lowepower.com void set_instance_registered(bool v = true) { 25212391Sjason@lowepower.com if (inst->simple_layout) 25312391Sjason@lowepower.com inst->simple_instance_registered = v; 25412391Sjason@lowepower.com else if (v) 25512391Sjason@lowepower.com inst->nonsimple.status[index] |= instance::status_instance_registered; 25612391Sjason@lowepower.com else 25712391Sjason@lowepower.com inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered; 25812391Sjason@lowepower.com } 25912391Sjason@lowepower.com}; 26012391Sjason@lowepower.com 26112391Sjason@lowepower.com// Container for accessing and iterating over an instance's values/holders 26212391Sjason@lowepower.comstruct values_and_holders { 26312391Sjason@lowepower.comprivate: 26412391Sjason@lowepower.com instance *inst; 26512391Sjason@lowepower.com using type_vec = std::vector<detail::type_info *>; 26612391Sjason@lowepower.com const type_vec &tinfo; 26712391Sjason@lowepower.com 26812391Sjason@lowepower.compublic: 26912391Sjason@lowepower.com values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {} 27012391Sjason@lowepower.com 27112391Sjason@lowepower.com struct iterator { 27212391Sjason@lowepower.com private: 27314299Sbbruce@ucdavis.edu instance *inst = nullptr; 27414299Sbbruce@ucdavis.edu const type_vec *types = nullptr; 27512391Sjason@lowepower.com value_and_holder curr; 27612391Sjason@lowepower.com friend struct values_and_holders; 27712391Sjason@lowepower.com iterator(instance *inst, const type_vec *tinfo) 27812391Sjason@lowepower.com : inst{inst}, types{tinfo}, 27912391Sjason@lowepower.com curr(inst /* instance */, 28012391Sjason@lowepower.com types->empty() ? nullptr : (*types)[0] /* type info */, 28112391Sjason@lowepower.com 0, /* vpos: (non-simple types only): the first vptr comes first */ 28212391Sjason@lowepower.com 0 /* index */) 28312391Sjason@lowepower.com {} 28412391Sjason@lowepower.com // Past-the-end iterator: 28512391Sjason@lowepower.com iterator(size_t end) : curr(end) {} 28612391Sjason@lowepower.com public: 28712391Sjason@lowepower.com bool operator==(const iterator &other) { return curr.index == other.curr.index; } 28812391Sjason@lowepower.com bool operator!=(const iterator &other) { return curr.index != other.curr.index; } 28912391Sjason@lowepower.com iterator &operator++() { 29012391Sjason@lowepower.com if (!inst->simple_layout) 29112391Sjason@lowepower.com curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs; 29212391Sjason@lowepower.com ++curr.index; 29312391Sjason@lowepower.com curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr; 29412391Sjason@lowepower.com return *this; 29512391Sjason@lowepower.com } 29612391Sjason@lowepower.com value_and_holder &operator*() { return curr; } 29712391Sjason@lowepower.com value_and_holder *operator->() { return &curr; } 29812391Sjason@lowepower.com }; 29912391Sjason@lowepower.com 30012391Sjason@lowepower.com iterator begin() { return iterator(inst, &tinfo); } 30112391Sjason@lowepower.com iterator end() { return iterator(tinfo.size()); } 30212391Sjason@lowepower.com 30312391Sjason@lowepower.com iterator find(const type_info *find_type) { 30412391Sjason@lowepower.com auto it = begin(), endit = end(); 30512391Sjason@lowepower.com while (it != endit && it->type != find_type) ++it; 30612391Sjason@lowepower.com return it; 30712391Sjason@lowepower.com } 30812391Sjason@lowepower.com 30912391Sjason@lowepower.com size_t size() { return tinfo.size(); } 31012391Sjason@lowepower.com}; 31112391Sjason@lowepower.com 31212391Sjason@lowepower.com/** 31312391Sjason@lowepower.com * Extracts C++ value and holder pointer references from an instance (which may contain multiple 31412391Sjason@lowepower.com * values/holders for python-side multiple inheritance) that match the given type. Throws an error 31512391Sjason@lowepower.com * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance. If 31612391Sjason@lowepower.com * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned, 31712391Sjason@lowepower.com * regardless of type (and the resulting .type will be nullptr). 31812391Sjason@lowepower.com * 31912391Sjason@lowepower.com * The returned object should be short-lived: in particular, it must not outlive the called-upon 32012391Sjason@lowepower.com * instance. 32112391Sjason@lowepower.com */ 32212391Sjason@lowepower.comPYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) { 32312391Sjason@lowepower.com // Optimize common case: 32412391Sjason@lowepower.com if (!find_type || Py_TYPE(this) == find_type->type) 32512391Sjason@lowepower.com return value_and_holder(this, find_type, 0, 0); 32612391Sjason@lowepower.com 32712391Sjason@lowepower.com detail::values_and_holders vhs(this); 32812391Sjason@lowepower.com auto it = vhs.find(find_type); 32912391Sjason@lowepower.com if (it != vhs.end()) 33012391Sjason@lowepower.com return *it; 33112391Sjason@lowepower.com 33212391Sjason@lowepower.com if (!throw_if_missing) 33312391Sjason@lowepower.com return value_and_holder(); 33412391Sjason@lowepower.com 33512391Sjason@lowepower.com#if defined(NDEBUG) 33612391Sjason@lowepower.com pybind11_fail("pybind11::detail::instance::get_value_and_holder: " 33712391Sjason@lowepower.com "type is not a pybind11 base of the given instance " 33812391Sjason@lowepower.com "(compile in debug mode for type details)"); 33912391Sjason@lowepower.com#else 34012391Sjason@lowepower.com pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" + 34112391Sjason@lowepower.com std::string(find_type->type->tp_name) + "' is not a pybind11 base of the given `" + 34212391Sjason@lowepower.com std::string(Py_TYPE(this)->tp_name) + "' instance"); 34312391Sjason@lowepower.com#endif 34412391Sjason@lowepower.com} 34512391Sjason@lowepower.com 34612391Sjason@lowepower.comPYBIND11_NOINLINE inline void instance::allocate_layout() { 34712391Sjason@lowepower.com auto &tinfo = all_type_info(Py_TYPE(this)); 34812391Sjason@lowepower.com 34912391Sjason@lowepower.com const size_t n_types = tinfo.size(); 35012391Sjason@lowepower.com 35112391Sjason@lowepower.com if (n_types == 0) 35212391Sjason@lowepower.com pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types"); 35312391Sjason@lowepower.com 35412391Sjason@lowepower.com simple_layout = 35512391Sjason@lowepower.com n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs(); 35612391Sjason@lowepower.com 35712391Sjason@lowepower.com // Simple path: no python-side multiple inheritance, and a small-enough holder 35812391Sjason@lowepower.com if (simple_layout) { 35912391Sjason@lowepower.com simple_value_holder[0] = nullptr; 36012391Sjason@lowepower.com simple_holder_constructed = false; 36112391Sjason@lowepower.com simple_instance_registered = false; 36212391Sjason@lowepower.com } 36312391Sjason@lowepower.com else { // multiple base types or a too-large holder 36412391Sjason@lowepower.com // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer, 36512391Sjason@lowepower.com // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool 36612391Sjason@lowepower.com // values that tracks whether each associated holder has been initialized. Each [block] is 36712391Sjason@lowepower.com // padded, if necessary, to an integer multiple of sizeof(void *). 36812391Sjason@lowepower.com size_t space = 0; 36912391Sjason@lowepower.com for (auto t : tinfo) { 37012391Sjason@lowepower.com space += 1; // value pointer 37112391Sjason@lowepower.com space += t->holder_size_in_ptrs; // holder instance 37212391Sjason@lowepower.com } 37312391Sjason@lowepower.com size_t flags_at = space; 37412391Sjason@lowepower.com space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered) 37512391Sjason@lowepower.com 37612391Sjason@lowepower.com // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values, 37712391Sjason@lowepower.com // in particular, need to be 0). Use Python's memory allocation functions: in Python 3.6 37812391Sjason@lowepower.com // they default to using pymalloc, which is designed to be efficient for small allocations 37912391Sjason@lowepower.com // like the one we're doing here; in earlier versions (and for larger allocations) they are 38012391Sjason@lowepower.com // just wrappers around malloc. 38112391Sjason@lowepower.com#if PY_VERSION_HEX >= 0x03050000 38212391Sjason@lowepower.com nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *)); 38312391Sjason@lowepower.com if (!nonsimple.values_and_holders) throw std::bad_alloc(); 38412391Sjason@lowepower.com#else 38512391Sjason@lowepower.com nonsimple.values_and_holders = (void **) PyMem_New(void *, space); 38612391Sjason@lowepower.com if (!nonsimple.values_and_holders) throw std::bad_alloc(); 38712391Sjason@lowepower.com std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *)); 38812391Sjason@lowepower.com#endif 38912391Sjason@lowepower.com nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]); 39012391Sjason@lowepower.com } 39112391Sjason@lowepower.com owned = true; 39212391Sjason@lowepower.com} 39312391Sjason@lowepower.com 39412391Sjason@lowepower.comPYBIND11_NOINLINE inline void instance::deallocate_layout() { 39512391Sjason@lowepower.com if (!simple_layout) 39612391Sjason@lowepower.com PyMem_Free(nonsimple.values_and_holders); 39712391Sjason@lowepower.com} 39812391Sjason@lowepower.com 39911986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) { 40012037Sandreas.sandberg@arm.com handle type = detail::get_type_handle(tp, false); 40111986Sandreas.sandberg@arm.com if (!type) 40211986Sandreas.sandberg@arm.com return false; 40312037Sandreas.sandberg@arm.com return isinstance(obj, type); 40411986Sandreas.sandberg@arm.com} 40511986Sandreas.sandberg@arm.com 40611986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline std::string error_string() { 40711986Sandreas.sandberg@arm.com if (!PyErr_Occurred()) { 40811986Sandreas.sandberg@arm.com PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred"); 40911986Sandreas.sandberg@arm.com return "Unknown internal error occurred"; 41011986Sandreas.sandberg@arm.com } 41111986Sandreas.sandberg@arm.com 41211986Sandreas.sandberg@arm.com error_scope scope; // Preserve error state 41311986Sandreas.sandberg@arm.com 41411986Sandreas.sandberg@arm.com std::string errorString; 41511986Sandreas.sandberg@arm.com if (scope.type) { 41611986Sandreas.sandberg@arm.com errorString += handle(scope.type).attr("__name__").cast<std::string>(); 41711986Sandreas.sandberg@arm.com errorString += ": "; 41811986Sandreas.sandberg@arm.com } 41911986Sandreas.sandberg@arm.com if (scope.value) 42011986Sandreas.sandberg@arm.com errorString += (std::string) str(scope.value); 42111986Sandreas.sandberg@arm.com 42211986Sandreas.sandberg@arm.com PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace); 42311986Sandreas.sandberg@arm.com 42411986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION >= 3 42511986Sandreas.sandberg@arm.com if (scope.trace != nullptr) 42611986Sandreas.sandberg@arm.com PyException_SetTraceback(scope.value, scope.trace); 42711986Sandreas.sandberg@arm.com#endif 42811986Sandreas.sandberg@arm.com 42912037Sandreas.sandberg@arm.com#if !defined(PYPY_VERSION) 43011986Sandreas.sandberg@arm.com if (scope.trace) { 43111986Sandreas.sandberg@arm.com PyTracebackObject *trace = (PyTracebackObject *) scope.trace; 43211986Sandreas.sandberg@arm.com 43311986Sandreas.sandberg@arm.com /* Get the deepest trace possible */ 43411986Sandreas.sandberg@arm.com while (trace->tb_next) 43511986Sandreas.sandberg@arm.com trace = trace->tb_next; 43611986Sandreas.sandberg@arm.com 43711986Sandreas.sandberg@arm.com PyFrameObject *frame = trace->tb_frame; 43811986Sandreas.sandberg@arm.com errorString += "\n\nAt:\n"; 43911986Sandreas.sandberg@arm.com while (frame) { 44011986Sandreas.sandberg@arm.com int lineno = PyFrame_GetLineNumber(frame); 44111986Sandreas.sandberg@arm.com errorString += 44211986Sandreas.sandberg@arm.com " " + handle(frame->f_code->co_filename).cast<std::string>() + 44311986Sandreas.sandberg@arm.com "(" + std::to_string(lineno) + "): " + 44411986Sandreas.sandberg@arm.com handle(frame->f_code->co_name).cast<std::string>() + "\n"; 44511986Sandreas.sandberg@arm.com frame = frame->f_back; 44611986Sandreas.sandberg@arm.com } 44711986Sandreas.sandberg@arm.com } 44812037Sandreas.sandberg@arm.com#endif 44911986Sandreas.sandberg@arm.com 45011986Sandreas.sandberg@arm.com return errorString; 45111986Sandreas.sandberg@arm.com} 45211986Sandreas.sandberg@arm.com 45311986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) { 45411986Sandreas.sandberg@arm.com auto &instances = get_internals().registered_instances; 45511986Sandreas.sandberg@arm.com auto range = instances.equal_range(ptr); 45611986Sandreas.sandberg@arm.com for (auto it = range.first; it != range.second; ++it) { 45712391Sjason@lowepower.com for (auto vh : values_and_holders(it->second)) { 45812391Sjason@lowepower.com if (vh.type == type) 45912391Sjason@lowepower.com return handle((PyObject *) it->second); 46012391Sjason@lowepower.com } 46111986Sandreas.sandberg@arm.com } 46211986Sandreas.sandberg@arm.com return handle(); 46311986Sandreas.sandberg@arm.com} 46411986Sandreas.sandberg@arm.com 46511986Sandreas.sandberg@arm.cominline PyThreadState *get_thread_state_unchecked() { 46612037Sandreas.sandberg@arm.com#if defined(PYPY_VERSION) 46712037Sandreas.sandberg@arm.com return PyThreadState_GET(); 46812037Sandreas.sandberg@arm.com#elif PY_VERSION_HEX < 0x03000000 46911986Sandreas.sandberg@arm.com return _PyThreadState_Current; 47011986Sandreas.sandberg@arm.com#elif PY_VERSION_HEX < 0x03050000 47111986Sandreas.sandberg@arm.com return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current); 47211986Sandreas.sandberg@arm.com#elif PY_VERSION_HEX < 0x03050200 47311986Sandreas.sandberg@arm.com return (PyThreadState*) _PyThreadState_Current.value; 47411986Sandreas.sandberg@arm.com#else 47511986Sandreas.sandberg@arm.com return _PyThreadState_UncheckedGet(); 47611986Sandreas.sandberg@arm.com#endif 47711986Sandreas.sandberg@arm.com} 47811986Sandreas.sandberg@arm.com 47912391Sjason@lowepower.com// Forward declarations 48011986Sandreas.sandberg@arm.cominline void keep_alive_impl(handle nurse, handle patient); 48112391Sjason@lowepower.cominline PyObject *make_new_instance(PyTypeObject *type); 48211986Sandreas.sandberg@arm.com 48311986Sandreas.sandberg@arm.comclass type_caster_generic { 48411986Sandreas.sandberg@arm.compublic: 48511986Sandreas.sandberg@arm.com PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info) 48612391Sjason@lowepower.com : typeinfo(get_type_info(type_info)), cpptype(&type_info) { } 48711986Sandreas.sandberg@arm.com 48812391Sjason@lowepower.com type_caster_generic(const type_info *typeinfo) 48912391Sjason@lowepower.com : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { } 49012391Sjason@lowepower.com 49112391Sjason@lowepower.com bool load(handle src, bool convert) { 49212391Sjason@lowepower.com return load_impl<type_caster_generic>(src, convert); 49311986Sandreas.sandberg@arm.com } 49411986Sandreas.sandberg@arm.com 49512391Sjason@lowepower.com PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent, 49612391Sjason@lowepower.com const detail::type_info *tinfo, 49712391Sjason@lowepower.com void *(*copy_constructor)(const void *), 49812391Sjason@lowepower.com void *(*move_constructor)(const void *), 49912391Sjason@lowepower.com const void *existing_holder = nullptr) { 50012391Sjason@lowepower.com if (!tinfo) // no type info: error will be set already 50112391Sjason@lowepower.com return handle(); 50211986Sandreas.sandberg@arm.com 50312391Sjason@lowepower.com void *src = const_cast<void *>(_src); 50412391Sjason@lowepower.com if (src == nullptr) 50512391Sjason@lowepower.com return none().release(); 50611986Sandreas.sandberg@arm.com 50712391Sjason@lowepower.com auto it_instances = get_internals().registered_instances.equal_range(src); 50812391Sjason@lowepower.com for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) { 50912391Sjason@lowepower.com for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) { 51012391Sjason@lowepower.com if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype)) 51112391Sjason@lowepower.com return handle((PyObject *) it_i->second).inc_ref(); 51211986Sandreas.sandberg@arm.com } 51311986Sandreas.sandberg@arm.com } 51411986Sandreas.sandberg@arm.com 51512391Sjason@lowepower.com auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type)); 51612391Sjason@lowepower.com auto wrapper = reinterpret_cast<instance *>(inst.ptr()); 51711986Sandreas.sandberg@arm.com wrapper->owned = false; 51812391Sjason@lowepower.com void *&valueptr = values_and_holders(wrapper).begin()->value_ptr(); 51911986Sandreas.sandberg@arm.com 52011986Sandreas.sandberg@arm.com switch (policy) { 52111986Sandreas.sandberg@arm.com case return_value_policy::automatic: 52211986Sandreas.sandberg@arm.com case return_value_policy::take_ownership: 52312391Sjason@lowepower.com valueptr = src; 52411986Sandreas.sandberg@arm.com wrapper->owned = true; 52511986Sandreas.sandberg@arm.com break; 52611986Sandreas.sandberg@arm.com 52711986Sandreas.sandberg@arm.com case return_value_policy::automatic_reference: 52811986Sandreas.sandberg@arm.com case return_value_policy::reference: 52912391Sjason@lowepower.com valueptr = src; 53011986Sandreas.sandberg@arm.com wrapper->owned = false; 53111986Sandreas.sandberg@arm.com break; 53211986Sandreas.sandberg@arm.com 53311986Sandreas.sandberg@arm.com case return_value_policy::copy: 53411986Sandreas.sandberg@arm.com if (copy_constructor) 53512391Sjason@lowepower.com valueptr = copy_constructor(src); 53611986Sandreas.sandberg@arm.com else 53711986Sandreas.sandberg@arm.com throw cast_error("return_value_policy = copy, but the " 53811986Sandreas.sandberg@arm.com "object is non-copyable!"); 53911986Sandreas.sandberg@arm.com wrapper->owned = true; 54011986Sandreas.sandberg@arm.com break; 54111986Sandreas.sandberg@arm.com 54211986Sandreas.sandberg@arm.com case return_value_policy::move: 54311986Sandreas.sandberg@arm.com if (move_constructor) 54412391Sjason@lowepower.com valueptr = move_constructor(src); 54511986Sandreas.sandberg@arm.com else if (copy_constructor) 54612391Sjason@lowepower.com valueptr = copy_constructor(src); 54711986Sandreas.sandberg@arm.com else 54811986Sandreas.sandberg@arm.com throw cast_error("return_value_policy = move, but the " 54911986Sandreas.sandberg@arm.com "object is neither movable nor copyable!"); 55011986Sandreas.sandberg@arm.com wrapper->owned = true; 55111986Sandreas.sandberg@arm.com break; 55211986Sandreas.sandberg@arm.com 55311986Sandreas.sandberg@arm.com case return_value_policy::reference_internal: 55412391Sjason@lowepower.com valueptr = src; 55511986Sandreas.sandberg@arm.com wrapper->owned = false; 55612391Sjason@lowepower.com keep_alive_impl(inst, parent); 55711986Sandreas.sandberg@arm.com break; 55811986Sandreas.sandberg@arm.com 55911986Sandreas.sandberg@arm.com default: 56011986Sandreas.sandberg@arm.com throw cast_error("unhandled return_value_policy: should not happen!"); 56111986Sandreas.sandberg@arm.com } 56211986Sandreas.sandberg@arm.com 56312391Sjason@lowepower.com tinfo->init_instance(wrapper, existing_holder); 56411986Sandreas.sandberg@arm.com 56511986Sandreas.sandberg@arm.com return inst.release(); 56611986Sandreas.sandberg@arm.com } 56711986Sandreas.sandberg@arm.com 56812391Sjason@lowepower.com // Base methods for generic caster; there are overridden in copyable_holder_caster 56912391Sjason@lowepower.com void load_value(value_and_holder &&v_h) { 57012391Sjason@lowepower.com auto *&vptr = v_h.value_ptr(); 57112391Sjason@lowepower.com // Lazy allocation for unallocated values: 57212391Sjason@lowepower.com if (vptr == nullptr) { 57312391Sjason@lowepower.com auto *type = v_h.type ? v_h.type : typeinfo; 57414299Sbbruce@ucdavis.edu if (type->operator_new) { 57514299Sbbruce@ucdavis.edu vptr = type->operator_new(type->type_size); 57614299Sbbruce@ucdavis.edu } else { 57714299Sbbruce@ucdavis.edu #if defined(PYBIND11_CPP17) 57814299Sbbruce@ucdavis.edu if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 57914299Sbbruce@ucdavis.edu vptr = ::operator new(type->type_size, 58014299Sbbruce@ucdavis.edu (std::align_val_t) type->type_align); 58114299Sbbruce@ucdavis.edu else 58214299Sbbruce@ucdavis.edu #endif 58314299Sbbruce@ucdavis.edu vptr = ::operator new(type->type_size); 58414299Sbbruce@ucdavis.edu } 58512391Sjason@lowepower.com } 58612391Sjason@lowepower.com value = vptr; 58712391Sjason@lowepower.com } 58812391Sjason@lowepower.com bool try_implicit_casts(handle src, bool convert) { 58912391Sjason@lowepower.com for (auto &cast : typeinfo->implicit_casts) { 59012391Sjason@lowepower.com type_caster_generic sub_caster(*cast.first); 59112391Sjason@lowepower.com if (sub_caster.load(src, convert)) { 59212391Sjason@lowepower.com value = cast.second(sub_caster.value); 59312391Sjason@lowepower.com return true; 59412391Sjason@lowepower.com } 59512391Sjason@lowepower.com } 59612391Sjason@lowepower.com return false; 59712391Sjason@lowepower.com } 59812391Sjason@lowepower.com bool try_direct_conversions(handle src) { 59912391Sjason@lowepower.com for (auto &converter : *typeinfo->direct_conversions) { 60012391Sjason@lowepower.com if (converter(src.ptr(), value)) 60112391Sjason@lowepower.com return true; 60212391Sjason@lowepower.com } 60312391Sjason@lowepower.com return false; 60412391Sjason@lowepower.com } 60512391Sjason@lowepower.com void check_holder_compat() {} 60612391Sjason@lowepower.com 60712391Sjason@lowepower.com PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) { 60812391Sjason@lowepower.com auto caster = type_caster_generic(ti); 60912391Sjason@lowepower.com if (caster.load(src, false)) 61012391Sjason@lowepower.com return caster.value; 61112391Sjason@lowepower.com return nullptr; 61212391Sjason@lowepower.com } 61312391Sjason@lowepower.com 61412391Sjason@lowepower.com /// Try to load with foreign typeinfo, if available. Used when there is no 61512391Sjason@lowepower.com /// native typeinfo, or when the native one wasn't able to produce a value. 61612391Sjason@lowepower.com PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) { 61712391Sjason@lowepower.com constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID; 61812391Sjason@lowepower.com const auto pytype = src.get_type(); 61912391Sjason@lowepower.com if (!hasattr(pytype, local_key)) 62012391Sjason@lowepower.com return false; 62112391Sjason@lowepower.com 62212391Sjason@lowepower.com type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key)); 62312391Sjason@lowepower.com // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type 62412391Sjason@lowepower.com if (foreign_typeinfo->module_local_load == &local_load 62512391Sjason@lowepower.com || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype))) 62612391Sjason@lowepower.com return false; 62712391Sjason@lowepower.com 62812391Sjason@lowepower.com if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) { 62912391Sjason@lowepower.com value = result; 63012391Sjason@lowepower.com return true; 63112391Sjason@lowepower.com } 63212391Sjason@lowepower.com return false; 63312391Sjason@lowepower.com } 63412391Sjason@lowepower.com 63512391Sjason@lowepower.com // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant 63612391Sjason@lowepower.com // bits of code between here and copyable_holder_caster where the two classes need different 63712391Sjason@lowepower.com // logic (without having to resort to virtual inheritance). 63812391Sjason@lowepower.com template <typename ThisT> 63912391Sjason@lowepower.com PYBIND11_NOINLINE bool load_impl(handle src, bool convert) { 64012391Sjason@lowepower.com if (!src) return false; 64112391Sjason@lowepower.com if (!typeinfo) return try_load_foreign_module_local(src); 64212391Sjason@lowepower.com if (src.is_none()) { 64312391Sjason@lowepower.com // Defer accepting None to other overloads (if we aren't in convert mode): 64412391Sjason@lowepower.com if (!convert) return false; 64512391Sjason@lowepower.com value = nullptr; 64612391Sjason@lowepower.com return true; 64712391Sjason@lowepower.com } 64812391Sjason@lowepower.com 64912391Sjason@lowepower.com auto &this_ = static_cast<ThisT &>(*this); 65012391Sjason@lowepower.com this_.check_holder_compat(); 65112391Sjason@lowepower.com 65212391Sjason@lowepower.com PyTypeObject *srctype = Py_TYPE(src.ptr()); 65312391Sjason@lowepower.com 65412391Sjason@lowepower.com // Case 1: If src is an exact type match for the target type then we can reinterpret_cast 65512391Sjason@lowepower.com // the instance's value pointer to the target type: 65612391Sjason@lowepower.com if (srctype == typeinfo->type) { 65712391Sjason@lowepower.com this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder()); 65812391Sjason@lowepower.com return true; 65912391Sjason@lowepower.com } 66012391Sjason@lowepower.com // Case 2: We have a derived class 66112391Sjason@lowepower.com else if (PyType_IsSubtype(srctype, typeinfo->type)) { 66212391Sjason@lowepower.com auto &bases = all_type_info(srctype); 66312391Sjason@lowepower.com bool no_cpp_mi = typeinfo->simple_type; 66412391Sjason@lowepower.com 66512391Sjason@lowepower.com // Case 2a: the python type is a Python-inherited derived class that inherits from just 66612391Sjason@lowepower.com // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of 66712391Sjason@lowepower.com // the right type and we can use reinterpret_cast. 66812391Sjason@lowepower.com // (This is essentially the same as case 2b, but because not using multiple inheritance 66912391Sjason@lowepower.com // is extremely common, we handle it specially to avoid the loop iterator and type 67012391Sjason@lowepower.com // pointer lookup overhead) 67112391Sjason@lowepower.com if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) { 67212391Sjason@lowepower.com this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder()); 67312391Sjason@lowepower.com return true; 67412391Sjason@lowepower.com } 67512391Sjason@lowepower.com // Case 2b: the python type inherits from multiple C++ bases. Check the bases to see if 67612391Sjason@lowepower.com // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we 67712391Sjason@lowepower.com // can safely reinterpret_cast to the relevant pointer. 67812391Sjason@lowepower.com else if (bases.size() > 1) { 67912391Sjason@lowepower.com for (auto base : bases) { 68012391Sjason@lowepower.com if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) { 68112391Sjason@lowepower.com this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base)); 68212391Sjason@lowepower.com return true; 68312391Sjason@lowepower.com } 68412391Sjason@lowepower.com } 68512391Sjason@lowepower.com } 68612391Sjason@lowepower.com 68712391Sjason@lowepower.com // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match 68812391Sjason@lowepower.com // in the registered bases, above, so try implicit casting (needed for proper C++ casting 68912391Sjason@lowepower.com // when MI is involved). 69012391Sjason@lowepower.com if (this_.try_implicit_casts(src, convert)) 69112391Sjason@lowepower.com return true; 69212391Sjason@lowepower.com } 69312391Sjason@lowepower.com 69412391Sjason@lowepower.com // Perform an implicit conversion 69512391Sjason@lowepower.com if (convert) { 69612391Sjason@lowepower.com for (auto &converter : typeinfo->implicit_conversions) { 69712391Sjason@lowepower.com auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type)); 69812391Sjason@lowepower.com if (load_impl<ThisT>(temp, false)) { 69912391Sjason@lowepower.com loader_life_support::add_patient(temp); 70012391Sjason@lowepower.com return true; 70112391Sjason@lowepower.com } 70212391Sjason@lowepower.com } 70312391Sjason@lowepower.com if (this_.try_direct_conversions(src)) 70412391Sjason@lowepower.com return true; 70512391Sjason@lowepower.com } 70612391Sjason@lowepower.com 70712391Sjason@lowepower.com // Failed to match local typeinfo. Try again with global. 70812391Sjason@lowepower.com if (typeinfo->module_local) { 70912391Sjason@lowepower.com if (auto gtype = get_global_type_info(*typeinfo->cpptype)) { 71012391Sjason@lowepower.com typeinfo = gtype; 71112391Sjason@lowepower.com return load(src, false); 71212391Sjason@lowepower.com } 71312391Sjason@lowepower.com } 71412391Sjason@lowepower.com 71512391Sjason@lowepower.com // Global typeinfo has precedence over foreign module_local 71612391Sjason@lowepower.com return try_load_foreign_module_local(src); 71712391Sjason@lowepower.com } 71812391Sjason@lowepower.com 71912391Sjason@lowepower.com 72012391Sjason@lowepower.com // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast 72112391Sjason@lowepower.com // isn't needed or can't be used. If the type is unknown, sets the error and returns a pair 72212391Sjason@lowepower.com // with .second = nullptr. (p.first = nullptr is not an error: it becomes None). 72312391Sjason@lowepower.com PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type( 72412391Sjason@lowepower.com const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) { 72512391Sjason@lowepower.com if (auto *tpi = get_type_info(cast_type)) 72612391Sjason@lowepower.com return {src, const_cast<const type_info *>(tpi)}; 72712391Sjason@lowepower.com 72812391Sjason@lowepower.com // Not found, set error: 72912391Sjason@lowepower.com std::string tname = rtti_type ? rtti_type->name() : cast_type.name(); 73012391Sjason@lowepower.com detail::clean_type_id(tname); 73112391Sjason@lowepower.com std::string msg = "Unregistered type : " + tname; 73212391Sjason@lowepower.com PyErr_SetString(PyExc_TypeError, msg.c_str()); 73312391Sjason@lowepower.com return {nullptr, nullptr}; 73412391Sjason@lowepower.com } 73512391Sjason@lowepower.com 73611986Sandreas.sandberg@arm.com const type_info *typeinfo = nullptr; 73712391Sjason@lowepower.com const std::type_info *cpptype = nullptr; 73811986Sandreas.sandberg@arm.com void *value = nullptr; 73911986Sandreas.sandberg@arm.com}; 74011986Sandreas.sandberg@arm.com 74112391Sjason@lowepower.com/** 74212391Sjason@lowepower.com * Determine suitable casting operator for pointer-or-lvalue-casting type casters. The type caster 74312391Sjason@lowepower.com * needs to provide `operator T*()` and `operator T&()` operators. 74412391Sjason@lowepower.com * 74512391Sjason@lowepower.com * If the type supports moving the value away via an `operator T&&() &&` method, it should use 74612391Sjason@lowepower.com * `movable_cast_op_type` instead. 74712391Sjason@lowepower.com */ 74811986Sandreas.sandberg@arm.comtemplate <typename T> 74912391Sjason@lowepower.comusing cast_op_type = 75012391Sjason@lowepower.com conditional_t<std::is_pointer<remove_reference_t<T>>::value, 75112391Sjason@lowepower.com typename std::add_pointer<intrinsic_t<T>>::type, 75212391Sjason@lowepower.com typename std::add_lvalue_reference<intrinsic_t<T>>::type>; 75312391Sjason@lowepower.com 75412391Sjason@lowepower.com/** 75512391Sjason@lowepower.com * Determine suitable casting operator for a type caster with a movable value. Such a type caster 75612391Sjason@lowepower.com * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`. The latter will be 75712391Sjason@lowepower.com * called in appropriate contexts where the value can be moved rather than copied. 75812391Sjason@lowepower.com * 75912391Sjason@lowepower.com * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro. 76012391Sjason@lowepower.com */ 76112391Sjason@lowepower.comtemplate <typename T> 76212391Sjason@lowepower.comusing movable_cast_op_type = 76312391Sjason@lowepower.com conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value, 76412391Sjason@lowepower.com typename std::add_pointer<intrinsic_t<T>>::type, 76512391Sjason@lowepower.com conditional_t<std::is_rvalue_reference<T>::value, 76612391Sjason@lowepower.com typename std::add_rvalue_reference<intrinsic_t<T>>::type, 76712391Sjason@lowepower.com typename std::add_lvalue_reference<intrinsic_t<T>>::type>>; 76811986Sandreas.sandberg@arm.com 76911986Sandreas.sandberg@arm.com// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when 77011986Sandreas.sandberg@arm.com// T is non-copyable, but code containing such a copy constructor fails to actually compile. 77111986Sandreas.sandberg@arm.comtemplate <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {}; 77211986Sandreas.sandberg@arm.com 77311986Sandreas.sandberg@arm.com// Specialization for types that appear to be copy constructible but also look like stl containers 77411986Sandreas.sandberg@arm.com// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if 77511986Sandreas.sandberg@arm.com// so, copy constructability depends on whether the value_type is copy constructible. 77612391Sjason@lowepower.comtemplate <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of< 77712391Sjason@lowepower.com std::is_copy_constructible<Container>, 77814299Sbbruce@ucdavis.edu std::is_same<typename Container::value_type &, typename Container::reference>, 77914299Sbbruce@ucdavis.edu // Avoid infinite recursion 78014299Sbbruce@ucdavis.edu negation<std::is_same<Container, typename Container::value_type>> 78112391Sjason@lowepower.com >::value>> : is_copy_constructible<typename Container::value_type> {}; 78212391Sjason@lowepower.com 78312391Sjason@lowepower.com#if !defined(PYBIND11_CPP17) 78412391Sjason@lowepower.com// Likewise for std::pair before C++17 (which mandates that the copy constructor not exist when the 78512391Sjason@lowepower.com// two types aren't themselves copy constructible). 78612391Sjason@lowepower.comtemplate <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>> 78712391Sjason@lowepower.com : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {}; 78812391Sjason@lowepower.com#endif 78911986Sandreas.sandberg@arm.com 79014299Sbbruce@ucdavis.eduNAMESPACE_END(detail) 79114299Sbbruce@ucdavis.edu 79214299Sbbruce@ucdavis.edu// polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed 79314299Sbbruce@ucdavis.edu// to by `src` actually is an instance of some class derived from `itype`. 79414299Sbbruce@ucdavis.edu// If so, it sets `tinfo` to point to the std::type_info representing that derived 79514299Sbbruce@ucdavis.edu// type, and returns a pointer to the start of the most-derived object of that type 79614299Sbbruce@ucdavis.edu// (in which `src` is a subobject; this will be the same address as `src` in most 79714299Sbbruce@ucdavis.edu// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src` 79814299Sbbruce@ucdavis.edu// and leaves `tinfo` at its default value of nullptr. 79914299Sbbruce@ucdavis.edu// 80014299Sbbruce@ucdavis.edu// The default polymorphic_type_hook just returns src. A specialization for polymorphic 80114299Sbbruce@ucdavis.edu// types determines the runtime type of the passed object and adjusts the this-pointer 80214299Sbbruce@ucdavis.edu// appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear 80314299Sbbruce@ucdavis.edu// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is 80414299Sbbruce@ucdavis.edu// registered with pybind11, and this Animal is in fact a Dog). 80514299Sbbruce@ucdavis.edu// 80614299Sbbruce@ucdavis.edu// You may specialize polymorphic_type_hook yourself for types that want to appear 80714299Sbbruce@ucdavis.edu// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern 80814299Sbbruce@ucdavis.edu// in performance-sensitive applications, used most notably in LLVM.) 80914299Sbbruce@ucdavis.edutemplate <typename itype, typename SFINAE = void> 81014299Sbbruce@ucdavis.edustruct polymorphic_type_hook 81114299Sbbruce@ucdavis.edu{ 81214299Sbbruce@ucdavis.edu static const void *get(const itype *src, const std::type_info*&) { return src; } 81314299Sbbruce@ucdavis.edu}; 81414299Sbbruce@ucdavis.edutemplate <typename itype> 81514299Sbbruce@ucdavis.edustruct polymorphic_type_hook<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>> 81614299Sbbruce@ucdavis.edu{ 81714299Sbbruce@ucdavis.edu static const void *get(const itype *src, const std::type_info*& type) { 81814299Sbbruce@ucdavis.edu type = src ? &typeid(*src) : nullptr; 81914299Sbbruce@ucdavis.edu return dynamic_cast<const void*>(src); 82014299Sbbruce@ucdavis.edu } 82114299Sbbruce@ucdavis.edu}; 82214299Sbbruce@ucdavis.edu 82314299Sbbruce@ucdavis.eduNAMESPACE_BEGIN(detail) 82414299Sbbruce@ucdavis.edu 82511986Sandreas.sandberg@arm.com/// Generic type caster for objects stored on the heap 82611986Sandreas.sandberg@arm.comtemplate <typename type> class type_caster_base : public type_caster_generic { 82711986Sandreas.sandberg@arm.com using itype = intrinsic_t<type>; 82814299Sbbruce@ucdavis.edu 82911986Sandreas.sandberg@arm.compublic: 83014299Sbbruce@ucdavis.edu static constexpr auto name = _<type>(); 83111986Sandreas.sandberg@arm.com 83211986Sandreas.sandberg@arm.com type_caster_base() : type_caster_base(typeid(type)) { } 83311986Sandreas.sandberg@arm.com explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { } 83411986Sandreas.sandberg@arm.com 83511986Sandreas.sandberg@arm.com static handle cast(const itype &src, return_value_policy policy, handle parent) { 83611986Sandreas.sandberg@arm.com if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) 83711986Sandreas.sandberg@arm.com policy = return_value_policy::copy; 83811986Sandreas.sandberg@arm.com return cast(&src, policy, parent); 83911986Sandreas.sandberg@arm.com } 84011986Sandreas.sandberg@arm.com 84111986Sandreas.sandberg@arm.com static handle cast(itype &&src, return_value_policy, handle parent) { 84211986Sandreas.sandberg@arm.com return cast(&src, return_value_policy::move, parent); 84311986Sandreas.sandberg@arm.com } 84411986Sandreas.sandberg@arm.com 84514299Sbbruce@ucdavis.edu // Returns a (pointer, type_info) pair taking care of necessary type lookup for a 84614299Sbbruce@ucdavis.edu // polymorphic type (using RTTI by default, but can be overridden by specializing 84714299Sbbruce@ucdavis.edu // polymorphic_type_hook). If the instance isn't derived, returns the base version. 84812391Sjason@lowepower.com static std::pair<const void *, const type_info *> src_and_type(const itype *src) { 84912391Sjason@lowepower.com auto &cast_type = typeid(itype); 85012391Sjason@lowepower.com const std::type_info *instance_type = nullptr; 85114299Sbbruce@ucdavis.edu const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type); 85214299Sbbruce@ucdavis.edu if (instance_type && !same_type(cast_type, *instance_type)) { 85314299Sbbruce@ucdavis.edu // This is a base pointer to a derived type. If the derived type is registered 85414299Sbbruce@ucdavis.edu // with pybind11, we want to make the full derived object available. 85514299Sbbruce@ucdavis.edu // In the typical case where itype is polymorphic, we get the correct 85614299Sbbruce@ucdavis.edu // derived pointer (which may be != base pointer) by a dynamic_cast to 85714299Sbbruce@ucdavis.edu // most derived type. If itype is not polymorphic, we won't get here 85814299Sbbruce@ucdavis.edu // except via a user-provided specialization of polymorphic_type_hook, 85914299Sbbruce@ucdavis.edu // and the user has promised that no this-pointer adjustment is 86014299Sbbruce@ucdavis.edu // required in that case, so it's OK to use static_cast. 86114299Sbbruce@ucdavis.edu if (const auto *tpi = get_type_info(*instance_type)) 86214299Sbbruce@ucdavis.edu return {vsrc, tpi}; 86312391Sjason@lowepower.com } 86412391Sjason@lowepower.com // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so 86512391Sjason@lowepower.com // don't do a cast 86614299Sbbruce@ucdavis.edu return type_caster_generic::src_and_type(src, cast_type, instance_type); 86712391Sjason@lowepower.com } 86812391Sjason@lowepower.com 86911986Sandreas.sandberg@arm.com static handle cast(const itype *src, return_value_policy policy, handle parent) { 87012391Sjason@lowepower.com auto st = src_and_type(src); 87111986Sandreas.sandberg@arm.com return type_caster_generic::cast( 87212391Sjason@lowepower.com st.first, policy, parent, st.second, 87311986Sandreas.sandberg@arm.com make_copy_constructor(src), make_move_constructor(src)); 87411986Sandreas.sandberg@arm.com } 87511986Sandreas.sandberg@arm.com 87612037Sandreas.sandberg@arm.com static handle cast_holder(const itype *src, const void *holder) { 87712391Sjason@lowepower.com auto st = src_and_type(src); 87812037Sandreas.sandberg@arm.com return type_caster_generic::cast( 87912391Sjason@lowepower.com st.first, return_value_policy::take_ownership, {}, st.second, 88012037Sandreas.sandberg@arm.com nullptr, nullptr, holder); 88112037Sandreas.sandberg@arm.com } 88212037Sandreas.sandberg@arm.com 88314299Sbbruce@ucdavis.edu template <typename T> using cast_op_type = detail::cast_op_type<T>; 88411986Sandreas.sandberg@arm.com 88511986Sandreas.sandberg@arm.com operator itype*() { return (type *) value; } 88611986Sandreas.sandberg@arm.com operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); } 88711986Sandreas.sandberg@arm.com 88811986Sandreas.sandberg@arm.comprotected: 88912391Sjason@lowepower.com using Constructor = void *(*)(const void *); 89012391Sjason@lowepower.com 89111986Sandreas.sandberg@arm.com /* Only enabled when the types are {copy,move}-constructible *and* when the type 89212391Sjason@lowepower.com does not have a private operator new implementation. */ 89312391Sjason@lowepower.com template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>> 89412391Sjason@lowepower.com static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) { 89512391Sjason@lowepower.com return [](const void *arg) -> void * { 89612391Sjason@lowepower.com return new T(*reinterpret_cast<const T *>(arg)); 89712391Sjason@lowepower.com }; 89812391Sjason@lowepower.com } 89912391Sjason@lowepower.com 90012391Sjason@lowepower.com template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>> 90112391Sjason@lowepower.com static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) { 90212391Sjason@lowepower.com return [](const void *arg) -> void * { 90312391Sjason@lowepower.com return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg)))); 90412391Sjason@lowepower.com }; 90512391Sjason@lowepower.com } 90611986Sandreas.sandberg@arm.com 90711986Sandreas.sandberg@arm.com static Constructor make_copy_constructor(...) { return nullptr; } 90811986Sandreas.sandberg@arm.com static Constructor make_move_constructor(...) { return nullptr; } 90911986Sandreas.sandberg@arm.com}; 91011986Sandreas.sandberg@arm.com 91111986Sandreas.sandberg@arm.comtemplate <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { }; 91211986Sandreas.sandberg@arm.comtemplate <typename type> using make_caster = type_caster<intrinsic_t<type>>; 91311986Sandreas.sandberg@arm.com 91411986Sandreas.sandberg@arm.com// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T 91511986Sandreas.sandberg@arm.comtemplate <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) { 91611986Sandreas.sandberg@arm.com return caster.operator typename make_caster<T>::template cast_op_type<T>(); 91711986Sandreas.sandberg@arm.com} 91812391Sjason@lowepower.comtemplate <typename T> typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type> 91912391Sjason@lowepower.comcast_op(make_caster<T> &&caster) { 92012391Sjason@lowepower.com return std::move(caster).operator 92112391Sjason@lowepower.com typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>(); 92211986Sandreas.sandberg@arm.com} 92311986Sandreas.sandberg@arm.com 92412391Sjason@lowepower.comtemplate <typename type> class type_caster<std::reference_wrapper<type>> { 92512391Sjason@lowepower.comprivate: 92612391Sjason@lowepower.com using caster_t = make_caster<type>; 92712391Sjason@lowepower.com caster_t subcaster; 92812391Sjason@lowepower.com using subcaster_cast_op_type = typename caster_t::template cast_op_type<type>; 92912391Sjason@lowepower.com static_assert(std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value, 93012391Sjason@lowepower.com "std::reference_wrapper<T> caster requires T to have a caster with an `T &` operator"); 93111986Sandreas.sandberg@arm.compublic: 93212391Sjason@lowepower.com bool load(handle src, bool convert) { return subcaster.load(src, convert); } 93314299Sbbruce@ucdavis.edu static constexpr auto name = caster_t::name; 93411986Sandreas.sandberg@arm.com static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) { 93512391Sjason@lowepower.com // It is definitely wrong to take ownership of this pointer, so mask that rvp 93612391Sjason@lowepower.com if (policy == return_value_policy::take_ownership || policy == return_value_policy::automatic) 93712391Sjason@lowepower.com policy = return_value_policy::automatic_reference; 93812391Sjason@lowepower.com return caster_t::cast(&src.get(), policy, parent); 93911986Sandreas.sandberg@arm.com } 94011986Sandreas.sandberg@arm.com template <typename T> using cast_op_type = std::reference_wrapper<type>; 94112391Sjason@lowepower.com operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type&(); } 94211986Sandreas.sandberg@arm.com}; 94311986Sandreas.sandberg@arm.com 94411986Sandreas.sandberg@arm.com#define PYBIND11_TYPE_CASTER(type, py_name) \ 94511986Sandreas.sandberg@arm.com protected: \ 94611986Sandreas.sandberg@arm.com type value; \ 94711986Sandreas.sandberg@arm.com public: \ 94814299Sbbruce@ucdavis.edu static constexpr auto name = py_name; \ 94912391Sjason@lowepower.com template <typename T_, enable_if_t<std::is_same<type, remove_cv_t<T_>>::value, int> = 0> \ 95012391Sjason@lowepower.com static handle cast(T_ *src, return_value_policy policy, handle parent) { \ 95112037Sandreas.sandberg@arm.com if (!src) return none().release(); \ 95212391Sjason@lowepower.com if (policy == return_value_policy::take_ownership) { \ 95312391Sjason@lowepower.com auto h = cast(std::move(*src), policy, parent); delete src; return h; \ 95412391Sjason@lowepower.com } else { \ 95512391Sjason@lowepower.com return cast(*src, policy, parent); \ 95612391Sjason@lowepower.com } \ 95711986Sandreas.sandberg@arm.com } \ 95811986Sandreas.sandberg@arm.com operator type*() { return &value; } \ 95911986Sandreas.sandberg@arm.com operator type&() { return value; } \ 96012391Sjason@lowepower.com operator type&&() && { return std::move(value); } \ 96112391Sjason@lowepower.com template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_> 96211986Sandreas.sandberg@arm.com 96311986Sandreas.sandberg@arm.com 96412037Sandreas.sandberg@arm.comtemplate <typename CharT> using is_std_char_type = any_of< 96512037Sandreas.sandberg@arm.com std::is_same<CharT, char>, /* std::string */ 96612037Sandreas.sandberg@arm.com std::is_same<CharT, char16_t>, /* std::u16string */ 96712037Sandreas.sandberg@arm.com std::is_same<CharT, char32_t>, /* std::u32string */ 96812037Sandreas.sandberg@arm.com std::is_same<CharT, wchar_t> /* std::wstring */ 96912037Sandreas.sandberg@arm.com>; 97012037Sandreas.sandberg@arm.com 97111986Sandreas.sandberg@arm.comtemplate <typename T> 97212037Sandreas.sandberg@arm.comstruct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> { 97312037Sandreas.sandberg@arm.com using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>; 97412037Sandreas.sandberg@arm.com using _py_type_1 = conditional_t<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>; 97512037Sandreas.sandberg@arm.com using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>; 97611986Sandreas.sandberg@arm.compublic: 97711986Sandreas.sandberg@arm.com 97812037Sandreas.sandberg@arm.com bool load(handle src, bool convert) { 97911986Sandreas.sandberg@arm.com py_type py_value; 98011986Sandreas.sandberg@arm.com 98112037Sandreas.sandberg@arm.com if (!src) 98211986Sandreas.sandberg@arm.com return false; 98312037Sandreas.sandberg@arm.com 98412037Sandreas.sandberg@arm.com if (std::is_floating_point<T>::value) { 98512037Sandreas.sandberg@arm.com if (convert || PyFloat_Check(src.ptr())) 98612037Sandreas.sandberg@arm.com py_value = (py_type) PyFloat_AsDouble(src.ptr()); 98712037Sandreas.sandberg@arm.com else 98812037Sandreas.sandberg@arm.com return false; 98912391Sjason@lowepower.com } else if (PyFloat_Check(src.ptr())) { 99012391Sjason@lowepower.com return false; 99112391Sjason@lowepower.com } else if (std::is_unsigned<py_type>::value) { 99212391Sjason@lowepower.com py_value = as_unsigned<py_type>(src.ptr()); 99312391Sjason@lowepower.com } else { // signed integer: 99412391Sjason@lowepower.com py_value = sizeof(T) <= sizeof(long) 99512391Sjason@lowepower.com ? (py_type) PyLong_AsLong(src.ptr()) 99612391Sjason@lowepower.com : (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr()); 99711986Sandreas.sandberg@arm.com } 99811986Sandreas.sandberg@arm.com 99912391Sjason@lowepower.com bool py_err = py_value == (py_type) -1 && PyErr_Occurred(); 100014299Sbbruce@ucdavis.edu 100114299Sbbruce@ucdavis.edu // Protect std::numeric_limits::min/max with parentheses 100212391Sjason@lowepower.com if (py_err || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) && 100314299Sbbruce@ucdavis.edu (py_value < (py_type) (std::numeric_limits<T>::min)() || 100414299Sbbruce@ucdavis.edu py_value > (py_type) (std::numeric_limits<T>::max)()))) { 100512391Sjason@lowepower.com bool type_error = py_err && PyErr_ExceptionMatches( 100612391Sjason@lowepower.com#if PY_VERSION_HEX < 0x03000000 && !defined(PYPY_VERSION) 100712391Sjason@lowepower.com PyExc_SystemError 100811986Sandreas.sandberg@arm.com#else 100912391Sjason@lowepower.com PyExc_TypeError 101011986Sandreas.sandberg@arm.com#endif 101112391Sjason@lowepower.com ); 101211986Sandreas.sandberg@arm.com PyErr_Clear(); 101312037Sandreas.sandberg@arm.com if (type_error && convert && PyNumber_Check(src.ptr())) { 101412391Sjason@lowepower.com auto tmp = reinterpret_steal<object>(std::is_floating_point<T>::value 101512391Sjason@lowepower.com ? PyNumber_Float(src.ptr()) 101612391Sjason@lowepower.com : PyNumber_Long(src.ptr())); 101711986Sandreas.sandberg@arm.com PyErr_Clear(); 101811986Sandreas.sandberg@arm.com return load(tmp, false); 101911986Sandreas.sandberg@arm.com } 102011986Sandreas.sandberg@arm.com return false; 102111986Sandreas.sandberg@arm.com } 102211986Sandreas.sandberg@arm.com 102311986Sandreas.sandberg@arm.com value = (T) py_value; 102411986Sandreas.sandberg@arm.com return true; 102511986Sandreas.sandberg@arm.com } 102611986Sandreas.sandberg@arm.com 102714299Sbbruce@ucdavis.edu template<typename U = T> 102814299Sbbruce@ucdavis.edu static typename std::enable_if<std::is_floating_point<U>::value, handle>::type 102914299Sbbruce@ucdavis.edu cast(U src, return_value_policy /* policy */, handle /* parent */) { 103014299Sbbruce@ucdavis.edu return PyFloat_FromDouble((double) src); 103114299Sbbruce@ucdavis.edu } 103214299Sbbruce@ucdavis.edu 103314299Sbbruce@ucdavis.edu template<typename U = T> 103414299Sbbruce@ucdavis.edu static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) <= sizeof(long)), handle>::type 103514299Sbbruce@ucdavis.edu cast(U src, return_value_policy /* policy */, handle /* parent */) { 103614299Sbbruce@ucdavis.edu return PYBIND11_LONG_FROM_SIGNED((long) src); 103714299Sbbruce@ucdavis.edu } 103814299Sbbruce@ucdavis.edu 103914299Sbbruce@ucdavis.edu template<typename U = T> 104014299Sbbruce@ucdavis.edu static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) <= sizeof(unsigned long)), handle>::type 104114299Sbbruce@ucdavis.edu cast(U src, return_value_policy /* policy */, handle /* parent */) { 104214299Sbbruce@ucdavis.edu return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src); 104314299Sbbruce@ucdavis.edu } 104414299Sbbruce@ucdavis.edu 104514299Sbbruce@ucdavis.edu template<typename U = T> 104614299Sbbruce@ucdavis.edu static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) > sizeof(long)), handle>::type 104714299Sbbruce@ucdavis.edu cast(U src, return_value_policy /* policy */, handle /* parent */) { 104814299Sbbruce@ucdavis.edu return PyLong_FromLongLong((long long) src); 104914299Sbbruce@ucdavis.edu } 105014299Sbbruce@ucdavis.edu 105114299Sbbruce@ucdavis.edu template<typename U = T> 105214299Sbbruce@ucdavis.edu static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) > sizeof(unsigned long)), handle>::type 105314299Sbbruce@ucdavis.edu cast(U src, return_value_policy /* policy */, handle /* parent */) { 105414299Sbbruce@ucdavis.edu return PyLong_FromUnsignedLongLong((unsigned long long) src); 105511986Sandreas.sandberg@arm.com } 105611986Sandreas.sandberg@arm.com 105711986Sandreas.sandberg@arm.com PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float")); 105811986Sandreas.sandberg@arm.com}; 105911986Sandreas.sandberg@arm.com 106011986Sandreas.sandberg@arm.comtemplate<typename T> struct void_caster { 106111986Sandreas.sandberg@arm.compublic: 106212391Sjason@lowepower.com bool load(handle src, bool) { 106312391Sjason@lowepower.com if (src && src.is_none()) 106412391Sjason@lowepower.com return true; 106512391Sjason@lowepower.com return false; 106612391Sjason@lowepower.com } 106711986Sandreas.sandberg@arm.com static handle cast(T, return_value_policy /* policy */, handle /* parent */) { 106811986Sandreas.sandberg@arm.com return none().inc_ref(); 106911986Sandreas.sandberg@arm.com } 107011986Sandreas.sandberg@arm.com PYBIND11_TYPE_CASTER(T, _("None")); 107111986Sandreas.sandberg@arm.com}; 107211986Sandreas.sandberg@arm.com 107311986Sandreas.sandberg@arm.comtemplate <> class type_caster<void_type> : public void_caster<void_type> {}; 107411986Sandreas.sandberg@arm.com 107511986Sandreas.sandberg@arm.comtemplate <> class type_caster<void> : public type_caster<void_type> { 107611986Sandreas.sandberg@arm.compublic: 107711986Sandreas.sandberg@arm.com using type_caster<void_type>::cast; 107811986Sandreas.sandberg@arm.com 107911986Sandreas.sandberg@arm.com bool load(handle h, bool) { 108011986Sandreas.sandberg@arm.com if (!h) { 108111986Sandreas.sandberg@arm.com return false; 108211986Sandreas.sandberg@arm.com } else if (h.is_none()) { 108311986Sandreas.sandberg@arm.com value = nullptr; 108411986Sandreas.sandberg@arm.com return true; 108511986Sandreas.sandberg@arm.com } 108611986Sandreas.sandberg@arm.com 108711986Sandreas.sandberg@arm.com /* Check if this is a capsule */ 108811986Sandreas.sandberg@arm.com if (isinstance<capsule>(h)) { 108911986Sandreas.sandberg@arm.com value = reinterpret_borrow<capsule>(h); 109011986Sandreas.sandberg@arm.com return true; 109111986Sandreas.sandberg@arm.com } 109211986Sandreas.sandberg@arm.com 109311986Sandreas.sandberg@arm.com /* Check if this is a C++ type */ 109412391Sjason@lowepower.com auto &bases = all_type_info((PyTypeObject *) h.get_type().ptr()); 109512391Sjason@lowepower.com if (bases.size() == 1) { // Only allowing loading from a single-value type 109612391Sjason@lowepower.com value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr(); 109711986Sandreas.sandberg@arm.com return true; 109811986Sandreas.sandberg@arm.com } 109911986Sandreas.sandberg@arm.com 110011986Sandreas.sandberg@arm.com /* Fail */ 110111986Sandreas.sandberg@arm.com return false; 110211986Sandreas.sandberg@arm.com } 110311986Sandreas.sandberg@arm.com 110411986Sandreas.sandberg@arm.com static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) { 110511986Sandreas.sandberg@arm.com if (ptr) 110611986Sandreas.sandberg@arm.com return capsule(ptr).release(); 110711986Sandreas.sandberg@arm.com else 110811986Sandreas.sandberg@arm.com return none().inc_ref(); 110911986Sandreas.sandberg@arm.com } 111011986Sandreas.sandberg@arm.com 111111986Sandreas.sandberg@arm.com template <typename T> using cast_op_type = void*&; 111211986Sandreas.sandberg@arm.com operator void *&() { return value; } 111314299Sbbruce@ucdavis.edu static constexpr auto name = _("capsule"); 111411986Sandreas.sandberg@arm.comprivate: 111511986Sandreas.sandberg@arm.com void *value = nullptr; 111611986Sandreas.sandberg@arm.com}; 111711986Sandreas.sandberg@arm.com 111812391Sjason@lowepower.comtemplate <> class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> { }; 111911986Sandreas.sandberg@arm.com 112011986Sandreas.sandberg@arm.comtemplate <> class type_caster<bool> { 112111986Sandreas.sandberg@arm.compublic: 112212391Sjason@lowepower.com bool load(handle src, bool convert) { 112311986Sandreas.sandberg@arm.com if (!src) return false; 112411986Sandreas.sandberg@arm.com else if (src.ptr() == Py_True) { value = true; return true; } 112511986Sandreas.sandberg@arm.com else if (src.ptr() == Py_False) { value = false; return true; } 112612391Sjason@lowepower.com else if (convert || !strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name)) { 112712391Sjason@lowepower.com // (allow non-implicit conversion for numpy booleans) 112812391Sjason@lowepower.com 112912391Sjason@lowepower.com Py_ssize_t res = -1; 113012391Sjason@lowepower.com if (src.is_none()) { 113112391Sjason@lowepower.com res = 0; // None is implicitly converted to False 113212391Sjason@lowepower.com } 113312391Sjason@lowepower.com #if defined(PYPY_VERSION) 113412391Sjason@lowepower.com // On PyPy, check that "__bool__" (or "__nonzero__" on Python 2.7) attr exists 113512391Sjason@lowepower.com else if (hasattr(src, PYBIND11_BOOL_ATTR)) { 113612391Sjason@lowepower.com res = PyObject_IsTrue(src.ptr()); 113712391Sjason@lowepower.com } 113812391Sjason@lowepower.com #else 113912391Sjason@lowepower.com // Alternate approach for CPython: this does the same as the above, but optimized 114012391Sjason@lowepower.com // using the CPython API so as to avoid an unneeded attribute lookup. 114112391Sjason@lowepower.com else if (auto tp_as_number = src.ptr()->ob_type->tp_as_number) { 114212391Sjason@lowepower.com if (PYBIND11_NB_BOOL(tp_as_number)) { 114312391Sjason@lowepower.com res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr()); 114412391Sjason@lowepower.com } 114512391Sjason@lowepower.com } 114612391Sjason@lowepower.com #endif 114712391Sjason@lowepower.com if (res == 0 || res == 1) { 114812391Sjason@lowepower.com value = (bool) res; 114912391Sjason@lowepower.com return true; 115012391Sjason@lowepower.com } 115112391Sjason@lowepower.com } 115212391Sjason@lowepower.com return false; 115311986Sandreas.sandberg@arm.com } 115411986Sandreas.sandberg@arm.com static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) { 115511986Sandreas.sandberg@arm.com return handle(src ? Py_True : Py_False).inc_ref(); 115611986Sandreas.sandberg@arm.com } 115711986Sandreas.sandberg@arm.com PYBIND11_TYPE_CASTER(bool, _("bool")); 115811986Sandreas.sandberg@arm.com}; 115911986Sandreas.sandberg@arm.com 116012037Sandreas.sandberg@arm.com// Helper class for UTF-{8,16,32} C++ stl strings: 116112391Sjason@lowepower.comtemplate <typename StringType, bool IsView = false> struct string_caster { 116212391Sjason@lowepower.com using CharT = typename StringType::value_type; 116312391Sjason@lowepower.com 116412037Sandreas.sandberg@arm.com // Simplify life by being able to assume standard char sizes (the standard only guarantees 116512391Sjason@lowepower.com // minimums, but Python requires exact sizes) 116612037Sandreas.sandberg@arm.com static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1"); 116712037Sandreas.sandberg@arm.com static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2"); 116812037Sandreas.sandberg@arm.com static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4"); 116912037Sandreas.sandberg@arm.com // wchar_t can be either 16 bits (Windows) or 32 (everywhere else) 117012037Sandreas.sandberg@arm.com static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4, 117112037Sandreas.sandberg@arm.com "Unsupported wchar_t size != 2/4"); 117212037Sandreas.sandberg@arm.com static constexpr size_t UTF_N = 8 * sizeof(CharT); 117312037Sandreas.sandberg@arm.com 117411986Sandreas.sandberg@arm.com bool load(handle src, bool) { 117512037Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION < 3 117611986Sandreas.sandberg@arm.com object temp; 117712037Sandreas.sandberg@arm.com#endif 117811986Sandreas.sandberg@arm.com handle load_src = src; 117911986Sandreas.sandberg@arm.com if (!src) { 118011986Sandreas.sandberg@arm.com return false; 118111986Sandreas.sandberg@arm.com } else if (!PyUnicode_Check(load_src.ptr())) { 118212037Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION >= 3 118312391Sjason@lowepower.com return load_bytes(load_src); 118412391Sjason@lowepower.com#else 118512391Sjason@lowepower.com if (sizeof(CharT) == 1) { 118612391Sjason@lowepower.com return load_bytes(load_src); 118712391Sjason@lowepower.com } 118812391Sjason@lowepower.com 118912037Sandreas.sandberg@arm.com // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false 119012037Sandreas.sandberg@arm.com if (!PYBIND11_BYTES_CHECK(load_src.ptr())) 119112037Sandreas.sandberg@arm.com return false; 119212391Sjason@lowepower.com 119311986Sandreas.sandberg@arm.com temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr())); 119411986Sandreas.sandberg@arm.com if (!temp) { PyErr_Clear(); return false; } 119511986Sandreas.sandberg@arm.com load_src = temp; 119612037Sandreas.sandberg@arm.com#endif 119711986Sandreas.sandberg@arm.com } 119812037Sandreas.sandberg@arm.com 119912037Sandreas.sandberg@arm.com object utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString( 120012037Sandreas.sandberg@arm.com load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr)); 120112037Sandreas.sandberg@arm.com if (!utfNbytes) { PyErr_Clear(); return false; } 120212037Sandreas.sandberg@arm.com 120312037Sandreas.sandberg@arm.com const CharT *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr())); 120412037Sandreas.sandberg@arm.com size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT); 120512037Sandreas.sandberg@arm.com if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32 120612037Sandreas.sandberg@arm.com value = StringType(buffer, length); 120712391Sjason@lowepower.com 120812391Sjason@lowepower.com // If we're loading a string_view we need to keep the encoded Python object alive: 120912391Sjason@lowepower.com if (IsView) 121012391Sjason@lowepower.com loader_life_support::add_patient(utfNbytes); 121112391Sjason@lowepower.com 121211986Sandreas.sandberg@arm.com return true; 121311986Sandreas.sandberg@arm.com } 121411986Sandreas.sandberg@arm.com 121512037Sandreas.sandberg@arm.com static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) { 121612391Sjason@lowepower.com const char *buffer = reinterpret_cast<const char *>(src.data()); 121712037Sandreas.sandberg@arm.com ssize_t nbytes = ssize_t(src.size() * sizeof(CharT)); 121812037Sandreas.sandberg@arm.com handle s = decode_utfN(buffer, nbytes); 121912037Sandreas.sandberg@arm.com if (!s) throw error_already_set(); 122012037Sandreas.sandberg@arm.com return s; 122111986Sandreas.sandberg@arm.com } 122211986Sandreas.sandberg@arm.com 122312037Sandreas.sandberg@arm.com PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME)); 122412037Sandreas.sandberg@arm.com 122512037Sandreas.sandberg@arm.comprivate: 122612037Sandreas.sandberg@arm.com static handle decode_utfN(const char *buffer, ssize_t nbytes) { 122712037Sandreas.sandberg@arm.com#if !defined(PYPY_VERSION) 122812037Sandreas.sandberg@arm.com return 122912037Sandreas.sandberg@arm.com UTF_N == 8 ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) : 123012037Sandreas.sandberg@arm.com UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) : 123112037Sandreas.sandberg@arm.com PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr); 123212037Sandreas.sandberg@arm.com#else 123312037Sandreas.sandberg@arm.com // PyPy seems to have multiple problems related to PyUnicode_UTF*: the UTF8 version 123412037Sandreas.sandberg@arm.com // sometimes segfaults for unknown reasons, while the UTF16 and 32 versions require a 123514299Sbbruce@ucdavis.edu // non-const char * arguments, which is also a nuisance, so bypass the whole thing by just 123612037Sandreas.sandberg@arm.com // passing the encoding as a string value, which works properly: 123712037Sandreas.sandberg@arm.com return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr); 123812037Sandreas.sandberg@arm.com#endif 123912037Sandreas.sandberg@arm.com } 124012391Sjason@lowepower.com 124112391Sjason@lowepower.com // When loading into a std::string or char*, accept a bytes object as-is (i.e. 124212391Sjason@lowepower.com // without any encoding/decoding attempt). For other C++ char sizes this is a no-op. 124312391Sjason@lowepower.com // which supports loading a unicode from a str, doesn't take this path. 124412391Sjason@lowepower.com template <typename C = CharT> 124512391Sjason@lowepower.com bool load_bytes(enable_if_t<sizeof(C) == 1, handle> src) { 124612391Sjason@lowepower.com if (PYBIND11_BYTES_CHECK(src.ptr())) { 124712391Sjason@lowepower.com // We were passed a Python 3 raw bytes; accept it into a std::string or char* 124812391Sjason@lowepower.com // without any encoding attempt. 124912391Sjason@lowepower.com const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr()); 125012391Sjason@lowepower.com if (bytes) { 125112391Sjason@lowepower.com value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr())); 125212391Sjason@lowepower.com return true; 125312391Sjason@lowepower.com } 125412391Sjason@lowepower.com } 125512391Sjason@lowepower.com 125612391Sjason@lowepower.com return false; 125712391Sjason@lowepower.com } 125812391Sjason@lowepower.com 125912391Sjason@lowepower.com template <typename C = CharT> 126012391Sjason@lowepower.com bool load_bytes(enable_if_t<sizeof(C) != 1, handle>) { return false; } 126111986Sandreas.sandberg@arm.com}; 126211986Sandreas.sandberg@arm.com 126312391Sjason@lowepower.comtemplate <typename CharT, class Traits, class Allocator> 126412391Sjason@lowepower.comstruct type_caster<std::basic_string<CharT, Traits, Allocator>, enable_if_t<is_std_char_type<CharT>::value>> 126512391Sjason@lowepower.com : string_caster<std::basic_string<CharT, Traits, Allocator>> {}; 126612391Sjason@lowepower.com 126712391Sjason@lowepower.com#ifdef PYBIND11_HAS_STRING_VIEW 126812391Sjason@lowepower.comtemplate <typename CharT, class Traits> 126912391Sjason@lowepower.comstruct type_caster<std::basic_string_view<CharT, Traits>, enable_if_t<is_std_char_type<CharT>::value>> 127012391Sjason@lowepower.com : string_caster<std::basic_string_view<CharT, Traits>, true> {}; 127112391Sjason@lowepower.com#endif 127212391Sjason@lowepower.com 127312037Sandreas.sandberg@arm.com// Type caster for C-style strings. We basically use a std::string type caster, but also add the 127412037Sandreas.sandberg@arm.com// ability to use None as a nullptr char* (which the string caster doesn't allow). 127512037Sandreas.sandberg@arm.comtemplate <typename CharT> struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> { 127612037Sandreas.sandberg@arm.com using StringType = std::basic_string<CharT>; 127712037Sandreas.sandberg@arm.com using StringCaster = type_caster<StringType>; 127812037Sandreas.sandberg@arm.com StringCaster str_caster; 127912037Sandreas.sandberg@arm.com bool none = false; 128014299Sbbruce@ucdavis.edu CharT one_char = 0; 128111986Sandreas.sandberg@arm.compublic: 128211986Sandreas.sandberg@arm.com bool load(handle src, bool convert) { 128312037Sandreas.sandberg@arm.com if (!src) return false; 128412037Sandreas.sandberg@arm.com if (src.is_none()) { 128512037Sandreas.sandberg@arm.com // Defer accepting None to other overloads (if we aren't in convert mode): 128612037Sandreas.sandberg@arm.com if (!convert) return false; 128712037Sandreas.sandberg@arm.com none = true; 128812037Sandreas.sandberg@arm.com return true; 128912037Sandreas.sandberg@arm.com } 129012037Sandreas.sandberg@arm.com return str_caster.load(src, convert); 129111986Sandreas.sandberg@arm.com } 129211986Sandreas.sandberg@arm.com 129312037Sandreas.sandberg@arm.com static handle cast(const CharT *src, return_value_policy policy, handle parent) { 129412037Sandreas.sandberg@arm.com if (src == nullptr) return pybind11::none().inc_ref(); 129512037Sandreas.sandberg@arm.com return StringCaster::cast(StringType(src), policy, parent); 129611986Sandreas.sandberg@arm.com } 129711986Sandreas.sandberg@arm.com 129812037Sandreas.sandberg@arm.com static handle cast(CharT src, return_value_policy policy, handle parent) { 129912037Sandreas.sandberg@arm.com if (std::is_same<char, CharT>::value) { 130012037Sandreas.sandberg@arm.com handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr); 130112037Sandreas.sandberg@arm.com if (!s) throw error_already_set(); 130212037Sandreas.sandberg@arm.com return s; 130312037Sandreas.sandberg@arm.com } 130412037Sandreas.sandberg@arm.com return StringCaster::cast(StringType(1, src), policy, parent); 130511986Sandreas.sandberg@arm.com } 130611986Sandreas.sandberg@arm.com 130712037Sandreas.sandberg@arm.com operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); } 130814299Sbbruce@ucdavis.edu operator CharT&() { 130912037Sandreas.sandberg@arm.com if (none) 131012037Sandreas.sandberg@arm.com throw value_error("Cannot convert None to a character"); 131112037Sandreas.sandberg@arm.com 131212037Sandreas.sandberg@arm.com auto &value = static_cast<StringType &>(str_caster); 131312037Sandreas.sandberg@arm.com size_t str_len = value.size(); 131412037Sandreas.sandberg@arm.com if (str_len == 0) 131512037Sandreas.sandberg@arm.com throw value_error("Cannot convert empty string to a character"); 131612037Sandreas.sandberg@arm.com 131712037Sandreas.sandberg@arm.com // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that 131812037Sandreas.sandberg@arm.com // is too high, and one for multiple unicode characters (caught later), so we need to figure 131912037Sandreas.sandberg@arm.com // out how long the first encoded character is in bytes to distinguish between these two 132012037Sandreas.sandberg@arm.com // errors. We also allow want to allow unicode characters U+0080 through U+00FF, as those 132112037Sandreas.sandberg@arm.com // can fit into a single char value. 132212037Sandreas.sandberg@arm.com if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) { 132312037Sandreas.sandberg@arm.com unsigned char v0 = static_cast<unsigned char>(value[0]); 132412037Sandreas.sandberg@arm.com size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127 132512037Sandreas.sandberg@arm.com (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence 132612037Sandreas.sandberg@arm.com (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence 132712037Sandreas.sandberg@arm.com 4; // 0b11110xxx - start of 4-byte sequence 132812037Sandreas.sandberg@arm.com 132912037Sandreas.sandberg@arm.com if (char0_bytes == str_len) { 133012037Sandreas.sandberg@arm.com // If we have a 128-255 value, we can decode it into a single char: 133112037Sandreas.sandberg@arm.com if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx 133214299Sbbruce@ucdavis.edu one_char = static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F)); 133314299Sbbruce@ucdavis.edu return one_char; 133412037Sandreas.sandberg@arm.com } 133512037Sandreas.sandberg@arm.com // Otherwise we have a single character, but it's > U+00FF 133612037Sandreas.sandberg@arm.com throw value_error("Character code point not in range(0x100)"); 133712037Sandreas.sandberg@arm.com } 133812037Sandreas.sandberg@arm.com } 133912037Sandreas.sandberg@arm.com 134012037Sandreas.sandberg@arm.com // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a 134112037Sandreas.sandberg@arm.com // surrogate pair with total length 2 instantly indicates a range error (but not a "your 134212037Sandreas.sandberg@arm.com // string was too long" error). 134312037Sandreas.sandberg@arm.com else if (StringCaster::UTF_N == 16 && str_len == 2) { 134414299Sbbruce@ucdavis.edu one_char = static_cast<CharT>(value[0]); 134514299Sbbruce@ucdavis.edu if (one_char >= 0xD800 && one_char < 0xE000) 134612037Sandreas.sandberg@arm.com throw value_error("Character code point not in range(0x10000)"); 134712037Sandreas.sandberg@arm.com } 134812037Sandreas.sandberg@arm.com 134912037Sandreas.sandberg@arm.com if (str_len != 1) 135012037Sandreas.sandberg@arm.com throw value_error("Expected a character, but multi-character string found"); 135112037Sandreas.sandberg@arm.com 135214299Sbbruce@ucdavis.edu one_char = value[0]; 135314299Sbbruce@ucdavis.edu return one_char; 135412037Sandreas.sandberg@arm.com } 135511986Sandreas.sandberg@arm.com 135614299Sbbruce@ucdavis.edu static constexpr auto name = _(PYBIND11_STRING_NAME); 135714299Sbbruce@ucdavis.edu template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>; 135811986Sandreas.sandberg@arm.com}; 135911986Sandreas.sandberg@arm.com 136012391Sjason@lowepower.com// Base implementation for std::tuple and std::pair 136112391Sjason@lowepower.comtemplate <template<typename...> class Tuple, typename... Ts> class tuple_caster { 136212391Sjason@lowepower.com using type = Tuple<Ts...>; 136312391Sjason@lowepower.com static constexpr auto size = sizeof...(Ts); 136412391Sjason@lowepower.com using indices = make_index_sequence<size>; 136511986Sandreas.sandberg@arm.compublic: 136611986Sandreas.sandberg@arm.com 136711986Sandreas.sandberg@arm.com bool load(handle src, bool convert) { 136811986Sandreas.sandberg@arm.com if (!isinstance<sequence>(src)) 136911986Sandreas.sandberg@arm.com return false; 137011986Sandreas.sandberg@arm.com const auto seq = reinterpret_borrow<sequence>(src); 137111986Sandreas.sandberg@arm.com if (seq.size() != size) 137211986Sandreas.sandberg@arm.com return false; 137311986Sandreas.sandberg@arm.com return load_impl(seq, convert, indices{}); 137411986Sandreas.sandberg@arm.com } 137511986Sandreas.sandberg@arm.com 137612391Sjason@lowepower.com template <typename T> 137712391Sjason@lowepower.com static handle cast(T &&src, return_value_policy policy, handle parent) { 137812391Sjason@lowepower.com return cast_impl(std::forward<T>(src), policy, parent, indices{}); 137911986Sandreas.sandberg@arm.com } 138011986Sandreas.sandberg@arm.com 138114299Sbbruce@ucdavis.edu static constexpr auto name = _("Tuple[") + concat(make_caster<Ts>::name...) + _("]"); 138211986Sandreas.sandberg@arm.com 138311986Sandreas.sandberg@arm.com template <typename T> using cast_op_type = type; 138411986Sandreas.sandberg@arm.com 138512391Sjason@lowepower.com operator type() & { return implicit_cast(indices{}); } 138612391Sjason@lowepower.com operator type() && { return std::move(*this).implicit_cast(indices{}); } 138711986Sandreas.sandberg@arm.com 138811986Sandreas.sandberg@arm.comprotected: 138911986Sandreas.sandberg@arm.com template <size_t... Is> 139012391Sjason@lowepower.com type implicit_cast(index_sequence<Is...>) & { return type(cast_op<Ts>(std::get<Is>(subcasters))...); } 139112391Sjason@lowepower.com template <size_t... Is> 139212391Sjason@lowepower.com type implicit_cast(index_sequence<Is...>) && { return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...); } 139311986Sandreas.sandberg@arm.com 139411986Sandreas.sandberg@arm.com static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; } 139511986Sandreas.sandberg@arm.com 139611986Sandreas.sandberg@arm.com template <size_t... Is> 139711986Sandreas.sandberg@arm.com bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) { 139812391Sjason@lowepower.com for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...}) 139911986Sandreas.sandberg@arm.com if (!r) 140011986Sandreas.sandberg@arm.com return false; 140111986Sandreas.sandberg@arm.com return true; 140211986Sandreas.sandberg@arm.com } 140311986Sandreas.sandberg@arm.com 140411986Sandreas.sandberg@arm.com /* Implementation: Convert a C++ tuple into a Python tuple */ 140512391Sjason@lowepower.com template <typename T, size_t... Is> 140612391Sjason@lowepower.com static handle cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence<Is...>) { 140712391Sjason@lowepower.com std::array<object, size> entries{{ 140812391Sjason@lowepower.com reinterpret_steal<object>(make_caster<Ts>::cast(std::get<Is>(std::forward<T>(src)), policy, parent))... 140911986Sandreas.sandberg@arm.com }}; 141011986Sandreas.sandberg@arm.com for (const auto &entry: entries) 141111986Sandreas.sandberg@arm.com if (!entry) 141211986Sandreas.sandberg@arm.com return handle(); 141311986Sandreas.sandberg@arm.com tuple result(size); 141411986Sandreas.sandberg@arm.com int counter = 0; 141511986Sandreas.sandberg@arm.com for (auto & entry: entries) 141611986Sandreas.sandberg@arm.com PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr()); 141711986Sandreas.sandberg@arm.com return result.release(); 141811986Sandreas.sandberg@arm.com } 141911986Sandreas.sandberg@arm.com 142012391Sjason@lowepower.com Tuple<make_caster<Ts>...> subcasters; 142111986Sandreas.sandberg@arm.com}; 142211986Sandreas.sandberg@arm.com 142312391Sjason@lowepower.comtemplate <typename T1, typename T2> class type_caster<std::pair<T1, T2>> 142412391Sjason@lowepower.com : public tuple_caster<std::pair, T1, T2> {}; 142512391Sjason@lowepower.com 142612391Sjason@lowepower.comtemplate <typename... Ts> class type_caster<std::tuple<Ts...>> 142712391Sjason@lowepower.com : public tuple_caster<std::tuple, Ts...> {}; 142812391Sjason@lowepower.com 142912037Sandreas.sandberg@arm.com/// Helper class which abstracts away certain actions. Users can provide specializations for 143012037Sandreas.sandberg@arm.com/// custom holders, but it's only necessary if the type has a non-standard interface. 143112037Sandreas.sandberg@arm.comtemplate <typename T> 143212037Sandreas.sandberg@arm.comstruct holder_helper { 143312037Sandreas.sandberg@arm.com static auto get(const T &p) -> decltype(p.get()) { return p.get(); } 143412037Sandreas.sandberg@arm.com}; 143512037Sandreas.sandberg@arm.com 143611986Sandreas.sandberg@arm.com/// Type caster for holder types like std::shared_ptr, etc. 143712037Sandreas.sandberg@arm.comtemplate <typename type, typename holder_type> 143812037Sandreas.sandberg@arm.comstruct copyable_holder_caster : public type_caster_base<type> { 143911986Sandreas.sandberg@arm.compublic: 144011986Sandreas.sandberg@arm.com using base = type_caster_base<type>; 144112391Sjason@lowepower.com static_assert(std::is_base_of<base, type_caster<type>>::value, 144212391Sjason@lowepower.com "Holder classes are only supported for custom types"); 144311986Sandreas.sandberg@arm.com using base::base; 144411986Sandreas.sandberg@arm.com using base::cast; 144511986Sandreas.sandberg@arm.com using base::typeinfo; 144611986Sandreas.sandberg@arm.com using base::value; 144711986Sandreas.sandberg@arm.com 144812391Sjason@lowepower.com bool load(handle src, bool convert) { 144912391Sjason@lowepower.com return base::template load_impl<copyable_holder_caster<type, holder_type>>(src, convert); 145011986Sandreas.sandberg@arm.com } 145111986Sandreas.sandberg@arm.com 145212391Sjason@lowepower.com explicit operator type*() { return this->value; } 145312391Sjason@lowepower.com explicit operator type&() { return *(this->value); } 145414299Sbbruce@ucdavis.edu explicit operator holder_type*() { return std::addressof(holder); } 145511986Sandreas.sandberg@arm.com 145612391Sjason@lowepower.com // Workaround for Intel compiler bug 145712391Sjason@lowepower.com // see pybind11 issue 94 145812391Sjason@lowepower.com #if defined(__ICC) || defined(__INTEL_COMPILER) 145912391Sjason@lowepower.com operator holder_type&() { return holder; } 146012391Sjason@lowepower.com #else 146112391Sjason@lowepower.com explicit operator holder_type&() { return holder; } 146212391Sjason@lowepower.com #endif 146312391Sjason@lowepower.com 146412391Sjason@lowepower.com static handle cast(const holder_type &src, return_value_policy, handle) { 146512391Sjason@lowepower.com const auto *ptr = holder_helper<holder_type>::get(src); 146612391Sjason@lowepower.com return type_caster_base<type>::cast_holder(ptr, &src); 146712391Sjason@lowepower.com } 146812391Sjason@lowepower.com 146912391Sjason@lowepower.comprotected: 147012391Sjason@lowepower.com friend class type_caster_generic; 147112391Sjason@lowepower.com void check_holder_compat() { 147212037Sandreas.sandberg@arm.com if (typeinfo->default_holder) 147312037Sandreas.sandberg@arm.com throw cast_error("Unable to load a custom holder type from a default-holder instance"); 147411986Sandreas.sandberg@arm.com } 147511986Sandreas.sandberg@arm.com 147612391Sjason@lowepower.com bool load_value(value_and_holder &&v_h) { 147712391Sjason@lowepower.com if (v_h.holder_constructed()) { 147812391Sjason@lowepower.com value = v_h.value_ptr(); 147914299Sbbruce@ucdavis.edu holder = v_h.template holder<holder_type>(); 148011986Sandreas.sandberg@arm.com return true; 148111986Sandreas.sandberg@arm.com } else { 148211986Sandreas.sandberg@arm.com throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) " 148311986Sandreas.sandberg@arm.com#if defined(NDEBUG) 148411986Sandreas.sandberg@arm.com "(compile in debug mode for type information)"); 148511986Sandreas.sandberg@arm.com#else 148611986Sandreas.sandberg@arm.com "of type '" + type_id<holder_type>() + "''"); 148711986Sandreas.sandberg@arm.com#endif 148811986Sandreas.sandberg@arm.com } 148911986Sandreas.sandberg@arm.com } 149011986Sandreas.sandberg@arm.com 149111986Sandreas.sandberg@arm.com template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0> 149211986Sandreas.sandberg@arm.com bool try_implicit_casts(handle, bool) { return false; } 149311986Sandreas.sandberg@arm.com 149411986Sandreas.sandberg@arm.com template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0> 149511986Sandreas.sandberg@arm.com bool try_implicit_casts(handle src, bool convert) { 149611986Sandreas.sandberg@arm.com for (auto &cast : typeinfo->implicit_casts) { 149712037Sandreas.sandberg@arm.com copyable_holder_caster sub_caster(*cast.first); 149811986Sandreas.sandberg@arm.com if (sub_caster.load(src, convert)) { 149911986Sandreas.sandberg@arm.com value = cast.second(sub_caster.value); 150011986Sandreas.sandberg@arm.com holder = holder_type(sub_caster.holder, (type *) value); 150111986Sandreas.sandberg@arm.com return true; 150211986Sandreas.sandberg@arm.com } 150311986Sandreas.sandberg@arm.com } 150411986Sandreas.sandberg@arm.com return false; 150511986Sandreas.sandberg@arm.com } 150611986Sandreas.sandberg@arm.com 150712391Sjason@lowepower.com static bool try_direct_conversions(handle) { return false; } 150811986Sandreas.sandberg@arm.com 150911986Sandreas.sandberg@arm.com 151011986Sandreas.sandberg@arm.com holder_type holder; 151111986Sandreas.sandberg@arm.com}; 151211986Sandreas.sandberg@arm.com 151311986Sandreas.sandberg@arm.com/// Specialize for the common std::shared_ptr, so users don't need to 151411986Sandreas.sandberg@arm.comtemplate <typename T> 151512037Sandreas.sandberg@arm.comclass type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { }; 151612037Sandreas.sandberg@arm.com 151712037Sandreas.sandberg@arm.comtemplate <typename type, typename holder_type> 151812037Sandreas.sandberg@arm.comstruct move_only_holder_caster { 151912391Sjason@lowepower.com static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value, 152012391Sjason@lowepower.com "Holder classes are only supported for custom types"); 152112391Sjason@lowepower.com 152212037Sandreas.sandberg@arm.com static handle cast(holder_type &&src, return_value_policy, handle) { 152312037Sandreas.sandberg@arm.com auto *ptr = holder_helper<holder_type>::get(src); 152414299Sbbruce@ucdavis.edu return type_caster_base<type>::cast_holder(ptr, std::addressof(src)); 152512037Sandreas.sandberg@arm.com } 152614299Sbbruce@ucdavis.edu static constexpr auto name = type_caster_base<type>::name; 152712037Sandreas.sandberg@arm.com}; 152812037Sandreas.sandberg@arm.com 152912037Sandreas.sandberg@arm.comtemplate <typename type, typename deleter> 153012037Sandreas.sandberg@arm.comclass type_caster<std::unique_ptr<type, deleter>> 153112037Sandreas.sandberg@arm.com : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { }; 153212037Sandreas.sandberg@arm.com 153312037Sandreas.sandberg@arm.comtemplate <typename type, typename holder_type> 153412391Sjason@lowepower.comusing type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value, 153512037Sandreas.sandberg@arm.com copyable_holder_caster<type, holder_type>, 153612037Sandreas.sandberg@arm.com move_only_holder_caster<type, holder_type>>; 153712037Sandreas.sandberg@arm.com 153812037Sandreas.sandberg@arm.comtemplate <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; }; 153911986Sandreas.sandberg@arm.com 154011986Sandreas.sandberg@arm.com/// Create a specialization for custom holder types (silently ignores std::shared_ptr) 154112037Sandreas.sandberg@arm.com#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \ 154211986Sandreas.sandberg@arm.com namespace pybind11 { namespace detail { \ 154311986Sandreas.sandberg@arm.com template <typename type> \ 154412037Sandreas.sandberg@arm.com struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__> { }; \ 154512037Sandreas.sandberg@arm.com template <typename type> \ 154611986Sandreas.sandberg@arm.com class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \ 154711986Sandreas.sandberg@arm.com : public type_caster_holder<type, holder_type> { }; \ 154811986Sandreas.sandberg@arm.com }} 154911986Sandreas.sandberg@arm.com 155011986Sandreas.sandberg@arm.com// PYBIND11_DECLARE_HOLDER_TYPE holder types: 155111986Sandreas.sandberg@arm.comtemplate <typename base, typename holder> struct is_holder_type : 155211986Sandreas.sandberg@arm.com std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {}; 155311986Sandreas.sandberg@arm.com// Specialization for always-supported unique_ptr holders: 155411986Sandreas.sandberg@arm.comtemplate <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> : 155511986Sandreas.sandberg@arm.com std::true_type {}; 155611986Sandreas.sandberg@arm.com 155714299Sbbruce@ucdavis.edutemplate <typename T> struct handle_type_name { static constexpr auto name = _<T>(); }; 155814299Sbbruce@ucdavis.edutemplate <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); }; 155914299Sbbruce@ucdavis.edutemplate <> struct handle_type_name<args> { static constexpr auto name = _("*args"); }; 156014299Sbbruce@ucdavis.edutemplate <> struct handle_type_name<kwargs> { static constexpr auto name = _("**kwargs"); }; 156111986Sandreas.sandberg@arm.com 156211986Sandreas.sandberg@arm.comtemplate <typename type> 156311986Sandreas.sandberg@arm.comstruct pyobject_caster { 156411986Sandreas.sandberg@arm.com template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0> 156511986Sandreas.sandberg@arm.com bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); } 156611986Sandreas.sandberg@arm.com 156711986Sandreas.sandberg@arm.com template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0> 156811986Sandreas.sandberg@arm.com bool load(handle src, bool /* convert */) { 156911986Sandreas.sandberg@arm.com if (!isinstance<type>(src)) 157011986Sandreas.sandberg@arm.com return false; 157111986Sandreas.sandberg@arm.com value = reinterpret_borrow<type>(src); 157211986Sandreas.sandberg@arm.com return true; 157311986Sandreas.sandberg@arm.com } 157411986Sandreas.sandberg@arm.com 157511986Sandreas.sandberg@arm.com static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) { 157611986Sandreas.sandberg@arm.com return src.inc_ref(); 157711986Sandreas.sandberg@arm.com } 157814299Sbbruce@ucdavis.edu PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name); 157911986Sandreas.sandberg@arm.com}; 158011986Sandreas.sandberg@arm.com 158111986Sandreas.sandberg@arm.comtemplate <typename T> 158211986Sandreas.sandberg@arm.comclass type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { }; 158311986Sandreas.sandberg@arm.com 158411986Sandreas.sandberg@arm.com// Our conditions for enabling moving are quite restrictive: 158511986Sandreas.sandberg@arm.com// At compile time: 158611986Sandreas.sandberg@arm.com// - T needs to be a non-const, non-pointer, non-reference type 158711986Sandreas.sandberg@arm.com// - type_caster<T>::operator T&() must exist 158811986Sandreas.sandberg@arm.com// - the type must be move constructible (obviously) 158911986Sandreas.sandberg@arm.com// At run-time: 159011986Sandreas.sandberg@arm.com// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it 159111986Sandreas.sandberg@arm.com// must have ref_count() == 1)h 159211986Sandreas.sandberg@arm.com// If any of the above are not satisfied, we fall back to copying. 159312037Sandreas.sandberg@arm.comtemplate <typename T> using move_is_plain_type = satisfies_none_of<T, 159412037Sandreas.sandberg@arm.com std::is_void, std::is_pointer, std::is_reference, std::is_const 159512037Sandreas.sandberg@arm.com>; 159611986Sandreas.sandberg@arm.comtemplate <typename T, typename SFINAE = void> struct move_always : std::false_type {}; 159712037Sandreas.sandberg@arm.comtemplate <typename T> struct move_always<T, enable_if_t<all_of< 159812037Sandreas.sandberg@arm.com move_is_plain_type<T>, 159912391Sjason@lowepower.com negation<is_copy_constructible<T>>, 160012037Sandreas.sandberg@arm.com std::is_move_constructible<T>, 160112037Sandreas.sandberg@arm.com std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&> 160212037Sandreas.sandberg@arm.com>::value>> : std::true_type {}; 160311986Sandreas.sandberg@arm.comtemplate <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {}; 160412037Sandreas.sandberg@arm.comtemplate <typename T> struct move_if_unreferenced<T, enable_if_t<all_of< 160512037Sandreas.sandberg@arm.com move_is_plain_type<T>, 160612037Sandreas.sandberg@arm.com negation<move_always<T>>, 160712037Sandreas.sandberg@arm.com std::is_move_constructible<T>, 160812037Sandreas.sandberg@arm.com std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&> 160912037Sandreas.sandberg@arm.com>::value>> : std::true_type {}; 161012037Sandreas.sandberg@arm.comtemplate <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>; 161111986Sandreas.sandberg@arm.com 161211986Sandreas.sandberg@arm.com// Detect whether returning a `type` from a cast on type's type_caster is going to result in a 161311986Sandreas.sandberg@arm.com// reference or pointer to a local variable of the type_caster. Basically, only 161411986Sandreas.sandberg@arm.com// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe; 161511986Sandreas.sandberg@arm.com// everything else returns a reference/pointer to a local variable. 161611986Sandreas.sandberg@arm.comtemplate <typename type> using cast_is_temporary_value_reference = bool_constant< 161711986Sandreas.sandberg@arm.com (std::is_reference<type>::value || std::is_pointer<type>::value) && 161814299Sbbruce@ucdavis.edu !std::is_base_of<type_caster_generic, make_caster<type>>::value && 161914299Sbbruce@ucdavis.edu !std::is_same<intrinsic_t<type>, void>::value 162011986Sandreas.sandberg@arm.com>; 162111986Sandreas.sandberg@arm.com 162212037Sandreas.sandberg@arm.com// When a value returned from a C++ function is being cast back to Python, we almost always want to 162312037Sandreas.sandberg@arm.com// force `policy = move`, regardless of the return value policy the function/method was declared 162414299Sbbruce@ucdavis.edu// with. 162512037Sandreas.sandberg@arm.comtemplate <typename Return, typename SFINAE = void> struct return_value_policy_override { 162614299Sbbruce@ucdavis.edu static return_value_policy policy(return_value_policy p) { return p; } 162714299Sbbruce@ucdavis.edu}; 162814299Sbbruce@ucdavis.edu 162914299Sbbruce@ucdavis.edutemplate <typename Return> struct return_value_policy_override<Return, 163014299Sbbruce@ucdavis.edu detail::enable_if_t<std::is_base_of<type_caster_generic, make_caster<Return>>::value, void>> { 163112037Sandreas.sandberg@arm.com static return_value_policy policy(return_value_policy p) { 163214299Sbbruce@ucdavis.edu return !std::is_lvalue_reference<Return>::value && 163314299Sbbruce@ucdavis.edu !std::is_pointer<Return>::value 163414299Sbbruce@ucdavis.edu ? return_value_policy::move : p; 163512037Sandreas.sandberg@arm.com } 163612037Sandreas.sandberg@arm.com}; 163712037Sandreas.sandberg@arm.com 163811986Sandreas.sandberg@arm.com// Basic python -> C++ casting; throws if casting fails 163911986Sandreas.sandberg@arm.comtemplate <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) { 164011986Sandreas.sandberg@arm.com if (!conv.load(handle, true)) { 164111986Sandreas.sandberg@arm.com#if defined(NDEBUG) 164211986Sandreas.sandberg@arm.com throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)"); 164311986Sandreas.sandberg@arm.com#else 164411986Sandreas.sandberg@arm.com throw cast_error("Unable to cast Python instance of type " + 164514299Sbbruce@ucdavis.edu (std::string) str(handle.get_type()) + " to C++ type '" + type_id<T>() + "'"); 164611986Sandreas.sandberg@arm.com#endif 164711986Sandreas.sandberg@arm.com } 164811986Sandreas.sandberg@arm.com return conv; 164911986Sandreas.sandberg@arm.com} 165011986Sandreas.sandberg@arm.com// Wrapper around the above that also constructs and returns a type_caster 165111986Sandreas.sandberg@arm.comtemplate <typename T> make_caster<T> load_type(const handle &handle) { 165211986Sandreas.sandberg@arm.com make_caster<T> conv; 165311986Sandreas.sandberg@arm.com load_type(conv, handle); 165411986Sandreas.sandberg@arm.com return conv; 165511986Sandreas.sandberg@arm.com} 165611986Sandreas.sandberg@arm.com 165711986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 165811986Sandreas.sandberg@arm.com 165911986Sandreas.sandberg@arm.com// pytype -> C++ type 166011986Sandreas.sandberg@arm.comtemplate <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0> 166111986Sandreas.sandberg@arm.comT cast(const handle &handle) { 166211986Sandreas.sandberg@arm.com using namespace detail; 166311986Sandreas.sandberg@arm.com static_assert(!cast_is_temporary_value_reference<T>::value, 166411986Sandreas.sandberg@arm.com "Unable to cast type to reference: value is local to type caster"); 166511986Sandreas.sandberg@arm.com return cast_op<T>(load_type<T>(handle)); 166611986Sandreas.sandberg@arm.com} 166711986Sandreas.sandberg@arm.com 166811986Sandreas.sandberg@arm.com// pytype -> pytype (calls converting constructor) 166911986Sandreas.sandberg@arm.comtemplate <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0> 167011986Sandreas.sandberg@arm.comT cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); } 167111986Sandreas.sandberg@arm.com 167211986Sandreas.sandberg@arm.com// C++ type -> py::object 167311986Sandreas.sandberg@arm.comtemplate <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0> 167411986Sandreas.sandberg@arm.comobject cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference, 167511986Sandreas.sandberg@arm.com handle parent = handle()) { 167611986Sandreas.sandberg@arm.com if (policy == return_value_policy::automatic) 167711986Sandreas.sandberg@arm.com policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy; 167811986Sandreas.sandberg@arm.com else if (policy == return_value_policy::automatic_reference) 167911986Sandreas.sandberg@arm.com policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy; 168011986Sandreas.sandberg@arm.com return reinterpret_steal<object>(detail::make_caster<T>::cast(value, policy, parent)); 168111986Sandreas.sandberg@arm.com} 168211986Sandreas.sandberg@arm.com 168311986Sandreas.sandberg@arm.comtemplate <typename T> T handle::cast() const { return pybind11::cast<T>(*this); } 168411986Sandreas.sandberg@arm.comtemplate <> inline void handle::cast() const { return; } 168511986Sandreas.sandberg@arm.com 168611986Sandreas.sandberg@arm.comtemplate <typename T> 168712037Sandreas.sandberg@arm.comdetail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) { 168811986Sandreas.sandberg@arm.com if (obj.ref_count() > 1) 168911986Sandreas.sandberg@arm.com#if defined(NDEBUG) 169011986Sandreas.sandberg@arm.com throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references" 169111986Sandreas.sandberg@arm.com " (compile in debug mode for details)"); 169211986Sandreas.sandberg@arm.com#else 169311986Sandreas.sandberg@arm.com throw cast_error("Unable to move from Python " + (std::string) str(obj.get_type()) + 169411986Sandreas.sandberg@arm.com " instance to C++ " + type_id<T>() + " instance: instance has multiple references"); 169511986Sandreas.sandberg@arm.com#endif 169611986Sandreas.sandberg@arm.com 169711986Sandreas.sandberg@arm.com // Move into a temporary and return that, because the reference may be a local value of `conv` 169811986Sandreas.sandberg@arm.com T ret = std::move(detail::load_type<T>(obj).operator T&()); 169911986Sandreas.sandberg@arm.com return ret; 170011986Sandreas.sandberg@arm.com} 170111986Sandreas.sandberg@arm.com 170211986Sandreas.sandberg@arm.com// Calling cast() on an rvalue calls pybind::cast with the object rvalue, which does: 170311986Sandreas.sandberg@arm.com// - If we have to move (because T has no copy constructor), do it. This will fail if the moved 170411986Sandreas.sandberg@arm.com// object has multiple references, but trying to copy will fail to compile. 170511986Sandreas.sandberg@arm.com// - If both movable and copyable, check ref count: if 1, move; otherwise copy 170611986Sandreas.sandberg@arm.com// - Otherwise (not movable), copy. 170711986Sandreas.sandberg@arm.comtemplate <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) { 170811986Sandreas.sandberg@arm.com return move<T>(std::move(object)); 170911986Sandreas.sandberg@arm.com} 171011986Sandreas.sandberg@arm.comtemplate <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) { 171111986Sandreas.sandberg@arm.com if (object.ref_count() > 1) 171211986Sandreas.sandberg@arm.com return cast<T>(object); 171311986Sandreas.sandberg@arm.com else 171411986Sandreas.sandberg@arm.com return move<T>(std::move(object)); 171511986Sandreas.sandberg@arm.com} 171611986Sandreas.sandberg@arm.comtemplate <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) { 171711986Sandreas.sandberg@arm.com return cast<T>(object); 171811986Sandreas.sandberg@arm.com} 171911986Sandreas.sandberg@arm.com 172011986Sandreas.sandberg@arm.comtemplate <typename T> T object::cast() const & { return pybind11::cast<T>(*this); } 172111986Sandreas.sandberg@arm.comtemplate <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); } 172211986Sandreas.sandberg@arm.comtemplate <> inline void object::cast() const & { return; } 172311986Sandreas.sandberg@arm.comtemplate <> inline void object::cast() && { return; } 172411986Sandreas.sandberg@arm.com 172511986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 172611986Sandreas.sandberg@arm.com 172711986Sandreas.sandberg@arm.com// Declared in pytypes.h: 172811986Sandreas.sandberg@arm.comtemplate <typename T, enable_if_t<!is_pyobject<T>::value, int>> 172911986Sandreas.sandberg@arm.comobject object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); } 173011986Sandreas.sandberg@arm.com 173111986Sandreas.sandberg@arm.comstruct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro 173211986Sandreas.sandberg@arm.comtemplate <typename ret_type> using overload_caster_t = conditional_t< 173311986Sandreas.sandberg@arm.com cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>; 173411986Sandreas.sandberg@arm.com 173511986Sandreas.sandberg@arm.com// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then 173611986Sandreas.sandberg@arm.com// store the result in the given variable. For other types, this is a no-op. 173711986Sandreas.sandberg@arm.comtemplate <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) { 173811986Sandreas.sandberg@arm.com return cast_op<T>(load_type(caster, o)); 173911986Sandreas.sandberg@arm.com} 174011986Sandreas.sandberg@arm.comtemplate <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) { 174111986Sandreas.sandberg@arm.com pybind11_fail("Internal error: cast_ref fallback invoked"); } 174211986Sandreas.sandberg@arm.com 174311986Sandreas.sandberg@arm.com// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even 174411986Sandreas.sandberg@arm.com// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in 174511986Sandreas.sandberg@arm.com// cases where pybind11::cast is valid. 174611986Sandreas.sandberg@arm.comtemplate <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) { 174711986Sandreas.sandberg@arm.com return pybind11::cast<T>(std::move(o)); } 174811986Sandreas.sandberg@arm.comtemplate <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) { 174911986Sandreas.sandberg@arm.com pybind11_fail("Internal error: cast_safe fallback invoked"); } 175011986Sandreas.sandberg@arm.comtemplate <> inline void cast_safe<void>(object &&) {} 175111986Sandreas.sandberg@arm.com 175211986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 175311986Sandreas.sandberg@arm.com 175414299Sbbruce@ucdavis.edutemplate <return_value_policy policy = return_value_policy::automatic_reference> 175514299Sbbruce@ucdavis.edutuple make_tuple() { return tuple(0); } 175614299Sbbruce@ucdavis.edu 175711986Sandreas.sandberg@arm.comtemplate <return_value_policy policy = return_value_policy::automatic_reference, 175811986Sandreas.sandberg@arm.com typename... Args> tuple make_tuple(Args&&... args_) { 175912391Sjason@lowepower.com constexpr size_t size = sizeof...(Args); 176011986Sandreas.sandberg@arm.com std::array<object, size> args { 176111986Sandreas.sandberg@arm.com { reinterpret_steal<object>(detail::make_caster<Args>::cast( 176211986Sandreas.sandberg@arm.com std::forward<Args>(args_), policy, nullptr))... } 176311986Sandreas.sandberg@arm.com }; 176412391Sjason@lowepower.com for (size_t i = 0; i < args.size(); i++) { 176512391Sjason@lowepower.com if (!args[i]) { 176611986Sandreas.sandberg@arm.com#if defined(NDEBUG) 176711986Sandreas.sandberg@arm.com throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)"); 176811986Sandreas.sandberg@arm.com#else 176912391Sjason@lowepower.com std::array<std::string, size> argtypes { {type_id<Args>()...} }; 177012391Sjason@lowepower.com throw cast_error("make_tuple(): unable to convert argument of type '" + 177112391Sjason@lowepower.com argtypes[i] + "' to Python object"); 177211986Sandreas.sandberg@arm.com#endif 177311986Sandreas.sandberg@arm.com } 177411986Sandreas.sandberg@arm.com } 177511986Sandreas.sandberg@arm.com tuple result(size); 177611986Sandreas.sandberg@arm.com int counter = 0; 177711986Sandreas.sandberg@arm.com for (auto &arg_value : args) 177811986Sandreas.sandberg@arm.com PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr()); 177911986Sandreas.sandberg@arm.com return result; 178011986Sandreas.sandberg@arm.com} 178111986Sandreas.sandberg@arm.com 178212037Sandreas.sandberg@arm.com/// \ingroup annotations 178312037Sandreas.sandberg@arm.com/// Annotation for arguments 178411986Sandreas.sandberg@arm.comstruct arg { 178512037Sandreas.sandberg@arm.com /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument. 178612391Sjason@lowepower.com constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { } 178712037Sandreas.sandberg@arm.com /// Assign a value to this argument 178811986Sandreas.sandberg@arm.com template <typename T> arg_v operator=(T &&value) const; 178912037Sandreas.sandberg@arm.com /// Indicate that the type should not be converted in the type caster 179012037Sandreas.sandberg@arm.com arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; } 179112391Sjason@lowepower.com /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args) 179212391Sjason@lowepower.com arg &none(bool flag = true) { flag_none = flag; return *this; } 179311986Sandreas.sandberg@arm.com 179412037Sandreas.sandberg@arm.com const char *name; ///< If non-null, this is a named kwargs argument 179512037Sandreas.sandberg@arm.com bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!) 179612391Sjason@lowepower.com bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument 179711986Sandreas.sandberg@arm.com}; 179811986Sandreas.sandberg@arm.com 179912037Sandreas.sandberg@arm.com/// \ingroup annotations 180012037Sandreas.sandberg@arm.com/// Annotation for arguments with values 180111986Sandreas.sandberg@arm.comstruct arg_v : arg { 180212037Sandreas.sandberg@arm.comprivate: 180311986Sandreas.sandberg@arm.com template <typename T> 180412037Sandreas.sandberg@arm.com arg_v(arg &&base, T &&x, const char *descr = nullptr) 180512037Sandreas.sandberg@arm.com : arg(base), 180611986Sandreas.sandberg@arm.com value(reinterpret_steal<object>( 180711986Sandreas.sandberg@arm.com detail::make_caster<T>::cast(x, return_value_policy::automatic, {}) 180811986Sandreas.sandberg@arm.com )), 180911986Sandreas.sandberg@arm.com descr(descr) 181011986Sandreas.sandberg@arm.com#if !defined(NDEBUG) 181111986Sandreas.sandberg@arm.com , type(type_id<T>()) 181211986Sandreas.sandberg@arm.com#endif 181311986Sandreas.sandberg@arm.com { } 181411986Sandreas.sandberg@arm.com 181512037Sandreas.sandberg@arm.compublic: 181612037Sandreas.sandberg@arm.com /// Direct construction with name, default, and description 181712037Sandreas.sandberg@arm.com template <typename T> 181812037Sandreas.sandberg@arm.com arg_v(const char *name, T &&x, const char *descr = nullptr) 181912037Sandreas.sandberg@arm.com : arg_v(arg(name), std::forward<T>(x), descr) { } 182012037Sandreas.sandberg@arm.com 182112037Sandreas.sandberg@arm.com /// Called internally when invoking `py::arg("a") = value` 182212037Sandreas.sandberg@arm.com template <typename T> 182312037Sandreas.sandberg@arm.com arg_v(const arg &base, T &&x, const char *descr = nullptr) 182412037Sandreas.sandberg@arm.com : arg_v(arg(base), std::forward<T>(x), descr) { } 182512037Sandreas.sandberg@arm.com 182612037Sandreas.sandberg@arm.com /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg& 182712037Sandreas.sandberg@arm.com arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; } 182812037Sandreas.sandberg@arm.com 182912391Sjason@lowepower.com /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg& 183012391Sjason@lowepower.com arg_v &none(bool flag = true) { arg::none(flag); return *this; } 183112391Sjason@lowepower.com 183212037Sandreas.sandberg@arm.com /// The default value 183311986Sandreas.sandberg@arm.com object value; 183412037Sandreas.sandberg@arm.com /// The (optional) description of the default value 183511986Sandreas.sandberg@arm.com const char *descr; 183611986Sandreas.sandberg@arm.com#if !defined(NDEBUG) 183712037Sandreas.sandberg@arm.com /// The C++ type name of the default value (only available when compiled in debug mode) 183811986Sandreas.sandberg@arm.com std::string type; 183911986Sandreas.sandberg@arm.com#endif 184011986Sandreas.sandberg@arm.com}; 184111986Sandreas.sandberg@arm.com 184211986Sandreas.sandberg@arm.comtemplate <typename T> 184312037Sandreas.sandberg@arm.comarg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward<T>(value)}; } 184411986Sandreas.sandberg@arm.com 184511986Sandreas.sandberg@arm.com/// Alias for backward compatibility -- to be removed in version 2.0 184611986Sandreas.sandberg@arm.comtemplate <typename /*unused*/> using arg_t = arg_v; 184711986Sandreas.sandberg@arm.com 184811986Sandreas.sandberg@arm.cominline namespace literals { 184912037Sandreas.sandberg@arm.com/** \rst 185012037Sandreas.sandberg@arm.com String literal version of `arg` 185112037Sandreas.sandberg@arm.com \endrst */ 185211986Sandreas.sandberg@arm.comconstexpr arg operator"" _a(const char *name, size_t) { return arg(name); } 185311986Sandreas.sandberg@arm.com} 185411986Sandreas.sandberg@arm.com 185511986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 185611986Sandreas.sandberg@arm.com 185712391Sjason@lowepower.com// forward declaration (definition in attr.h) 185812037Sandreas.sandberg@arm.comstruct function_record; 185912037Sandreas.sandberg@arm.com 186012037Sandreas.sandberg@arm.com/// Internal data associated with a single function call 186112037Sandreas.sandberg@arm.comstruct function_call { 186214299Sbbruce@ucdavis.edu function_call(const function_record &f, handle p); // Implementation in attr.h 186312037Sandreas.sandberg@arm.com 186412037Sandreas.sandberg@arm.com /// The function data: 186512037Sandreas.sandberg@arm.com const function_record &func; 186612037Sandreas.sandberg@arm.com 186712037Sandreas.sandberg@arm.com /// Arguments passed to the function: 186812037Sandreas.sandberg@arm.com std::vector<handle> args; 186912037Sandreas.sandberg@arm.com 187012037Sandreas.sandberg@arm.com /// The `convert` value the arguments should be loaded with 187112037Sandreas.sandberg@arm.com std::vector<bool> args_convert; 187212037Sandreas.sandberg@arm.com 187314299Sbbruce@ucdavis.edu /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if 187414299Sbbruce@ucdavis.edu /// present, are also in `args` but without a reference). 187514299Sbbruce@ucdavis.edu object args_ref, kwargs_ref; 187614299Sbbruce@ucdavis.edu 187712037Sandreas.sandberg@arm.com /// The parent, if any 187812037Sandreas.sandberg@arm.com handle parent; 187912391Sjason@lowepower.com 188012391Sjason@lowepower.com /// If this is a call to an initializer, this argument contains `self` 188112391Sjason@lowepower.com handle init_self; 188212037Sandreas.sandberg@arm.com}; 188312037Sandreas.sandberg@arm.com 188412037Sandreas.sandberg@arm.com 188511986Sandreas.sandberg@arm.com/// Helper class which loads arguments for C++ functions called from Python 188611986Sandreas.sandberg@arm.comtemplate <typename... Args> 188711986Sandreas.sandberg@arm.comclass argument_loader { 188811986Sandreas.sandberg@arm.com using indices = make_index_sequence<sizeof...(Args)>; 188911986Sandreas.sandberg@arm.com 189012037Sandreas.sandberg@arm.com template <typename Arg> using argument_is_args = std::is_same<intrinsic_t<Arg>, args>; 189112037Sandreas.sandberg@arm.com template <typename Arg> using argument_is_kwargs = std::is_same<intrinsic_t<Arg>, kwargs>; 189212037Sandreas.sandberg@arm.com // Get args/kwargs argument positions relative to the end of the argument list: 189312037Sandreas.sandberg@arm.com static constexpr auto args_pos = constexpr_first<argument_is_args, Args...>() - (int) sizeof...(Args), 189412037Sandreas.sandberg@arm.com kwargs_pos = constexpr_first<argument_is_kwargs, Args...>() - (int) sizeof...(Args); 189512037Sandreas.sandberg@arm.com 189612037Sandreas.sandberg@arm.com static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1; 189712037Sandreas.sandberg@arm.com 189812037Sandreas.sandberg@arm.com static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function"); 189912037Sandreas.sandberg@arm.com 190011986Sandreas.sandberg@arm.compublic: 190112037Sandreas.sandberg@arm.com static constexpr bool has_kwargs = kwargs_pos < 0; 190212037Sandreas.sandberg@arm.com static constexpr bool has_args = args_pos < 0; 190311986Sandreas.sandberg@arm.com 190414299Sbbruce@ucdavis.edu static constexpr auto arg_names = concat(type_descr(make_caster<Args>::name)...); 190511986Sandreas.sandberg@arm.com 190612037Sandreas.sandberg@arm.com bool load_args(function_call &call) { 190712037Sandreas.sandberg@arm.com return load_impl_sequence(call, indices{}); 190811986Sandreas.sandberg@arm.com } 190911986Sandreas.sandberg@arm.com 191012391Sjason@lowepower.com template <typename Return, typename Guard, typename Func> 191112391Sjason@lowepower.com enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && { 191212391Sjason@lowepower.com return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{}); 191311986Sandreas.sandberg@arm.com } 191411986Sandreas.sandberg@arm.com 191512391Sjason@lowepower.com template <typename Return, typename Guard, typename Func> 191612391Sjason@lowepower.com enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) && { 191712391Sjason@lowepower.com std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{}); 191811986Sandreas.sandberg@arm.com return void_type(); 191911986Sandreas.sandberg@arm.com } 192011986Sandreas.sandberg@arm.com 192111986Sandreas.sandberg@arm.comprivate: 192211986Sandreas.sandberg@arm.com 192312037Sandreas.sandberg@arm.com static bool load_impl_sequence(function_call &, index_sequence<>) { return true; } 192411986Sandreas.sandberg@arm.com 192511986Sandreas.sandberg@arm.com template <size_t... Is> 192612037Sandreas.sandberg@arm.com bool load_impl_sequence(function_call &call, index_sequence<Is...>) { 192712391Sjason@lowepower.com for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...}) 192811986Sandreas.sandberg@arm.com if (!r) 192911986Sandreas.sandberg@arm.com return false; 193011986Sandreas.sandberg@arm.com return true; 193111986Sandreas.sandberg@arm.com } 193211986Sandreas.sandberg@arm.com 193312391Sjason@lowepower.com template <typename Return, typename Func, size_t... Is, typename Guard> 193412391Sjason@lowepower.com Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) { 193512391Sjason@lowepower.com return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...); 193611986Sandreas.sandberg@arm.com } 193711986Sandreas.sandberg@arm.com 193812391Sjason@lowepower.com std::tuple<make_caster<Args>...> argcasters; 193911986Sandreas.sandberg@arm.com}; 194011986Sandreas.sandberg@arm.com 194111986Sandreas.sandberg@arm.com/// Helper class which collects only positional arguments for a Python function call. 194211986Sandreas.sandberg@arm.com/// A fancier version below can collect any argument, but this one is optimal for simple calls. 194311986Sandreas.sandberg@arm.comtemplate <return_value_policy policy> 194411986Sandreas.sandberg@arm.comclass simple_collector { 194511986Sandreas.sandberg@arm.compublic: 194611986Sandreas.sandberg@arm.com template <typename... Ts> 194711986Sandreas.sandberg@arm.com explicit simple_collector(Ts &&...values) 194811986Sandreas.sandberg@arm.com : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { } 194911986Sandreas.sandberg@arm.com 195011986Sandreas.sandberg@arm.com const tuple &args() const & { return m_args; } 195111986Sandreas.sandberg@arm.com dict kwargs() const { return {}; } 195211986Sandreas.sandberg@arm.com 195311986Sandreas.sandberg@arm.com tuple args() && { return std::move(m_args); } 195411986Sandreas.sandberg@arm.com 195511986Sandreas.sandberg@arm.com /// Call a Python function and pass the collected arguments 195611986Sandreas.sandberg@arm.com object call(PyObject *ptr) const { 195711986Sandreas.sandberg@arm.com PyObject *result = PyObject_CallObject(ptr, m_args.ptr()); 195811986Sandreas.sandberg@arm.com if (!result) 195911986Sandreas.sandberg@arm.com throw error_already_set(); 196011986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 196111986Sandreas.sandberg@arm.com } 196211986Sandreas.sandberg@arm.com 196311986Sandreas.sandberg@arm.comprivate: 196411986Sandreas.sandberg@arm.com tuple m_args; 196511986Sandreas.sandberg@arm.com}; 196611986Sandreas.sandberg@arm.com 196711986Sandreas.sandberg@arm.com/// Helper class which collects positional, keyword, * and ** arguments for a Python function call 196811986Sandreas.sandberg@arm.comtemplate <return_value_policy policy> 196911986Sandreas.sandberg@arm.comclass unpacking_collector { 197011986Sandreas.sandberg@arm.compublic: 197111986Sandreas.sandberg@arm.com template <typename... Ts> 197211986Sandreas.sandberg@arm.com explicit unpacking_collector(Ts &&...values) { 197311986Sandreas.sandberg@arm.com // Tuples aren't (easily) resizable so a list is needed for collection, 197411986Sandreas.sandberg@arm.com // but the actual function call strictly requires a tuple. 197511986Sandreas.sandberg@arm.com auto args_list = list(); 197611986Sandreas.sandberg@arm.com int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... }; 197711986Sandreas.sandberg@arm.com ignore_unused(_); 197811986Sandreas.sandberg@arm.com 197911986Sandreas.sandberg@arm.com m_args = std::move(args_list); 198011986Sandreas.sandberg@arm.com } 198111986Sandreas.sandberg@arm.com 198211986Sandreas.sandberg@arm.com const tuple &args() const & { return m_args; } 198311986Sandreas.sandberg@arm.com const dict &kwargs() const & { return m_kwargs; } 198411986Sandreas.sandberg@arm.com 198511986Sandreas.sandberg@arm.com tuple args() && { return std::move(m_args); } 198611986Sandreas.sandberg@arm.com dict kwargs() && { return std::move(m_kwargs); } 198711986Sandreas.sandberg@arm.com 198811986Sandreas.sandberg@arm.com /// Call a Python function and pass the collected arguments 198911986Sandreas.sandberg@arm.com object call(PyObject *ptr) const { 199011986Sandreas.sandberg@arm.com PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr()); 199111986Sandreas.sandberg@arm.com if (!result) 199211986Sandreas.sandberg@arm.com throw error_already_set(); 199311986Sandreas.sandberg@arm.com return reinterpret_steal<object>(result); 199411986Sandreas.sandberg@arm.com } 199511986Sandreas.sandberg@arm.com 199611986Sandreas.sandberg@arm.comprivate: 199711986Sandreas.sandberg@arm.com template <typename T> 199811986Sandreas.sandberg@arm.com void process(list &args_list, T &&x) { 199911986Sandreas.sandberg@arm.com auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {})); 200011986Sandreas.sandberg@arm.com if (!o) { 200111986Sandreas.sandberg@arm.com#if defined(NDEBUG) 200211986Sandreas.sandberg@arm.com argument_cast_error(); 200311986Sandreas.sandberg@arm.com#else 200411986Sandreas.sandberg@arm.com argument_cast_error(std::to_string(args_list.size()), type_id<T>()); 200511986Sandreas.sandberg@arm.com#endif 200611986Sandreas.sandberg@arm.com } 200711986Sandreas.sandberg@arm.com args_list.append(o); 200811986Sandreas.sandberg@arm.com } 200911986Sandreas.sandberg@arm.com 201011986Sandreas.sandberg@arm.com void process(list &args_list, detail::args_proxy ap) { 201111986Sandreas.sandberg@arm.com for (const auto &a : ap) 201211986Sandreas.sandberg@arm.com args_list.append(a); 201311986Sandreas.sandberg@arm.com } 201411986Sandreas.sandberg@arm.com 201511986Sandreas.sandberg@arm.com void process(list &/*args_list*/, arg_v a) { 201612037Sandreas.sandberg@arm.com if (!a.name) 201712037Sandreas.sandberg@arm.com#if defined(NDEBUG) 201812037Sandreas.sandberg@arm.com nameless_argument_error(); 201912037Sandreas.sandberg@arm.com#else 202012037Sandreas.sandberg@arm.com nameless_argument_error(a.type); 202112037Sandreas.sandberg@arm.com#endif 202212037Sandreas.sandberg@arm.com 202311986Sandreas.sandberg@arm.com if (m_kwargs.contains(a.name)) { 202411986Sandreas.sandberg@arm.com#if defined(NDEBUG) 202511986Sandreas.sandberg@arm.com multiple_values_error(); 202611986Sandreas.sandberg@arm.com#else 202711986Sandreas.sandberg@arm.com multiple_values_error(a.name); 202811986Sandreas.sandberg@arm.com#endif 202911986Sandreas.sandberg@arm.com } 203011986Sandreas.sandberg@arm.com if (!a.value) { 203111986Sandreas.sandberg@arm.com#if defined(NDEBUG) 203211986Sandreas.sandberg@arm.com argument_cast_error(); 203311986Sandreas.sandberg@arm.com#else 203411986Sandreas.sandberg@arm.com argument_cast_error(a.name, a.type); 203511986Sandreas.sandberg@arm.com#endif 203611986Sandreas.sandberg@arm.com } 203711986Sandreas.sandberg@arm.com m_kwargs[a.name] = a.value; 203811986Sandreas.sandberg@arm.com } 203911986Sandreas.sandberg@arm.com 204011986Sandreas.sandberg@arm.com void process(list &/*args_list*/, detail::kwargs_proxy kp) { 204111986Sandreas.sandberg@arm.com if (!kp) 204211986Sandreas.sandberg@arm.com return; 204311986Sandreas.sandberg@arm.com for (const auto &k : reinterpret_borrow<dict>(kp)) { 204411986Sandreas.sandberg@arm.com if (m_kwargs.contains(k.first)) { 204511986Sandreas.sandberg@arm.com#if defined(NDEBUG) 204611986Sandreas.sandberg@arm.com multiple_values_error(); 204711986Sandreas.sandberg@arm.com#else 204811986Sandreas.sandberg@arm.com multiple_values_error(str(k.first)); 204911986Sandreas.sandberg@arm.com#endif 205011986Sandreas.sandberg@arm.com } 205111986Sandreas.sandberg@arm.com m_kwargs[k.first] = k.second; 205211986Sandreas.sandberg@arm.com } 205311986Sandreas.sandberg@arm.com } 205411986Sandreas.sandberg@arm.com 205512037Sandreas.sandberg@arm.com [[noreturn]] static void nameless_argument_error() { 205612037Sandreas.sandberg@arm.com throw type_error("Got kwargs without a name; only named arguments " 205712037Sandreas.sandberg@arm.com "may be passed via py::arg() to a python function call. " 205812037Sandreas.sandberg@arm.com "(compile in debug mode for details)"); 205912037Sandreas.sandberg@arm.com } 206012037Sandreas.sandberg@arm.com [[noreturn]] static void nameless_argument_error(std::string type) { 206112037Sandreas.sandberg@arm.com throw type_error("Got kwargs without a name of type '" + type + "'; only named " 206212037Sandreas.sandberg@arm.com "arguments may be passed via py::arg() to a python function call. "); 206312037Sandreas.sandberg@arm.com } 206411986Sandreas.sandberg@arm.com [[noreturn]] static void multiple_values_error() { 206511986Sandreas.sandberg@arm.com throw type_error("Got multiple values for keyword argument " 206611986Sandreas.sandberg@arm.com "(compile in debug mode for details)"); 206711986Sandreas.sandberg@arm.com } 206811986Sandreas.sandberg@arm.com 206911986Sandreas.sandberg@arm.com [[noreturn]] static void multiple_values_error(std::string name) { 207011986Sandreas.sandberg@arm.com throw type_error("Got multiple values for keyword argument '" + name + "'"); 207111986Sandreas.sandberg@arm.com } 207211986Sandreas.sandberg@arm.com 207311986Sandreas.sandberg@arm.com [[noreturn]] static void argument_cast_error() { 207411986Sandreas.sandberg@arm.com throw cast_error("Unable to convert call argument to Python object " 207511986Sandreas.sandberg@arm.com "(compile in debug mode for details)"); 207611986Sandreas.sandberg@arm.com } 207711986Sandreas.sandberg@arm.com 207811986Sandreas.sandberg@arm.com [[noreturn]] static void argument_cast_error(std::string name, std::string type) { 207911986Sandreas.sandberg@arm.com throw cast_error("Unable to convert call argument '" + name 208011986Sandreas.sandberg@arm.com + "' of type '" + type + "' to Python object"); 208111986Sandreas.sandberg@arm.com } 208211986Sandreas.sandberg@arm.com 208311986Sandreas.sandberg@arm.comprivate: 208411986Sandreas.sandberg@arm.com tuple m_args; 208511986Sandreas.sandberg@arm.com dict m_kwargs; 208611986Sandreas.sandberg@arm.com}; 208711986Sandreas.sandberg@arm.com 208811986Sandreas.sandberg@arm.com/// Collect only positional arguments for a Python function call 208911986Sandreas.sandberg@arm.comtemplate <return_value_policy policy, typename... Args, 209012037Sandreas.sandberg@arm.com typename = enable_if_t<all_of<is_positional<Args>...>::value>> 209111986Sandreas.sandberg@arm.comsimple_collector<policy> collect_arguments(Args &&...args) { 209211986Sandreas.sandberg@arm.com return simple_collector<policy>(std::forward<Args>(args)...); 209311986Sandreas.sandberg@arm.com} 209411986Sandreas.sandberg@arm.com 209511986Sandreas.sandberg@arm.com/// Collect all arguments, including keywords and unpacking (only instantiated when needed) 209611986Sandreas.sandberg@arm.comtemplate <return_value_policy policy, typename... Args, 209712037Sandreas.sandberg@arm.com typename = enable_if_t<!all_of<is_positional<Args>...>::value>> 209811986Sandreas.sandberg@arm.comunpacking_collector<policy> collect_arguments(Args &&...args) { 209911986Sandreas.sandberg@arm.com // Following argument order rules for generalized unpacking according to PEP 448 210011986Sandreas.sandberg@arm.com static_assert( 210111986Sandreas.sandberg@arm.com constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>() 210211986Sandreas.sandberg@arm.com && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(), 210311986Sandreas.sandberg@arm.com "Invalid function call: positional args must precede keywords and ** unpacking; " 210411986Sandreas.sandberg@arm.com "* unpacking must precede ** unpacking" 210511986Sandreas.sandberg@arm.com ); 210611986Sandreas.sandberg@arm.com return unpacking_collector<policy>(std::forward<Args>(args)...); 210711986Sandreas.sandberg@arm.com} 210811986Sandreas.sandberg@arm.com 210911986Sandreas.sandberg@arm.comtemplate <typename Derived> 211011986Sandreas.sandberg@arm.comtemplate <return_value_policy policy, typename... Args> 211111986Sandreas.sandberg@arm.comobject object_api<Derived>::operator()(Args &&...args) const { 211211986Sandreas.sandberg@arm.com return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr()); 211311986Sandreas.sandberg@arm.com} 211411986Sandreas.sandberg@arm.com 211511986Sandreas.sandberg@arm.comtemplate <typename Derived> 211611986Sandreas.sandberg@arm.comtemplate <return_value_policy policy, typename... Args> 211711986Sandreas.sandberg@arm.comobject object_api<Derived>::call(Args &&...args) const { 211811986Sandreas.sandberg@arm.com return operator()<policy>(std::forward<Args>(args)...); 211911986Sandreas.sandberg@arm.com} 212011986Sandreas.sandberg@arm.com 212111986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 212211986Sandreas.sandberg@arm.com 212314299Sbbruce@ucdavis.edu#define PYBIND11_MAKE_OPAQUE(...) \ 212411986Sandreas.sandberg@arm.com namespace pybind11 { namespace detail { \ 212514299Sbbruce@ucdavis.edu template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \ 212611986Sandreas.sandberg@arm.com }} 212711986Sandreas.sandberg@arm.com 212814299Sbbruce@ucdavis.edu/// Lets you pass a type containing a `,` through a macro parameter without needing a separate 212914299Sbbruce@ucdavis.edu/// typedef, e.g.: `PYBIND11_OVERLOAD(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)` 213014299Sbbruce@ucdavis.edu#define PYBIND11_TYPE(...) __VA_ARGS__ 213114299Sbbruce@ucdavis.edu 213212391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE) 2133