cast.h 51.7 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;
Wenzel Jakob's avatar
Wenzel Jakob committed
29
30
    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
    void *get_buffer_data = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
31
32
33
    /** 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
34
};
35

Wenzel Jakob's avatar
Wenzel Jakob committed
36
37
38
39
40
PYBIND11_NOINLINE inline internals &get_internals() {
    static internals *internals_ptr = nullptr;
    if (internals_ptr)
        return *internals_ptr;
    handle builtins(PyEval_GetBuiltins());
41
    const char *id = PYBIND11_INTERNALS_ID;
42
43
44
45
    capsule caps;
    if (builtins.contains(id)) {
        caps = builtins[id];
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
46
47
48
49
    if (caps.check()) {
        internals_ptr = caps;
    } else {
        internals_ptr = new internals();
50
51
52
53
54
55
56
        #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
57
        builtins[id] = capsule(internals_ptr);
58
59
60
61
        internals_ptr->registered_exception_translators.push_front(
            [](std::exception_ptr p) -> void {
                try {
                    if (p) std::rethrow_exception(p);
62
                } catch (error_already_set &e)           { e.restore();                                    return;
63
                } catch (const builtin_exception &e)     { e.set_error();                                  return;
64
65
66
67
68
69
70
71
72
73
74
75
76
                } 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
77
78
79
80
    }
    return *internals_ptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
81
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
Wenzel Jakob's avatar
Wenzel Jakob committed
82
83
84
85
86
87
    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
88
        if (!type)
89
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
90
91
92
    } while (true);
}

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

96
97
    auto it = types.find(std::type_index(tp));
    if (it != types.end())
Wenzel Jakob's avatar
Wenzel Jakob committed
98
        return (detail::type_info *) it->second;
Wenzel Jakob's avatar
Wenzel Jakob committed
99
100
101
102
103
    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
104
105
106
    return nullptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
107
108
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
109
110
111
112
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

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

Wenzel Jakob's avatar
Wenzel Jakob committed
118
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
119

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

    return errorString;
}

131
132
133
134
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
135
        auto instance_type = detail::get_type_info(Py_TYPE(it->second));
136
137
138
139
        if (instance_type && instance_type == type)
            return handle((PyObject *) it->second);
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
140
141
}

142
143
144
145
146
147
148
149
150
151
152
153
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
}

154
155
156
// Forward declaration
inline void keep_alive_impl(handle nurse, handle patient);

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

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

    bool load(handle src, bool convert, PyTypeObject *tobj) {
Wenzel Jakob's avatar
Wenzel Jakob committed
169
        if (!src || !typeinfo)
Wenzel Jakob's avatar
Wenzel Jakob committed
170
            return false;
171
        if (src.is_none()) {
172
173
            value = nullptr;
            return true;
Wenzel Jakob's avatar
Wenzel Jakob committed
174
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
175
176
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

        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
212
213
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
214
215
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
216
217
218
219
220
221
                    return true;
            }
        }
        return false;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
222
223
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
                                         const std::type_info *type_info,
224
                                         const std::type_info *type_info_backup,
Wenzel Jakob's avatar
Wenzel Jakob committed
225
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
226
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
227
                                         const void *existing_holder = nullptr) {
228
        void *src = const_cast<void *>(_src);
Wenzel Jakob's avatar
Wenzel Jakob committed
229
        if (src == nullptr)
Wenzel Jakob's avatar
Wenzel Jakob committed
230
            return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
231

232
        auto &internals = get_internals();
Wenzel Jakob's avatar
Wenzel Jakob committed
233

234
        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
235
236
237
238
239
        if (it == internals.registered_types_cpp.end()) {
            type_info = type_info_backup;
            it = internals.registered_types_cpp.find(std::type_index(*type_info));
        }

240
        if (it == internals.registered_types_cpp.end()) {
241
242
243
            std::string tname = type_info->name();
            detail::clean_type_id(tname);
            std::string msg = "Unregistered type : " + tname;
Wenzel Jakob's avatar
Wenzel Jakob committed
244
            PyErr_SetString(PyExc_TypeError, msg.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
245
            return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
246
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
247

248
        auto tinfo = (const detail::type_info *) it->second;
249
250

        auto it_instances = internals.registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
251
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
Wenzel Jakob's avatar
Wenzel Jakob committed
252
            auto instance_type = detail::get_type_info(Py_TYPE(it_i->second));
253
            if (instance_type && instance_type == tinfo)
Jason Rhinelander's avatar
Jason Rhinelander committed
254
                return handle((PyObject *) it_i->second).inc_ref();
255
256
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
257
258
259
260
261
262
263
        object inst(PyType_GenericAlloc(tinfo->type, 0), false);

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

        wrapper->value = src;
        wrapper->owned = true;

Wenzel Jakob's avatar
Wenzel Jakob committed
264
265
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::take_ownership;
266
267
        else if (policy == return_value_policy::automatic_reference)
            policy = return_value_policy::reference;
Wenzel Jakob's avatar
Wenzel Jakob committed
268

Wenzel Jakob's avatar
Wenzel Jakob committed
269
        if (policy == return_value_policy::copy) {
270
271
272
            if (copy_constructor)
                wrapper->value = copy_constructor(wrapper->value);
            else
273
                throw cast_error("return_value_policy = copy, but the object is non-copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
274
        } else if (policy == return_value_policy::move) {
275
276
277
            if (move_constructor)
                wrapper->value = move_constructor(wrapper->value);
            else if (copy_constructor)
Wenzel Jakob's avatar
Wenzel Jakob committed
278
                wrapper->value = copy_constructor(wrapper->value);
279
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
280
                throw cast_error("return_value_policy = move, but the object is neither movable nor copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
281
        } else if (policy == return_value_policy::reference) {
Wenzel Jakob's avatar
Wenzel Jakob committed
282
            wrapper->owned = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
283
        } else if (policy == return_value_policy::reference_internal) {
Wenzel Jakob's avatar
Wenzel Jakob committed
284
            wrapper->owned = false;
285
            detail::keep_alive_impl(inst, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
286
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
287
288

        tinfo->init_holder(inst.ptr(), existing_holder);
289
290

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

        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
293
294
295
296
    }

protected:
    const type_info *typeinfo = nullptr;
297
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
298
299
300
    object temp;
};

301
302
/* Determine suitable casting operator */
template <typename T>
303
using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
304
305
    typename std::add_pointer<intrinsic_t<T>>::type,
    typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
