cast.h 53.2 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
2
    pybind11/cast.h: Partial template specializations to cast between
Wenzel Jakob's avatar
Wenzel Jakob committed
3
4
    C++ and Python types

5
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
6
7
8
9
10

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

11
#pragma once
Wenzel Jakob's avatar
Wenzel Jakob committed
12

13
14
#include "pytypes.h"
#include "typeid.h"
15
#include "descr.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
16
#include <array>
Wenzel Jakob's avatar
Wenzel Jakob committed
17
#include <limits>
Wenzel Jakob's avatar
Wenzel Jakob committed
18

19
NAMESPACE_BEGIN(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
20
21
NAMESPACE_BEGIN(detail)

Wenzel Jakob's avatar
Wenzel Jakob committed
22
23
24
25
26
/// Additional type information which does not fit into the PyTypeObject
struct type_info {
    PyTypeObject *type;
    size_t type_size;
    void (*init_holder)(PyObject *, const void *);
Wenzel Jakob's avatar
Wenzel Jakob committed
27
28
    std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
    std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
29
    std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
Wenzel Jakob's avatar
Wenzel Jakob committed
30
31
    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
    void *get_buffer_data = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
32
33
34
    /** A simple type never occurs as a (direct or indirect) parent
     * of a class that makes use of multiple inheritance */
    bool simple_type = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
35
};
36

Wenzel Jakob's avatar
Wenzel Jakob committed
37
38
39
40
41
PYBIND11_NOINLINE inline internals &get_internals() {
    static internals *internals_ptr = nullptr;
    if (internals_ptr)
        return *internals_ptr;
    handle builtins(PyEval_GetBuiltins());
42
    const char *id = PYBIND11_INTERNALS_ID;
43
44
45
46
    capsule caps;
    if (builtins.contains(id)) {
        caps = builtins[id];
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
47
48
49
50
    if (caps.check()) {
        internals_ptr = caps;
    } else {
        internals_ptr = new internals();
51
52
53
54
55
56
57
        #if defined(WITH_THREAD)
            PyEval_InitThreads();
            PyThreadState *tstate = PyThreadState_Get();
            internals_ptr->tstate = PyThread_create_key();
            PyThread_set_key_value(internals_ptr->tstate, tstate);
            internals_ptr->istate = tstate->interp;
        #endif
58
        builtins[id] = capsule(internals_ptr);
59
60
61
62
        internals_ptr->registered_exception_translators.push_front(
            [](std::exception_ptr p) -> void {
                try {
                    if (p) std::rethrow_exception(p);
63
                } catch (error_already_set &e)           { e.restore();                                    return;
64
                } catch (const builtin_exception &e)     { e.set_error();                                  return;
65
66
67
68
69
70
71
72
73
74
75
76
77
                } catch (const std::bad_alloc &e)        { PyErr_SetString(PyExc_MemoryError,   e.what()); return;
                } catch (const std::domain_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::length_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::out_of_range &e)     { PyErr_SetString(PyExc_IndexError,    e.what()); return;
                } catch (const std::range_error &e)      { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::exception &e)        { PyErr_SetString(PyExc_RuntimeError,  e.what()); return;
                } catch (...) {
                    PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
                    return;
                }
            }
        );
Wenzel Jakob's avatar
Wenzel Jakob committed
78
79
80
81
    }
    return *internals_ptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
82
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
Wenzel Jakob's avatar
Wenzel Jakob committed
83
84
85
86
87
88
    auto const &type_dict = get_internals().registered_types_py;
    do {
        auto it = type_dict.find(type);
        if (it != type_dict.end())
            return (detail::type_info *) it->second;
        type = type->tp_base;
Wenzel Jakob's avatar
Wenzel Jakob committed
89
        if (!type)
90
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
91
92
93
    } while (true);
}

94
95
PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_info &tp,
                                                          bool throw_if_missing = false) {
Wenzel Jakob's avatar
Wenzel Jakob committed
96
97
    auto &types = get_internals().registered_types_cpp;

98
99
    auto it = types.find(std::type_index(tp));
    if (it != types.end())
Wenzel Jakob's avatar
Wenzel Jakob committed
100
        return (detail::type_info *) it->second;
Wenzel Jakob's avatar
Wenzel Jakob committed
101
102
103
104
105
    if (throw_if_missing) {
        std::string tname = tp.name();
        detail::clean_type_id(tname);
        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
106
107
108
    return nullptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
109
110
PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
Wenzel Jakob's avatar
Wenzel Jakob committed
111
112
113
114
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

PYBIND11_NOINLINE inline std::string error_string() {
115
116
117
118
119
    if (!PyErr_Occurred()) {
        PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
        return "Unknown internal error occurred";
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
120
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
121

122
    std::string errorString;
Wenzel Jakob's avatar
Wenzel Jakob committed
123
124
    if (scope.type) {
        errorString += handle(scope.type).attr("__name__").cast<std::string>();
Wenzel Jakob's avatar
Wenzel Jakob committed
125
126
        errorString += ": ";
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
127
128
    if (scope.value)
        errorString += (std::string) handle(scope.value).str();
Wenzel Jakob's avatar
Wenzel Jakob committed
129
130
131
132

    return errorString;
}

133
134
135
136
PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
    auto &instances = get_internals().registered_instances;
    auto range = instances.equal_range(ptr);
    for (auto it = range.first; it != range.second; ++it) {
Wenzel Jakob's avatar
Wenzel Jakob committed
137
        auto instance_type = detail::get_type_info(Py_TYPE(it->second));
138
139
140
141
        if (instance_type && instance_type == type)
            return handle((PyObject *) it->second);
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
142
143
}

144
145
146
147
148
149
150
151
152
153
154
155
inline PyThreadState *get_thread_state_unchecked() {
#if   PY_VERSION_HEX < 0x03000000
    return _PyThreadState_Current;
#elif PY_VERSION_HEX < 0x03050000
    return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
#elif PY_VERSION_HEX < 0x03050200
    return (PyThreadState*) _PyThreadState_Current.value;
#else
    return _PyThreadState_UncheckedGet();
#endif
}

156
157
158
// Forward declaration
inline void keep_alive_impl(handle nurse, handle patient);

Wenzel Jakob's avatar
Wenzel Jakob committed
159
160
161
class type_caster_generic {
public:
    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
162
     : typeinfo(get_type_info(type_info)) { }
Wenzel Jakob's avatar
Wenzel Jakob committed
163

Wenzel Jakob's avatar
Wenzel Jakob committed
164
    PYBIND11_NOINLINE bool load(handle src, bool convert) {
165
166
        if (!src)
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
167
168
169
170
        return load(src, convert, Py_TYPE(src.ptr()));
    }

    bool load(handle src, bool convert, PyTypeObject *tobj) {
Wenzel Jakob's avatar
Wenzel Jakob committed
171
        if (!src || !typeinfo)
Wenzel Jakob's avatar
Wenzel Jakob committed
172
            return false;
173
        if (src.is_none()) {
174
175
            value = nullptr;
            return true;
Wenzel Jakob's avatar
Wenzel Jakob committed
176
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

        if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
            /* Check if we can safely perform a reinterpret-style cast */
            if (PyType_IsSubtype(tobj, typeinfo->type)) {
                value = reinterpret_cast<instance<void> *>(src.ptr())->value;
                return true;
            }
        } else { /* Case 2: multiple inheritance */
            /* Check if we can safely perform a reinterpret-style cast */
            if (tobj == typeinfo->type) {
                value = reinterpret_cast<instance<void> *>(src.ptr())->value;
                return true;
            }

            /* If this is a python class, also check the parents recursively */
            auto const &type_dict = get_internals().registered_types_py;
            bool new_style_class = PyType_Check(tobj);
            if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
                tuple parents(tobj->tp_bases, true);
                for (handle parent : parents) {
                    bool result = load(src, convert, (PyTypeObject *) parent.ptr());
                    if (result)
                        return true;
                }
            }

            /* Try implicit casts */
            for (auto &cast : typeinfo->implicit_casts) {
                type_caster_generic sub_caster(*cast.first);
                if (sub_caster.load(src, convert)) {
                    value = cast.second(sub_caster.value);
                    return true;
                }
            }
        }

        /* Perform an implicit conversion */
Wenzel Jakob's avatar
Wenzel Jakob committed
214
215
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
216
217
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
218
219
                    return true;
            }
220
221
222
223
            for (auto &converter : *typeinfo->direct_conversions) {
                if (converter(src.ptr(), value))
                    return true;
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
224
225
226
227
        }
        return false;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
228
229
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
                                         const std::type_info *type_info,
230
                                         const std::type_info *type_info_backup,
Wenzel Jakob's avatar
Wenzel Jakob committed
231
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
232
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
233
                                         const void *existing_holder = nullptr) {
234
        void *src = const_cast<void *>(_src);
Wenzel Jakob's avatar
Wenzel Jakob committed
235
        if (src == nullptr)
Wenzel Jakob's avatar
Wenzel Jakob committed
236
            return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
237

238
        auto &internals = get_internals();
Wenzel Jakob's avatar
Wenzel Jakob committed
239

240
        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
241
242
243
244
245
        if (it == internals.registered_types_cpp.end()) {
            type_info = type_info_backup;
            it = internals.registered_types_cpp.find(std::type_index(*type_info));
        }

246
        if (it == internals.registered_types_cpp.end()) {
247
248
249
            std::string tname = type_info->name();
            detail::clean_type_id(tname);
            std::string msg = "Unregistered type : " + tname;
Wenzel Jakob's avatar
Wenzel Jakob committed
250
            PyErr_SetString(PyExc_TypeError, msg.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
251
            return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
252
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
253

254
        auto tinfo = (const detail::type_info *) it->second;
255
256

        auto it_instances = internals.registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
257
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
Wenzel Jakob's avatar
Wenzel Jakob committed
258
            auto instance_type = detail::get_type_info(Py_TYPE(it_i->second));
259
            if (instance_type && instance_type == tinfo)
Jason Rhinelander's avatar
Jason Rhinelander committed
260
                return handle((PyObject *) it_i->second).inc_ref();
261
262
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
263
264
265
266
        object inst(PyType_GenericAlloc(tinfo->type, 0), false);

        auto wrapper = (instance<void> *) inst.ptr();

267
268
269
270
        wrapper->value = nullptr;
        wrapper->owned = false;

        switch (policy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
            case return_value_policy::automatic:
            case return_value_policy::take_ownership:
                wrapper->value = src;
                wrapper->owned = true;
                break;

            case return_value_policy::automatic_reference:
            case return_value_policy::reference:
                wrapper->value = src;
                wrapper->owned = false;
                break;

            case return_value_policy::copy:
                if (copy_constructor)
                    wrapper->value = copy_constructor(src);
                else
                    throw cast_error("return_value_policy = copy, but the "
                                     "object is non-copyable!");
                wrapper->owned = true;
                break;

            case return_value_policy::move:
                if (move_constructor)
                    wrapper->value = move_constructor(src);
                else if (copy_constructor)
                    wrapper->value = copy_constructor(src);
                else
                    throw cast_error("return_value_policy = move, but the "
                                     "object is neither movable nor copyable!");
                wrapper->owned = true;
                break;

            case return_value_policy::reference_internal:
                wrapper->value = src;
                wrapper->owned = false;
                detail::keep_alive_impl(inst, parent);
                break;

            default:
                throw cast_error("unhandled return_value_policy: should not happen!");
Wenzel Jakob's avatar
Wenzel Jakob committed
311
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
312
313

        tinfo->init_holder(inst.ptr(), existing_holder);
314
315

        internals.registered_instances.emplace(wrapper->value, inst.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
316
317

        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
318
319
320
321
    }

protected:
    const type_info *typeinfo = nullptr;
322
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
323
324
325
    object temp;
};

326
327
/* Determine suitable casting operator */
template <typename T>
328
using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
329
330
    typename std::add_pointer<intrinsic_t<T>>::type,
    typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
331

332
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
333
template <typename type> class type_caster_base : public type_caster_generic {
334
    using itype = intrinsic_t<type>;
335
public:
336
    static PYBIND11_DESCR name() { return type_descr(_<type>()); }
337

Wenzel Jakob's avatar
Wenzel Jakob committed
338
    type_caster_base() : type_caster_base(typeid(type)) { }
339
    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
340

341
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
342
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
343
            policy = return_value_policy::copy;
344
        return cast(&src, policy, parent);
345
346
    }

347
    static handle cast(itype &&src, return_value_policy policy, handle parent) {
348
        if (policy != return_value_policy::copy)
Wenzel Jakob's avatar
Wenzel Jakob committed
349
350
351
352
            policy = return_value_policy::move;
        return cast(&src, policy, parent);
    }

353
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
354
355
        return type_caster_generic::cast(
            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
356
            make_copy_constructor(src), make_move_constructor(src));
357
358
    }

359
360
    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;

361
362
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
363

364
protected:
365
366
367
368
369
370
371
372
373
374
375
    typedef void *(*Constructor)(const void *stream);
#if !defined(_MSC_VER)
    /* Only enabled when the types are {copy,move}-constructible *and* when the type
       does not have a private operator new implementaton. */
    template <typename T = type> static auto make_copy_constructor(const T *value) -> decltype(new T(*value), Constructor(nullptr)) {
        return [](const void *arg) -> void * { return new T(*((const T *) arg)); }; }
    template <typename T = type> static auto make_move_constructor(const T *value) -> decltype(new T(std::move(*((T *) value))), Constructor(nullptr)) {
        return [](const void *arg) -> void * { return (void *) new T(std::move(*((T *) arg))); }; }
#else
    /* Visual Studio 2015's SFINAE implementation doesn't yet handle the above robustly in all situations.
       Use a workaround that only tests for constructibility for now. */
376
    template <typename T = type, typename = enable_if_t<std::is_copy_constructible<T>::value>>
377
378
    static Constructor make_copy_constructor(const T *value) {
        return [](const void *arg) -> void * { return new T(*((const T *)arg)); }; }
379
    template <typename T = type, typename = enable_if_t<std::is_move_constructible<T>::value>>
380
381
382
383
384
    static Constructor make_move_constructor(const T *value) {
        return [](const void *arg) -> void * { return (void *) new T(std::move(*((T *)arg))); }; }
#endif
    static Constructor make_copy_constructor(...) { return nullptr; }
    static Constructor make_move_constructor(...) { return nullptr; }
385
386
};

Wenzel Jakob's avatar
Wenzel Jakob committed
387
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
388
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
389
390

template <typename type> class type_caster<std::reference_wrapper<type>> : public type_caster_base<type> {
391
392
public:
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
393
        return type_caster_base<type>::cast(&src.get(), policy, parent);
394
    }
395
396
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
    operator std::reference_wrapper<type>() { return std::ref(*((type *) this->value)); }
397
398
};

399
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
400
401
402
    protected: \
        type value; \
    public: \
403
        static PYBIND11_DESCR name() { return type_descr(py_name); } \
Wenzel Jakob's avatar
Wenzel Jakob committed
404
        static handle cast(const type *src, return_value_policy policy, handle parent) { \
Wenzel Jakob's avatar
Wenzel Jakob committed
405
406
407
            return cast(*src, policy, parent); \
        } \
        operator type*() { return &value; } \
408
        operator type&() { return value; } \
409
        template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>
Wenzel Jakob's avatar
Wenzel Jakob committed
410

411

Wenzel Jakob's avatar
Wenzel Jakob committed
412
template <typename T>
413
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
414
415
416
417
    typedef typename std::conditional<sizeof(T) <= sizeof(long), long, long long>::type _py_type_0;
    typedef typename std::conditional<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>::type _py_type_1;
    typedef typename std::conditional<std::is_floating_point<T>::value, double, _py_type_1>::type py_type;
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
418

Wenzel Jakob's avatar
Wenzel Jakob committed
419
    bool load(handle src, bool) {
Wenzel Jakob's avatar
Wenzel Jakob committed
420
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
421

422
423
424
        if (!src) {
            return false;
        } if (std::is_floating_point<T>::value) {
Wenzel Jakob's avatar
Wenzel Jakob committed
425
            py_value = (py_type) PyFloat_AsDouble(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
426
        } else if (sizeof(T) <= sizeof(long)) {
427
428
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
429
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
430
                py_value = (py_type) PyLong_AsLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
431
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
432
                py_value = (py_type) PyLong_AsUnsignedLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
433
        } else {
434
435
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
436
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
437
                py_value = (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
438
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
439
                py_value = (py_type) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
440
441
442
443
444
445
        }

        if ((py_value == (py_type) -1 && PyErr_Occurred()) ||
            (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) &&
               (py_value < (py_type) std::numeric_limits<T>::min() ||
                py_value > (py_type) std::numeric_limits<T>::max()))) {
446
447
448
449
450
#if PY_VERSION_HEX < 0x03000000
            bool type_error = PyErr_ExceptionMatches(PyExc_SystemError);
#else
            bool type_error = PyErr_ExceptionMatches(PyExc_TypeError);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
451
            PyErr_Clear();
452
453
            if (type_error && PyNumber_Check(src.ptr()))
                return load(object(PyNumber_Long(src.ptr()), true), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
454
455
            return false;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
456

Wenzel Jakob's avatar
Wenzel Jakob committed
457
458
459
460
        value = (T) py_value;
        return true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
461
    static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
        if (std::is_floating_point<T>::value) {
            return PyFloat_FromDouble((double) src);
        } else if (sizeof(T) <= sizeof(long)) {
            if (std::is_signed<T>::value)
                return PyLong_FromLong((long) src);
            else
                return PyLong_FromUnsignedLong((unsigned long) src);
        } else {
            if (std::is_signed<T>::value)
                return PyLong_FromLongLong((long long) src);
            else
                return PyLong_FromUnsignedLongLong((unsigned long long) src);
        }
    }

477
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
478
};
Wenzel Jakob's avatar
Wenzel Jakob committed
479

480
template <> class type_caster<void_type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
481
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
482
483
    bool load(handle, bool) { return false; }
    static handle cast(void_type, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
484
        return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
485
    }
486
    PYBIND11_TYPE_CASTER(void_type, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
487
488
};

489
490
491
492
493
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
494
495
        if (!h) {
            return false;
496
        } else if (h.is_none()) {
497
498
499
            value = nullptr;
            return true;
        }
500
501

        /* Check if this is a capsule */
502
        capsule c(h, true);
503
504
505
506
507
508
        if (c.check()) {
            value = (void *) c;
            return true;
        }

        /* Check if this is a C++ type */
Wenzel Jakob's avatar
Wenzel Jakob committed
509
        if (get_type_info((PyTypeObject *) h.get_type().ptr())) {
510
511
512
513
514
515
            value = ((instance<void> *) h.ptr())->value;
            return true;
        }

        /* Fail */
        return false;
516
517
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
518
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
519
520
521
        if (ptr)
            return capsule(ptr).release();
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
522
            return none().inc_ref();
523
    }
524

525
526
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
527
    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
528
private:
529
    void *value = nullptr;
530
531
};

Wenzel Jakob's avatar
Wenzel Jakob committed
532
template <> class type_caster<std::nullptr_t> : public type_caster<void_type> { };
533

Wenzel Jakob's avatar
Wenzel Jakob committed
534
535
template <> class type_caster<bool> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
536
    bool load(handle src, bool) {
537
538
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
539
        else if (src.ptr() == Py_False) { value = false; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
540
541
        else return false;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
542
543
    static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
        return handle(src ? Py_True : Py_False).inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
544
    }
545
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
546
547
548
549
};

template <> class type_caster<std::string> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
550
    bool load(handle src, bool) {
551
        object temp;
Wenzel Jakob's avatar
Wenzel Jakob committed
552
        handle load_src = src;
553
554
555
        if (!src) {
            return false;
        } else if (PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
556
            temp = object(PyUnicode_AsUTF8String(load_src.ptr()), false);
557
            if (!temp) { PyErr_Clear(); return false; }  // UnicodeEncodeError
Wenzel Jakob's avatar
Wenzel Jakob committed
558
            load_src = temp;
559
560
561
        }
        char *buffer;
        ssize_t length;
Wenzel Jakob's avatar
Wenzel Jakob committed
562
        int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(load_src.ptr(), &buffer, &length);
563
        if (err == -1) { PyErr_Clear(); return false; }  // TypeError
564
        value = std::string(buffer, (size_t) length);
565
        success = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
566
567
        return true;
    }
568

Wenzel Jakob's avatar
Wenzel Jakob committed
569
    static handle cast(const std::string &src, return_value_policy /* policy */, handle /* parent */) {
570
        return PyUnicode_FromStringAndSize(src.c_str(), (ssize_t) src.length());
Wenzel Jakob's avatar
Wenzel Jakob committed
571
    }
572
573

    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
574
575
protected:
    bool success = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
576
577
};

578
template <typename type, typename deleter> class type_caster<std::unique_ptr<type, deleter>> {
579
public:
580
    static handle cast(std::unique_ptr<type, deleter> &&src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
581
        handle result = type_caster_base<type>::cast(src.get(), policy, parent);
582
583
584
585
        if (result)
            src.release();
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
586
    static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
587
588
};

hulucc's avatar
hulucc committed
589
template <> class type_caster<std::wstring> {
Wenzel Jakob's avatar
Wenzel Jakob committed
590
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
591
592
593
    bool load(handle src, bool) {
        object temp;
        handle load_src = src;
594
595
596
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
597
598
599
600
            temp = object(PyUnicode_FromObject(load_src.ptr()), false);
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
        }
601
602
603
604
605
606
607
608
609
610
611
612
        wchar_t *buffer = nullptr;
        ssize_t length = -1;
#if PY_MAJOR_VERSION >= 3
        buffer = PyUnicode_AsWideCharString(load_src.ptr(), &length);
#else
        temp = object(
            sizeof(wchar_t) == sizeof(short)
                ? PyUnicode_AsUTF16String(load_src.ptr())
                : PyUnicode_AsUTF32String(load_src.ptr()), false);
        if (temp) {
            int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), (char **) &buffer, &length);
            if (err == -1) { buffer = nullptr; }  // TypeError
613
            length = length / (ssize_t) sizeof(wchar_t) - 1; ++buffer; // Skip BOM
614
        }
615
616
#endif
        if (!buffer) { PyErr_Clear(); return false; }
617
        value = std::wstring(buffer, (size_t) length);
Wenzel Jakob's avatar
Wenzel Jakob committed
618
619
620
        success = true;
        return true;
    }
hulucc's avatar
hulucc committed
621

Wenzel Jakob's avatar
Wenzel Jakob committed
622
    static handle cast(const std::wstring &src, return_value_policy /* policy */, handle /* parent */) {
623
        return PyUnicode_FromWideChar(src.c_str(), (ssize_t) src.length());
Wenzel Jakob's avatar
Wenzel Jakob committed
624
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
625

Wenzel Jakob's avatar
Wenzel Jakob committed
626
    PYBIND11_TYPE_CASTER(std::wstring, _(PYBIND11_STRING_NAME));
627
628
protected:
    bool success = false;
hulucc's avatar
hulucc committed
629
630
};

631
template <> class type_caster<char> : public type_caster<std::string> {
Wenzel Jakob's avatar
Wenzel Jakob committed
632
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
633
    bool load(handle src, bool convert) {
634
        if (src.is_none()) return true;
635
636
637
        return type_caster<std::string>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
638
    static handle cast(const char *src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
639
        if (src == nullptr) return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
640
641
642
        return PyUnicode_FromString(src);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
643
    static handle cast(char src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
644
645
646
647
        char str[2] = { src, '\0' };
        return PyUnicode_DecodeLatin1(str, 1, nullptr);
    }

648
    operator char*() { return success ? (char *) value.c_str() : nullptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
649
    operator char&() { return value[0]; }
650

651
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
Wenzel Jakob's avatar
Wenzel Jakob committed
652
653
};

654
template <> class type_caster<wchar_t> : public type_caster<std::wstring> {
hulucc's avatar
hulucc committed
655
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
656
    bool load(handle src, bool convert) {
657
        if (src.is_none()) return true;
658
659
660
        return type_caster<std::wstring>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
661
    static handle cast(const wchar_t *src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
662
        if (src == nullptr) return none().inc_ref();
663
        return PyUnicode_FromWideChar(src, (ssize_t) wcslen(src));
Wenzel Jakob's avatar
Wenzel Jakob committed
664
    }
hulucc's avatar
hulucc committed
665

Wenzel Jakob's avatar
Wenzel Jakob committed
666
667
668
669
    static handle cast(wchar_t src, return_value_policy /* policy */, handle /* parent */) {
        wchar_t wstr[2] = { src, L'\0' };
        return PyUnicode_FromWideChar(wstr, 1);
    }
hulucc's avatar
hulucc committed
670

671
    operator wchar_t*() { return success ? (wchar_t *) value.c_str() : nullptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
672
    operator wchar_t&() { return value[0]; }
hulucc's avatar
hulucc committed
673

Wenzel Jakob's avatar
Wenzel Jakob committed
674
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
hulucc's avatar
hulucc committed
675
676
};

Wenzel Jakob's avatar
Wenzel Jakob committed
677
678
679
template <typename T1, typename T2> class type_caster<std::pair<T1, T2>> {
    typedef std::pair<T1, T2> type;
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
680
    bool load(handle src, bool convert) {
681
682
683
        if (!src)
            return false;
        else if (!PyTuple_Check(src.ptr()) || PyTuple_Size(src.ptr()) != 2)
Wenzel Jakob's avatar
Wenzel Jakob committed
684
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
685
686
        return  first.load(PyTuple_GET_ITEM(src.ptr(), 0), convert) &&
               second.load(PyTuple_GET_ITEM(src.ptr(), 1), convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
687
688
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
689
    static handle cast(const type &src, return_value_policy policy, handle parent) {
690
691
        object o1 = object(make_caster<T1>::cast(src.first, policy, parent), false);
        object o2 = object(make_caster<T2>::cast(src.second, policy, parent), false);
692
        if (!o1 || !o2)
Wenzel Jakob's avatar
Wenzel Jakob committed
693
694
695
696
697
            return handle();
        tuple result(2);
        PyTuple_SET_ITEM(result.ptr(), 0, o1.release().ptr());
        PyTuple_SET_ITEM(result.ptr(), 1, o2.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
698
699
    }

700
701
    static PYBIND11_DESCR name() {
        return type_descr(
702
703
            _("Tuple[") + make_caster<T1>::name() + _(", ") + make_caster<T2>::name() + _("]")
        );
Wenzel Jakob's avatar
Wenzel Jakob committed
704
705
    }

706
707
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
708
    operator type() {
709
710
        return type(first.operator typename make_caster<T1>::template cast_op_type<T1>(),
                    second.operator typename make_caster<T2>::template cast_op_type<T2>());
Wenzel Jakob's avatar
Wenzel Jakob committed
711
712
    }
protected:
713
714
    make_caster<T1> first;
    make_caster<T2> second;
Wenzel Jakob's avatar
Wenzel Jakob committed
715
716
};

717
template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
718
    typedef std::tuple<Tuple...> type;
719
    typedef std::tuple<intrinsic_t<Tuple>...> itype;
720
721
    typedef std::tuple<args> args_type;
    typedef std::tuple<args, kwargs> args_kwargs_type;
Wenzel Jakob's avatar
Wenzel Jakob committed
722
723
724
public:
    enum { size = sizeof...(Tuple) };

725
726
727
    static constexpr const bool has_kwargs = std::is_same<itype, args_kwargs_type>::value;
    static constexpr const bool has_args = has_kwargs || std::is_same<itype, args_type>::value;

Wenzel Jakob's avatar
Wenzel Jakob committed
728
    bool load(handle src, bool convert) {
729
730
        if (!src || !PyTuple_Check(src.ptr()) || PyTuple_GET_SIZE(src.ptr()) != size)
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
731
        return load(src, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
732
733
    }

734
    template <typename T = itype, enable_if_t<
735
        !std::is_same<T, args_type>::value &&
736
        !std::is_same<T, args_kwargs_type>::value, int> = 0>
737
738
739
740
    bool load_args(handle args, handle, bool convert) {
        return load(args, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
    }

741
    template <typename T = itype, enable_if_t<std::is_same<T, args_type>::value, int> = 0>
742
743
744
745
746
    bool load_args(handle args, handle, bool convert) {
        std::get<0>(value).load(args, convert);
        return true;
    }

747
    template <typename T = itype, enable_if_t<std::is_same<T, args_kwargs_type>::value, int> = 0>
748
749
750
751
752
    bool load_args(handle args, handle kwargs, bool convert) {
        std::get<0>(value).load(args, convert);
        std::get<1>(value).load(kwargs, convert);
        return true;
    }
753

Wenzel Jakob's avatar
Wenzel Jakob committed
754
    static handle cast(const type &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
755
        return cast(src, policy, parent, typename make_index_sequence<size>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
756
757
    }

758
    static PYBIND11_DESCR element_names() {
759
        return detail::concat(make_caster<Tuple>::name()...);
760
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
761

762
    static PYBIND11_DESCR name() {
763
        return type_descr(_("Tuple[") + element_names() + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
764
765
    }

766
    template <typename ReturnValue, typename Func> enable_if_t<!std::is_void<ReturnValue>::value, ReturnValue> call(Func &&f) {
767
        return call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
768
769
    }

770
    template <typename ReturnValue, typename Func> enable_if_t<std::is_void<ReturnValue>::value, void_type> call(Func &&f) {
771
        call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
772
        return void_type();
Wenzel Jakob's avatar
Wenzel Jakob committed
773
774
    }

775
776
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
777
    operator type() {
Wenzel Jakob's avatar
Wenzel Jakob committed
778
        return cast(typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
779
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
780

Wenzel Jakob's avatar
Wenzel Jakob committed
781
protected:
782
    template <typename ReturnValue, typename Func, size_t ... Index> ReturnValue call(Func &&f, index_sequence<Index...>) {
783
        return f(std::get<Index>(value)
784
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
785
786
787
    }

    template <size_t ... Index> type cast(index_sequence<Index...>) {
788
        return type(std::get<Index>(value)
789
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
790
791
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
792
793
    template <size_t ... Indices> bool load(handle src, bool convert, index_sequence<Indices...>) {
        std::array<bool, size> success {{
794
            std::get<Indices>(value).load(PyTuple_GET_ITEM(src.ptr(), Indices), convert)...
Wenzel Jakob's avatar
Wenzel Jakob committed
795
        }};
796
        (void) convert; /* avoid a warning when the tuple is empty */
Wenzel Jakob's avatar
Wenzel Jakob committed
797
        for (bool r : success)
Wenzel Jakob's avatar
Wenzel Jakob committed
798
799
800
801
802
803
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
Wenzel Jakob's avatar
Wenzel Jakob committed
804
805
    template <size_t ... Indices> static handle cast(const type &src, return_value_policy policy, handle parent, index_sequence<Indices...>) {
        std::array<object, size> entries {{
806
            object(make_caster<Tuple>::cast(std::get<Indices>(src), policy, parent), false)...
Wenzel Jakob's avatar
Wenzel Jakob committed
807
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
808
809
810
811
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
812
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
813
814
815
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
816
817
818
    }

protected:
819
    std::tuple<make_caster<Tuple>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
820
821
822
};

/// Type caster for holder types like std::shared_ptr, etc.
Wenzel Jakob's avatar
Wenzel Jakob committed
823
template <typename type, typename holder_type> class type_caster_holder : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
824
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
825
826
827
828
829
830
    using base = type_caster_base<type>;
    using base::base;
    using base::cast;
    using base::typeinfo;
    using base::value;
    using base::temp;
831

Wenzel Jakob's avatar
Wenzel Jakob committed
832
833
834
835
836
837
    PYBIND11_NOINLINE bool load(handle src, bool convert) {
        return load(src, convert, Py_TYPE(src.ptr()));
    }

    bool load(handle src, bool convert, PyTypeObject *tobj) {
        if (!src || !typeinfo)
Wenzel Jakob's avatar
Wenzel Jakob committed
838
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
839
        if (src.is_none()) {
840
841
            value = nullptr;
            return true;
Wenzel Jakob's avatar
Wenzel Jakob committed
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
        }

        if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
            /* Check if we can safely perform a reinterpret-style cast */
            if (PyType_IsSubtype(tobj, typeinfo->type)) {
                auto inst = (instance<type, holder_type> *) src.ptr();
                value = (void *) inst->value;
                holder = inst->holder;
                return true;
            }
        } else { /* Case 2: multiple inheritance */
            /* Check if we can safely perform a reinterpret-style cast */
            if (tobj == typeinfo->type) {
                auto inst = (instance<type, holder_type> *) src.ptr();
                value = (void *) inst->value;
                holder = inst->holder;
                return true;
            }

            /* If this is a python class, also check the parents recursively */
            auto const &type_dict = get_internals().registered_types_py;
            bool new_style_class = PyType_Check(tobj);
            if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
                tuple parents(tobj->tp_bases, true);
                for (handle parent : parents) {
                    bool result = load(src, convert, (PyTypeObject *) parent.ptr());
                    if (result)
                        return true;
                }
            }

            if (try_implicit_casts(src, convert))
                return true;
875
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
876

877
878
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
879
880
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
881
882
883
                    return true;
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900

        return false;
    }

    template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle, bool) { return false; }

    template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle src, bool convert) {
        for (auto &cast : typeinfo->implicit_casts) {
            type_caster_holder sub_caster(*cast.first);
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                holder = holder_type(sub_caster.holder, (type *) value);
                return true;
            }
        }
901
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
902
    }
903

Wenzel Jakob's avatar
Wenzel Jakob committed
904
905
906
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type*() { return &holder; }
907

908
909
910
911
912
913
914
915
    // Workaround for Intel compiler bug
    // see pybind11 issue 94
    #if defined(__ICC) || defined(__INTEL_COMPILER)
    operator holder_type&() { return holder; }
    #else
    explicit operator holder_type&() { return holder; }
    #endif

916
    static handle cast(const holder_type &src, return_value_policy, handle) {
917
        return type_caster_generic::cast(
918
            src.get(), return_value_policy::take_ownership, handle(),
919
            src.get() ? &typeid(*src.get()) : nullptr, &typeid(type),
920
            nullptr, nullptr, &src);
921
922
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
923
924
925
926
protected:
    holder_type holder;
};

927
928
929
930
931
932
933
934
935
936
937
938
/// Specialize for the common std::shared_ptr, so users don't need to
template <typename T>
class type_caster<std::shared_ptr<T>> : public type_caster_holder<T, std::shared_ptr<T>> { };

/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type) \
    namespace pybind11 { namespace detail { \
    template <typename type> \
    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
        : public type_caster_holder<type, holder_type> { }; \
    }}

939
// PYBIND11_DECLARE_HOLDER_TYPE holder types:
940
template <typename base, typename holder> struct is_holder_type :
941
942
943
944
    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
// Specialization for always-supported unique_ptr holders:
template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
    std::true_type {};
945

946
947
template <typename T> struct handle_type_name { static PYBIND11_DESCR name() { return _<T>(); } };
template <> struct handle_type_name<bytes> { static PYBIND11_DESCR name() { return _(PYBIND11_BYTES_NAME); } };
948
949
template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
950

951
template <typename type>
952
struct type_caster<type, enable_if_t<is_pyobject<type>::value>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
953
public:
954
    template <typename T = type, enable_if_t<!std::is_base_of<object, T>::value, int> = 0>
955
    bool load(handle src, bool /* convert */) { value = type(src); return value.check(); }
956

957
    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
958
    bool load(handle src, bool /* convert */) { value = type(src, true); return value.check(); }
959

Wenzel Jakob's avatar
Wenzel Jakob committed
960
961
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
962
    }
963
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
Wenzel Jakob's avatar
Wenzel Jakob committed
964
965
};

966
967
968
969
970
971
972
973
974
975
// Our conditions for enabling moving are quite restrictive:
// At compile time:
// - T needs to be a non-const, non-pointer, non-reference type
// - type_caster<T>::operator T&() must exist
// - the type must be move constructible (obviously)
// At run-time:
// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
//   must have ref_count() == 1)h
// If any of the above are not satisfied, we fall back to copying.
template <typename T, typename SFINAE = void> struct move_is_plain_type : std::false_type {};
976
template <typename T> struct move_is_plain_type<T, enable_if_t<
977
        !std::is_void<T>::value && !std::is_pointer<T>::value && !std::is_reference<T>::value && !std::is_const<T>::value
978
    >> : std::true_type { };
979
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
980
template <typename T> struct move_always<T, enable_if_t<
981
982
983
        move_is_plain_type<T>::value &&
        !std::is_copy_constructible<T>::value && std::is_move_constructible<T>::value &&
        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
984
    >> : std::true_type { };
985
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
986
template <typename T> struct move_if_unreferenced<T, enable_if_t<
987
988
989
        move_is_plain_type<T>::value &&
        !move_always<T>::value && std::is_move_constructible<T>::value &&
        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
990
    >> : std::true_type { };
991
992
template <typename T> using move_never = std::integral_constant<bool, !move_always<T>::value && !move_if_unreferenced<T>::value>;

993
994
995
996
997
998
999
1000
1001
// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
// reference or pointer to a local variable of the type_caster.  Basically, only
// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
// everything else returns a reference/pointer to a local variable.
template <typename type> using cast_is_temporary_value_reference = bool_constant<
    (std::is_reference<type>::value || std::is_pointer<type>::value) &&
    !std::is_base_of<type_caster_generic, make_caster<type>>::value
>;

1002
// Basic python -> C++ casting; throws if casting fails
Jason Rhinelander's avatar
Jason Rhinelander committed
1003
template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1004
1005
1006
1007
1008
1009
1010
1011
    if (!conv.load(handle, true)) {
#if defined(NDEBUG)
        throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
#else
        throw cast_error("Unable to cast Python instance of type " +
            (std::string) handle.get_type().str() + " to C++ type '" + type_id<T>() + "''");
#endif
    }
1012
1013
    return conv;
}
1014
1015
1016
1017
1018
1019
// Wrapper around the above that also constructs and returns a type_caster
template <typename T> make_caster<T> load_type(const handle &handle) {
    make_caster<T> conv;
    load_type(conv, handle);
    return conv;
}
1020
1021
1022
1023
1024
1025
1026
1027

NAMESPACE_END(detail)

template <typename T> T cast(const handle &handle) {
    static_assert(!detail::cast_is_temporary_value_reference<T>::value,
            "Unable to cast type to reference: value is local to type caster");
    using type_caster = detail::make_caster<T>;
    return detail::load_type<T>(handle).operator typename type_caster::template cast_op_type<T>();
Wenzel Jakob's avatar
Wenzel Jakob committed
1028
1029
}

1030
1031
1032
template <typename T> object cast(const T &value,
        return_value_policy policy = return_value_policy::automatic_reference,
        handle parent = handle()) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1033
1034
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
1035
1036
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
1037
    return object(detail::make_caster<T>::cast(value, policy, parent), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
1038
1039
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1040
template <typename T> T handle::cast() const { return pybind11::cast<T>(*this); }
1041
template <> inline void handle::cast() const { return; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1042

1043
template <typename T>
1044
detail::enable_if_t<detail::move_always<T>::value || detail::move_if_unreferenced<T>::value, T> move(object &&obj) {
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
    if (obj.ref_count() > 1)
#if defined(NDEBUG)
        throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
            " (compile in debug mode for details)");
#else
        throw cast_error("Unable to move from Python " + (std::string) obj.get_type().str() +
                " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
#endif

    // Move into a temporary and return that, because the reference may be a local value of `conv`
1055
    T ret = std::move(detail::load_type<T>(obj).operator T&());
1056
1057
1058
1059
1060
1061
1062
1063
    return ret;
}

// Calling cast() on an rvalue calls pybind::cast with the object rvalue, which does:
// - If we have to move (because T has no copy constructor), do it.  This will fail if the moved
//   object has multiple references, but trying to copy will fail to compile.
// - If both movable and copyable, check ref count: if 1, move; otherwise copy
// - Otherwise (not movable), copy.
1064
template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1065
1066
    return move<T>(std::move(object));
}
1067
template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1068
1069
1070
1071
1072
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
1073
template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1074
1075
1076
1077
1078
1079
1080
1081
    return cast<T>(object);
}

template <typename T> T object::cast() const & { return pybind11::cast<T>(*this); }
template <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); }
template <> inline void object::cast() const & { return; }
template <> inline void object::cast() && { return; }

1082
1083
NAMESPACE_BEGIN(detail)

1084
1085
1086
struct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro
template <typename ret_type> using overload_caster_t = conditional_t<
    cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>;
1087
1088
1089

// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
// store the result in the given variable.  For other types, this is a no-op.
1090
1091
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
    return load_type(caster, o).operator typename make_caster<T>::template cast_op_type<T>();
1092
}
1093
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
    pybind11_fail("Internal error: cast_ref fallback invoked"); }

// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
// cases where pybind11::cast is valid.
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
    return pybind11::cast<T>(std::move(o)); }
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
    pybind11_fail("Internal error: cast_safe fallback invoked"); }
template <> inline void cast_safe<void>(object &&) {}

NAMESPACE_END(detail)
1106

1107
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
1108
          typename... Args> tuple make_tuple(Args&&... args_) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1109
    const size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
1110
    std::array<object, size> args {
1111
        { object(detail::make_caster<Args>::cast(
1112
            std::forward<Args>(args_), policy, nullptr), false)... }
Wenzel Jakob's avatar
Wenzel Jakob committed
1113
    };
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
    for (auto &arg_value : args) {
        if (!arg_value) {
#if defined(NDEBUG)
            throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
            throw cast_error("make_tuple(): unable to convert arguments of types '" +
                (std::string) type_id<std::tuple<Args...>>() + "' to Python object");
#endif
        }
    }
1124
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
1125
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1126
    for (auto &arg_value : args)
1127
1128
1129
1130
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
/// Annotation for keyword arguments
struct arg {
    constexpr explicit arg(const char *name) : name(name) { }
    template <typename T> arg_v operator=(T &&value) const;

    const char *name;
};

/// Annotation for keyword arguments with values
struct arg_v : arg {
    template <typename T>
    arg_v(const char *name, T &&x, const char *descr = nullptr)
        : arg(name),
          value(detail::make_caster<T>::cast(x, return_value_policy::automatic, handle()), false),
          descr(descr)
#if !defined(NDEBUG)
        , type(type_id<T>())
#endif
    { }

    object value;
    const char *descr;
#if !defined(NDEBUG)
    std::string type;
#endif
};

template <typename T>
arg_v arg::operator=(T &&value) const { return {name, std::forward<T>(value)}; }

Wenzel Jakob's avatar
Wenzel Jakob committed
1161
/// Alias for backward compatibility -- to be removed in version 2.0
1162
1163
1164
1165
1166
1167
1168
template <typename /*unused*/> using arg_t = arg_v;

inline namespace literals {
/// String literal version of arg
constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
}

1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
NAMESPACE_BEGIN(detail)
NAMESPACE_BEGIN(constexpr_impl)
/// Implementation details for constexpr functions
constexpr int first(int i) { return i; }
template <typename T, typename... Ts>
constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }

constexpr int last(int /*i*/, int result) { return result; }
template <typename T, typename... Ts>
constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
NAMESPACE_END(constexpr_impl)

/// Return the index of the first type in Ts which satisfies Predicate<T>
template <template<typename> class Predicate, typename... Ts>
constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }

/// Return the index of the last type in Ts which satisfies Predicate<T>
template <template<typename> class Predicate, typename... Ts>
constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }

/// Helper class which collects only positional arguments for a Python function call.
/// A fancier version below can collect any argument, but this one is optimal for simple calls.
template <return_value_policy policy>
class simple_collector {
public:
    template <typename... Ts>
1195
    explicit simple_collector(Ts &&...values)
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
        : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { }

    const tuple &args() const & { return m_args; }
    dict kwargs() const { return {}; }

    tuple args() && { return std::move(m_args); }

    /// Call a Python function and pass the collected arguments
    object call(PyObject *ptr) const {
        auto result = object(PyObject_CallObject(ptr, m_args.ptr()), false);
        if (!result)
            throw error_already_set();
        return result;
    }

private:
    tuple m_args;
};

/// Helper class which collects positional, keyword, * and ** arguments for a Python function call
template <return_value_policy policy>
class unpacking_collector {
public:
    template <typename... Ts>
1220
    explicit unpacking_collector(Ts &&...values) {
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
        // Tuples aren't (easily) resizable so a list is needed for collection,
        // but the actual function call strictly requires a tuple.
        auto args_list = list();
        int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
        ignore_unused(_);

        m_args = object(PyList_AsTuple(args_list.ptr()), false);
    }

    const tuple &args() const & { return m_args; }
    const dict &kwargs() const & { return m_kwargs; }

    tuple args() && { return std::move(m_args); }
    dict kwargs() && { return std::move(m_kwargs); }

    /// Call a Python function and pass the collected arguments
    object call(PyObject *ptr) const {
        auto result = object(PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr()), false);
        if (!result)
            throw error_already_set();
        return result;
    }

private:
    template <typename T>
    void process(list &args_list, T &&x) {
        auto o = object(detail::make_caster<T>::cast(std::forward<T>(x), policy, nullptr), false);
        if (!o) {
#if defined(NDEBUG)
            argument_cast_error();
#else
            argument_cast_error(std::to_string(args_list.size()), type_id<T>());
#endif
        }
        args_list.append(o);
    }

    void process(list &args_list, detail::args_proxy ap) {
1259
        for (const auto &a : ap)
1260
            args_list.append(a);
1261
1262
    }

1263
    void process(list &/*args_list*/, arg_v a) {
1264
        if (m_kwargs.contains(a.name)) {
1265
1266
1267
1268
1269
1270
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
1271
        if (!a.value) {
1272
1273
1274
#if defined(NDEBUG)
            argument_cast_error();
#else
1275
            argument_cast_error(a.name, a.type);
1276
1277
#endif
        }
1278
        m_kwargs[a.name] = a.value;
1279
1280
1281
    }

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
1282
1283
        if (!kp)
            return;
1284
        for (const auto &k : dict(kp, true)) {
1285
            if (m_kwargs.contains(k.first)) {
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
#if defined(NDEBUG)
                multiple_values_error();
#else
                multiple_values_error(k.first.str());
#endif
            }
            m_kwargs[k.first] = k.second;
        }
    }

    [[noreturn]] static void multiple_values_error() {
        throw type_error("Got multiple values for keyword argument "
                         "(compile in debug mode for details)");
    }

    [[noreturn]] static void multiple_values_error(std::string name) {
        throw type_error("Got multiple values for keyword argument '" + name + "'");
    }

    [[noreturn]] static void argument_cast_error() {
        throw cast_error("Unable to convert call argument to Python object "
                         "(compile in debug mode for details)");
    }

    [[noreturn]] static void argument_cast_error(std::string name, std::string type) {
        throw cast_error("Unable to convert call argument '" + name
                         + "' of type '" + type + "' to Python object");
    }

private:
    tuple m_args;
    dict m_kwargs;
};

/// Collect only positional arguments for a Python function call
template <return_value_policy policy, typename... Args,
          typename = enable_if_t<all_of_t<is_positional, Args...>::value>>
simple_collector<policy> collect_arguments(Args &&...args) {
1324
    return simple_collector<policy>(std::forward<Args>(args)...);
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
}

/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
template <return_value_policy policy, typename... Args,
          typename = enable_if_t<!all_of_t<is_positional, Args...>::value>>
unpacking_collector<policy> collect_arguments(Args &&...args) {
    // Following argument order rules for generalized unpacking according to PEP 448
    static_assert(
        constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>()
        && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(),
        "Invalid function call: positional args must precede keywords and ** unpacking; "
        "* unpacking must precede ** unpacking"
    );
1338
    return unpacking_collector<policy>(std::forward<Args>(args)...);
1339
1340
}

1341
template <typename Derived>
1342
template <return_value_policy policy, typename... Args>
1343
1344
object object_api<Derived>::operator()(Args &&...args) const {
    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
1345
1346
}

1347
1348
1349
template <typename Derived>
template <return_value_policy policy, typename... Args>
object object_api<Derived>::call(Args &&...args) const {
1350
    return operator()<policy>(std::forward<Args>(args)...);
1351
1352
}

1353
1354
NAMESPACE_END(detail)

Wenzel Jakob's avatar
Wenzel Jakob committed
1355
1356
1357
1358
1359
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

1360
NAMESPACE_END(pybind11)