cast.h 22.4 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
5
6
7
8
9
10
    C++ and Python types

    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>

    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"
Wenzel Jakob's avatar
Wenzel Jakob committed
15
#include <array>
Wenzel Jakob's avatar
Wenzel Jakob committed
16
#include <limits>
Wenzel Jakob's avatar
Wenzel Jakob committed
17

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

21
#if PY_MAJOR_VERSION >= 3
22
#define PYBIND11_AS_STRING PyBytes_AsString
23
#else
24
#define PYBIND11_AS_STRING PyString_AsString
25
26
#endif

27
/** Linked list descriptor type for function signatures (produces smaller binaries
28
    compared to a previous solution using std::string and operator +=) */
29
30
31
32
33
34
35
36
37
38
39
40
class descr {
public:
    struct entry {
        const std::type_info *type = nullptr;
        const char *str = nullptr;
        entry *next = nullptr;
        entry(const std::type_info *type) : type(type) { }
        entry(const char *str) : str(str) { }
    };

    descr() { }
    descr(descr &&d) : first(d.first), last(d.last) { d.first = d.last = nullptr; }
41
42
    PYBIND11_NOINLINE descr(const char *str) { first = last = new entry { str }; }
    PYBIND11_NOINLINE descr(const std::type_info &type) { first = last = new entry { &type }; }
43

44
    PYBIND11_NOINLINE void operator+(const char *str) {
45
46
47
48
49
        entry *next = new entry { str };
        last->next = next;
        last = next;
    }

50
    PYBIND11_NOINLINE void operator+(const std::type_info *type) {
51
52
53
54
55
        entry *next = new entry { type };
        last->next = next;
        last = next;
    }

56
    PYBIND11_NOINLINE void operator+=(descr &&other) {
57
58
59
60
61
62
        last->next = other.first;
        while (last->next)
            last = last->next;
        other.first = other.last = nullptr;
    }

63
    PYBIND11_NOINLINE friend descr operator+(descr &&l, descr &&r) {
64
65
66
67
68
        descr result(std::move(l));
        result += std::move(r);
        return result;
    }

69
    PYBIND11_NOINLINE std::string str() const {
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
        std::string result;
        auto const& registered_types = get_internals().registered_types;
        for (entry *it = first; it != nullptr; it = it->next) {
            if (it->type) {
                auto it2 = registered_types.find(it->type);
                if (it2 != registered_types.end()) {
                    result += it2->second.type->tp_name;
                } else {
                    std::string tname(it->type->name());
                    detail::clean_type_id(tname);
                    result += tname;
                }
            } else {
                result += it->str;
            }
        }
        return result;
    }

89
    PYBIND11_NOINLINE ~descr() {
90
91
92
93
94
95
96
97
98
99
100
        while (first) {
            entry *tmp = first->next;
            delete first;
            first = tmp;
        }
    }

    entry *first = nullptr;
    entry *last = nullptr;
};