306

307
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
308
template <typename type> class type_caster_base : public type_caster_generic {
309
    using itype = intrinsic_t<type>;
310
public:
311
    static PYBIND11_DESCR name() { return type_descr(_<type>()); }
312

Wenzel Jakob's avatar
Wenzel Jakob committed
313
314
    type_caster_base() : type_caster_base(typeid(type)) { }
    type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
315

316
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
317
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
318
            policy = return_value_policy::copy;
319
        return cast(&src, policy, parent);
320
321
    }

322
    static handle cast(itype &&src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
323
324
325
326
327
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
            policy = return_value_policy::move;
        return cast(&src, policy, parent);
    }

328
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
329
330
        return type_caster_generic::cast(
            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
331
            make_copy_constructor(src), make_move_constructor(src));
332
333
    }

334
335
    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;

336
337
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
338

339
protected:
340
341
342
343
344
345
346
347
348
349
350
    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. */
351
    template <typename T = type, typename = enable_if_t<std::is_copy_constructible<T>::value>>
352
353
    static Constructor make_copy_constructor(const T *value) {
        return [](const void *arg) -> void * { return new T(*((const T *)arg)); }; }
354
    template <typename T = type, typename = enable_if_t<std::is_move_constructible<T>::value>>
355
356
357
358
359
    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; }
360
361
};

Wenzel Jakob's avatar
Wenzel Jakob committed
362
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
363
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
364
365

