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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
90
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
91
92
    auto &types = get_internals().registered_types_cpp;

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

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
115
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
116

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

    return errorString;
}

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

139
140
141
142
143
144
145
146
147
148
149
150
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
}

151
152
153
// Forward declaration
inline void keep_alive_impl(handle nurse, handle patient);

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

Wenzel Jakob's avatar
Wenzel Jakob committed
159
    PYBIND11_NOINLINE bool load(handle src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
160
161
162
163
        return load(src, convert, Py_TYPE(src.ptr()));
    }

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

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

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

227
        auto &internals = get_internals();
Wenzel Jakob's avatar
Wenzel Jakob committed
228

229
        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
230
231
232
233
234
        if (it == internals.registered_types_cpp.end()) {
            type_info = type_info_backup;
            it = internals.registered_types_cpp.find(std::type_index(*type_info));
        }

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

243
        auto tinfo = (const detail::type_info *) it->second;
244
245

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

Wenzel Jakob's avatar
Wenzel Jakob committed
252
253
254
255
256
257
258
        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
259
260
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::take_ownership;
261
262
        else if (policy == return_value_policy::automatic_reference)
            policy = return_value_policy::reference;
Wenzel Jakob's avatar
Wenzel Jakob committed
263

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

        tinfo->init_holder(inst.ptr(), existing_holder);
284
285

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

        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
288
289
290
291
    }

protected:
    const type_info *typeinfo = nullptr;
292
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
293
294
295
    object temp;
};

296
297
/* Determine suitable casting operator */
template <typename T>
298
using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
299
300
    typename std::add_pointer<intrinsic_t<T>>::type,
    typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
301

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

Wenzel Jakob's avatar
Wenzel Jakob committed
308
309
    type_caster_base() : type_caster_base(typeid(type)) { }
    type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
310

311
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
312
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
313
            policy = return_value_policy::copy;
314
        return cast(&src, policy, parent);
315
316
    }

317
    static handle cast(itype &&src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
318
319
320
321
322
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
            policy = return_value_policy::move;
        return cast(&src, policy, parent);
    }

323
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
324
325
        return type_caster_generic::cast(
            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
326
            make_copy_constructor(src), make_move_constructor(src));
327
328
    }

329
330
    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;

331
332
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
333

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

Wenzel Jakob's avatar
Wenzel Jakob committed
357
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
358
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
359
360

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

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

381
382
383
384
385
386
387
#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
388
389
template <typename T>
struct type_caster<
390
391
    T, enable_if_t<std::is_integral<T>::value ||
                   std::is_floating_point<T>::value>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
392
393
394
395
    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
396

Wenzel Jakob's avatar
Wenzel Jakob committed
397
    bool load(handle src, bool) {
Wenzel Jakob's avatar
Wenzel Jakob committed
398
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
399

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

        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
427

Wenzel Jakob's avatar
Wenzel Jakob committed
428
429
430
431
        value = (T) py_value;
        return true;
    }

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

448
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
449
};
Wenzel Jakob's avatar
Wenzel Jakob committed
450

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

460
461
462
463
464
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

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

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

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

        /* Fail */
        return false;
487
488
    }

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

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

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

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

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

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

    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
545
546
protected:
    bool success = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
547
548
};

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

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

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

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

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

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

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

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

622
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
Wenzel Jakob's avatar
Wenzel Jakob committed
623
624
};

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
637
638
639
640
    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
641

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

Wenzel Jakob's avatar
Wenzel Jakob committed
645
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
hulucc's avatar
hulucc committed
646
647
};

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

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

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

677
678
    template <typename T> using cast_op_type = type;

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

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

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

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

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

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

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

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

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

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

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

746
747
    template <typename T> using cast_op_type = type;

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

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

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

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

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

protected:
790
    std::tuple<make_caster<Tuple>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
791
792
793
};

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

Wenzel Jakob's avatar
Wenzel Jakob committed
803
804
805
806
807
808
    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
809
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
810
        if (src.is_none()) {
811
812
            value = nullptr;
            return true;
Wenzel Jakob's avatar
Wenzel Jakob committed
813
814
815
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
        }

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

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

        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;
            }
        }
872
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
873
    }
874

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

879
880
881
882
883
884
885
886
    // 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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
894
895
896
897
protected:
    holder_type holder;
};

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

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

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

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

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

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

952
953
954
955
956
957
958
959
960
// 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
>;

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

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
987
988
}

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

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

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

1041
1042
NAMESPACE_BEGIN(detail)

1043
1044
1045
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>;
1046
1047
1048

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

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

1090
1091
1092
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
/// 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
1120
/// Alias for backward compatibility -- to be removed in version 2.0
1121
1122
1123
1124
1125
1126
1127
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); }
}

1128
1129
1130
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
1222
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) {
            args_list.append(a.cast<object>());
        }
    }

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

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
        for (const auto &k : dict(kp, true)) {
            if (m_kwargs[k.first]) {
#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
1296
    return { std::forward<Args>(args)... };
1297
1298
1299
1300
1301
1302
1303
}

NAMESPACE_END(detail)

template <return_value_policy policy, typename... Args>
object handle::operator()(Args &&...args) const {
    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(m_ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
1304
1305
}

1306
1307
1308
template <return_value_policy policy,
          typename... Args> object handle::call(Args &&... args) const {
    return operator()<policy>(std::forward<Args>(args)...);
1309
1310
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1311
1312
1313
1314
1315
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

1316
NAMESPACE_END(pybind11)