101
class type_caster_custom {
Wenzel Jakob's avatar
Wenzel Jakob committed
102
public:
103
    PYBIND11_NOINLINE type_caster_custom(const std::type_info *type_info) {
104
        auto & registered_types = get_internals().registered_types;
105
        auto it = registered_types.find(type_info);
106
        if (it != registered_types.end()) {
Wenzel Jakob's avatar
Wenzel Jakob committed
107
            typeinfo = &it->second;
108
109
110
111
112
113
114
115
116
117
118
        } else {
            /* Unknown type?! Since std::type_info* often varies across
               module boundaries, the following does an explicit check */
            for (auto const &type : registered_types) {
                if (strcmp(type.first->name(), type_info->name()) == 0) {
                    registered_types[type_info] = type.second;
                    typeinfo = &type.second;
                    break;
                }
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
119
120
    }

121
    PYBIND11_NOINLINE bool load(PyObject *src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
122
123
124
        if (src == nullptr || typeinfo == nullptr)
            return false;
        if (PyType_IsSubtype(Py_TYPE(src), typeinfo->type)) {
125
            value = ((instance<void> *) src)->value;
Wenzel Jakob's avatar
Wenzel Jakob committed
126
127
128
129
130
131
132
133
134
135
136
137
            return true;
        }
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
                temp = object(converter(src, typeinfo->type), false);
                if (load(temp.ptr(), false))
                    return true;
            }
        }
        return false;
    }

138
139
140
    PYBIND11_NOINLINE static PyObject *cast(const void *_src, return_value_policy policy, PyObject *parent,
                                            const std::type_info *type_info, void *(*copy_constructor)(const void *)) {
        void *src = const_cast<void *>(_src);
Wenzel Jakob's avatar
Wenzel Jakob committed
141
142
143
144
145
        if (src == nullptr) {
            Py_INCREF(Py_None);
            return Py_None;
        }
        // avoid an issue with internal references matching their parent's address
Wenzel Jakob's avatar
Wenzel Jakob committed
146
147
        bool dont_cache = policy == return_value_policy::reference_internal &&
                          parent && ((instance<void> *) parent)->value == (void *) src;
Wenzel Jakob's avatar
Wenzel Jakob committed
148
149
150
151
152
153
154
        auto& internals = get_internals();
        auto it_instance = internals.registered_instances.find(src);
        if (it_instance != internals.registered_instances.end() && !dont_cache) {
            PyObject *inst = it_instance->second;
            Py_INCREF(inst);
            return inst;
        }
155
        auto it = internals.registered_types.find(type_info);
Wenzel Jakob's avatar
Wenzel Jakob committed
156
        if (it == internals.registered_types.end()) {
157
158
159
            std::string tname = type_info->name();
            detail::clean_type_id(tname);
            std::string msg = "Unregistered type : " + tname;
Wenzel Jakob's avatar
Wenzel Jakob committed
160
161
162
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        }
163
164
        auto &reg_type = it->second;
        instance<void> *inst = (instance<void> *) PyType_GenericAlloc(reg_type.type, 0);
Wenzel Jakob's avatar
Wenzel Jakob committed
165
166
167
168
169
170
        inst->value = src;
        inst->owned = true;
        inst->parent = nullptr;
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::take_ownership;
        if (policy == return_value_policy::copy) {
171
172
173
            inst->value = copy_constructor(inst->value);
            if (inst->value == nullptr)
                throw cast_error("return_value_policy = copy, but the object is non-copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
174
175
176
177
178
179
180
        } else if (policy == return_value_policy::reference) {
            inst->owned = false;
        } else if (policy == return_value_policy::reference_internal) {
            inst->owned = false;
            inst->parent = parent;
            Py_XINCREF(parent);
        }
181
182
183
184
185
        PyObject *inst_pyobj = (PyObject *) inst;
        reg_type.init_holder(inst_pyobj);
        if (!dont_cache)
            internals.registered_instances[inst->value] = inst_pyobj;
        return inst_pyobj;
Wenzel Jakob's avatar
Wenzel Jakob committed
186
187
188
189
    }

protected:
    const type_info *typeinfo = nullptr;
190
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
191
192
193
    object temp;
};

194
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
195
template <typename type, typename Enable = void> class type_caster : public type_caster_custom {
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
public:
    static descr name() { return typeid(type); }

    type_caster() : type_caster_custom(&typeid(type)) { }

    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::copy;
        return type_caster_custom::cast(&src, policy, parent, &typeid(type), &copy_constructor);
    }

    static PyObject *cast(const type *src, return_value_policy policy, PyObject *parent) {
        return type_caster_custom::cast(src, policy, parent, &typeid(type), &copy_constructor);
    }

    operator type*() { return (type *) value; }
Wenzel Jakob's avatar
Wenzel Jakob committed
212
    operator type&() { return *((type *) value); }
213
214
215
protected:
    template <typename T = type, typename std::enable_if<std::is_copy_constructible<T>::value, int>::type = 0>
    static void *copy_constructor(const void *arg) {
Wenzel Jakob's avatar
Wenzel Jakob committed
216
        return new type(*((const type *)arg));
217
218
219
220
221
    }
    template <typename T = type, typename std::enable_if<!std::is_copy_constructible<T>::value, int>::type = 0>
    static void *copy_constructor(const void *) { return nullptr; }
};