template <typename type> class type_caster<std::reference_wrapper<type>> : public type_caster_base<type> {
366
367
public:
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
368
        return type_caster_base<type>::cast(&src.get(), policy, parent);
369
    }
370
371
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
    operator std::reference_wrapper<type>() { return std::ref(*((type *) this->value)); }
372
373
};

374
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
375
376
377
    protected: \
        type value; \
    public: \
378
        static PYBIND11_DESCR name() { return type_descr(py_name); } \
Wenzel Jakob's avatar
Wenzel Jakob committed
379
        static handle cast(const type *src, return_value_policy policy, handle parent) { \
Wenzel Jakob's avatar
Wenzel Jakob committed
380
381
382
            return cast(*src, policy, parent); \
        } \
        operator type*() { return &value; } \
383
        operator type&() { return value; } \
384
        template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>
Wenzel Jakob's avatar
Wenzel Jakob committed
385

386
387
388
389
390
391
392
#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type) \
    namespace pybind11 { namespace detail { \
    template <typename type> class type_caster<holder_type> \
        : public type_caster_holder<type, holder_type> { }; \
    }}


Wenzel Jakob's avatar
Wenzel Jakob committed
393
template <typename T>
394
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
395
396
397
398
    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
399

Wenzel Jakob's avatar
Wenzel Jakob committed
400
    bool load(handle src, bool) {
Wenzel Jakob's avatar
Wenzel Jakob committed
401
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
402

403
404
405
        if (!src) {
            return false;
        } if (std::is_floating_point<T>::value) {
Wenzel Jakob's avatar
Wenzel Jakob committed
406
            py_value = (py_type) PyFloat_AsDouble(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
407
        } else if (sizeof(T) <= sizeof(long)) {
408
409
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
410
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
411
                py_value = (py_type) PyLong_AsLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
412
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
413
                py_value = (py_type) PyLong_AsUnsignedLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
414
        } else {
415
416
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
417
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
418
                py_value = (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
419
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
420
                py_value = (py_type) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
421
422
423
424
425
426
427
428
429
        }

        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()))) {
            PyErr_Clear();
            return false;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
430

Wenzel Jakob's avatar
Wenzel Jakob committed
431
432
433
434
        value = (T) py_value;
        return true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
435
    static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
        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);
        }
    }

451
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
452
};
Wenzel Jakob's avatar
Wenzel Jakob committed
453

454
template <> class type_caster<void_type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
455
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
456
457
    bool load(handle, bool) { return false; }
    static handle cast(void_type, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
458
        return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
459
    }
460
    PYBIND11_TYPE_CASTER(void_type, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
461
462
};

463
464
465
466
467
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
468
469
        if (!h) {
            return false;
470
        } else if (h.is_none()) {
471
472
473
            value = nullptr;
            return true;
        }
474
475

        /* Check if this is a capsule */
476
        capsule c(h, true);
477
478
479
480
481
482
        if (c.check()) {
            value = (void *) c;
            return true;
        }

        /* Check if this is a C++ type */
Wenzel Jakob's avatar
Wenzel Jakob committed
483
        if (get_type_info((PyTypeObject *) h.get_type().ptr())) {
484
485
486
487
488
489
            value = ((instance<void> *) h.ptr())->value;
            return true;
        }

        /* Fail */
        return false;
490
491
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
492
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
493
494
495
        if (ptr)
            return capsule(ptr).release();
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
496
            return none().inc_ref();
497
    }
498

499
500
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
501
    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
502
private:
503
    void *value = nullptr;
504
505
};

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

Wenzel Jakob's avatar
Wenzel Jakob committed
508
509
template <> class type_caster<bool> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
510
    bool load(handle src, bool) {
511
512
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
513
        else if (src.ptr() == Py_False) { value = false; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
514
515
        else return false;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
516
517
    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
518
    }
519
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
520
521
522
523
};

