cast.h revision 11986:c12e4625ab56 
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 "typeid.h"
15#include "descr.h"
16#include <array>
17#include <limits>
18
19NAMESPACE_BEGIN(pybind11)
20NAMESPACE_BEGIN(detail)
21
22/// Additional type information which does not fit into the PyTypeObject
23struct type_info {
24    PyTypeObject *type;
25    size_t type_size;
26    void (*init_holder)(PyObject *, const void *);
27    std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
28    std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
29    std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
30    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
31    void *get_buffer_data = nullptr;
32    /** A simple type never occurs as a (direct or indirect) parent
33     * of a class that makes use of multiple inheritance */
34    bool simple_type = true;
35};
36
37PYBIND11_NOINLINE inline internals &get_internals() {
38    static internals *internals_ptr = nullptr;
39    if (internals_ptr)
40        return *internals_ptr;
41    handle builtins(PyEval_GetBuiltins());
42    const char *id = PYBIND11_INTERNALS_ID;
43    if (builtins.contains(id) && isinstance<capsule>(builtins[id])) {
44        internals_ptr = capsule(builtins[id]);
45    } else {
46        internals_ptr = new internals();
47        #if defined(WITH_THREAD)
48            PyEval_InitThreads();
49            PyThreadState *tstate = PyThreadState_Get();
50            internals_ptr->tstate = PyThread_create_key();
51            PyThread_set_key_value(internals_ptr->tstate, tstate);
52            internals_ptr->istate = tstate->interp;
53        #endif
54        builtins[id] = capsule(internals_ptr);
55        internals_ptr->registered_exception_translators.push_front(
56            [](std::exception_ptr p) -> void {
57                try {
58                    if (p) std::rethrow_exception(p);
59                } catch (error_already_set &e)           { e.restore();                                    return;
60                } catch (const builtin_exception &e)     { e.set_error();                                  return;
61                } catch (const std::bad_alloc &e)        { PyErr_SetString(PyExc_MemoryError,   e.what()); return;
62                } catch (const std::domain_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
63                } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError,    e.what()); return;
64                } catch (const std::length_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
65                } catch (const std::out_of_range &e)     { PyErr_SetString(PyExc_IndexError,    e.what()); return;
66                } catch (const std::range_error &e)      { PyErr_SetString(PyExc_ValueError,    e.what()); return;
67                } catch (const std::exception &e)        { PyErr_SetString(PyExc_RuntimeError,  e.what()); return;
68                } catch (...) {
69                    PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
70                    return;
71                }
72            }
73        );
74    }
75    return *internals_ptr;
76}
77
78PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
79    auto const &type_dict = get_internals().registered_types_py;
80    do {
81        auto it = type_dict.find(type);
82        if (it != type_dict.end())
83            return (detail::type_info *) it->second;
84        type = type->tp_base;
85        if (!type)
86            return nullptr;
87    } while (true);
88}
89
90PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_info &tp,
91                                                          bool throw_if_missing = false) {
92    auto &types = get_internals().registered_types_cpp;
93
94    auto it = types.find(std::type_index(tp));
95    if (it != types.end())
96        return (detail::type_info *) it->second;
97    if (throw_if_missing) {
98        std::string tname = tp.name();
99        detail::clean_type_id(tname);
100        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
101    }
102    return nullptr;
103}
104
105PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
106    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
107    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
108}
109
110PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
111    const auto type = detail::get_type_handle(tp, false);
112    if (!type)
113        return false;
114
115    const auto result = PyObject_IsInstance(obj.ptr(), type.ptr());
116    if (result == -1)
117        throw error_already_set();
118    return result != 0;
119}
120
121PYBIND11_NOINLINE inline std::string error_string() {
122    if (!PyErr_Occurred()) {
123        PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
124        return "Unknown internal error occurred";
125    }
126
127    error_scope scope; // Preserve error state
128
129    std::string errorString;
130    if (scope.type) {
131        errorString += handle(scope.type).attr("__name__").cast<std::string>();
132        errorString += ": ";
133    }
134    if (scope.value)
135        errorString += (std::string) str(scope.value);
136
137    PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
138
139#if PY_MAJOR_VERSION >= 3
140    if (scope.trace != nullptr)
141        PyException_SetTraceback(scope.value, scope.trace);
142#endif
143
144    if (scope.trace) {
145        PyTracebackObject *trace = (PyTracebackObject *) scope.trace;
146
147        /* Get the deepest trace possible */
148        while (trace->tb_next)
149            trace = trace->tb_next;
150
151        PyFrameObject *frame = trace->tb_frame;
152        errorString += "\n\nAt:\n";
153        while (frame) {
154            int lineno = PyFrame_GetLineNumber(frame);
155            errorString +=
156                "  " + handle(frame->f_code->co_filename).cast<std::string>() +
157                "(" + std::to_string(lineno) + "): " +
158                handle(frame->f_code->co_name).cast<std::string>() + "\n";
159            frame = frame->f_back;
160        }
161        trace = trace->tb_next;
162    }
163
164    return errorString;
165}
166
167PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
168    auto &instances = get_internals().registered_instances;
169    auto range = instances.equal_range(ptr);
170    for (auto it = range.first; it != range.second; ++it) {
171        auto instance_type = detail::get_type_info(Py_TYPE(it->second));
172        if (instance_type && instance_type == type)
173            return handle((PyObject *) it->second);
174    }
175    return handle();
176}
177
178inline PyThreadState *get_thread_state_unchecked() {
179#if   PY_VERSION_HEX < 0x03000000
180    return _PyThreadState_Current;
181#elif PY_VERSION_HEX < 0x03050000
182    return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
183#elif PY_VERSION_HEX < 0x03050200
184    return (PyThreadState*) _PyThreadState_Current.value;
185#else
186    return _PyThreadState_UncheckedGet();
187#endif
188}
189
190// Forward declaration
191inline void keep_alive_impl(handle nurse, handle patient);
192
193class type_caster_generic {
194public:
195    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
196     : typeinfo(get_type_info(type_info)) { }
197
198    PYBIND11_NOINLINE bool load(handle src, bool convert) {
199        if (!src)
200            return false;
201        return load(src, convert, Py_TYPE(src.ptr()));
202    }
203
204    bool load(handle src, bool convert, PyTypeObject *tobj) {
205        if (!src || !typeinfo)
206            return false;
207        if (src.is_none()) {
208            value = nullptr;
209            return true;
210        }
211
212        if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
213            /* Check if we can safely perform a reinterpret-style cast */
214            if (PyType_IsSubtype(tobj, typeinfo->type)) {
215                value = reinterpret_cast<instance<void> *>(src.ptr())->value;
216                return true;
217            }
218        } else { /* Case 2: multiple inheritance */
219            /* Check if we can safely perform a reinterpret-style cast */
220            if (tobj == typeinfo->type) {
221                value = reinterpret_cast<instance<void> *>(src.ptr())->value;
222                return true;
223            }
224
225            /* If this is a python class, also check the parents recursively */
226            auto const &type_dict = get_internals().registered_types_py;
227            bool new_style_class = PyType_Check(tobj);
228            if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
229                auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
230                for (handle parent : parents) {
231                    bool result = load(src, convert, (PyTypeObject *) parent.ptr());
232                    if (result)
233                        return true;
234                }
235            }
236
237            /* Try implicit casts */
238            for (auto &cast : typeinfo->implicit_casts) {
239                type_caster_generic sub_caster(*cast.first);
240                if (sub_caster.load(src, convert)) {
241                    value = cast.second(sub_caster.value);
242                    return true;
243                }
244            }
245        }
246
247        /* Perform an implicit conversion */
248        if (convert) {
249            for (auto &converter : typeinfo->implicit_conversions) {
250                temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
251                if (load(temp, false))
252                    return true;
253            }
254            for (auto &converter : *typeinfo->direct_conversions) {
255                if (converter(src.ptr(), value))
256                    return true;
257            }
258        }
259        return false;
260    }
261
262    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
263                                         const std::type_info *type_info,
264                                         const std::type_info *type_info_backup,
265                                         void *(*copy_constructor)(const void *),
266                                         void *(*move_constructor)(const void *),
267                                         const void *existing_holder = nullptr) {
268        void *src = const_cast<void *>(_src);
269        if (src == nullptr)
270            return none().inc_ref();
271
272        auto &internals = get_internals();
273
274        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
275        if (it == internals.registered_types_cpp.end()) {
276            type_info = type_info_backup;
277            it = internals.registered_types_cpp.find(std::type_index(*type_info));
278        }
279
280        if (it == internals.registered_types_cpp.end()) {
281            std::string tname = type_info->name();
282            detail::clean_type_id(tname);
283            std::string msg = "Unregistered type : " + tname;
284            PyErr_SetString(PyExc_TypeError, msg.c_str());
285            return handle();
286        }
287
288        auto tinfo = (const detail::type_info *) it->second;
289
290        auto it_instances = internals.registered_instances.equal_range(src);
291        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
292            auto instance_type = detail::get_type_info(Py_TYPE(it_i->second));
293            if (instance_type && instance_type == tinfo)
294                return handle((PyObject *) it_i->second).inc_ref();
295        }
296
297        auto inst = reinterpret_steal<object>(PyType_GenericAlloc(tinfo->type, 0));
298
299        auto wrapper = (instance<void> *) inst.ptr();
300
301        wrapper->value = nullptr;
302        wrapper->owned = false;
303
304        switch (policy) {
305            case return_value_policy::automatic:
306            case return_value_policy::take_ownership:
307                wrapper->value = src;
308                wrapper->owned = true;
309                break;
310
311            case return_value_policy::automatic_reference:
312            case return_value_policy::reference:
313                wrapper->value = src;
314                wrapper->owned = false;
315                break;
316
317            case return_value_policy::copy:
318                if (copy_constructor)
319                    wrapper->value = copy_constructor(src);
320                else
321                    throw cast_error("return_value_policy = copy, but the "
322                                     "object is non-copyable!");
323                wrapper->owned = true;
324                break;
325
326            case return_value_policy::move:
327                if (move_constructor)
328                    wrapper->value = move_constructor(src);
329                else if (copy_constructor)
330                    wrapper->value = copy_constructor(src);
331                else
332                    throw cast_error("return_value_policy = move, but the "
333                                     "object is neither movable nor copyable!");
334                wrapper->owned = true;
335                break;
336
337            case return_value_policy::reference_internal:
338                wrapper->value = src;
339                wrapper->owned = false;
340                detail::keep_alive_impl(inst, parent);
341                break;
342
343            default:
344                throw cast_error("unhandled return_value_policy: should not happen!");
345        }
346
347        tinfo->init_holder(inst.ptr(), existing_holder);
348
349        internals.registered_instances.emplace(wrapper->value, inst.ptr());
350
351        return inst.release();
352    }
353
354protected:
355    const type_info *typeinfo = nullptr;
356    void *value = nullptr;
357    object temp;
358};
359
360/* Determine suitable casting operator */
361template <typename T>
362using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
363    typename std::add_pointer<intrinsic_t<T>>::type,
364    typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
365
366// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
367// T is non-copyable, but code containing such a copy constructor fails to actually compile.
368template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};
369
370// Specialization for types that appear to be copy constructible but also look like stl containers
371// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
372// so, copy constructability depends on whether the value_type is copy constructible.
373template <typename Container> struct is_copy_constructible<Container, enable_if_t<
374        std::is_copy_constructible<Container>::value &&
375        std::is_same<typename Container::value_type &, typename Container::reference>::value
376    >> : std::is_copy_constructible<typename Container::value_type> {};
377
378/// Generic type caster for objects stored on the heap
379template <typename type> class type_caster_base : public type_caster_generic {
380    using itype = intrinsic_t<type>;
381public:
382    static PYBIND11_DESCR name() { return type_descr(_<type>()); }
383
384    type_caster_base() : type_caster_base(typeid(type)) { }
385    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
386
387    static handle cast(const itype &src, return_value_policy policy, handle parent) {
388        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
389            policy = return_value_policy::copy;
390        return cast(&src, policy, parent);
391    }
392
393    static handle cast(itype &&src, return_value_policy, handle parent) {
394        return cast(&src, return_value_policy::move, parent);
395    }
396
397    static handle cast(const itype *src, return_value_policy policy, handle parent) {
398        return type_caster_generic::cast(
399            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
400            make_copy_constructor(src), make_move_constructor(src));
401    }
402
403    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;
404
405    operator itype*() { return (type *) value; }
406    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
407
408protected:
409    typedef void *(*Constructor)(const void *stream);
410#if !defined(_MSC_VER)
411    /* Only enabled when the types are {copy,move}-constructible *and* when the type
412       does not have a private operator new implementaton. */
413    template <typename T = type, typename = enable_if_t<is_copy_constructible<T>::value>> static auto make_copy_constructor(const T *value) -> decltype(new T(*value), Constructor(nullptr)) {
414        return [](const void *arg) -> void * { return new T(*((const T *) arg)); }; }
415    template <typename T = type> static auto make_move_constructor(const T *value) -> decltype(new T(std::move(*((T *) value))), Constructor(nullptr)) {
416        return [](const void *arg) -> void * { return (void *) new T(std::move(*((T *) arg))); }; }
417#else
418    /* Visual Studio 2015's SFINAE implementation doesn't yet handle the above robustly in all situations.
419       Use a workaround that only tests for constructibility for now. */
420    template <typename T = type, typename = enable_if_t<is_copy_constructible<T>::value>>
421    static Constructor make_copy_constructor(const T *value) {
422        return [](const void *arg) -> void * { return new T(*((const T *)arg)); }; }
423    template <typename T = type, typename = enable_if_t<std::is_move_constructible<T>::value>>
424    static Constructor make_move_constructor(const T *value) {
425        return [](const void *arg) -> void * { return (void *) new T(std::move(*((T *)arg))); }; }
426#endif
427
428    static Constructor make_copy_constructor(...) { return nullptr; }
429    static Constructor make_move_constructor(...) { return nullptr; }
430};
431
432template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
433template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
434
435// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
436template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
437    return caster.operator typename make_caster<T>::template cast_op_type<T>();
438}
439template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &&caster) {
440    return cast_op<T>(caster);
441}
442
443template <typename type> class type_caster<std::reference_wrapper<type>> : public type_caster_base<type> {
444public:
445    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
446        return type_caster_base<type>::cast(&src.get(), policy, parent);
447    }
448    template <typename T> using cast_op_type = std::reference_wrapper<type>;
449    operator std::reference_wrapper<type>() { return std::ref(*((type *) this->value)); }
450};
451
452#define PYBIND11_TYPE_CASTER(type, py_name) \
453    protected: \
454        type value; \
455    public: \
456        static PYBIND11_DESCR name() { return type_descr(py_name); } \
457        static handle cast(const type *src, return_value_policy policy, handle parent) { \
458            return cast(*src, policy, parent); \
459        } \
460        operator type*() { return &value; } \
461        operator type&() { return value; } \
462        template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>
463
464
465template <typename T>
466struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value>> {
467    typedef typename std::conditional<sizeof(T) <= sizeof(long), long, long long>::type _py_type_0;
468    typedef typename std::conditional<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>::type _py_type_1;
469    typedef typename std::conditional<std::is_floating_point<T>::value, double, _py_type_1>::type py_type;
470public:
471
472    bool load(handle src, bool) {
473        py_type py_value;
474
475        if (!src) {
476            return false;
477        } if (std::is_floating_point<T>::value) {
478            py_value = (py_type) PyFloat_AsDouble(src.ptr());
479        } else if (sizeof(T) <= sizeof(long)) {
480            if (PyFloat_Check(src.ptr()))
481                return false;
482            if (std::is_signed<T>::value)
483                py_value = (py_type) PyLong_AsLong(src.ptr());
484            else
485                py_value = (py_type) PyLong_AsUnsignedLong(src.ptr());
486        } else {
487            if (PyFloat_Check(src.ptr()))
488                return false;
489            if (std::is_signed<T>::value)
490                py_value = (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
491            else
492                py_value = (py_type) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(src.ptr());
493        }
494
495        if ((py_value == (py_type) -1 && PyErr_Occurred()) ||
496            (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) &&
497               (py_value < (py_type) std::numeric_limits<T>::min() ||
498                py_value > (py_type) std::numeric_limits<T>::max()))) {
499#if PY_VERSION_HEX < 0x03000000
500            bool type_error = PyErr_ExceptionMatches(PyExc_SystemError);
501#else
502            bool type_error = PyErr_ExceptionMatches(PyExc_TypeError);
503#endif
504            PyErr_Clear();
505            if (type_error && PyNumber_Check(src.ptr())) {
506                auto tmp = reinterpret_borrow<object>(std::is_floating_point<T>::value
507                                                      ? PyNumber_Float(src.ptr())
508                                                      : PyNumber_Long(src.ptr()));
509                PyErr_Clear();
510                return load(tmp, false);
511            }
512            return false;
513        }
514
515        value = (T) py_value;
516        return true;
517    }
518
519    static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
520        if (std::is_floating_point<T>::value) {
521            return PyFloat_FromDouble((double) src);
522        } else if (sizeof(T) <= sizeof(long)) {
523            if (std::is_signed<T>::value)
524                return PyLong_FromLong((long) src);
525            else
526                return PyLong_FromUnsignedLong((unsigned long) src);
527        } else {
528            if (std::is_signed<T>::value)
529                return PyLong_FromLongLong((long long) src);
530            else
531                return PyLong_FromUnsignedLongLong((unsigned long long) src);
532        }
533    }
534
535    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
536};
537
538template<typename T> struct void_caster {
539public:
540    bool load(handle, bool) { return false; }
541    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
542        return none().inc_ref();
543    }
544    PYBIND11_TYPE_CASTER(T, _("None"));
545};
546
547template <> class type_caster<void_type> : public void_caster<void_type> {};
548
549template <> class type_caster<void> : public type_caster<void_type> {
550public:
551    using type_caster<void_type>::cast;
552
553    bool load(handle h, bool) {
554        if (!h) {
555            return false;
556        } else if (h.is_none()) {
557            value = nullptr;
558            return true;
559        }
560
561        /* Check if this is a capsule */
562        if (isinstance<capsule>(h)) {
563            value = reinterpret_borrow<capsule>(h);
564            return true;
565        }
566
567        /* Check if this is a C++ type */
568        if (get_type_info((PyTypeObject *) h.get_type().ptr())) {
569            value = ((instance<void> *) h.ptr())->value;
570            return true;
571        }
572
573        /* Fail */
574        return false;
575    }
576
577    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
578        if (ptr)
579            return capsule(ptr).release();
580        else
581            return none().inc_ref();
582    }
583
584    template <typename T> using cast_op_type = void*&;
585    operator void *&() { return value; }
586    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
587private:
588    void *value = nullptr;
589};
590
591template <> class type_caster<std::nullptr_t> : public type_caster<void_type> { };
592
593template <> class type_caster<bool> {
594public:
595    bool load(handle src, bool) {
596        if (!src) return false;
597        else if (src.ptr() == Py_True) { value = true; return true; }
598        else if (src.ptr() == Py_False) { value = false; return true; }
599        else return false;
600    }
601    static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
602        return handle(src ? Py_True : Py_False).inc_ref();
603    }
604    PYBIND11_TYPE_CASTER(bool, _("bool"));
605};
606
607template <> class type_caster<std::string> {
608public:
609    bool load(handle src, bool) {
610        object temp;
611        handle load_src = src;
612        if (!src) {
613            return false;
614        } else if (PyUnicode_Check(load_src.ptr())) {
615            temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(load_src.ptr()));
616            if (!temp) { PyErr_Clear(); return false; }  // UnicodeEncodeError
617            load_src = temp;
618        }
619        char *buffer;
620        ssize_t length;
621        int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(load_src.ptr(), &buffer, &length);
622        if (err == -1) { PyErr_Clear(); return false; }  // TypeError
623        value = std::string(buffer, (size_t) length);
624        success = true;
625        return true;
626    }
627
628    static handle cast(const std::string &src, return_value_policy /* policy */, handle /* parent */) {
629        return PyUnicode_FromStringAndSize(src.c_str(), (ssize_t) src.length());
630    }
631
632    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
633protected:
634    bool success = false;
635};
636
637template <typename type, typename deleter> class type_caster<std::unique_ptr<type, deleter>> {
638public:
639    static handle cast(std::unique_ptr<type, deleter> &&src, return_value_policy policy, handle parent) {
640        handle result = type_caster_base<type>::cast(src.get(), policy, parent);
641        if (result)
642            src.release();
643        return result;
644    }
645    static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
646};
647
648template <> class type_caster<std::wstring> {
649public:
650    bool load(handle src, bool) {
651        object temp;
652        handle load_src = src;
653        if (!src) {
654            return false;
655        } else if (!PyUnicode_Check(load_src.ptr())) {
656            temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
657            if (!temp) { PyErr_Clear(); return false; }
658            load_src = temp;
659        }
660        wchar_t *buffer = nullptr;
661        ssize_t length = -1;
662#if PY_MAJOR_VERSION >= 3
663        buffer = PyUnicode_AsWideCharString(load_src.ptr(), &length);
664#else
665        temp = reinterpret_steal<object>(
666            sizeof(wchar_t) == sizeof(short)
667                ? PyUnicode_AsUTF16String(load_src.ptr())
668                : PyUnicode_AsUTF32String(load_src.ptr()));
669        if (temp) {
670            int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), (char **) &buffer, &length);
671            if (err == -1) { buffer = nullptr; }  // TypeError
672            length = length / (ssize_t) sizeof(wchar_t) - 1; ++buffer; // Skip BOM
673        }
674#endif
675        if (!buffer) { PyErr_Clear(); return false; }
676        value = std::wstring(buffer, (size_t) length);
677        success = true;
678        return true;
679    }
680
681    static handle cast(const std::wstring &src, return_value_policy /* policy */, handle /* parent */) {
682        return PyUnicode_FromWideChar(src.c_str(), (ssize_t) src.length());
683    }
684
685    PYBIND11_TYPE_CASTER(std::wstring, _(PYBIND11_STRING_NAME));
686protected:
687    bool success = false;
688};
689
690template <> class type_caster<char> : public type_caster<std::string> {
691public:
692    bool load(handle src, bool convert) {
693        if (src.is_none()) return true;
694        return type_caster<std::string>::load(src, convert);
695    }
696
697    static handle cast(const char *src, return_value_policy /* policy */, handle /* parent */) {
698        if (src == nullptr) return none().inc_ref();
699        return PyUnicode_FromString(src);
700    }
701
702    static handle cast(char src, return_value_policy /* policy */, handle /* parent */) {
703        char str[2] = { src, '\0' };
704        return PyUnicode_DecodeLatin1(str, 1, nullptr);
705    }
706
707    operator char*() { return success ? (char *) value.c_str() : nullptr; }
708    operator char&() { return value[0]; }
709
710    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
711};
712
713template <> class type_caster<wchar_t> : public type_caster<std::wstring> {
714public:
715    bool load(handle src, bool convert) {
716        if (src.is_none()) return true;
717        return type_caster<std::wstring>::load(src, convert);
718    }
719
720    static handle cast(const wchar_t *src, return_value_policy /* policy */, handle /* parent */) {
721        if (src == nullptr) return none().inc_ref();
722        return PyUnicode_FromWideChar(src, (ssize_t) wcslen(src));
723    }
724
725    static handle cast(wchar_t src, return_value_policy /* policy */, handle /* parent */) {
726        wchar_t wstr[2] = { src, L'\0' };
727        return PyUnicode_FromWideChar(wstr, 1);
728    }
729
730    operator wchar_t*() { return success ? (wchar_t *) value.c_str() : nullptr; }
731    operator wchar_t&() { return value[0]; }
732
733    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
734};
735
736template <typename T1, typename T2> class type_caster<std::pair<T1, T2>> {
737    typedef std::pair<T1, T2> type;
738public:
739    bool load(handle src, bool convert) {
740        if (!isinstance<sequence>(src))
741            return false;
742        const auto seq = reinterpret_borrow<sequence>(src);
743        if (seq.size() != 2)
744            return false;
745        return first.load(seq[0], convert) && second.load(seq[1], convert);
746    }
747
748    static handle cast(const type &src, return_value_policy policy, handle parent) {
749        auto o1 = reinterpret_steal<object>(make_caster<T1>::cast(src.first, policy, parent));
750        auto o2 = reinterpret_steal<object>(make_caster<T2>::cast(src.second, policy, parent));
751        if (!o1 || !o2)
752            return handle();
753        tuple result(2);
754        PyTuple_SET_ITEM(result.ptr(), 0, o1.release().ptr());
755        PyTuple_SET_ITEM(result.ptr(), 1, o2.release().ptr());
756        return result.release();
757    }
758
759    static PYBIND11_DESCR name() {
760        return type_descr(
761            _("Tuple[") + make_caster<T1>::name() + _(", ") + make_caster<T2>::name() + _("]")
762        );
763    }
764
765    template <typename T> using cast_op_type = type;
766
767    operator type() {
768        return type(cast_op<T1>(first), cast_op<T2>(second));
769    }
770protected:
771    make_caster<T1> first;
772    make_caster<T2> second;
773};
774
775template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
776    using type = std::tuple<Tuple...>;
777    using indices = make_index_sequence<sizeof...(Tuple)>;
778    static constexpr auto size = sizeof...(Tuple);
779
780public:
781    bool load(handle src, bool convert) {
782        if (!isinstance<sequence>(src))
783            return false;
784        const auto seq = reinterpret_borrow<sequence>(src);
785        if (seq.size() != size)
786            return false;
787        return load_impl(seq, convert, indices{});
788    }
789
790    static handle cast(const type &src, return_value_policy policy, handle parent) {
791        return cast_impl(src, policy, parent, indices{});
792    }
793
794    static PYBIND11_DESCR name() {
795        return type_descr(_("Tuple[") + detail::concat(make_caster<Tuple>::name()...) + _("]"));
796    }
797
798    template <typename T> using cast_op_type = type;
799
800    operator type() { return implicit_cast(indices{}); }
801
802protected:
803    template <size_t... Is>
804    type implicit_cast(index_sequence<Is...>) { return type(cast_op<Tuple>(std::get<Is>(value))...); }
805
806    static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
807
808    template <size_t... Is>
809    bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
810        for (bool r : {std::get<Is>(value).load(seq[Is], convert)...})
811            if (!r)
812                return false;
813        return true;
814    }
815
816    static handle cast_impl(const type &, return_value_policy, handle,
817                            index_sequence<>) { return tuple().release(); }
818
819    /* Implementation: Convert a C++ tuple into a Python tuple */
820    template <size_t... Is>
821    static handle cast_impl(const type &src, return_value_policy policy, handle parent, index_sequence<Is...>) {
822        std::array<object, size> entries {{
823            reinterpret_steal<object>(make_caster<Tuple>::cast(std::get<Is>(src), policy, parent))...
824        }};
825        for (const auto &entry: entries)
826            if (!entry)
827                return handle();
828        tuple result(size);
829        int counter = 0;
830        for (auto & entry: entries)
831            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
832        return result.release();
833    }
834
835protected:
836    std::tuple<make_caster<Tuple>...> value;
837};
838
839/// Type caster for holder types like std::shared_ptr, etc.
840template <typename type, typename holder_type> class type_caster_holder : public type_caster_base<type> {
841public:
842    using base = type_caster_base<type>;
843    using base::base;
844    using base::cast;
845    using base::typeinfo;
846    using base::value;
847    using base::temp;
848
849    PYBIND11_NOINLINE bool load(handle src, bool convert) {
850        return load(src, convert, Py_TYPE(src.ptr()));
851    }
852
853    bool load(handle src, bool convert, PyTypeObject *tobj) {
854        if (!src || !typeinfo)
855            return false;
856        if (src.is_none()) {
857            value = nullptr;
858            return true;
859        }
860
861        if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
862            /* Check if we can safely perform a reinterpret-style cast */
863            if (PyType_IsSubtype(tobj, typeinfo->type))
864                return load_value_and_holder(src);
865        } else { /* Case 2: multiple inheritance */
866            /* Check if we can safely perform a reinterpret-style cast */
867            if (tobj == typeinfo->type)
868                return load_value_and_holder(src);
869
870            /* If this is a python class, also check the parents recursively */
871            auto const &type_dict = get_internals().registered_types_py;
872            bool new_style_class = PyType_Check(tobj);
873            if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
874                auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
875                for (handle parent : parents) {
876                    bool result = load(src, convert, (PyTypeObject *) parent.ptr());
877                    if (result)
878                        return true;
879                }
880            }
881
882            if (try_implicit_casts(src, convert))
883                return true;
884        }
885
886        if (convert) {
887            for (auto &converter : typeinfo->implicit_conversions) {
888                temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
889                if (load(temp, false))
890                    return true;
891            }
892        }
893
894        return false;
895    }
896
897    bool load_value_and_holder(handle src) {
898        auto inst = (instance<type, holder_type> *) src.ptr();
899        value = (void *) inst->value;
900        if (inst->holder_constructed) {
901            holder = inst->holder;
902            return true;
903        } else {
904            throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
905#if defined(NDEBUG)
906                             "(compile in debug mode for type information)");
907#else
908                             "of type '" + type_id<holder_type>() + "''");
909#endif
910        }
911    }
912
913    template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
914    bool try_implicit_casts(handle, bool) { return false; }
915
916    template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
917    bool try_implicit_casts(handle src, bool convert) {
918        for (auto &cast : typeinfo->implicit_casts) {
919            type_caster_holder sub_caster(*cast.first);
920            if (sub_caster.load(src, convert)) {
921                value = cast.second(sub_caster.value);
922                holder = holder_type(sub_caster.holder, (type *) value);
923                return true;
924            }
925        }
926        return false;
927    }
928
929    explicit operator type*() { return this->value; }
930    explicit operator type&() { return *(this->value); }
931    explicit operator holder_type*() { return &holder; }
932
933    // Workaround for Intel compiler bug
934    // see pybind11 issue 94
935    #if defined(__ICC) || defined(__INTEL_COMPILER)
936    operator holder_type&() { return holder; }
937    #else
938    explicit operator holder_type&() { return holder; }
939    #endif
940
941    static handle cast(const holder_type &src, return_value_policy, handle) {
942        return type_caster_generic::cast(
943            src.get(), return_value_policy::take_ownership, handle(),
944            src.get() ? &typeid(*src.get()) : nullptr, &typeid(type),
945            nullptr, nullptr, &src);
946    }
947
948protected:
949    holder_type holder;
950};
951
952/// Specialize for the common std::shared_ptr, so users don't need to
953template <typename T>
954class type_caster<std::shared_ptr<T>> : public type_caster_holder<T, std::shared_ptr<T>> { };
955
956/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
957#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type) \
958    namespace pybind11 { namespace detail { \
959    template <typename type> \
960    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
961        : public type_caster_holder<type, holder_type> { }; \
962    }}
963
964// PYBIND11_DECLARE_HOLDER_TYPE holder types:
965template <typename base, typename holder> struct is_holder_type :
966    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
967// Specialization for always-supported unique_ptr holders:
968template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
969    std::true_type {};
970
971template <typename T> struct handle_type_name { static PYBIND11_DESCR name() { return _<T>(); } };
972template <> struct handle_type_name<bytes> { static PYBIND11_DESCR name() { return _(PYBIND11_BYTES_NAME); } };
973template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
974template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
975
976template <typename type>
977struct pyobject_caster {
978    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
979    bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); }
980
981    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
982    bool load(handle src, bool /* convert */) {
983        if (!isinstance<type>(src))
984            return false;
985        value = reinterpret_borrow<type>(src);
986        return true;
987    }
988
989    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
990        return src.inc_ref();
991    }
992    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
993};
994
995template <typename T>
996class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };
997
998// Our conditions for enabling moving are quite restrictive:
999// At compile time:
1000// - T needs to be a non-const, non-pointer, non-reference type
1001// - type_caster<T>::operator T&() must exist
1002// - the type must be move constructible (obviously)
1003// At run-time:
1004// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
1005//   must have ref_count() == 1)h
1006// If any of the above are not satisfied, we fall back to copying.
1007template <typename T, typename SFINAE = void> struct move_is_plain_type : std::false_type {};
1008template <typename T> struct move_is_plain_type<T, enable_if_t<
1009        !std::is_void<T>::value && !std::is_pointer<T>::value && !std::is_reference<T>::value && !std::is_const<T>::value
1010    >> : std::true_type { };
1011template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
1012template <typename T> struct move_always<T, enable_if_t<
1013        move_is_plain_type<T>::value &&
1014        !std::is_copy_constructible<T>::value && std::is_move_constructible<T>::value &&
1015        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
1016    >> : std::true_type { };
1017template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
1018template <typename T> struct move_if_unreferenced<T, enable_if_t<
1019        move_is_plain_type<T>::value &&
1020        !move_always<T>::value && std::is_move_constructible<T>::value &&
1021        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
1022    >> : std::true_type { };
1023template <typename T> using move_never = std::integral_constant<bool, !move_always<T>::value && !move_if_unreferenced<T>::value>;
1024
1025// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
1026// reference or pointer to a local variable of the type_caster.  Basically, only
1027// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
1028// everything else returns a reference/pointer to a local variable.
1029template <typename type> using cast_is_temporary_value_reference = bool_constant<
1030    (std::is_reference<type>::value || std::is_pointer<type>::value) &&
1031    !std::is_base_of<type_caster_generic, make_caster<type>>::value
1032>;
1033
1034// Basic python -> C++ casting; throws if casting fails
1035template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1036    if (!conv.load(handle, true)) {
1037#if defined(NDEBUG)
1038        throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
1039#else
1040        throw cast_error("Unable to cast Python instance of type " +
1041            (std::string) str(handle.get_type()) + " to C++ type '" + type_id<T>() + "''");
1042#endif
1043    }
1044    return conv;
1045}
1046// Wrapper around the above that also constructs and returns a type_caster
1047template <typename T> make_caster<T> load_type(const handle &handle) {
1048    make_caster<T> conv;
1049    load_type(conv, handle);
1050    return conv;
1051}
1052
1053NAMESPACE_END(detail)
1054
1055// pytype -> C++ type
1056template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
1057T cast(const handle &handle) {
1058    using namespace detail;
1059    static_assert(!cast_is_temporary_value_reference<T>::value,
1060            "Unable to cast type to reference: value is local to type caster");
1061    return cast_op<T>(load_type<T>(handle));
1062}
1063
1064// pytype -> pytype (calls converting constructor)
1065template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
1066T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); }
1067
1068// C++ type -> py::object
1069template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
1070object cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference,
1071            handle parent = handle()) {
1072    if (policy == return_value_policy::automatic)
1073        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
1074    else if (policy == return_value_policy::automatic_reference)
1075        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
1076    return reinterpret_steal<object>(detail::make_caster<T>::cast(value, policy, parent));
1077}
1078
1079template <typename T> T handle::cast() const { return pybind11::cast<T>(*this); }
1080template <> inline void handle::cast() const { return; }
1081
1082template <typename T>
1083detail::enable_if_t<detail::move_always<T>::value || detail::move_if_unreferenced<T>::value, T> move(object &&obj) {
1084    if (obj.ref_count() > 1)
1085#if defined(NDEBUG)
1086        throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
1087            " (compile in debug mode for details)");
1088#else
1089        throw cast_error("Unable to move from Python " + (std::string) str(obj.get_type()) +
1090                " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
1091#endif
1092
1093    // Move into a temporary and return that, because the reference may be a local value of `conv`
1094    T ret = std::move(detail::load_type<T>(obj).operator T&());
1095    return ret;
1096}
1097
1098// Calling cast() on an rvalue calls pybind::cast with the object rvalue, which does:
1099// - If we have to move (because T has no copy constructor), do it.  This will fail if the moved
1100//   object has multiple references, but trying to copy will fail to compile.
1101// - If both movable and copyable, check ref count: if 1, move; otherwise copy
1102// - Otherwise (not movable), copy.
1103template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1104    return move<T>(std::move(object));
1105}
1106template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1107    if (object.ref_count() > 1)
1108        return cast<T>(object);
1109    else
1110        return move<T>(std::move(object));
1111}
1112template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1113    return cast<T>(object);
1114}
1115
1116template <typename T> T object::cast() const & { return pybind11::cast<T>(*this); }
1117template <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); }
1118template <> inline void object::cast() const & { return; }
1119template <> inline void object::cast() && { return; }
1120
1121NAMESPACE_BEGIN(detail)
1122
1123// Declared in pytypes.h:
1124template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
1125object object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); }
1126
1127struct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro
1128template <typename ret_type> using overload_caster_t = conditional_t<
1129    cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>;
1130
1131// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
1132// store the result in the given variable.  For other types, this is a no-op.
1133template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
1134    return cast_op<T>(load_type(caster, o));
1135}
1136template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
1137    pybind11_fail("Internal error: cast_ref fallback invoked"); }
1138
1139// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
1140// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
1141// cases where pybind11::cast is valid.
1142template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
1143    return pybind11::cast<T>(std::move(o)); }
1144template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
1145    pybind11_fail("Internal error: cast_safe fallback invoked"); }
1146template <> inline void cast_safe<void>(object &&) {}
1147
1148NAMESPACE_END(detail)
1149
1150template <return_value_policy policy = return_value_policy::automatic_reference,
1151          typename... Args> tuple make_tuple(Args&&... args_) {
1152    const size_t size = sizeof...(Args);
1153    std::array<object, size> args {
1154        { reinterpret_steal<object>(detail::make_caster<Args>::cast(
1155            std::forward<Args>(args_), policy, nullptr))... }
1156    };
1157    for (auto &arg_value : args) {
1158        if (!arg_value) {
1159#if defined(NDEBUG)
1160            throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
1161#else
1162            throw cast_error("make_tuple(): unable to convert arguments of types '" +
1163                (std::string) type_id<std::tuple<Args...>>() + "' to Python object");
1164#endif
1165        }
1166    }
1167    tuple result(size);
1168    int counter = 0;
1169    for (auto &arg_value : args)
1170        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
1171    return result;
1172}
1173
1174/// Annotation for keyword arguments
1175struct arg {
1176    constexpr explicit arg(const char *name) : name(name) { }
1177    template <typename T> arg_v operator=(T &&value) const;
1178
1179    const char *name;
1180};
1181
1182/// Annotation for keyword arguments with values
1183struct arg_v : arg {
1184    template <typename T>
1185    arg_v(const char *name, T &&x, const char *descr = nullptr)
1186        : arg(name),
1187          value(reinterpret_steal<object>(
1188              detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
1189          )),
1190          descr(descr)
1191#if !defined(NDEBUG)
1192        , type(type_id<T>())
1193#endif
1194    { }
1195
1196    object value;
1197    const char *descr;
1198#if !defined(NDEBUG)
1199    std::string type;
1200#endif
1201};
1202
1203template <typename T>
1204arg_v arg::operator=(T &&value) const { return {name, std::forward<T>(value)}; }
1205
1206/// Alias for backward compatibility -- to be removed in version 2.0
1207template <typename /*unused*/> using arg_t = arg_v;
1208
1209inline namespace literals {
1210/// String literal version of arg
1211constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
1212}
1213
1214NAMESPACE_BEGIN(detail)
1215
1216/// Helper class which loads arguments for C++ functions called from Python
1217template <typename... Args>
1218class argument_loader {
1219    using itypes = type_list<intrinsic_t<Args>...>;
1220    using indices = make_index_sequence<sizeof...(Args)>;
1221
1222public:
1223    static constexpr auto has_kwargs = std::is_same<itypes, type_list<args, kwargs>>::value;
1224    static constexpr auto has_args = has_kwargs || std::is_same<itypes, type_list<args>>::value;
1225
1226    static PYBIND11_DESCR arg_names() { return detail::concat(make_caster<Args>::name()...); }
1227
1228    bool load_args(handle args, handle kwargs, bool convert) {
1229        return load_impl(args, kwargs, convert, itypes{});
1230    }
1231
1232    template <typename Return, typename Func>
1233    enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) {
1234        return call_impl<Return>(std::forward<Func>(f), indices{});
1235    }
1236
1237    template <typename Return, typename Func>
1238    enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) {
1239        call_impl<Return>(std::forward<Func>(f), indices{});
1240        return void_type();
1241    }
1242
1243private:
1244    bool load_impl(handle args_, handle, bool convert, type_list<args>) {
1245        std::get<0>(value).load(args_, convert);
1246        return true;
1247    }
1248
1249    bool load_impl(handle args_, handle kwargs_, bool convert, type_list<args, kwargs>) {
1250        std::get<0>(value).load(args_, convert);
1251        std::get<1>(value).load(kwargs_, convert);
1252        return true;
1253    }
1254
1255    bool load_impl(handle args, handle, bool convert, ... /* anything else */) {
1256        return load_impl_sequence(args, convert, indices{});
1257    }
1258
1259    static constexpr bool load_impl_sequence(handle, bool, index_sequence<>) { return true; }
1260
1261    template <size_t... Is>
1262    bool load_impl_sequence(handle src, bool convert, index_sequence<Is...>) {
1263        for (bool r : {std::get<Is>(value).load(PyTuple_GET_ITEM(src.ptr(), Is), convert)...})
1264            if (!r)
1265                return false;
1266        return true;
1267    }
1268
1269    template <typename Return, typename Func, size_t... Is>
1270    Return call_impl(Func &&f, index_sequence<Is...>) {
1271        return std::forward<Func>(f)(cast_op<Args>(std::get<Is>(value))...);
1272    }
1273
1274private:
1275    std::tuple<make_caster<Args>...> value;
1276};
1277
1278NAMESPACE_BEGIN(constexpr_impl)
1279/// Implementation details for constexpr functions
1280constexpr int first(int i) { return i; }
1281template <typename T, typename... Ts>
1282constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }
1283
1284constexpr int last(int /*i*/, int result) { return result; }
1285template <typename T, typename... Ts>
1286constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
1287NAMESPACE_END(constexpr_impl)
1288
1289/// Return the index of the first type in Ts which satisfies Predicate<T>
1290template <template<typename> class Predicate, typename... Ts>
1291constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }
1292
1293/// Return the index of the last type in Ts which satisfies Predicate<T>
1294template <template<typename> class Predicate, typename... Ts>
1295constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }
1296
1297/// Helper class which collects only positional arguments for a Python function call.
1298/// A fancier version below can collect any argument, but this one is optimal for simple calls.
1299template <return_value_policy policy>
1300class simple_collector {
1301public:
1302    template <typename... Ts>
1303    explicit simple_collector(Ts &&...values)
1304        : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { }
1305
1306    const tuple &args() const & { return m_args; }
1307    dict kwargs() const { return {}; }
1308
1309    tuple args() && { return std::move(m_args); }
1310
1311    /// Call a Python function and pass the collected arguments
1312    object call(PyObject *ptr) const {
1313        PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
1314        if (!result)
1315            throw error_already_set();
1316        return reinterpret_steal<object>(result);
1317    }
1318
1319private:
1320    tuple m_args;
1321};
1322
1323/// Helper class which collects positional, keyword, * and ** arguments for a Python function call
1324template <return_value_policy policy>
1325class unpacking_collector {
1326public:
1327    template <typename... Ts>
1328    explicit unpacking_collector(Ts &&...values) {
1329        // Tuples aren't (easily) resizable so a list is needed for collection,
1330        // but the actual function call strictly requires a tuple.
1331        auto args_list = list();
1332        int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
1333        ignore_unused(_);
1334
1335        m_args = std::move(args_list);
1336    }
1337
1338    const tuple &args() const & { return m_args; }
1339    const dict &kwargs() const & { return m_kwargs; }
1340
1341    tuple args() && { return std::move(m_args); }
1342    dict kwargs() && { return std::move(m_kwargs); }
1343
1344    /// Call a Python function and pass the collected arguments
1345    object call(PyObject *ptr) const {
1346        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
1347        if (!result)
1348            throw error_already_set();
1349        return reinterpret_steal<object>(result);
1350    }
1351
1352private:
1353    template <typename T>
1354    void process(list &args_list, T &&x) {
1355        auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
1356        if (!o) {
1357#if defined(NDEBUG)
1358            argument_cast_error();
1359#else
1360            argument_cast_error(std::to_string(args_list.size()), type_id<T>());
1361#endif
1362        }
1363        args_list.append(o);
1364    }
1365
1366    void process(list &args_list, detail::args_proxy ap) {
1367        for (const auto &a : ap)
1368            args_list.append(a);
1369    }
1370
1371    void process(list &/*args_list*/, arg_v a) {
1372        if (m_kwargs.contains(a.name)) {
1373#if defined(NDEBUG)
1374            multiple_values_error();
1375#else
1376            multiple_values_error(a.name);
1377#endif
1378        }
1379        if (!a.value) {
1380#if defined(NDEBUG)
1381            argument_cast_error();
1382#else
1383            argument_cast_error(a.name, a.type);
1384#endif
1385        }
1386        m_kwargs[a.name] = a.value;
1387    }
1388
1389    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
1390        if (!kp)
1391            return;
1392        for (const auto &k : reinterpret_borrow<dict>(kp)) {
1393            if (m_kwargs.contains(k.first)) {
1394#if defined(NDEBUG)
1395                multiple_values_error();
1396#else
1397                multiple_values_error(str(k.first));
1398#endif
1399            }
1400            m_kwargs[k.first] = k.second;
1401        }
1402    }
1403
1404    [[noreturn]] static void multiple_values_error() {
1405        throw type_error("Got multiple values for keyword argument "
1406                         "(compile in debug mode for details)");
1407    }
1408
1409    [[noreturn]] static void multiple_values_error(std::string name) {
1410        throw type_error("Got multiple values for keyword argument '" + name + "'");
1411    }
1412
1413    [[noreturn]] static void argument_cast_error() {
1414        throw cast_error("Unable to convert call argument to Python object "
1415                         "(compile in debug mode for details)");
1416    }
1417
1418    [[noreturn]] static void argument_cast_error(std::string name, std::string type) {
1419        throw cast_error("Unable to convert call argument '" + name
1420                         + "' of type '" + type + "' to Python object");
1421    }
1422
1423private:
1424    tuple m_args;
1425    dict m_kwargs;
1426};
1427
1428/// Collect only positional arguments for a Python function call
1429template <return_value_policy policy, typename... Args,
1430          typename = enable_if_t<all_of_t<is_positional, Args...>::value>>
1431simple_collector<policy> collect_arguments(Args &&...args) {
1432    return simple_collector<policy>(std::forward<Args>(args)...);
1433}
1434
1435/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
1436template <return_value_policy policy, typename... Args,
1437          typename = enable_if_t<!all_of_t<is_positional, Args...>::value>>
1438unpacking_collector<policy> collect_arguments(Args &&...args) {
1439    // Following argument order rules for generalized unpacking according to PEP 448
1440    static_assert(
1441        constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>()
1442        && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(),
1443        "Invalid function call: positional args must precede keywords and ** unpacking; "
1444        "* unpacking must precede ** unpacking"
1445    );
1446    return unpacking_collector<policy>(std::forward<Args>(args)...);
1447}
1448
1449template <typename Derived>
1450template <return_value_policy policy, typename... Args>
1451object object_api<Derived>::operator()(Args &&...args) const {
1452    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
1453}
1454
1455template <typename Derived>
1456template <return_value_policy policy, typename... Args>
1457object object_api<Derived>::call(Args &&...args) const {
1458    return operator()<policy>(std::forward<Args>(args)...);
1459}
1460
1461NAMESPACE_END(detail)
1462
1463#define PYBIND11_MAKE_OPAQUE(Type) \
1464    namespace pybind11 { namespace detail { \
1465        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
1466    }}
1467
1468NAMESPACE_END(pybind11)
1469