222
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
223
224
225
    protected: \
        type value; \
    public: \
Wenzel Jakob's avatar
Wenzel Jakob committed
226
        static descr name() { return py_name; } \
Wenzel Jakob's avatar
Wenzel Jakob committed
227
228
229
230
        static PyObject *cast(const type *src, return_value_policy policy, PyObject *parent) { \
            return cast(*src, policy, parent); \
        } \
        operator type*() { return &value; } \
Wenzel Jakob's avatar
Wenzel Jakob committed
231
        operator type&() { return value; }
Wenzel Jakob's avatar
Wenzel Jakob committed
232

233
234
235
236
237
238
239
#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
240
241
242
243
244
245
246
247
template <typename T>
struct type_caster<
    T, typename std::enable_if<std::is_integral<T>::value ||
                               std::is_floating_point<T>::value>::type> {
    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
248

Wenzel Jakob's avatar
Wenzel Jakob committed
249
250
    bool load(PyObject *src, bool) {
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
251

Wenzel Jakob's avatar
Wenzel Jakob committed
252
253
254
255
256
257
258
259
260
        if (std::is_floating_point<T>::value) {
            py_value = (py_type) PyFloat_AsDouble(src);
        } else if (sizeof(T) <= sizeof(long)) {
            if (std::is_signed<T>::value)
                py_value = (py_type) PyLong_AsLong(src);
            else
                py_value = (py_type) PyLong_AsUnsignedLong(src);
        } else {
            if (std::is_signed<T>::value)
261
                py_value = (py_type) detail::PyLong_AsLongLong_(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
262
            else
263
                py_value = (py_type) detail::PyLong_AsUnsignedLongLong_(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
264
265
266
267
268
269
270
271
272
        }

        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
273

Wenzel Jakob's avatar
Wenzel Jakob committed
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
        value = (T) py_value;
        return true;
    }

    static PyObject *cast(T src, return_value_policy /* policy */, PyObject * /* parent */) {
        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);
        }
    }

    static PyObject *cast(const T *src, return_value_policy policy, PyObject *parent) {
        return cast(*src, policy, parent);
    }

    static descr name() {
        return std::is_floating_point<T>::value ? "float" : "int";
    }

    operator T*() { return &value; }
    operator T&() { return value; }

protected:
    T value;
};
Wenzel Jakob's avatar
Wenzel Jakob committed
308

309
template <> class type_caster<void_type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
310
public:
311
    bool load(PyObject *, bool) { return false; }
312
    static PyObject *cast(void_type, return_value_policy /* policy */, PyObject * /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
313
314
315
        Py_INCREF(Py_None);
        return Py_None;
    }
316
    PYBIND11_TYPE_CASTER(void_type, "None");
Wenzel Jakob's avatar
Wenzel Jakob committed
317
318
};

Wenzel Jakob's avatar
Wenzel Jakob committed
319
320
template <> class type_caster<void> : public type_caster<void_type> { };
template <> class type_caster<std::nullptr_t> : public type_caster<void_type> { };
321

Wenzel Jakob's avatar
Wenzel Jakob committed
322
323
324
325
326
327
328
329
330
331
332
333
template <> class type_caster<bool> {
public:
    bool load(PyObject *src, bool) {
        if (src == Py_True) { value = true; return true; }
        else if (src == Py_False) { value = false; return true; }
        else return false;
    }
    static PyObject *cast(bool src, return_value_policy /* policy */, PyObject * /* parent */) {
        PyObject *result = src ? Py_True : Py_False;
        Py_INCREF(result);
        return result;
    }
334
    PYBIND11_TYPE_CASTER(bool, "bool");
Wenzel Jakob's avatar
Wenzel Jakob committed
335
336
337
338
339
};