template <> class type_caster<std::string> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
524
    bool load(handle src, bool) {
525
        object temp;
Wenzel Jakob's avatar
Wenzel Jakob committed
526
        handle load_src = src;
527
528
529
        if (!src) {
            return false;
        } else if (PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
530
            temp = object(PyUnicode_AsUTF8String(load_src.ptr()), false);
531
            if (!temp) { PyErr_Clear(); return false; }  // UnicodeEncodeError
Wenzel Jakob's avatar
Wenzel Jakob committed
532
            load_src = temp;
533
534
535
        }
        char *buffer;
        ssize_t length;
Wenzel Jakob's avatar
Wenzel Jakob committed
536
        int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(load_src.ptr(), &buffer, &length);
537
        if (err == -1) { PyErr_Clear(); return false; }  // TypeError
538
        value = std::string(buffer, (size_t) length);
539
        success = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
540
541
        return true;
    }
542

Wenzel Jakob's avatar
Wenzel Jakob committed
543
    static handle cast(const std::string &src, return_value_policy /* policy */, handle /* parent */) {
544
        return PyUnicode_FromStringAndSize(src.c_str(), (ssize_t) src.length());
Wenzel Jakob's avatar
Wenzel Jakob committed
545
    }
546
547

    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
548
549
protected:
    bool success = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
550
551
};

552
template <typename type, typename deleter> class type_caster<std::unique_ptr<type, deleter>> {
553
public:
554
    static handle cast(std::unique_ptr<type, deleter> &&src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
555
        handle result = type_caster_base<type>::cast(src.get(), policy, parent);
556
557
558
559
        if (result)
            src.release();
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
560
    static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
561
562
};

hulucc's avatar
hulucc committed
563
template <> class type_caster<std::wstring> {
Wenzel Jakob's avatar
Wenzel Jakob committed
564
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
565
566
567
    bool load(handle src, bool) {
        object temp;
        handle load_src = src;
568
569
570
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
571
572
573
574
            temp = object(PyUnicode_FromObject(load_src.ptr()), false);
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
        }
575
576
577
578
579
580
581
582
583
584
585
586
        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
587
            length = length / (ssize_t) sizeof(wchar_t) - 1; ++buffer; // Skip BOM
588
        }
589
590
#endif
        if (!buffer) { PyErr_Clear(); return false; }
591
        value = std::wstring(buffer, (size_t) length);
Wenzel Jakob's avatar
Wenzel Jakob committed
592
593
594
        success = true;
        return true;
    }
hulucc's avatar
hulucc committed
595

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

Wenzel Jakob's avatar
Wenzel Jakob committed
600
    PYBIND11_TYPE_CASTER(std::wstring, _(PYBIND11_STRING_NAME));
601
602
protected:
    bool success = false;
hulucc's avatar
hulucc committed
603
604
};

