1 /*
2 pybind11/cast.h: Partial template specializations to cast between
3 C++ and Python types
4
5 Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
6
7 All rights reserved. Use of this source code is governed by a
8 BSD-style license that can be found in the LICENSE file.
9 */
10
11 #pragma once
12
13 #include "pytypes.h"
14 #include "detail/typeid.h"
15 #include "detail/descr.h"
16 #include "detail/internals.h"
17 #include <array>
18 #include <limits>
19 #include <tuple>
20 #include <type_traits>
21
22 #if defined(PYBIND11_CPP17)
23 # if defined(__has_include)
24 # if __has_include(<string_view>)
25 # define PYBIND11_HAS_STRING_VIEW
26 # endif
27 # elif defined(_MSC_VER)
28 # define PYBIND11_HAS_STRING_VIEW
29 # endif
30 #endif
31 #ifdef PYBIND11_HAS_STRING_VIEW
32 #include <string_view>
33 #endif
34
35 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
36 # define PYBIND11_HAS_U8STRING
37 #endif
38
39 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
PYBIND11_NAMESPACE_BEGIN(detail)40 PYBIND11_NAMESPACE_BEGIN(detail)
41
42 /// A life support system for temporary objects created by `type_caster::load()`.
43 /// Adding a patient will keep it alive up until the enclosing function returns.
44 class loader_life_support {
45 public:
46 /// A new patient frame is created when a function is entered
47 loader_life_support() {
48 get_internals().loader_patient_stack.push_back(nullptr);
49 }
50
51 /// ... and destroyed after it returns
52 ~loader_life_support() {
53 auto &stack = get_internals().loader_patient_stack;
54 if (stack.empty())
55 pybind11_fail("loader_life_support: internal error");
56
57 auto ptr = stack.back();
58 stack.pop_back();
59 Py_CLEAR(ptr);
60
61 // A heuristic to reduce the stack's capacity (e.g. after long recursive calls)
62 if (stack.capacity() > 16 && !stack.empty() && stack.capacity() / stack.size() > 2)
63 stack.shrink_to_fit();
64 }
65
66 /// This can only be used inside a pybind11-bound function, either by `argument_loader`
67 /// at argument preparation time or by `py::cast()` at execution time.
68 PYBIND11_NOINLINE static void add_patient(handle h) {
69 auto &stack = get_internals().loader_patient_stack;
70 if (stack.empty())
71 throw cast_error("When called outside a bound function, py::cast() cannot "
72 "do Python -> C++ conversions which require the creation "
73 "of temporary values");
74
75 auto &list_ptr = stack.back();
76 if (list_ptr == nullptr) {
77 list_ptr = PyList_New(1);
78 if (!list_ptr)
79 pybind11_fail("loader_life_support: error allocating list");
80 PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
81 } else {
82 auto result = PyList_Append(list_ptr, h.ptr());
83 if (result == -1)
84 pybind11_fail("loader_life_support: error adding patient");
85 }
86 }
87 };
88
89 // Gets the cache entry for the given type, creating it if necessary. The return value is the pair
90 // returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
91 // just created.
92 inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);
93
94 // Populates a just-created cache entry.
all_type_info_populate(PyTypeObject * t,std::vector<type_info * > & bases)95 PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
96 std::vector<PyTypeObject *> check;
97 for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
98 check.push_back((PyTypeObject *) parent.ptr());
99
100 auto const &type_dict = get_internals().registered_types_py;
101 for (size_t i = 0; i < check.size(); i++) {
102 auto type = check[i];
103 // Ignore Python2 old-style class super type:
104 if (!PyType_Check((PyObject *) type)) continue;
105
106 // Check `type` in the current set of registered python types:
107 auto it = type_dict.find(type);
108 if (it != type_dict.end()) {
109 // We found a cache entry for it, so it's either pybind-registered or has pre-computed
110 // pybind bases, but we have to make sure we haven't already seen the type(s) before: we
111 // want to follow Python/virtual C++ rules that there should only be one instance of a
112 // common base.
113 for (auto *tinfo : it->second) {
114 // NB: Could use a second set here, rather than doing a linear search, but since
115 // having a large number of immediate pybind11-registered types seems fairly
116 // unlikely, that probably isn't worthwhile.
117 bool found = false;
118 for (auto *known : bases) {
119 if (known == tinfo) { found = true; break; }
120 }
121 if (!found) bases.push_back(tinfo);
122 }
123 }
124 else if (type->tp_bases) {
125 // It's some python type, so keep follow its bases classes to look for one or more
126 // registered types
127 if (i + 1 == check.size()) {
128 // When we're at the end, we can pop off the current element to avoid growing
129 // `check` when adding just one base (which is typical--i.e. when there is no
130 // multiple inheritance)
131 check.pop_back();
132 i--;
133 }
134 for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
135 check.push_back((PyTypeObject *) parent.ptr());
136 }
137 }
138 }
139
140 /**
141 * Extracts vector of type_info pointers of pybind-registered roots of the given Python type. Will
142 * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
143 * derived class that uses single inheritance. Will contain as many types as required for a Python
144 * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
145 * pybind-registered classes. Will be empty if neither the type nor any base classes are
146 * pybind-registered.
147 *
148 * The value is cached for the lifetime of the Python type.
149 */
all_type_info(PyTypeObject * type)150 inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
151 auto ins = all_type_info_get_cache(type);
152 if (ins.second)
153 // New cache entry: populate it
154 all_type_info_populate(type, ins.first->second);
155
156 return ins.first->second;
157 }
158
159 /**
160 * Gets a single pybind11 type info for a python type. Returns nullptr if neither the type nor any
161 * ancestors are pybind11-registered. Throws an exception if there are multiple bases--use
162 * `all_type_info` instead if you want to support multiple bases.
163 */
get_type_info(PyTypeObject * type)164 PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
165 auto &bases = all_type_info(type);
166 if (bases.empty())
167 return nullptr;
168 if (bases.size() > 1)
169 pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
170 return bases.front();
171 }
172
get_local_type_info(const std::type_index & tp)173 inline detail::type_info *get_local_type_info(const std::type_index &tp) {
174 auto &locals = registered_local_types_cpp();
175 auto it = locals.find(tp);
176 if (it != locals.end())
177 return it->second;
178 return nullptr;
179 }
180
get_global_type_info(const std::type_index & tp)181 inline detail::type_info *get_global_type_info(const std::type_index &tp) {
182 auto &types = get_internals().registered_types_cpp;
183 auto it = types.find(tp);
184 if (it != types.end())
185 return it->second;
186 return nullptr;
187 }
188
189 /// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
190 PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
191 bool throw_if_missing = false) {
192 if (auto ltype = get_local_type_info(tp))
193 return ltype;
194 if (auto gtype = get_global_type_info(tp))
195 return gtype;
196
197 if (throw_if_missing) {
198 std::string tname = tp.name();
199 detail::clean_type_id(tname);
200 pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
201 }
202 return nullptr;
203 }
204
get_type_handle(const std::type_info & tp,bool throw_if_missing)205 PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
206 detail::type_info *type_info = get_type_info(tp, throw_if_missing);
207 return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
208 }
209
210 struct value_and_holder {
211 instance *inst = nullptr;
212 size_t index = 0u;
213 const detail::type_info *type = nullptr;
214 void **vh = nullptr;
215
216 // Main constructor for a found value/holder:
value_and_holdervalue_and_holder217 value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) :
218 inst{i}, index{index}, type{type},
219 vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]}
220 {}
221
222 // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
223 value_and_holder() = default;
224
225 // Used for past-the-end iterator
value_and_holdervalue_and_holder226 value_and_holder(size_t index) : index{index} {}
227
value_ptrvalue_and_holder228 template <typename V = void> V *&value_ptr() const {
229 return reinterpret_cast<V *&>(vh[0]);
230 }
231 // True if this `value_and_holder` has a non-null value pointer
232 explicit operator bool() const { return value_ptr(); }
233
holdervalue_and_holder234 template <typename H> H &holder() const {
235 return reinterpret_cast<H &>(vh[1]);
236 }
holder_constructedvalue_and_holder237 bool holder_constructed() const {
238 return inst->simple_layout
239 ? inst->simple_holder_constructed
240 : inst->nonsimple.status[index] & instance::status_holder_constructed;
241 }
242 void set_holder_constructed(bool v = true) {
243 if (inst->simple_layout)
244 inst->simple_holder_constructed = v;
245 else if (v)
246 inst->nonsimple.status[index] |= instance::status_holder_constructed;
247 else
248 inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
249 }
instance_registeredvalue_and_holder250 bool instance_registered() const {
251 return inst->simple_layout
252 ? inst->simple_instance_registered
253 : inst->nonsimple.status[index] & instance::status_instance_registered;
254 }
255 void set_instance_registered(bool v = true) {
256 if (inst->simple_layout)
257 inst->simple_instance_registered = v;
258 else if (v)
259 inst->nonsimple.status[index] |= instance::status_instance_registered;
260 else
261 inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
262 }
263 };
264
265 // Container for accessing and iterating over an instance's values/holders
266 struct values_and_holders {
267 private:
268 instance *inst;
269 using type_vec = std::vector<detail::type_info *>;
270 const type_vec &tinfo;
271
272 public:
values_and_holdersvalues_and_holders273 values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}
274
275 struct iterator {
276 private:
277 instance *inst = nullptr;
278 const type_vec *types = nullptr;
279 value_and_holder curr;
280 friend struct values_and_holders;
iteratorvalues_and_holders::iterator281 iterator(instance *inst, const type_vec *tinfo)
282 : inst{inst}, types{tinfo},
283 curr(inst /* instance */,
284 types->empty() ? nullptr : (*types)[0] /* type info */,
285 0, /* vpos: (non-simple types only): the first vptr comes first */
286 0 /* index */)
287 {}
288 // Past-the-end iterator:
iteratorvalues_and_holders::iterator289 iterator(size_t end) : curr(end) {}
290 public:
291 bool operator==(const iterator &other) const { return curr.index == other.curr.index; }
292 bool operator!=(const iterator &other) const { return curr.index != other.curr.index; }
293 iterator &operator++() {
294 if (!inst->simple_layout)
295 curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
296 ++curr.index;
297 curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
298 return *this;
299 }
300 value_and_holder &operator*() { return curr; }
301 value_and_holder *operator->() { return &curr; }
302 };
303
beginvalues_and_holders304 iterator begin() { return iterator(inst, &tinfo); }
endvalues_and_holders305 iterator end() { return iterator(tinfo.size()); }
306
findvalues_and_holders307 iterator find(const type_info *find_type) {
308 auto it = begin(), endit = end();
309 while (it != endit && it->type != find_type) ++it;
310 return it;
311 }
312
sizevalues_and_holders313 size_t size() { return tinfo.size(); }
314 };
315
316 /**
317 * Extracts C++ value and holder pointer references from an instance (which may contain multiple
318 * values/holders for python-side multiple inheritance) that match the given type. Throws an error
319 * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance. If
320 * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
321 * regardless of type (and the resulting .type will be nullptr).
322 *
323 * The returned object should be short-lived: in particular, it must not outlive the called-upon
324 * instance.
325 */
get_value_and_holder(const type_info * find_type,bool throw_if_missing)326 PYBIND11_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*/) {
327 // Optimize common case:
328 if (!find_type || Py_TYPE(this) == find_type->type)
329 return value_and_holder(this, find_type, 0, 0);
330
331 detail::values_and_holders vhs(this);
332 auto it = vhs.find(find_type);
333 if (it != vhs.end())
334 return *it;
335
336 if (!throw_if_missing)
337 return value_and_holder();
338
339 #if defined(NDEBUG)
340 pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
341 "type is not a pybind11 base of the given instance "
342 "(compile in debug mode for type details)");
343 #else
344 pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
345 get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" +
346 get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
347 #endif
348 }
349
allocate_layout()350 PYBIND11_NOINLINE inline void instance::allocate_layout() {
351 auto &tinfo = all_type_info(Py_TYPE(this));
352
353 const size_t n_types = tinfo.size();
354
355 if (n_types == 0)
356 pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");
357
358 simple_layout =
359 n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();
360
361 // Simple path: no python-side multiple inheritance, and a small-enough holder
362 if (simple_layout) {
363 simple_value_holder[0] = nullptr;
364 simple_holder_constructed = false;
365 simple_instance_registered = false;
366 }
367 else { // multiple base types or a too-large holder
368 // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
369 // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
370 // values that tracks whether each associated holder has been initialized. Each [block] is
371 // padded, if necessary, to an integer multiple of sizeof(void *).
372 size_t space = 0;
373 for (auto t : tinfo) {
374 space += 1; // value pointer
375 space += t->holder_size_in_ptrs; // holder instance
376 }
377 size_t flags_at = space;
378 space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
379
380 // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
381 // in particular, need to be 0). Use Python's memory allocation functions: in Python 3.6
382 // they default to using pymalloc, which is designed to be efficient for small allocations
383 // like the one we're doing here; in earlier versions (and for larger allocations) they are
384 // just wrappers around malloc.
385 #if PY_VERSION_HEX >= 0x03050000
386 nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
387 if (!nonsimple.values_and_holders) throw std::bad_alloc();
388 #else
389 nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
390 if (!nonsimple.values_and_holders) throw std::bad_alloc();
391 std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *));
392 #endif
393 nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
394 }
395 owned = true;
396 }
397
deallocate_layout()398 PYBIND11_NOINLINE inline void instance::deallocate_layout() {
399 if (!simple_layout)
400 PyMem_Free(nonsimple.values_and_holders);
401 }
402
isinstance_generic(handle obj,const std::type_info & tp)403 PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
404 handle type = detail::get_type_handle(tp, false);
405 if (!type)
406 return false;
407 return isinstance(obj, type);
408 }
409
error_string()410 PYBIND11_NOINLINE inline std::string error_string() {
411 if (!PyErr_Occurred()) {
412 PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
413 return "Unknown internal error occurred";
414 }
415
416 error_scope scope; // Preserve error state
417
418 std::string errorString;
419 if (scope.type) {
420 errorString += handle(scope.type).attr("__name__").cast<std::string>();
421 errorString += ": ";
422 }
423 if (scope.value)
424 errorString += (std::string) str(scope.value);
425
426 PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
427
428 #if PY_MAJOR_VERSION >= 3
429 if (scope.trace != nullptr)
430 PyException_SetTraceback(scope.value, scope.trace);
431 #endif
432
433 #if !defined(PYPY_VERSION)
434 if (scope.trace) {
435 auto *trace = (PyTracebackObject *) scope.trace;
436
437 /* Get the deepest trace possible */
438 while (trace->tb_next)
439 trace = trace->tb_next;
440
441 PyFrameObject *frame = trace->tb_frame;
442 errorString += "\n\nAt:\n";
443 while (frame) {
444 int lineno = PyFrame_GetLineNumber(frame);
445 errorString +=
446 " " + handle(frame->f_code->co_filename).cast<std::string>() +
447 "(" + std::to_string(lineno) + "): " +
448 handle(frame->f_code->co_name).cast<std::string>() + "\n";
449 frame = frame->f_back;
450 }
451 }
452 #endif
453
454 return errorString;
455 }
456
get_object_handle(const void * ptr,const detail::type_info * type)457 PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
458 auto &instances = get_internals().registered_instances;
459 auto range = instances.equal_range(ptr);
460 for (auto it = range.first; it != range.second; ++it) {
461 for (const auto &vh : values_and_holders(it->second)) {
462 if (vh.type == type)
463 return handle((PyObject *) it->second);
464 }
465 }
466 return handle();
467 }
468
get_thread_state_unchecked()469 inline PyThreadState *get_thread_state_unchecked() {
470 #if defined(PYPY_VERSION)
471 return PyThreadState_GET();
472 #elif PY_VERSION_HEX < 0x03000000
473 return _PyThreadState_Current;
474 #elif PY_VERSION_HEX < 0x03050000
475 return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
476 #elif PY_VERSION_HEX < 0x03050200
477 return (PyThreadState*) _PyThreadState_Current.value;
478 #else
479 return _PyThreadState_UncheckedGet();
480 #endif
481 }
482
483 // Forward declarations
484 inline void keep_alive_impl(handle nurse, handle patient);
485 inline PyObject *make_new_instance(PyTypeObject *type);
486
487 class type_caster_generic {
488 public:
type_caster_generic(const std::type_info & type_info)489 PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
490 : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
491
type_caster_generic(const type_info * typeinfo)492 type_caster_generic(const type_info *typeinfo)
493 : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
494
load(handle src,bool convert)495 bool load(handle src, bool convert) {
496 return load_impl<type_caster_generic>(src, convert);
497 }
498
499 PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
500 const detail::type_info *tinfo,
501 void *(*copy_constructor)(const void *),
502 void *(*move_constructor)(const void *),
503 const void *existing_holder = nullptr) {
504 if (!tinfo) // no type info: error will be set already
505 return handle();
506
507 void *src = const_cast<void *>(_src);
508 if (src == nullptr)
509 return none().release();
510
511 auto it_instances = get_internals().registered_instances.equal_range(src);
512 for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
513 for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
514 if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
515 return handle((PyObject *) it_i->second).inc_ref();
516 }
517 }
518
519 auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
520 auto wrapper = reinterpret_cast<instance *>(inst.ptr());
521 wrapper->owned = false;
522 void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
523
524 switch (policy) {
525 case return_value_policy::automatic:
526 case return_value_policy::take_ownership:
527 valueptr = src;
528 wrapper->owned = true;
529 break;
530
531 case return_value_policy::automatic_reference:
532 case return_value_policy::reference:
533 valueptr = src;
534 wrapper->owned = false;
535 break;
536
537 case return_value_policy::copy:
538 if (copy_constructor)
539 valueptr = copy_constructor(src);
540 else {
541 #if defined(NDEBUG)
542 throw cast_error("return_value_policy = copy, but type is "
543 "non-copyable! (compile in debug mode for details)");
544 #else
545 std::string type_name(tinfo->cpptype->name());
546 detail::clean_type_id(type_name);
547 throw cast_error("return_value_policy = copy, but type " +
548 type_name + " is non-copyable!");
549 #endif
550 }
551 wrapper->owned = true;
552 break;
553
554 case return_value_policy::move:
555 if (move_constructor)
556 valueptr = move_constructor(src);
557 else if (copy_constructor)
558 valueptr = copy_constructor(src);
559 else {
560 #if defined(NDEBUG)
561 throw cast_error("return_value_policy = move, but type is neither "
562 "movable nor copyable! "
563 "(compile in debug mode for details)");
564 #else
565 std::string type_name(tinfo->cpptype->name());
566 detail::clean_type_id(type_name);
567 throw cast_error("return_value_policy = move, but type " +
568 type_name + " is neither movable nor copyable!");
569 #endif
570 }
571 wrapper->owned = true;
572 break;
573
574 case return_value_policy::reference_internal:
575 valueptr = src;
576 wrapper->owned = false;
577 keep_alive_impl(inst, parent);
578 break;
579
580 default:
581 throw cast_error("unhandled return_value_policy: should not happen!");
582 }
583
584 tinfo->init_instance(wrapper, existing_holder);
585
586 return inst.release();
587 }
588
589 // Base methods for generic caster; there are overridden in copyable_holder_caster
load_value(value_and_holder && v_h)590 void load_value(value_and_holder &&v_h) {
591 auto *&vptr = v_h.value_ptr();
592 // Lazy allocation for unallocated values:
593 if (vptr == nullptr) {
594 auto *type = v_h.type ? v_h.type : typeinfo;
595 if (type->operator_new) {
596 vptr = type->operator_new(type->type_size);
597 } else {
598 #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
599 if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
600 vptr = ::operator new(type->type_size,
601 std::align_val_t(type->type_align));
602 else
603 #endif
604 vptr = ::operator new(type->type_size);
605 }
606 }
607 value = vptr;
608 }
try_implicit_casts(handle src,bool convert)609 bool try_implicit_casts(handle src, bool convert) {
610 for (auto &cast : typeinfo->implicit_casts) {
611 type_caster_generic sub_caster(*cast.first);
612 if (sub_caster.load(src, convert)) {
613 value = cast.second(sub_caster.value);
614 return true;
615 }
616 }
617 return false;
618 }
try_direct_conversions(handle src)619 bool try_direct_conversions(handle src) {
620 for (auto &converter : *typeinfo->direct_conversions) {
621 if (converter(src.ptr(), value))
622 return true;
623 }
624 return false;
625 }
check_holder_compat()626 void check_holder_compat() {}
627
local_load(PyObject * src,const type_info * ti)628 PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
629 auto caster = type_caster_generic(ti);
630 if (caster.load(src, false))
631 return caster.value;
632 return nullptr;
633 }
634
635 /// Try to load with foreign typeinfo, if available. Used when there is no
636 /// native typeinfo, or when the native one wasn't able to produce a value.
try_load_foreign_module_local(handle src)637 PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
638 constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
639 const auto pytype = type::handle_of(src);
640 if (!hasattr(pytype, local_key))
641 return false;
642
643 type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
644 // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
645 if (foreign_typeinfo->module_local_load == &local_load
646 || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
647 return false;
648
649 if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
650 value = result;
651 return true;
652 }
653 return false;
654 }
655
656 // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
657 // bits of code between here and copyable_holder_caster where the two classes need different
658 // logic (without having to resort to virtual inheritance).
659 template <typename ThisT>
load_impl(handle src,bool convert)660 PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
661 if (!src) return false;
662 if (!typeinfo) return try_load_foreign_module_local(src);
663 if (src.is_none()) {
664 // Defer accepting None to other overloads (if we aren't in convert mode):
665 if (!convert) return false;
666 value = nullptr;
667 return true;
668 }
669
670 auto &this_ = static_cast<ThisT &>(*this);
671 this_.check_holder_compat();
672
673 PyTypeObject *srctype = Py_TYPE(src.ptr());
674
675 // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
676 // the instance's value pointer to the target type:
677 if (srctype == typeinfo->type) {
678 this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
679 return true;
680 }
681 // Case 2: We have a derived class
682 else if (PyType_IsSubtype(srctype, typeinfo->type)) {
683 auto &bases = all_type_info(srctype);
684 bool no_cpp_mi = typeinfo->simple_type;
685
686 // Case 2a: the python type is a Python-inherited derived class that inherits from just
687 // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
688 // the right type and we can use reinterpret_cast.
689 // (This is essentially the same as case 2b, but because not using multiple inheritance
690 // is extremely common, we handle it specially to avoid the loop iterator and type
691 // pointer lookup overhead)
692 if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
693 this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
694 return true;
695 }
696 // Case 2b: the python type inherits from multiple C++ bases. Check the bases to see if
697 // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
698 // can safely reinterpret_cast to the relevant pointer.
699 else if (bases.size() > 1) {
700 for (auto base : bases) {
701 if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
702 this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
703 return true;
704 }
705 }
706 }
707
708 // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
709 // in the registered bases, above, so try implicit casting (needed for proper C++ casting
710 // when MI is involved).
711 if (this_.try_implicit_casts(src, convert))
712 return true;
713 }
714
715 // Perform an implicit conversion
716 if (convert) {
717 for (auto &converter : typeinfo->implicit_conversions) {
718 auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
719 if (load_impl<ThisT>(temp, false)) {
720 loader_life_support::add_patient(temp);
721 return true;
722 }
723 }
724 if (this_.try_direct_conversions(src))
725 return true;
726 }
727
728 // Failed to match local typeinfo. Try again with global.
729 if (typeinfo->module_local) {
730 if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
731 typeinfo = gtype;
732 return load(src, false);
733 }
734 }
735
736 // Global typeinfo has precedence over foreign module_local
737 return try_load_foreign_module_local(src);
738 }
739
740
741 // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
742 // isn't needed or can't be used. If the type is unknown, sets the error and returns a pair
743 // with .second = nullptr. (p.first = nullptr is not an error: it becomes None).
744 PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
745 const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
746 if (auto *tpi = get_type_info(cast_type))
747 return {src, const_cast<const type_info *>(tpi)};
748
749 // Not found, set error:
750 std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
751 detail::clean_type_id(tname);
752 std::string msg = "Unregistered type : " + tname;
753 PyErr_SetString(PyExc_TypeError, msg.c_str());
754 return {nullptr, nullptr};
755 }
756
757 const type_info *typeinfo = nullptr;
758 const std::type_info *cpptype = nullptr;
759 void *value = nullptr;
760 };
761
762 /**
763 * Determine suitable casting operator for pointer-or-lvalue-casting type casters. The type caster
764 * needs to provide `operator T*()` and `operator T&()` operators.
765 *
766 * If the type supports moving the value away via an `operator T&&() &&` method, it should use
767 * `movable_cast_op_type` instead.
768 */
769 template <typename T>
770 using cast_op_type =
771 conditional_t<std::is_pointer<remove_reference_t<T>>::value,
772 typename std::add_pointer<intrinsic_t<T>>::type,
773 typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
774
775 /**
776 * Determine suitable casting operator for a type caster with a movable value. Such a type caster
777 * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`. The latter will be
778 * called in appropriate contexts where the value can be moved rather than copied.
779 *
780 * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
781 */
782 template <typename T>
783 using movable_cast_op_type =
784 conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
785 typename std::add_pointer<intrinsic_t<T>>::type,
786 conditional_t<std::is_rvalue_reference<T>::value,
787 typename std::add_rvalue_reference<intrinsic_t<T>>::type,
788 typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
789
790 // std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
791 // T is non-copyable, but code containing such a copy constructor fails to actually compile.
792 template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};
793
794 // Specialization for types that appear to be copy constructible but also look like stl containers
795 // (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
796 // so, copy constructability depends on whether the value_type is copy constructible.
797 template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
798 std::is_copy_constructible<Container>,
799 std::is_same<typename Container::value_type &, typename Container::reference>,
800 // Avoid infinite recursion
801 negation<std::is_same<Container, typename Container::value_type>>
802 >::value>> : is_copy_constructible<typename Container::value_type> {};
803
804 // Likewise for std::pair
805 // (after C++17 it is mandatory that the copy constructor not exist when the two types aren't themselves
806 // copy constructible, but this can not be relied upon when T1 or T2 are themselves containers).
807 template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
808 : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
809
810 // The same problems arise with std::is_copy_assignable, so we use the same workaround.
811 template <typename T, typename SFINAE = void> struct is_copy_assignable : std::is_copy_assignable<T> {};
812 template <typename Container> struct is_copy_assignable<Container, enable_if_t<all_of<
813 std::is_copy_assignable<Container>,
814 std::is_same<typename Container::value_type &, typename Container::reference>
815 >::value>> : is_copy_assignable<typename Container::value_type> {};
816 template <typename T1, typename T2> struct is_copy_assignable<std::pair<T1, T2>>
817 : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
818
819 PYBIND11_NAMESPACE_END(detail)
820
821 // polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
822 // to by `src` actually is an instance of some class derived from `itype`.
823 // If so, it sets `tinfo` to point to the std::type_info representing that derived
824 // type, and returns a pointer to the start of the most-derived object of that type
825 // (in which `src` is a subobject; this will be the same address as `src` in most
826 // single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
827 // and leaves `tinfo` at its default value of nullptr.
828 //
829 // The default polymorphic_type_hook just returns src. A specialization for polymorphic
830 // types determines the runtime type of the passed object and adjusts the this-pointer
831 // appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear
832 // to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is
833 // registered with pybind11, and this Animal is in fact a Dog).
834 //
835 // You may specialize polymorphic_type_hook yourself for types that want to appear
836 // polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern
837 // in performance-sensitive applications, used most notably in LLVM.)
838 //
839 // polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with
840 // std::enable_if. User provided specializations will always have higher priority than
841 // the default implementation and specialization provided in polymorphic_type_hook_base.
842 template <typename itype, typename SFINAE = void>
843 struct polymorphic_type_hook_base
844 {
845 static const void *get(const itype *src, const std::type_info*&) { return src; }
846 };
847 template <typename itype>
848 struct polymorphic_type_hook_base<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>>
849 {
850 static const void *get(const itype *src, const std::type_info*& type) {
851 type = src ? &typeid(*src) : nullptr;
852 return dynamic_cast<const void*>(src);
853 }
854 };
855 template <typename itype, typename SFINAE = void>
856 struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
857
858 PYBIND11_NAMESPACE_BEGIN(detail)
859
860 /// Generic type caster for objects stored on the heap
861 template <typename type> class type_caster_base : public type_caster_generic {
862 using itype = intrinsic_t<type>;
863
864 public:
865 static constexpr auto name = _<type>();
866
867 type_caster_base() : type_caster_base(typeid(type)) { }
868 explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
869
870 static handle cast(const itype &src, return_value_policy policy, handle parent) {
871 if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
872 policy = return_value_policy::copy;
873 return cast(&src, policy, parent);
874 }
875
876 static handle cast(itype &&src, return_value_policy, handle parent) {
877 return cast(&src, return_value_policy::move, parent);
878 }
879
880 // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
881 // polymorphic type (using RTTI by default, but can be overridden by specializing
882 // polymorphic_type_hook). If the instance isn't derived, returns the base version.
883 static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
884 auto &cast_type = typeid(itype);
885 const std::type_info *instance_type = nullptr;
886 const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
887 if (instance_type && !same_type(cast_type, *instance_type)) {
888 // This is a base pointer to a derived type. If the derived type is registered
889 // with pybind11, we want to make the full derived object available.
890 // In the typical case where itype is polymorphic, we get the correct
891 // derived pointer (which may be != base pointer) by a dynamic_cast to
892 // most derived type. If itype is not polymorphic, we won't get here
893 // except via a user-provided specialization of polymorphic_type_hook,
894 // and the user has promised that no this-pointer adjustment is
895 // required in that case, so it's OK to use static_cast.
896 if (const auto *tpi = get_type_info(*instance_type))
897 return {vsrc, tpi};
898 }
899 // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
900 // don't do a cast
901 return type_caster_generic::src_and_type(src, cast_type, instance_type);
902 }
903
904 static handle cast(const itype *src, return_value_policy policy, handle parent) {
905 auto st = src_and_type(src);
906 return type_caster_generic::cast(
907 st.first, policy, parent, st.second,
908 make_copy_constructor(src), make_move_constructor(src));
909 }
910
911 static handle cast_holder(const itype *src, const void *holder) {
912 auto st = src_and_type(src);
913 return type_caster_generic::cast(
914 st.first, return_value_policy::take_ownership, {}, st.second,
915 nullptr, nullptr, holder);
916 }
917
918 template <typename T> using cast_op_type = detail::cast_op_type<T>;
919
920 operator itype*() { return (type *) value; }
921 operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
922
923 protected:
924 using Constructor = void *(*)(const void *);
925
926 /* Only enabled when the types are {copy,move}-constructible *and* when the type
927 does not have a private operator new implementation. */
928 template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
929 static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
930 return [](const void *arg) -> void * {
931 return new T(*reinterpret_cast<const T *>(arg));
932 };
933 }
934
935 template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
936 static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
937 return [](const void *arg) -> void * {
938 return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
939 };
940 }
941
942 static Constructor make_copy_constructor(...) { return nullptr; }
943 static Constructor make_move_constructor(...) { return nullptr; }
944 };
945
946 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
947 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
948
949 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
950 template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
951 return caster.operator typename make_caster<T>::template cast_op_type<T>();
952 }
953 template <typename T> typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
954 cast_op(make_caster<T> &&caster) {
955 return std::move(caster).operator
956 typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>();
957 }
958
959 template <typename type> class type_caster<std::reference_wrapper<type>> {
960 private:
961 using caster_t = make_caster<type>;
962 caster_t subcaster;
963 using reference_t = type&;
964 using subcaster_cast_op_type =
965 typename caster_t::template cast_op_type<reference_t>;
966
967 static_assert(std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value ||
968 std::is_same<reference_t, subcaster_cast_op_type>::value,
969 "std::reference_wrapper<T> caster requires T to have a caster with an "
970 "`operator T &()` or `operator const T &()`");
971 public:
972 bool load(handle src, bool convert) { return subcaster.load(src, convert); }
973 static constexpr auto name = caster_t::name;
974 static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
975 // It is definitely wrong to take ownership of this pointer, so mask that rvp
976 if (policy == return_value_policy::take_ownership || policy == return_value_policy::automatic)
977 policy = return_value_policy::automatic_reference;
978 return caster_t::cast(&src.get(), policy, parent);
979 }
980 template <typename T> using cast_op_type = std::reference_wrapper<type>;
981 operator std::reference_wrapper<type>() { return cast_op<type &>(subcaster); }
982 };
983
984 #define PYBIND11_TYPE_CASTER(type, py_name) \
985 protected: \
986 type value; \
987 public: \
988 static constexpr auto name = py_name; \
989 template <typename T_, enable_if_t<std::is_same<type, remove_cv_t<T_>>::value, int> = 0> \
990 static handle cast(T_ *src, return_value_policy policy, handle parent) { \
991 if (!src) return none().release(); \
992 if (policy == return_value_policy::take_ownership) { \
993 auto h = cast(std::move(*src), policy, parent); delete src; return h; \
994 } else { \
995 return cast(*src, policy, parent); \
996 } \
997 } \
998 operator type*() { return &value; } \
999 operator type&() { return value; } \
1000 operator type&&() && { return std::move(value); } \
1001 template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
1002
1003
1004 template <typename CharT> using is_std_char_type = any_of<
1005 std::is_same<CharT, char>, /* std::string */
1006 #if defined(PYBIND11_HAS_U8STRING)
1007 std::is_same<CharT, char8_t>, /* std::u8string */
1008 #endif
1009 std::is_same<CharT, char16_t>, /* std::u16string */
1010 std::is_same<CharT, char32_t>, /* std::u32string */
1011 std::is_same<CharT, wchar_t> /* std::wstring */
1012 >;
1013
1014
1015 template <typename T>
1016 struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
1017 using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
1018 using _py_type_1 = conditional_t<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>;
1019 using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
1020 public:
1021
1022 bool load(handle src, bool convert) {
1023 py_type py_value;
1024
1025 if (!src)
1026 return false;
1027
1028 #if !defined(PYPY_VERSION)
1029 auto index_check = [](PyObject *o) { return PyIndex_Check(o); };
1030 #else
1031 // In PyPy 7.3.3, `PyIndex_Check` is implemented by calling `__index__`,
1032 // while CPython only considers the existence of `nb_index`/`__index__`.
1033 auto index_check = [](PyObject *o) { return hasattr(o, "__index__"); };
1034 #endif
1035
1036 if (std::is_floating_point<T>::value) {
1037 if (convert || PyFloat_Check(src.ptr()))
1038 py_value = (py_type) PyFloat_AsDouble(src.ptr());
1039 else
1040 return false;
1041 } else if (PyFloat_Check(src.ptr())) {
1042 return false;
1043 } else if (!convert && !PYBIND11_LONG_CHECK(src.ptr()) && !index_check(src.ptr())) {
1044 return false;
1045 } else {
1046 handle src_or_index = src;
1047 #if PY_VERSION_HEX < 0x03080000
1048 object index;
1049 if (!PYBIND11_LONG_CHECK(src.ptr())) { // So: index_check(src.ptr())
1050 index = reinterpret_steal<object>(PyNumber_Index(src.ptr()));
1051 if (!index) {
1052 PyErr_Clear();
1053 if (!convert)
1054 return false;
1055 }
1056 else {
1057 src_or_index = index;
1058 }
1059 }
1060 #endif
1061 if (std::is_unsigned<py_type>::value) {
1062 py_value = as_unsigned<py_type>(src_or_index.ptr());
1063 } else { // signed integer:
1064 py_value = sizeof(T) <= sizeof(long)
1065 ? (py_type) PyLong_AsLong(src_or_index.ptr())
1066 : (py_type) PYBIND11_LONG_AS_LONGLONG(src_or_index.ptr());
1067 }
1068 }
1069
1070 // Python API reported an error
1071 bool py_err = py_value == (py_type) -1 && PyErr_Occurred();
1072
1073 // Check to see if the conversion is valid (integers should match exactly)
1074 // Signed/unsigned checks happen elsewhere
1075 if (py_err || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) && py_value != (py_type) (T) py_value)) {
1076 PyErr_Clear();
1077 if (py_err && convert && PyNumber_Check(src.ptr())) {
1078 auto tmp = reinterpret_steal<object>(std::is_floating_point<T>::value
1079 ? PyNumber_Float(src.ptr())
1080 : PyNumber_Long(src.ptr()));
1081 PyErr_Clear();
1082 return load(tmp, false);
1083 }
1084 return false;
1085 }
1086
1087 value = (T) py_value;
1088 return true;
1089 }
1090
1091 template<typename U = T>
1092 static typename std::enable_if<std::is_floating_point<U>::value, handle>::type
1093 cast(U src, return_value_policy /* policy */, handle /* parent */) {
1094 return PyFloat_FromDouble((double) src);
1095 }
1096
1097 template<typename U = T>
1098 static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) <= sizeof(long)), handle>::type
1099 cast(U src, return_value_policy /* policy */, handle /* parent */) {
1100 return PYBIND11_LONG_FROM_SIGNED((long) src);
1101 }
1102
1103 template<typename U = T>
1104 static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) <= sizeof(unsigned long)), handle>::type
1105 cast(U src, return_value_policy /* policy */, handle /* parent */) {
1106 return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src);
1107 }
1108
1109 template<typename U = T>
1110 static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) > sizeof(long)), handle>::type
1111 cast(U src, return_value_policy /* policy */, handle /* parent */) {
1112 return PyLong_FromLongLong((long long) src);
1113 }
1114
1115 template<typename U = T>
1116 static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) > sizeof(unsigned long)), handle>::type
1117 cast(U src, return_value_policy /* policy */, handle /* parent */) {
1118 return PyLong_FromUnsignedLongLong((unsigned long long) src);
1119 }
1120
1121 PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
1122 };
1123
1124 template<typename T> struct void_caster {
1125 public:
1126 bool load(handle src, bool) {
1127 if (src && src.is_none())
1128 return true;
1129 return false;
1130 }
1131 static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
1132 return none().inc_ref();
1133 }
1134 PYBIND11_TYPE_CASTER(T, _("None"));
1135 };
1136
1137 template <> class type_caster<void_type> : public void_caster<void_type> {};
1138
1139 template <> class type_caster<void> : public type_caster<void_type> {
1140 public:
1141 using type_caster<void_type>::cast;
1142
1143 bool load(handle h, bool) {
1144 if (!h) {
1145 return false;
1146 } else if (h.is_none()) {
1147 value = nullptr;
1148 return true;
1149 }
1150
1151 /* Check if this is a capsule */
1152 if (isinstance<capsule>(h)) {
1153 value = reinterpret_borrow<capsule>(h);
1154 return true;
1155 }
1156
1157 /* Check if this is a C++ type */
1158 auto &bases = all_type_info((PyTypeObject *) type::handle_of(h).ptr());
1159 if (bases.size() == 1) { // Only allowing loading from a single-value type
1160 value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
1161 return true;
1162 }
1163
1164 /* Fail */
1165 return false;
1166 }
1167
1168 static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
1169 if (ptr)
1170 return capsule(ptr).release();
1171 else
1172 return none().inc_ref();
1173 }
1174
1175 template <typename T> using cast_op_type = void*&;
1176 operator void *&() { return value; }
1177 static constexpr auto name = _("capsule");
1178 private:
1179 void *value = nullptr;
1180 };
1181
1182 template <> class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> { };
1183
1184 template <> class type_caster<bool> {
1185 public:
1186 bool load(handle src, bool convert) {
1187 if (!src) return false;
1188 else if (src.ptr() == Py_True) { value = true; return true; }
1189 else if (src.ptr() == Py_False) { value = false; return true; }
1190 else if (convert || !strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name)) {
1191 // (allow non-implicit conversion for numpy booleans)
1192
1193 Py_ssize_t res = -1;
1194 if (src.is_none()) {
1195 res = 0; // None is implicitly converted to False
1196 }
1197 #if defined(PYPY_VERSION)
1198 // On PyPy, check that "__bool__" (or "__nonzero__" on Python 2.7) attr exists
1199 else if (hasattr(src, PYBIND11_BOOL_ATTR)) {
1200 res = PyObject_IsTrue(src.ptr());
1201 }
1202 #else
1203 // Alternate approach for CPython: this does the same as the above, but optimized
1204 // using the CPython API so as to avoid an unneeded attribute lookup.
1205 else if (auto tp_as_number = src.ptr()->ob_type->tp_as_number) {
1206 if (PYBIND11_NB_BOOL(tp_as_number)) {
1207 res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr());
1208 }
1209 }
1210 #endif
1211 if (res == 0 || res == 1) {
1212 value = (bool) res;
1213 return true;
1214 } else {
1215 PyErr_Clear();
1216 }
1217 }
1218 return false;
1219 }
1220 static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
1221 return handle(src ? Py_True : Py_False).inc_ref();
1222 }
1223 PYBIND11_TYPE_CASTER(bool, _("bool"));
1224 };
1225
1226 // Helper class for UTF-{8,16,32} C++ stl strings:
1227 template <typename StringType, bool IsView = false> struct string_caster {
1228 using CharT = typename StringType::value_type;
1229
1230 // Simplify life by being able to assume standard char sizes (the standard only guarantees
1231 // minimums, but Python requires exact sizes)
1232 static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1");
1233 #if defined(PYBIND11_HAS_U8STRING)
1234 static_assert(!std::is_same<CharT, char8_t>::value || sizeof(CharT) == 1, "Unsupported char8_t size != 1");
1235 #endif
1236 static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2");
1237 static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4");
1238 // wchar_t can be either 16 bits (Windows) or 32 (everywhere else)
1239 static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4,
1240 "Unsupported wchar_t size != 2/4");
1241 static constexpr size_t UTF_N = 8 * sizeof(CharT);
1242
1243 bool load(handle src, bool) {
1244 #if PY_MAJOR_VERSION < 3
1245 object temp;
1246 #endif
1247 handle load_src = src;
1248 if (!src) {
1249 return false;
1250 } else if (!PyUnicode_Check(load_src.ptr())) {
1251 #if PY_MAJOR_VERSION >= 3
1252 return load_bytes(load_src);
1253 #else
1254 if (std::is_same<CharT, char>::value) {
1255 return load_bytes(load_src);
1256 }
1257
1258 // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false
1259 if (!PYBIND11_BYTES_CHECK(load_src.ptr()))
1260 return false;
1261
1262 temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
1263 if (!temp) { PyErr_Clear(); return false; }
1264 load_src = temp;
1265 #endif
1266 }
1267
1268 auto utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString(
1269 load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
1270 if (!utfNbytes) { PyErr_Clear(); return false; }
1271
1272 const auto *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
1273 size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
1274 if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32
1275 value = StringType(buffer, length);
1276
1277 // If we're loading a string_view we need to keep the encoded Python object alive:
1278 if (IsView)
1279 loader_life_support::add_patient(utfNbytes);
1280
1281 return true;
1282 }
1283
1284 static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
1285 const char *buffer = reinterpret_cast<const char *>(src.data());
1286 auto nbytes = ssize_t(src.size() * sizeof(CharT));
1287 handle s = decode_utfN(buffer, nbytes);
1288 if (!s) throw error_already_set();
1289 return s;
1290 }
1291
1292 PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME));
1293
1294 private:
1295 static handle decode_utfN(const char *buffer, ssize_t nbytes) {
1296 #if !defined(PYPY_VERSION)
1297 return
1298 UTF_N == 8 ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) :
1299 UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) :
1300 PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
1301 #else
1302 // PyPy segfaults when on PyUnicode_DecodeUTF16 (and possibly on PyUnicode_DecodeUTF32 as well),
1303 // so bypass the whole thing by just passing the encoding as a string value, which works properly:
1304 return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr);
1305 #endif
1306 }
1307
1308 // When loading into a std::string or char*, accept a bytes object as-is (i.e.
1309 // without any encoding/decoding attempt). For other C++ char sizes this is a no-op.
1310 // which supports loading a unicode from a str, doesn't take this path.
1311 template <typename C = CharT>
1312 bool load_bytes(enable_if_t<std::is_same<C, char>::value, handle> src) {
1313 if (PYBIND11_BYTES_CHECK(src.ptr())) {
1314 // We were passed a Python 3 raw bytes; accept it into a std::string or char*
1315 // without any encoding attempt.
1316 const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr());
1317 if (bytes) {
1318 value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr()));
1319 return true;
1320 }
1321 }
1322
1323 return false;
1324 }
1325
1326 template <typename C = CharT>
1327 bool load_bytes(enable_if_t<!std::is_same<C, char>::value, handle>) { return false; }
1328 };
1329
1330 template <typename CharT, class Traits, class Allocator>
1331 struct type_caster<std::basic_string<CharT, Traits, Allocator>, enable_if_t<is_std_char_type<CharT>::value>>
1332 : string_caster<std::basic_string<CharT, Traits, Allocator>> {};
1333
1334 #ifdef PYBIND11_HAS_STRING_VIEW
1335 template <typename CharT, class Traits>
1336 struct type_caster<std::basic_string_view<CharT, Traits>, enable_if_t<is_std_char_type<CharT>::value>>
1337 : string_caster<std::basic_string_view<CharT, Traits>, true> {};
1338 #endif
1339
1340 // Type caster for C-style strings. We basically use a std::string type caster, but also add the
1341 // ability to use None as a nullptr char* (which the string caster doesn't allow).
1342 template <typename CharT> struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
1343 using StringType = std::basic_string<CharT>;
1344 using StringCaster = type_caster<StringType>;
1345 StringCaster str_caster;
1346 bool none = false;
1347 CharT one_char = 0;
1348 public:
1349 bool load(handle src, bool convert) {
1350 if (!src) return false;
1351 if (src.is_none()) {
1352 // Defer accepting None to other overloads (if we aren't in convert mode):
1353 if (!convert) return false;
1354 none = true;
1355 return true;
1356 }
1357 return str_caster.load(src, convert);
1358 }
1359
1360 static handle cast(const CharT *src, return_value_policy policy, handle parent) {
1361 if (src == nullptr) return pybind11::none().inc_ref();
1362 return StringCaster::cast(StringType(src), policy, parent);
1363 }
1364
1365 static handle cast(CharT src, return_value_policy policy, handle parent) {
1366 if (std::is_same<char, CharT>::value) {
1367 handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
1368 if (!s) throw error_already_set();
1369 return s;
1370 }
1371 return StringCaster::cast(StringType(1, src), policy, parent);
1372 }
1373
1374 operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
1375 operator CharT&() {
1376 if (none)
1377 throw value_error("Cannot convert None to a character");
1378
1379 auto &value = static_cast<StringType &>(str_caster);
1380 size_t str_len = value.size();
1381 if (str_len == 0)
1382 throw value_error("Cannot convert empty string to a character");
1383
1384 // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that
1385 // is too high, and one for multiple unicode characters (caught later), so we need to figure
1386 // out how long the first encoded character is in bytes to distinguish between these two
1387 // errors. We also allow want to allow unicode characters U+0080 through U+00FF, as those
1388 // can fit into a single char value.
1389 if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) {
1390 auto v0 = static_cast<unsigned char>(value[0]);
1391 size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127
1392 (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence
1393 (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence
1394 4; // 0b11110xxx - start of 4-byte sequence
1395
1396 if (char0_bytes == str_len) {
1397 // If we have a 128-255 value, we can decode it into a single char:
1398 if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx
1399 one_char = static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F));
1400 return one_char;
1401 }
1402 // Otherwise we have a single character, but it's > U+00FF
1403 throw value_error("Character code point not in range(0x100)");
1404 }
1405 }
1406
1407 // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a
1408 // surrogate pair with total length 2 instantly indicates a range error (but not a "your
1409 // string was too long" error).
1410 else if (StringCaster::UTF_N == 16 && str_len == 2) {
1411 one_char = static_cast<CharT>(value[0]);
1412 if (one_char >= 0xD800 && one_char < 0xE000)
1413 throw value_error("Character code point not in range(0x10000)");
1414 }
1415
1416 if (str_len != 1)
1417 throw value_error("Expected a character, but multi-character string found");
1418
1419 one_char = value[0];
1420 return one_char;
1421 }
1422
1423 static constexpr auto name = _(PYBIND11_STRING_NAME);
1424 template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>;
1425 };
1426
1427 // Base implementation for std::tuple and std::pair
1428 template <template<typename...> class Tuple, typename... Ts> class tuple_caster {
1429 using type = Tuple<Ts...>;
1430 static constexpr auto size = sizeof...(Ts);
1431 using indices = make_index_sequence<size>;
1432 public:
1433
1434 bool load(handle src, bool convert) {
1435 if (!isinstance<sequence>(src))
1436 return false;
1437 const auto seq = reinterpret_borrow<sequence>(src);
1438 if (seq.size() != size)
1439 return false;
1440 return load_impl(seq, convert, indices{});
1441 }
1442
1443 template <typename T>
1444 static handle cast(T &&src, return_value_policy policy, handle parent) {
1445 return cast_impl(std::forward<T>(src), policy, parent, indices{});
1446 }
1447
1448 // copied from the PYBIND11_TYPE_CASTER macro
1449 template <typename T>
1450 static handle cast(T *src, return_value_policy policy, handle parent) {
1451 if (!src) return none().release();
1452 if (policy == return_value_policy::take_ownership) {
1453 auto h = cast(std::move(*src), policy, parent); delete src; return h;
1454 } else {
1455 return cast(*src, policy, parent);
1456 }
1457 }
1458
1459 static constexpr auto name = _("Tuple[") + concat(make_caster<Ts>::name...) + _("]");
1460
1461 template <typename T> using cast_op_type = type;
1462
1463 operator type() & { return implicit_cast(indices{}); }
1464 operator type() && { return std::move(*this).implicit_cast(indices{}); }
1465
1466 protected:
1467 template <size_t... Is>
1468 type implicit_cast(index_sequence<Is...>) & { return type(cast_op<Ts>(std::get<Is>(subcasters))...); }
1469 template <size_t... Is>
1470 type implicit_cast(index_sequence<Is...>) && { return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...); }
1471
1472 static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
1473
1474 template <size_t... Is>
1475 bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
1476 #ifdef __cpp_fold_expressions
1477 if ((... || !std::get<Is>(subcasters).load(seq[Is], convert)))
1478 return false;
1479 #else
1480 for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...})
1481 if (!r)
1482 return false;
1483 #endif
1484 return true;
1485 }
1486
1487 /* Implementation: Convert a C++ tuple into a Python tuple */
1488 template <typename T, size_t... Is>
1489 static handle cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence<Is...>) {
1490 std::array<object, size> entries{{
1491 reinterpret_steal<object>(make_caster<Ts>::cast(std::get<Is>(std::forward<T>(src)), policy, parent))...
1492 }};
1493 for (const auto &entry: entries)
1494 if (!entry)
1495 return handle();
1496 tuple result(size);
1497 int counter = 0;
1498 for (auto & entry: entries)
1499 PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
1500 return result.release();
1501 }
1502
1503 Tuple<make_caster<Ts>...> subcasters;
1504 };
1505
1506 template <typename T1, typename T2> class type_caster<std::pair<T1, T2>>
1507 : public tuple_caster<std::pair, T1, T2> {};
1508
1509 template <typename... Ts> class type_caster<std::tuple<Ts...>>
1510 : public tuple_caster<std::tuple, Ts...> {};
1511
1512 /// Helper class which abstracts away certain actions. Users can provide specializations for
1513 /// custom holders, but it's only necessary if the type has a non-standard interface.
1514 template <typename T>
1515 struct holder_helper {
1516 static auto get(const T &p) -> decltype(p.get()) { return p.get(); }
1517 };
1518
1519 /// Type caster for holder types like std::shared_ptr, etc.
1520 template <typename type, typename holder_type>
1521 struct copyable_holder_caster : public type_caster_base<type> {
1522 public:
1523 using base = type_caster_base<type>;
1524 static_assert(std::is_base_of<base, type_caster<type>>::value,
1525 "Holder classes are only supported for custom types");
1526 using base::base;
1527 using base::cast;
1528 using base::typeinfo;
1529 using base::value;
1530
1531 bool load(handle src, bool convert) {
1532 return base::template load_impl<copyable_holder_caster<type, holder_type>>(src, convert);
1533 }
1534
1535 explicit operator type*() { return this->value; }
1536 // static_cast works around compiler error with MSVC 17 and CUDA 10.2
1537 // see issue #2180
1538 explicit operator type&() { return *(static_cast<type *>(this->value)); }
1539 explicit operator holder_type*() { return std::addressof(holder); }
1540 explicit operator holder_type&() { return holder; }
1541
1542 static handle cast(const holder_type &src, return_value_policy, handle) {
1543 const auto *ptr = holder_helper<holder_type>::get(src);
1544 return type_caster_base<type>::cast_holder(ptr, &src);
1545 }
1546
1547 protected:
1548 friend class type_caster_generic;
1549 void check_holder_compat() {
1550 if (typeinfo->default_holder)
1551 throw cast_error("Unable to load a custom holder type from a default-holder instance");
1552 }
1553
1554 bool load_value(value_and_holder &&v_h) {
1555 if (v_h.holder_constructed()) {
1556 value = v_h.value_ptr();
1557 holder = v_h.template holder<holder_type>();
1558 return true;
1559 } else {
1560 throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
1561 #if defined(NDEBUG)
1562 "(compile in debug mode for type information)");
1563 #else
1564 "of type '" + type_id<holder_type>() + "''");
1565 #endif
1566 }
1567 }
1568
1569 template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
1570 bool try_implicit_casts(handle, bool) { return false; }
1571
1572 template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
1573 bool try_implicit_casts(handle src, bool convert) {
1574 for (auto &cast : typeinfo->implicit_casts) {
1575 copyable_holder_caster sub_caster(*cast.first);
1576 if (sub_caster.load(src, convert)) {
1577 value = cast.second(sub_caster.value);
1578 holder = holder_type(sub_caster.holder, (type *) value);
1579 return true;
1580 }
1581 }
1582 return false;
1583 }
1584
1585 static bool try_direct_conversions(handle) { return false; }
1586
1587
1588 holder_type holder;
1589 };
1590
1591 /// Specialize for the common std::shared_ptr, so users don't need to
1592 template <typename T>
1593 class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
1594
1595 template <typename type, typename holder_type>
1596 struct move_only_holder_caster {
1597 static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
1598 "Holder classes are only supported for custom types");
1599
1600 static handle cast(holder_type &&src, return_value_policy, handle) {
1601 auto *ptr = holder_helper<holder_type>::get(src);
1602 return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
1603 }
1604 static constexpr auto name = type_caster_base<type>::name;
1605 };
1606
1607 template <typename type, typename deleter>
1608 class type_caster<std::unique_ptr<type, deleter>>
1609 : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { };
1610
1611 template <typename type, typename holder_type>
1612 using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
1613 copyable_holder_caster<type, holder_type>,
1614 move_only_holder_caster<type, holder_type>>;
1615
1616 template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };
1617
1618 /// Create a specialization for custom holder types (silently ignores std::shared_ptr)
1619 #define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \
1620 namespace pybind11 { namespace detail { \
1621 template <typename type> \
1622 struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__> { }; \
1623 template <typename type> \
1624 class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
1625 : public type_caster_holder<type, holder_type> { }; \
1626 }}
1627
1628 // PYBIND11_DECLARE_HOLDER_TYPE holder types:
1629 template <typename base, typename holder> struct is_holder_type :
1630 std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
1631 // Specialization for always-supported unique_ptr holders:
1632 template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
1633 std::true_type {};
1634
1635 template <typename T> struct handle_type_name { static constexpr auto name = _<T>(); };
1636 template <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); };
1637 template <> struct handle_type_name<int_> { static constexpr auto name = _("int"); };
1638 template <> struct handle_type_name<iterable> { static constexpr auto name = _("Iterable"); };
1639 template <> struct handle_type_name<iterator> { static constexpr auto name = _("Iterator"); };
1640 template <> struct handle_type_name<none> { static constexpr auto name = _("None"); };
1641 template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
1642 template <> struct handle_type_name<kwargs> { static constexpr auto name = _("**kwargs"); };
1643
1644 template <typename type>
1645 struct pyobject_caster {
1646 template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
1647 bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); }
1648
1649 template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
1650 bool load(handle src, bool /* convert */) {
1651 if (!isinstance<type>(src))
1652 return false;
1653 value = reinterpret_borrow<type>(src);
1654 return true;
1655 }
1656
1657 static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
1658 return src.inc_ref();
1659 }
1660 PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
1661 };
1662
1663 template <typename T>
1664 class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };
1665
1666 // Our conditions for enabling moving are quite restrictive:
1667 // At compile time:
1668 // - T needs to be a non-const, non-pointer, non-reference type
1669 // - type_caster<T>::operator T&() must exist
1670 // - the type must be move constructible (obviously)
1671 // At run-time:
1672 // - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
1673 // must have ref_count() == 1)h
1674 // If any of the above are not satisfied, we fall back to copying.
1675 template <typename T> using move_is_plain_type = satisfies_none_of<T,
1676 std::is_void, std::is_pointer, std::is_reference, std::is_const
1677 >;
1678 template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
1679 template <typename T> struct move_always<T, enable_if_t<all_of<
1680 move_is_plain_type<T>,
1681 negation<is_copy_constructible<T>>,
1682 std::is_move_constructible<T>,
1683 std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1684 >::value>> : std::true_type {};
1685 template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
1686 template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
1687 move_is_plain_type<T>,
1688 negation<move_always<T>>,
1689 std::is_move_constructible<T>,
1690 std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1691 >::value>> : std::true_type {};
1692 template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
1693
1694 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
1695 // reference or pointer to a local variable of the type_caster. Basically, only
1696 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
1697 // everything else returns a reference/pointer to a local variable.
1698 template <typename type> using cast_is_temporary_value_reference = bool_constant<
1699 (std::is_reference<type>::value || std::is_pointer<type>::value) &&
1700 !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
1701 !std::is_same<intrinsic_t<type>, void>::value
1702 >;
1703
1704 // When a value returned from a C++ function is being cast back to Python, we almost always want to
1705 // force `policy = move`, regardless of the return value policy the function/method was declared
1706 // with.
1707 template <typename Return, typename SFINAE = void> struct return_value_policy_override {
1708 static return_value_policy policy(return_value_policy p) { return p; }
1709 };
1710
1711 template <typename Return> struct return_value_policy_override<Return,
1712 detail::enable_if_t<std::is_base_of<type_caster_generic, make_caster<Return>>::value, void>> {
1713 static return_value_policy policy(return_value_policy p) {
1714 return !std::is_lvalue_reference<Return>::value &&
1715 !std::is_pointer<Return>::value
1716 ? return_value_policy::move : p;
1717 }
1718 };
1719
1720 // Basic python -> C++ casting; throws if casting fails
1721 template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1722 if (!conv.load(handle, true)) {
1723 #if defined(NDEBUG)
1724 throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
1725 #else
1726 throw cast_error("Unable to cast Python instance of type " +
1727 (std::string) str(type::handle_of(handle)) + " to C++ type '" + type_id<T>() + "'");
1728 #endif
1729 }
1730 return conv;
1731 }
1732 // Wrapper around the above that also constructs and returns a type_caster
1733 template <typename T> make_caster<T> load_type(const handle &handle) {
1734 make_caster<T> conv;
1735 load_type(conv, handle);
1736 return conv;
1737 }
1738
1739 PYBIND11_NAMESPACE_END(detail)
1740
1741 // pytype -> C++ type
1742 template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
1743 T cast(const handle &handle) {
1744 using namespace detail;
1745 static_assert(!cast_is_temporary_value_reference<T>::value,
1746 "Unable to cast type to reference: value is local to type caster");
1747 return cast_op<T>(load_type<T>(handle));
1748 }
1749
1750 // pytype -> pytype (calls converting constructor)
1751 template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
1752 T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); }
1753
1754 // C++ type -> py::object
1755 template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
1756 object cast(T &&value, return_value_policy policy = return_value_policy::automatic_reference,
1757 handle parent = handle()) {
1758 using no_ref_T = typename std::remove_reference<T>::type;
1759 if (policy == return_value_policy::automatic)
1760 policy = std::is_pointer<no_ref_T>::value ? return_value_policy::take_ownership :
1761 std::is_lvalue_reference<T>::value ? return_value_policy::copy : return_value_policy::move;
1762 else if (policy == return_value_policy::automatic_reference)
1763 policy = std::is_pointer<no_ref_T>::value ? return_value_policy::reference :
1764 std::is_lvalue_reference<T>::value ? return_value_policy::copy : return_value_policy::move;
1765 return reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(value), policy, parent));
1766 }
1767
1768 template <typename T> T handle::cast() const { return pybind11::cast<T>(*this); }
1769 template <> inline void handle::cast() const { return; }
1770
1771 template <typename T>
1772 detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
1773 if (obj.ref_count() > 1)
1774 #if defined(NDEBUG)
1775 throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
1776 " (compile in debug mode for details)");
1777 #else
1778 throw cast_error("Unable to move from Python " + (std::string) str(type::handle_of(obj)) +
1779 " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
1780 #endif
1781
1782 // Move into a temporary and return that, because the reference may be a local value of `conv`
1783 T ret = std::move(detail::load_type<T>(obj).operator T&());
1784 return ret;
1785 }
1786
1787 // Calling cast() on an rvalue calls pybind11::cast with the object rvalue, which does:
1788 // - If we have to move (because T has no copy constructor), do it. This will fail if the moved
1789 // object has multiple references, but trying to copy will fail to compile.
1790 // - If both movable and copyable, check ref count: if 1, move; otherwise copy
1791 // - Otherwise (not movable), copy.
1792 template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1793 return move<T>(std::move(object));
1794 }
1795 template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1796 if (object.ref_count() > 1)
1797 return cast<T>(object);
1798 else
1799 return move<T>(std::move(object));
1800 }
1801 template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1802 return cast<T>(object);
1803 }
1804
1805 template <typename T> T object::cast() const & { return pybind11::cast<T>(*this); }
1806 template <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); }
1807 template <> inline void object::cast() const & { return; }
1808 template <> inline void object::cast() && { return; }
1809
1810 PYBIND11_NAMESPACE_BEGIN(detail)
1811
1812 // Declared in pytypes.h:
1813 template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
1814 object object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); }
1815
1816 struct override_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the PYBIND11_OVERRIDE_OVERRIDE macro
1817 template <typename ret_type> using override_caster_t = conditional_t<
1818 cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, override_unused>;
1819
1820 // Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
1821 // store the result in the given variable. For other types, this is a no-op.
1822 template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
1823 return cast_op<T>(load_type(caster, o));
1824 }
1825 template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, override_unused &) {
1826 pybind11_fail("Internal error: cast_ref fallback invoked"); }
1827
1828 // Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
1829 // though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
1830 // cases where pybind11::cast is valid.
1831 template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
1832 return pybind11::cast<T>(std::move(o)); }
1833 template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
1834 pybind11_fail("Internal error: cast_safe fallback invoked"); }
1835 template <> inline void cast_safe<void>(object &&) {}
1836
1837 PYBIND11_NAMESPACE_END(detail)
1838
1839 template <return_value_policy policy = return_value_policy::automatic_reference>
1840 tuple make_tuple() { return tuple(0); }
1841
1842 template <return_value_policy policy = return_value_policy::automatic_reference,
1843 typename... Args> tuple make_tuple(Args&&... args_) {
1844 constexpr size_t size = sizeof...(Args);
1845 std::array<object, size> args {
1846 { reinterpret_steal<object>(detail::make_caster<Args>::cast(
1847 std::forward<Args>(args_), policy, nullptr))... }
1848 };
1849 for (size_t i = 0; i < args.size(); i++) {
1850 if (!args[i]) {
1851 #if defined(NDEBUG)
1852 throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
1853 #else
1854 std::array<std::string, size> argtypes { {type_id<Args>()...} };
1855 throw cast_error("make_tuple(): unable to convert argument of type '" +
1856 argtypes[i] + "' to Python object");
1857 #endif
1858 }
1859 }
1860 tuple result(size);
1861 int counter = 0;
1862 for (auto &arg_value : args)
1863 PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
1864 return result;
1865 }
1866
1867 /// \ingroup annotations
1868 /// Annotation for arguments
1869 struct arg {
1870 /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument.
1871 constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { }
1872 /// Assign a value to this argument
1873 template <typename T> arg_v operator=(T &&value) const;
1874 /// Indicate that the type should not be converted in the type caster
1875 arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; }
1876 /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args)
1877 arg &none(bool flag = true) { flag_none = flag; return *this; }
1878
1879 const char *name; ///< If non-null, this is a named kwargs argument
1880 bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!)
1881 bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument
1882 };
1883
1884 /// \ingroup annotations
1885 /// Annotation for arguments with values
1886 struct arg_v : arg {
1887 private:
1888 template <typename T>
1889 arg_v(arg &&base, T &&x, const char *descr = nullptr)
1890 : arg(base),
1891 value(reinterpret_steal<object>(
1892 detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
1893 )),
1894 descr(descr)
1895 #if !defined(NDEBUG)
1896 , type(type_id<T>())
1897 #endif
1898 {
1899 // Workaround! See:
1900 // https://github.com/pybind/pybind11/issues/2336
1901 // https://github.com/pybind/pybind11/pull/2685#issuecomment-731286700
1902 if (PyErr_Occurred()) {
1903 PyErr_Clear();
1904 }
1905 }
1906
1907 public:
1908 /// Direct construction with name, default, and description
1909 template <typename T>
1910 arg_v(const char *name, T &&x, const char *descr = nullptr)
1911 : arg_v(arg(name), std::forward<T>(x), descr) { }
1912
1913 /// Called internally when invoking `py::arg("a") = value`
1914 template <typename T>
1915 arg_v(const arg &base, T &&x, const char *descr = nullptr)
1916 : arg_v(arg(base), std::forward<T>(x), descr) { }
1917
1918 /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg&
1919 arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; }
1920
1921 /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg&
1922 arg_v &none(bool flag = true) { arg::none(flag); return *this; }
1923
1924 /// The default value
1925 object value;
1926 /// The (optional) description of the default value
1927 const char *descr;
1928 #if !defined(NDEBUG)
1929 /// The C++ type name of the default value (only available when compiled in debug mode)
1930 std::string type;
1931 #endif
1932 };
1933
1934 /// \ingroup annotations
1935 /// Annotation indicating that all following arguments are keyword-only; the is the equivalent of an
1936 /// unnamed '*' argument (in Python 3)
1937 struct kw_only {};
1938
1939 /// \ingroup annotations
1940 /// Annotation indicating that all previous arguments are positional-only; the is the equivalent of an
1941 /// unnamed '/' argument (in Python 3.8)
1942 struct pos_only {};
1943
1944 template <typename T>
1945 arg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward<T>(value)}; }
1946
1947 /// Alias for backward compatibility -- to be removed in version 2.0
1948 template <typename /*unused*/> using arg_t = arg_v;
1949
1950 inline namespace literals {
1951 /** \rst
1952 String literal version of `arg`
1953 \endrst */
1954 constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
1955 } // namespace literals
1956
1957 PYBIND11_NAMESPACE_BEGIN(detail)
1958
1959 // forward declaration (definition in attr.h)
1960 struct function_record;
1961
1962 /// Internal data associated with a single function call
1963 struct function_call {
1964 function_call(const function_record &f, handle p); // Implementation in attr.h
1965
1966 /// The function data:
1967 const function_record &func;
1968
1969 /// Arguments passed to the function:
1970 std::vector<handle> args;
1971
1972 /// The `convert` value the arguments should be loaded with
1973 std::vector<bool> args_convert;
1974
1975 /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if
1976 /// present, are also in `args` but without a reference).
1977 object args_ref, kwargs_ref;
1978
1979 /// The parent, if any
1980 handle parent;
1981
1982 /// If this is a call to an initializer, this argument contains `self`
1983 handle init_self;
1984 };
1985
1986
1987 /// Helper class which loads arguments for C++ functions called from Python
1988 template <typename... Args>
1989 class argument_loader {
1990 using indices = make_index_sequence<sizeof...(Args)>;
1991
1992 template <typename Arg> using argument_is_args = std::is_same<intrinsic_t<Arg>, args>;
1993 template <typename Arg> using argument_is_kwargs = std::is_same<intrinsic_t<Arg>, kwargs>;
1994 // Get args/kwargs argument positions relative to the end of the argument list:
1995 static constexpr auto args_pos = constexpr_first<argument_is_args, Args...>() - (int) sizeof...(Args),
1996 kwargs_pos = constexpr_first<argument_is_kwargs, Args...>() - (int) sizeof...(Args);
1997
1998 static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1;
1999
2000 static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function");
2001
2002 public:
2003 static constexpr bool has_kwargs = kwargs_pos < 0;
2004 static constexpr bool has_args = args_pos < 0;
2005
2006 static constexpr auto arg_names = concat(type_descr(make_caster<Args>::name)...);
2007
2008 bool load_args(function_call &call) {
2009 return load_impl_sequence(call, indices{});
2010 }
2011
2012 template <typename Return, typename Guard, typename Func>
2013 enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
2014 return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
2015 }
2016
2017 template <typename Return, typename Guard, typename Func>
2018 enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) && {
2019 std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
2020 return void_type();
2021 }
2022
2023 private:
2024
2025 static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
2026
2027 template <size_t... Is>
2028 bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
2029 #ifdef __cpp_fold_expressions
2030 if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
2031 return false;
2032 #else
2033 for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
2034 if (!r)
2035 return false;
2036 #endif
2037 return true;
2038 }
2039
2040 template <typename Return, typename Func, size_t... Is, typename Guard>
2041 Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) && {
2042 return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
2043 }
2044
2045 std::tuple<make_caster<Args>...> argcasters;
2046 };
2047
2048 /// Helper class which collects only positional arguments for a Python function call.
2049 /// A fancier version below can collect any argument, but this one is optimal for simple calls.
2050 template <return_value_policy policy>
2051 class simple_collector {
2052 public:
2053 template <typename... Ts>
2054 explicit simple_collector(Ts &&...values)
2055 : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { }
2056
2057 const tuple &args() const & { return m_args; }
2058 dict kwargs() const { return {}; }
2059
2060 tuple args() && { return std::move(m_args); }
2061
2062 /// Call a Python function and pass the collected arguments
2063 object call(PyObject *ptr) const {
2064 PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
2065 if (!result)
2066 throw error_already_set();
2067 return reinterpret_steal<object>(result);
2068 }
2069
2070 private:
2071 tuple m_args;
2072 };
2073
2074 /// Helper class which collects positional, keyword, * and ** arguments for a Python function call
2075 template <return_value_policy policy>
2076 class unpacking_collector {
2077 public:
2078 template <typename... Ts>
2079 explicit unpacking_collector(Ts &&...values) {
2080 // Tuples aren't (easily) resizable so a list is needed for collection,
2081 // but the actual function call strictly requires a tuple.
2082 auto args_list = list();
2083 int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
2084 ignore_unused(_);
2085
2086 m_args = std::move(args_list);
2087 }
2088
2089 const tuple &args() const & { return m_args; }
2090 const dict &kwargs() const & { return m_kwargs; }
2091
2092 tuple args() && { return std::move(m_args); }
2093 dict kwargs() && { return std::move(m_kwargs); }
2094
2095 /// Call a Python function and pass the collected arguments
2096 object call(PyObject *ptr) const {
2097 PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
2098 if (!result)
2099 throw error_already_set();
2100 return reinterpret_steal<object>(result);
2101 }
2102
2103 private:
2104 template <typename T>
2105 void process(list &args_list, T &&x) {
2106 auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
2107 if (!o) {
2108 #if defined(NDEBUG)
2109 argument_cast_error();
2110 #else
2111 argument_cast_error(std::to_string(args_list.size()), type_id<T>());
2112 #endif
2113 }
2114 args_list.append(o);
2115 }
2116
2117 void process(list &args_list, detail::args_proxy ap) {
2118 for (auto a : ap)
2119 args_list.append(a);
2120 }
2121
2122 void process(list &/*args_list*/, arg_v a) {
2123 if (!a.name)
2124 #if defined(NDEBUG)
2125 nameless_argument_error();
2126 #else
2127 nameless_argument_error(a.type);
2128 #endif
2129
2130 if (m_kwargs.contains(a.name)) {
2131 #if defined(NDEBUG)
2132 multiple_values_error();
2133 #else
2134 multiple_values_error(a.name);
2135 #endif
2136 }
2137 if (!a.value) {
2138 #if defined(NDEBUG)
2139 argument_cast_error();
2140 #else
2141 argument_cast_error(a.name, a.type);
2142 #endif
2143 }
2144 m_kwargs[a.name] = a.value;
2145 }
2146
2147 void process(list &/*args_list*/, detail::kwargs_proxy kp) {
2148 if (!kp)
2149 return;
2150 for (auto k : reinterpret_borrow<dict>(kp)) {
2151 if (m_kwargs.contains(k.first)) {
2152 #if defined(NDEBUG)
2153 multiple_values_error();
2154 #else
2155 multiple_values_error(str(k.first));
2156 #endif
2157 }
2158 m_kwargs[k.first] = k.second;
2159 }
2160 }
2161
2162 [[noreturn]] static void nameless_argument_error() {
2163 throw type_error("Got kwargs without a name; only named arguments "
2164 "may be passed via py::arg() to a python function call. "
2165 "(compile in debug mode for details)");
2166 }
2167 [[noreturn]] static void nameless_argument_error(std::string type) {
2168 throw type_error("Got kwargs without a name of type '" + type + "'; only named "
2169 "arguments may be passed via py::arg() to a python function call. ");
2170 }
2171 [[noreturn]] static void multiple_values_error() {
2172 throw type_error("Got multiple values for keyword argument "
2173 "(compile in debug mode for details)");
2174 }
2175
2176 [[noreturn]] static void multiple_values_error(std::string name) {
2177 throw type_error("Got multiple values for keyword argument '" + name + "'");
2178 }
2179
2180 [[noreturn]] static void argument_cast_error() {
2181 throw cast_error("Unable to convert call argument to Python object "
2182 "(compile in debug mode for details)");
2183 }
2184
2185 [[noreturn]] static void argument_cast_error(std::string name, std::string type) {
2186 throw cast_error("Unable to convert call argument '" + name
2187 + "' of type '" + type + "' to Python object");
2188 }
2189
2190 private:
2191 tuple m_args;
2192 dict m_kwargs;
2193 };
2194
2195 // [workaround(intel)] Separate function required here
2196 // We need to put this into a separate function because the Intel compiler
2197 // fails to compile enable_if_t<!all_of<is_positional<Args>...>::value>
2198 // (tested with ICC 2021.1 Beta 20200827).
2199 template <typename... Args>
2200 constexpr bool args_are_all_positional()
2201 {
2202 return all_of<is_positional<Args>...>::value;
2203 }
2204
2205 /// Collect only positional arguments for a Python function call
2206 template <return_value_policy policy, typename... Args,
2207 typename = enable_if_t<args_are_all_positional<Args...>()>>
2208 simple_collector<policy> collect_arguments(Args &&...args) {
2209 return simple_collector<policy>(std::forward<Args>(args)...);
2210 }
2211
2212 /// Collect all arguments, including keywords and unpacking (only instantiated when needed)
2213 template <return_value_policy policy, typename... Args,
2214 typename = enable_if_t<!args_are_all_positional<Args...>()>>
2215 unpacking_collector<policy> collect_arguments(Args &&...args) {
2216 // Following argument order rules for generalized unpacking according to PEP 448
2217 static_assert(
2218 constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>()
2219 && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(),
2220 "Invalid function call: positional args must precede keywords and ** unpacking; "
2221 "* unpacking must precede ** unpacking"
2222 );
2223 return unpacking_collector<policy>(std::forward<Args>(args)...);
2224 }
2225
2226 template <typename Derived>
2227 template <return_value_policy policy, typename... Args>
2228 object object_api<Derived>::operator()(Args &&...args) const {
2229 return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
2230 }
2231
2232 template <typename Derived>
2233 template <return_value_policy policy, typename... Args>
2234 object object_api<Derived>::call(Args &&...args) const {
2235 return operator()<policy>(std::forward<Args>(args)...);
2236 }
2237
2238 PYBIND11_NAMESPACE_END(detail)
2239
2240
2241 template<typename T>
2242 handle type::handle_of() {
2243 static_assert(
2244 std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>::value,
2245 "py::type::of<T> only supports the case where T is a registered C++ types."
2246 );
2247
2248 return detail::get_type_handle(typeid(T), true);
2249 }
2250
2251
2252 #define PYBIND11_MAKE_OPAQUE(...) \
2253 namespace pybind11 { namespace detail { \
2254 template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \
2255 }}
2256
2257 /// Lets you pass a type containing a `,` through a macro parameter without needing a separate
2258 /// typedef, e.g.: `PYBIND11_OVERRIDE(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)`
2259 #define PYBIND11_TYPE(...) __VA_ARGS__
2260
2261 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
2262