template <> class type_caster<std::string> {
public:
    bool load(PyObject *src, bool) {
340
341
#if PY_MAJOR_VERSION < 3
        if (PyString_Check(src)) { value = PyString_AsString(src); return true; }
342
#endif
343
344
345
        object temp(PyUnicode_AsUTF8String(src), false);
        const char *ptr = nullptr;
        if (temp)
346
            ptr = PYBIND11_AS_STRING(temp.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
347
        if (!ptr) { PyErr_Clear(); return false; }
348
        value = ptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
349
350
351
352
353
        return true;
    }
    static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) {
        return PyUnicode_FromString(src.c_str());
    }
354
    PYBIND11_TYPE_CASTER(std::string, "str");
Wenzel Jakob's avatar
Wenzel Jakob committed
355
356
357
358
359
};

template <> class type_caster<char> {
public:
    bool load(PyObject *src, bool) {
360
361
#if PY_MAJOR_VERSION < 3
        if (PyString_Check(src)) { value = PyString_AsString(src); return true; }
362
#endif
363
364
365
        object temp(PyUnicode_AsUTF8String(src), false);
        const char *ptr = nullptr;
        if (temp)
366
            ptr = PYBIND11_AS_STRING(temp.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
367
368
369
370
371
372
373
374
375
376
377
378
379
380
        if (!ptr) { PyErr_Clear(); return false; }
        value = ptr;
        return true;
    }

    static PyObject *cast(const char *src, return_value_policy /* policy */, PyObject * /* parent */) {
        return PyUnicode_FromString(src);
    }

    static PyObject *cast(char src, return_value_policy /* policy */, PyObject * /* parent */) {
        char str[2] = { src, '\0' };
        return PyUnicode_DecodeLatin1(str, 1, nullptr);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
381
    static descr name() { return "str"; }
Wenzel Jakob's avatar
Wenzel Jakob committed
382

383
384
    operator char*() { return (char *) value.c_str(); }
    operator char() { if (value.length() > 0) return value[0]; else return '\0'; }
Wenzel Jakob's avatar
Wenzel Jakob committed
385
protected:
386
    std::string value;
Wenzel Jakob's avatar
Wenzel Jakob committed
387
388
389
390
391
392
393
394
395
396
397
398
399
400
};

template <typename T1, typename T2> class type_caster<std::pair<T1, T2>> {
    typedef std::pair<T1, T2> type;
public:
    bool load(PyObject *src, bool convert) {
        if (!PyTuple_Check(src) || PyTuple_Size(src) != 2)
            return false;
        if (!first.load(PyTuple_GetItem(src, 0), convert))
            return false;
        return second.load(PyTuple_GetItem(src, 1), convert);
    }

    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
401
402
        PyObject *o1 = type_caster<typename decay<T1>::type>::cast(src.first, policy, parent);
        PyObject *o2 = type_caster<typename decay<T2>::type>::cast(src.second, policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
403
404
405
406
407
408
409
410
411
412
413
        if (!o1 || !o2) {
            Py_XDECREF(o1);
            Py_XDECREF(o2);
            return nullptr;
        }
        PyObject *tuple = PyTuple_New(2);
        PyTuple_SetItem(tuple, 0, o1);
        PyTuple_SetItem(tuple, 1, o2);
        return tuple;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
414
    static descr name() {
415
        class descr result("(");
Wenzel Jakob's avatar
Wenzel Jakob committed
416
        result += std::move(type_caster<typename decay<T1>::type>::name());
417
        result += ", ";
Wenzel Jakob's avatar
Wenzel Jakob committed
418
        result += std::move(type_caster<typename decay<T2>::type>::name());
419
420
        result += ")";
        return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
421
422
423
424
425
426
    }

    operator type() {
        return type(first, second);
    }
protected:
427
428
    type_caster<typename decay<T1>::type> first;
    type_caster<typename decay<T2>::type> second;
Wenzel Jakob's avatar
Wenzel Jakob committed
429
430
};

431
template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
432
433
434
435
436
    typedef std::tuple<Tuple...> type;
public:
    enum { size = sizeof...(Tuple) };

    bool load(PyObject *src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
437
        return load(src, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
438
439
440
    }

    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
441
        return cast(src, policy, parent, typename make_index_sequence<size>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
442
443
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
444
445
446
    static descr name(const char **keywords = nullptr, const char **values = nullptr) {
        std::array<class descr, size> names {{
            type_caster<typename decay<Tuple>::type>::name()...
Wenzel Jakob's avatar
Wenzel Jakob committed
447
        }};
448
449
450
451
        class descr result("(");
        for (int i=0; i<size; ++i) {
            if (keywords && keywords[i]) {
                result += keywords[i];
452
453
                result += " : ";
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
454
            result += std::move(names[i]);
455
            if (values && values[i]) {
456
                result += " = ";
457
                result += values[i];
458
            }
459
            if (i+1 < size)
Wenzel Jakob's avatar
Wenzel Jakob committed
460
461
462
463
464
465
                result += ", ";
        }
        result += ")";
        return result;
    }

466
467
    template <typename ReturnValue, typename Func> typename std::enable_if<!std::is_void<ReturnValue>::value, ReturnValue>::type call(Func &&f) {
        return call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
468
469
    }

470
    template <typename ReturnValue, typename Func> typename std::enable_if<std::is_void<ReturnValue>::value, void_type>::type call(Func &&f) {
471
        call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
472
        return void_type();
Wenzel Jakob's avatar
Wenzel Jakob committed
473
474
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
475
    operator type() {
Wenzel Jakob's avatar
Wenzel Jakob committed
476
        return cast(typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
477
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
478

Wenzel Jakob's avatar
Wenzel Jakob committed
479
protected:
480
    template <typename ReturnValue, typename Func, size_t ... Index> ReturnValue call(Func &&f, index_sequence<Index...>) {
Wenzel Jakob's avatar
Wenzel Jakob committed
481
482
483
484
        return f((Tuple) std::get<Index>(value)...);
    }

    template <size_t ... Index> type cast(index_sequence<Index...>) {
Wenzel Jakob's avatar
Wenzel Jakob committed
485
486
487
        return type((Tuple) std::get<Index>(value)...);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
488
    template <size_t ... Indices> bool load(PyObject *src, bool convert, index_sequence<Indices...>) {
Wenzel Jakob's avatar
Wenzel Jakob committed
489
490
491
492
493
        if (!PyTuple_Check(src))
            return false;
        if (PyTuple_Size(src) != size)
            return false;
        std::array<bool, size> results {{
494
            (PyTuple_GET_ITEM(src, Indices) != nullptr ? std::get<Indices>(value).load(PyTuple_GET_ITEM(src, Indices), convert) : false)...
Wenzel Jakob's avatar
Wenzel Jakob committed
495
        }};
496
        (void) convert; /* avoid a warning when the tuple is empty */
Wenzel Jakob's avatar
Wenzel Jakob committed
497
498
499
500
501
502
503
        for (bool r : results)
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
Wenzel Jakob's avatar
Wenzel Jakob committed
504
    template <size_t ... Indices> static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent, index_sequence<Indices...>) {
Wenzel Jakob's avatar
Wenzel Jakob committed
505
        std::array<PyObject *, size> results {{
506
            type_caster<typename decay<Tuple>::type>::cast(std::get<Indices>(src), policy, parent)...
Wenzel Jakob's avatar
Wenzel Jakob committed
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
        }};
        bool success = true;
        for (auto result : results)
            if (result == nullptr)
                success = false;
        if (success) {
            PyObject *tuple = PyTuple_New(size);
            int counter = 0;
            for (auto result : results)
                PyTuple_SetItem(tuple, counter++, result);
            return tuple;
        } else {
            for (auto result : results) {
                Py_XDECREF(result);
            }
            return nullptr;
        }
    }

protected:
527
    std::tuple<type_caster<typename decay<Tuple>::type>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
528
529
530
531
532
533
};

/// Type caster for holder types like std::shared_ptr, etc.
template <typename type, typename holder_type> class type_caster_holder : public type_caster<type> {
public:
    typedef type_caster<type> parent;
534
535
536
537
538
539
540
541
542
543
544
545

    template <typename T = holder_type,
              typename std::enable_if<std::is_same<std::shared_ptr<type>, T>::value, int>::type = 0>
    bool load(PyObject *src, bool convert) {
        if (!parent::load(src, convert))
            return false;
        holder = holder_type(((type *) parent::value)->shared_from_this());
        return true;
    }

    template <typename T = holder_type,
              typename std::enable_if<!std::is_same<std::shared_ptr<type>, T>::value, int>::type = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
546
547
548
    bool load(PyObject *src, bool convert) {
        if (!parent::load(src, convert))
            return false;
549
        holder = holder_type((type *) parent::value);
Wenzel Jakob's avatar
Wenzel Jakob committed
550
551
        return true;
    }
552

Wenzel Jakob's avatar
Wenzel Jakob committed
553
554
555
556
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type&() { return holder; }
    explicit operator holder_type*() { return &holder; }
557
558
559
560
561
562

    using type_caster<type>::cast;
    static PyObject *cast(const holder_type &src, return_value_policy policy, PyObject *parent) {
        return type_caster<type>::cast(src.get(), policy, parent);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
563
564
565
566
protected:
    holder_type holder;
};

567
568
template <typename type>
struct type_caster<type, typename std::enable_if<std::is_base_of<handle, type>::value>::type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
569
public:
570
571
572
573
574
575
    template <typename T = type, typename std::enable_if<std::is_same<T, handle>::value, int>::type = 0>
    bool load(PyObject *src, bool /* convert */) { value = handle(src); return value.check(); }

    template <typename T = type, typename std::enable_if<!std::is_same<T, handle>::value, int>::type = 0>
    bool load(PyObject *src, bool /* convert */) { value = type(src, true); return value.check(); }

Wenzel Jakob's avatar
Wenzel Jakob committed
576
577
578
579
    static PyObject *cast(const handle &src, return_value_policy /* policy */, PyObject * /* parent */) {
        src.inc_ref();
        return (PyObject *) src.ptr();
    }
580
    PYBIND11_TYPE_CASTER(type, typeid(type));
Wenzel Jakob's avatar
Wenzel Jakob committed
581
582
583
584
585
};

NAMESPACE_END(detail)

template <typename T> inline T cast(PyObject *object) {
Wenzel Jakob's avatar
Wenzel Jakob committed
586
    detail::type_caster<typename detail::decay<T>::type> conv;
Wenzel Jakob's avatar
Wenzel Jakob committed
587
588
589
590
591
592
593
594
    if (!conv.load(object, true))
        throw cast_error("Unable to cast Python object to C++ type");
    return conv;
}

template <typename T> inline object cast(const T &value, return_value_policy policy = return_value_policy::automatic, PyObject *parent = nullptr) {
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
Wenzel Jakob's avatar
Wenzel Jakob committed
595
    return object(detail::type_caster<typename detail::decay<T>::type>::cast(value, policy, parent), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
596
597
}

598
599
template <typename T> inline T handle::cast() const { return pybind11::cast<T>(m_ptr); }
template <> inline void handle::cast() const { return; }
Wenzel Jakob's avatar
Wenzel Jakob committed
600

601
template <typename... Args> inline object handle::call(Args&&... args_) {
Wenzel Jakob's avatar
Wenzel Jakob committed
602
603
    const size_t size = sizeof...(Args);
    std::array<PyObject *, size> args{
Wenzel Jakob's avatar
Wenzel Jakob committed
604
        { detail::type_caster<typename detail::decay<Args>::type>::cast(
Wenzel Jakob's avatar
Wenzel Jakob committed
605
            std::forward<Args>(args_), return_value_policy::reference, nullptr)... }
Wenzel Jakob's avatar
Wenzel Jakob committed
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
    };
    bool fail = false;
    for (auto result : args)
        if (result == nullptr)
            fail = true;
    if (fail) {
        for (auto result : args) {
            Py_XDECREF(result);
        }
        throw cast_error("handle::call(): unable to convert input arguments to Python objects");
    }
    PyObject *tuple = PyTuple_New(size);
    int counter = 0;
    for (auto result : args)
        PyTuple_SetItem(tuple, counter++, result);
    PyObject *result = PyObject_CallObject(m_ptr, tuple);
    Py_DECREF(tuple);
623
624
    if (result == nullptr && PyErr_Occurred())
        throw error_already_set();
Wenzel Jakob's avatar
Wenzel Jakob committed
625
626
627
    return object(result, false);
}

628
NAMESPACE_END(pybind11)