605
template <> class type_caster<char> : public type_caster<std::string> {
Wenzel Jakob's avatar
Wenzel Jakob committed
606
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
607
    bool load(handle src, bool convert) {
608
        if (src.is_none()) return true;
609
610
611
        return type_caster<std::string>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
612
    static handle cast(const char *src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
613
        if (src == nullptr) return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
614
615
616
        return PyUnicode_FromString(src);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
617
    static handle cast(char src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
618
619
620
621
        char str[2] = { src, '\0' };
        return PyUnicode_DecodeLatin1(str, 1, nullptr);
    }

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

625
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
Wenzel Jakob's avatar
Wenzel Jakob committed
626
627
};

628
template <> class type_caster<wchar_t> : public type_caster<std::wstring> {
hulucc's avatar
hulucc committed
629
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
630
    bool load(handle src, bool convert) {
631
        if (src.is_none()) return true;
632
633
634
        return type_caster<std::wstring>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
635
    static handle cast(const wchar_t *src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
636
        if (src == nullptr) return none().inc_ref();
637
        return PyUnicode_FromWideChar(src, (ssize_t) wcslen(src));
Wenzel Jakob's avatar
Wenzel Jakob committed
638
    }
hulucc's avatar
hulucc committed
639

Wenzel Jakob's avatar
Wenzel Jakob committed
640
641
642
643
    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
644

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

Wenzel Jakob's avatar
Wenzel Jakob committed
648
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
hulucc's avatar
hulucc committed
649
650
};

Wenzel Jakob's avatar
Wenzel Jakob committed
651
652
653
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
654
    bool load(handle src, bool convert) {
655
656
657
        if (!src)
            return false;
        else if (!PyTuple_Check(src.ptr()) || PyTuple_Size(src.ptr()) != 2)
Wenzel Jakob's avatar
Wenzel Jakob committed
658
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
659
660
        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
661
662
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
663
    static handle cast(const type &src, return_value_policy policy, handle parent) {
664
665
        object o1 = object(make_caster<T1>::cast(src.first, policy, parent), false);
        object o2 = object(make_caster<T2>::cast(src.second, policy, parent), false);
666
        if (!o1 || !o2)
Wenzel Jakob's avatar
Wenzel Jakob committed
667
668
669
670
671
            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
672
673
    }

674
675
    static PYBIND11_DESCR name() {
        return type_descr(
676
677
            _("Tuple[") + make_caster<T1>::name() + _(", ") + make_caster<T2>::name() + _("]")
        );
Wenzel Jakob's avatar
Wenzel Jakob committed
678
679
    }

680
681
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
682
    operator type() {
683
684
        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
685
686
    }
protected:
687
688
    make_caster<T1> first;
    make_caster<T2> second;
Wenzel Jakob's avatar
Wenzel Jakob committed
689
690
};

691
template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
692
    typedef std::tuple<Tuple...> type;
693
    typedef std::tuple<intrinsic_t<Tuple>...> itype;
694
695
    typedef std::tuple<args> args_type;
    typedef std::tuple<args, kwargs> args_kwargs_type;
Wenzel Jakob's avatar
Wenzel Jakob committed
696
697
698
public:
    enum { size = sizeof...(Tuple) };

699
700
701
    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
702
    bool load(handle src, bool convert) {
703
704
        if (!src || !PyTuple_Check(src.ptr()) || PyTuple_GET_SIZE(src.ptr()) != size)
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
705
        return load(src, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
706
707
    }

708
    template <typename T = itype, enable_if_t<
709
        !std::is_same<T, args_type>::value &&
710
        !std::is_same<T, args_kwargs_type>::value, int> = 0>
711
712
713
714
    bool load_args(handle args, handle, bool convert) {
        return load(args, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
    }

715
    template <typename T = itype, enable_if_t<std::is_same<T, args_type>::value, int> = 0>
716
717
718
719
720
    bool load_args(handle args, handle, bool convert) {
        std::get<0>(value).load(args, convert);
        return true;
    }

721
    template <typename T = itype, enable_if_t<std::is_same<T, args_kwargs_type>::value, int> = 0>
722
723
724
725
726
    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;
    }
727

Wenzel Jakob's avatar
Wenzel Jakob committed
728
    static handle cast(const type &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
729
        return cast(src, policy, parent, typename make_index_sequence<size>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
730
731
    }

732
    static PYBIND11_DESCR element_names() {
733
        return detail::concat(make_caster<Tuple>::name()...);
734
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
735

736
    static PYBIND11_DESCR name() {
737
        return type_descr(_("Tuple[") + element_names() + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
738
739
    }

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

744
    template <typename ReturnValue, typename Func> enable_if_t<std::is_void<ReturnValue>::value, void_type> call(Func &&f) {
745
        call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
746
        return void_type();
Wenzel Jakob's avatar
Wenzel Jakob committed
747
748
    }

749
750
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
751
    operator type() {
Wenzel Jakob's avatar
Wenzel Jakob committed
752
        return cast(typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
753
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
754

Wenzel Jakob's avatar
Wenzel Jakob committed
755
protected:
756
    template <typename ReturnValue, typename Func, size_t ... Index> ReturnValue call(Func &&f, index_sequence<Index...>) {
757
        return f(std::get<Index>(value)
758
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
759
760
761
    }

    template <size_t ... Index> type cast(index_sequence<Index...>) {
762
        return type(std::get<Index>(value)
763
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
764
765
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
766
767
    template <size_t ... Indices> bool load(handle src, bool convert, index_sequence<Indices...>) {
        std::array<bool, size> success {{
768
            std::get<Indices>(value).load(PyTuple_GET_ITEM(src.ptr(), Indices), convert)...
Wenzel Jakob's avatar
Wenzel Jakob committed
769
        }};
770
        (void) convert; /* avoid a warning when the tuple is empty */
Wenzel Jakob's avatar
Wenzel Jakob committed
771
        for (bool r : success)
Wenzel Jakob's avatar
Wenzel Jakob committed
772
773
774
775
776
777
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
Wenzel Jakob's avatar
Wenzel Jakob committed
778
779
    template <size_t ... Indices> static handle cast(const type &src, return_value_policy policy, handle parent, index_sequence<Indices...>) {
        std::array<object, size> entries {{
780
            object(make_caster<Tuple>::cast(std::get<Indices>(src), policy, parent), false)...
Wenzel Jakob's avatar
Wenzel Jakob committed
781
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
782
783
784
785
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
786
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
787
788
789
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
790
791
792
    }

protected:
793
    std::tuple<make_caster<Tuple>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
794
795
796
};

/// Type caster for holder types like std::shared_ptr, etc.
Wenzel Jakob's avatar
Wenzel Jakob committed
797
template <typename type, typename holder_type> class type_caster_holder : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
798
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
799
800
801
802
803
804
    using base = type_caster_base<type>;
    using base::base;
    using base::cast;
    using base::typeinfo;
    using base::value;
    using base::temp;
805

Wenzel Jakob's avatar
Wenzel Jakob committed
806
807
808
809
810
811
    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
812
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
813
        if (src.is_none()) {
814
815
            value = nullptr;
            return true;
Wenzel Jakob's avatar
Wenzel Jakob committed
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
        }

        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;
849
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
850

851
852
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
853
854
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
855
856
857
                    return true;
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874

        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;
            }
        }
875
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
876
    }
877

Wenzel Jakob's avatar
Wenzel Jakob committed
878
879
880
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type*() { return &holder; }
881

882
883
884
885
886
887
888
889
    // 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

890
    static handle cast(const holder_type &src, return_value_policy, handle) {
891
        return type_caster_generic::cast(
892
            src.get(), return_value_policy::take_ownership, handle(),
893
            src.get() ? &typeid(*src.get()) : nullptr, &typeid(type),
894
            nullptr, nullptr, &src);
895
896
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
897
898
899
900
protected:
    holder_type holder;
};

901
// PYBIND11_DECLARE_HOLDER_TYPE holder types:
902
template <typename base, typename holder> struct is_holder_type :
903
904
905
906
    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 {};
907

908
909
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); } };
910
911
template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
912

913
template <typename type>
914
struct type_caster<type, enable_if_t<is_pyobject<type>::value>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
915
public:
916
    template <typename T = type, enable_if_t<!std::is_base_of<object, T>::value, int> = 0>
917
    bool load(handle src, bool /* convert */) { value = type(src); return value.check(); }
918

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

Wenzel Jakob's avatar
Wenzel Jakob committed
922
923
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
924
    }
925
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
Wenzel Jakob's avatar
Wenzel Jakob committed
926
927
};

928
929
930
931
932
933
934
935
936
937
// 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 {};
938
template <typename T> struct move_is_plain_type<T, enable_if_t<
939
        !std::is_void<T>::value && !std::is_pointer<T>::value && !std::is_reference<T>::value && !std::is_const<T>::value
940
    >> : std::true_type { };
941
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
942
template <typename T> struct move_always<T, enable_if_t<
943
944
945
        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
946
    >> : std::true_type { };
947
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
948
template <typename T> struct move_if_unreferenced<T, enable_if_t<
949
950
951
        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
952
    >> : std::true_type { };
953
954
template <typename T> using move_never = std::integral_constant<bool, !move_always<T>::value && !move_if_unreferenced<T>::value>;

955
956
957
958
959
960
961
962
963
// 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
>;

964
// Basic python -> C++ casting; throws if casting fails
Jason Rhinelander's avatar
Jason Rhinelander committed
965
template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
966
967
968
969
970
971
972
973
    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
    }
974
975
    return conv;
}
976
977
978
979
980
981
// 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;
}
982
983
984
985
986
987
988
989

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
990
991
}

992
993
994
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
995
996
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
997
998
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
999
    return object(detail::make_caster<T>::cast(value, policy, parent), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
1000
1001
}

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

1005
template <typename T>
1006
detail::enable_if_t<detail::move_always<T>::value || detail::move_if_unreferenced<T>::value, T> move(object &&obj) {
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
    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`
1017
    T ret = std::move(detail::load_type<T>(obj).operator T&());
1018
1019
1020
1021
1022
1023
1024
1025
    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.
1026
template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1027
1028
    return move<T>(std::move(object));
}
1029
template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1030
1031
1032
1033
1034
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
1035
template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1036
1037
1038
1039
1040
1041
1042
1043
    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; }

1044
1045
NAMESPACE_BEGIN(detail)

1046
1047
1048
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>;
1049
1050
1051

// 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.
1052
1053
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>();
1054
}
1055
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
    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)
1068

1069
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
1070
          typename... Args> tuple make_tuple(Args&&... args_) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1071
    const size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
1072
    std::array<object, size> args {
1073
        { object(detail::make_caster<Args>::cast(
1074
            std::forward<Args>(args_), policy, nullptr), false)... }
Wenzel Jakob's avatar
Wenzel Jakob committed
1075
    };
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
    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
        }
    }
1086
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
1087
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1088
    for (auto &arg_value : args)
1089
1090
1091
1092
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
/// 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
1123
/// Alias for backward compatibility -- to be removed in version 2.0
1124
1125
1126
1127
1128
1129
1130
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); }
}

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
1161
1162
1163
1164
1165
1166
1167
1168
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
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
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>
    simple_collector(Ts &&...values)
        : 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>
    unpacking_collector(Ts &&...values) {
        // 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) {
        for (const auto &a : ap) {
1222
            args_list.append(a);
1223
1224
1225
        }
    }

1226
    void process(list &/*args_list*/, arg_v a) {
1227
        if (m_kwargs.contains(a.name)) {
1228
1229
1230
1231
1232
1233
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
1234
        if (!a.value) {
1235
1236
1237
#if defined(NDEBUG)
            argument_cast_error();
#else
1238
            argument_cast_error(a.name, a.type);
1239
1240
#endif
        }
1241
        m_kwargs[a.name] = a.value;
1242
1243
1244
1245
    }

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
        for (const auto &k : dict(kp, true)) {
1246
            if (m_kwargs.contains(k.first)) {
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
#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) {
    return {std::forward<Args>(args)...};
}

/// 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"
    );
Wenzel Jakob's avatar
Wenzel Jakob committed
1299
    return { std::forward<Args>(args)... };
1300
1301
}

1302
template <typename Derived>
1303
template <return_value_policy policy, typename... Args>
1304
1305
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
1306
1307
}

1308
1309
1310
template <typename Derived>
template <return_value_policy policy, typename... Args>
object object_api<Derived>::call(Args &&...args) const {
1311
    return operator()<policy>(std::forward<Args>(args)...);
1312
1313
}

1314
1315
NAMESPACE_END(detail)

Wenzel Jakob's avatar
Wenzel Jakob committed
1316
1317
1318
1319
1320
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

1321
NAMESPACE_END(pybind11)