cast.h 45.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>
18
#include <iostream>
Wenzel Jakob's avatar
Wenzel Jakob committed
19

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

Wenzel Jakob's avatar
Wenzel Jakob committed
23
24
25
26
27
28
29
30
31
/// 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 *);
    std::vector<PyObject *(*)(PyObject *, PyTypeObject *) > implicit_conversions;
    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
    void *get_buffer_data = nullptr;
};
32

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

79
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type, bool throw_if_missing = true) {
Wenzel Jakob's avatar
Wenzel Jakob committed
80
81
82
83
84
85
    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;
86
87
88
89
90
        if (!type) {
            if (throw_if_missing)
                pybind11_fail("pybind11::detail::get_type_info: unable to find type object!");
            return nullptr;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
91
92
93
94
95
96
    } while (true);
}

PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_info &tp) {
    auto &types = get_internals().registered_types_cpp;

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

PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp) {
    detail::type_info *type_info = get_type_info(tp);
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

PYBIND11_NOINLINE inline std::string error_string() {
109
110
   PyObject *type, *value, *traceback;
   PyErr_Fetch(&type, &value, &traceback);
Wenzel Jakob's avatar
Wenzel Jakob committed
111

112
113
114
   std::string errorString;
    if (type) {
        errorString += (std::string) handle(type).str();
Wenzel Jakob's avatar
Wenzel Jakob committed
115
116
        errorString += ": ";
    }
117
118
    if (value)
        errorString += (std::string) handle(value).str();
Wenzel Jakob's avatar
Wenzel Jakob committed
119

120
    PyErr_Restore(type, value, traceback);
Wenzel Jakob's avatar
Wenzel Jakob committed
121
122
123
    return errorString;
}

124
125
126
127
128
129
130
131
132
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) {
        auto instance_type = detail::get_type_info(Py_TYPE(it->second), false);
        if (instance_type && instance_type == type)
            return handle((PyObject *) it->second);
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
133
134
}

135
136
137
138
139
140
141
142
143
144
145
146
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
}

147
148
149
// Forward declaration
inline void keep_alive_impl(handle nurse, handle patient);

Wenzel Jakob's avatar
Wenzel Jakob committed
150
151
152
153
class type_caster_generic {
public:
    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
     : typeinfo(get_type_info(type_info)) { }
Wenzel Jakob's avatar
Wenzel Jakob committed
154

Wenzel Jakob's avatar
Wenzel Jakob committed
155
156
    PYBIND11_NOINLINE bool load(handle src, bool convert) {
        if (!src || !typeinfo)
Wenzel Jakob's avatar
Wenzel Jakob committed
157
            return false;
158
159
160
161
        if (src.ptr() == Py_None) {
            value = nullptr;
            return true;
        } else if (PyType_IsSubtype(Py_TYPE(src.ptr()), typeinfo->type)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
162
            value = ((instance<void> *) src.ptr())->value;
Wenzel Jakob's avatar
Wenzel Jakob committed
163
164
165
166
            return true;
        }
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
167
168
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
169
170
171
172
173
174
                    return true;
            }
        }
        return false;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
175
176
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
                                         const std::type_info *type_info,
177
                                         const std::type_info *type_info_backup,
Wenzel Jakob's avatar
Wenzel Jakob committed
178
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
179
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
180
                                         const void *existing_holder = nullptr) {
181
        void *src = const_cast<void *>(_src);
Wenzel Jakob's avatar
Wenzel Jakob committed
182
183
184
        if (src == nullptr)
            return handle(Py_None).inc_ref();

185
        auto &internals = get_internals();
Wenzel Jakob's avatar
Wenzel Jakob committed
186

187
        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
188
189
190
191
192
        if (it == internals.registered_types_cpp.end()) {
            type_info = type_info_backup;
            it = internals.registered_types_cpp.find(std::type_index(*type_info));
        }

193
        if (it == internals.registered_types_cpp.end()) {
194
195
196
            std::string tname = type_info->name();
            detail::clean_type_id(tname);
            std::string msg = "Unregistered type : " + tname;
Wenzel Jakob's avatar
Wenzel Jakob committed
197
            PyErr_SetString(PyExc_TypeError, msg.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
198
            return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
199
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
200

201
        auto tinfo = (const detail::type_info *) it->second;
202
203

        auto it_instances = internals.registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
204
205
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
            auto instance_type = detail::get_type_info(Py_TYPE(it_i->second), false);
206
            if (instance_type && instance_type == tinfo)
Jason Rhinelander's avatar
Jason Rhinelander committed
207
                return handle((PyObject *) it_i->second).inc_ref();
208
209
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
210
211
212
213
214
215
216
        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
217
218
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::take_ownership;
219
220
        else if (policy == return_value_policy::automatic_reference)
            policy = return_value_policy::reference;
Wenzel Jakob's avatar
Wenzel Jakob committed
221

Wenzel Jakob's avatar
Wenzel Jakob committed
222
        if (policy == return_value_policy::copy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
223
224
            wrapper->value = copy_constructor(wrapper->value);
            if (wrapper->value == nullptr)
225
                throw cast_error("return_value_policy = copy, but the object is non-copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
226
227
228
229
230
231
        } else if (policy == return_value_policy::move) {
            wrapper->value = move_constructor(wrapper->value);
            if (wrapper->value == nullptr)
                wrapper->value = copy_constructor(wrapper->value);
            if (wrapper->value == nullptr)
                throw cast_error("return_value_policy = move, but the object is neither movable nor copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
232
        } else if (policy == return_value_policy::reference) {
Wenzel Jakob's avatar
Wenzel Jakob committed
233
            wrapper->owned = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
234
        } else if (policy == return_value_policy::reference_internal) {
Wenzel Jakob's avatar
Wenzel Jakob committed
235
            wrapper->owned = false;
236
            detail::keep_alive_impl(inst, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
237
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
238
239

        tinfo->init_holder(inst.ptr(), existing_holder);
240
241

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

        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
244
245
246
247
    }

protected:
    const type_info *typeinfo = nullptr;
248
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
249
250
251
    object temp;
};

252
253
/* Determine suitable casting operator */
template <typename T>
254
using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
255
256
    typename std::add_pointer<intrinsic_t<T>>::type,
    typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
257

258
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
259
template <typename type> class type_caster_base : public type_caster_generic {
260
public:
261
    static PYBIND11_DESCR name() { return type_descr(_<type>()); }
262

Wenzel Jakob's avatar
Wenzel Jakob committed
263
    type_caster_base() : type_caster_generic(typeid(type)) { }
264

Wenzel Jakob's avatar
Wenzel Jakob committed
265
    static handle cast(const type &src, return_value_policy policy, handle parent) {
266
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
267
            policy = return_value_policy::copy;
268
        return cast(&src, policy, parent);
269
270
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
271
272
273
274
275
276
    static handle cast(type &&src, return_value_policy policy, handle parent) {
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
            policy = return_value_policy::move;
        return cast(&src, policy, parent);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
277
    static handle cast(const type *src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
278
279
        return type_caster_generic::cast(
            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
280
            make_copy_constructor(src), make_move_constructor(src));
281
282
    }

283
284
    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;

285
    operator type*() { return (type *) value; }
286
    operator type&() { if (!value) throw reference_cast_error(); return *((type *) value); }
287

288
protected:
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
    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. */
    template <typename T = type, typename = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
    static Constructor make_copy_constructor(const T *value) {
        return [](const void *arg) -> void * { return new T(*((const T *)arg)); }; }
    template <typename T = type, typename = typename std::enable_if<std::is_move_constructible<T>::value>::type>
    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; }
309
310
};

Wenzel Jakob's avatar
Wenzel Jakob committed
311
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
312
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
313
314

template <typename type> class type_caster<std::reference_wrapper<type>> : public type_caster_base<type> {
315
316
public:
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
317
        return type_caster_base<type>::cast(&src.get(), policy, parent);
318
    }
319
320
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
    operator std::reference_wrapper<type>() { return std::ref(*((type *) this->value)); }
321
322
};

323
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
324
325
326
    protected: \
        type value; \
    public: \
327
        static PYBIND11_DESCR name() { return type_descr(py_name); } \
Wenzel Jakob's avatar
Wenzel Jakob committed
328
        static handle cast(const type *src, return_value_policy policy, handle parent) { \
Wenzel Jakob's avatar
Wenzel Jakob committed
329
330
331
            return cast(*src, policy, parent); \
        } \
        operator type*() { return &value; } \
332
        operator type&() { return value; } \
333
        template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>
Wenzel Jakob's avatar
Wenzel Jakob committed
334

335
336
337
338
339
340
341
#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
342
343
344
345
346
347
348
349
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
350

Wenzel Jakob's avatar
Wenzel Jakob committed
351
    bool load(handle src, bool) {
Wenzel Jakob's avatar
Wenzel Jakob committed
352
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
353

354
355
356
        if (!src) {
            return false;
        } if (std::is_floating_point<T>::value) {
Wenzel Jakob's avatar
Wenzel Jakob committed
357
            py_value = (py_type) PyFloat_AsDouble(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
358
        } else if (sizeof(T) <= sizeof(long)) {
359
360
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
361
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
362
                py_value = (py_type) PyLong_AsLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
363
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
364
                py_value = (py_type) PyLong_AsUnsignedLong(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
365
        } else {
366
367
            if (PyFloat_Check(src.ptr()))
                return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
368
            if (std::is_signed<T>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
369
                py_value = (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
370
            else
Wenzel Jakob's avatar
Wenzel Jakob committed
371
                py_value = (py_type) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
372
373
374
375
376
377
378
379
380
        }

        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
381

Wenzel Jakob's avatar
Wenzel Jakob committed
382
383
384
385
        value = (T) py_value;
        return true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
386
    static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
        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);
        }
    }

402
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
403
};
Wenzel Jakob's avatar
Wenzel Jakob committed
404

405
template <> class type_caster<void_type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
406
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
407
408
409
    bool load(handle, bool) { return false; }
    static handle cast(void_type, return_value_policy /* policy */, handle /* parent */) {
        return handle(Py_None).inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
410
    }
411
    PYBIND11_TYPE_CASTER(void_type, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
412
413
};

414
415
416
417
418
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
419
420
421
        if (!h) {
            return false;
        } else if (h.ptr() == Py_None) {
422
423
424
            value = nullptr;
            return true;
        }
425
426

        /* Check if this is a capsule */
427
        capsule c(h, true);
428
429
430
431
432
433
434
435
436
437
438
439
440
        if (c.check()) {
            value = (void *) c;
            return true;
        }

        /* Check if this is a C++ type */
        if (get_type_info((PyTypeObject *) h.get_type().ptr(), false)) {
            value = ((instance<void> *) h.ptr())->value;
            return true;
        }

        /* Fail */
        return false;
441
442
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
443
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
444
445
446
447
        if (ptr)
            return capsule(ptr).release();
        else
            return handle(Py_None).inc_ref();
448
    }
449

450
451
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
452
    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
453
private:
454
    void *value = nullptr;
455
456
};

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

Wenzel Jakob's avatar
Wenzel Jakob committed
459
460
template <> class type_caster<bool> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
461
    bool load(handle src, bool) {
462
463
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
464
        else if (src.ptr() == Py_False) { value = false; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
465
466
        else return false;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
467
468
    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
469
    }
470
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
471
472
473
474
};

template <> class type_caster<std::string> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
475
    bool load(handle src, bool) {
476
        object temp;
Wenzel Jakob's avatar
Wenzel Jakob committed
477
        handle load_src = src;
478
479
480
        if (!src) {
            return false;
        } else if (PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
481
            temp = object(PyUnicode_AsUTF8String(load_src.ptr()), false);
482
            if (!temp) { PyErr_Clear(); return false; }  // UnicodeEncodeError
Wenzel Jakob's avatar
Wenzel Jakob committed
483
            load_src = temp;
484
485
486
        }
        char *buffer;
        ssize_t length;
Wenzel Jakob's avatar
Wenzel Jakob committed
487
        int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(load_src.ptr(), &buffer, &length);
488
        if (err == -1) { PyErr_Clear(); return false; }  // TypeError
489
        value = std::string(buffer, (size_t) length);
490
        success = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
491
492
        return true;
    }
493

Wenzel Jakob's avatar
Wenzel Jakob committed
494
    static handle cast(const std::string &src, return_value_policy /* policy */, handle /* parent */) {
495
        return PyUnicode_FromStringAndSize(src.c_str(), (ssize_t) src.length());
Wenzel Jakob's avatar
Wenzel Jakob committed
496
    }
497
498

    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
499
500
protected:
    bool success = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
501
502
};

503
template <typename type, typename deleter> class type_caster<std::unique_ptr<type, deleter>> {
504
public:
505
    static handle cast(std::unique_ptr<type, deleter> &&src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
506
        handle result = type_caster_base<type>::cast(src.get(), policy, parent);
507
508
509
510
        if (result)
            src.release();
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
511
    static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
512
513
};

hulucc's avatar
hulucc committed
514
template <> class type_caster<std::wstring> {
Wenzel Jakob's avatar
Wenzel Jakob committed
515
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
516
517
518
    bool load(handle src, bool) {
        object temp;
        handle load_src = src;
519
520
521
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
522
523
524
525
            temp = object(PyUnicode_FromObject(load_src.ptr()), false);
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
        }
526
527
528
529
530
531
532
533
534
535
536
537
        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
538
            length = length / (ssize_t) sizeof(wchar_t) - 1; ++buffer; // Skip BOM
539
        }
540
541
#endif
        if (!buffer) { PyErr_Clear(); return false; }
542
        value = std::wstring(buffer, (size_t) length);
Wenzel Jakob's avatar
Wenzel Jakob committed
543
544
545
        success = true;
        return true;
    }
hulucc's avatar
hulucc committed
546

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

Wenzel Jakob's avatar
Wenzel Jakob committed
551
    PYBIND11_TYPE_CASTER(std::wstring, _(PYBIND11_STRING_NAME));
552
553
protected:
    bool success = false;
hulucc's avatar
hulucc committed
554
555
};

556
template <> class type_caster<char> : public type_caster<std::string> {
Wenzel Jakob's avatar
Wenzel Jakob committed
557
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
558
    bool load(handle src, bool convert) {
559
        if (src.ptr() == Py_None) return true;
560
561
562
        return type_caster<std::string>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
563
    static handle cast(const char *src, return_value_policy /* policy */, handle /* parent */) {
564
        if (src == nullptr) return handle(Py_None).inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
565
566
567
        return PyUnicode_FromString(src);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
568
    static handle cast(char src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
569
570
571
572
        char str[2] = { src, '\0' };
        return PyUnicode_DecodeLatin1(str, 1, nullptr);
    }

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

576
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
Wenzel Jakob's avatar
Wenzel Jakob committed
577
578
};

579
template <> class type_caster<wchar_t> : public type_caster<std::wstring> {
hulucc's avatar
hulucc committed
580
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
581
    bool load(handle src, bool convert) {
582
        if (src.ptr() == Py_None) return true;
583
584
585
        return type_caster<std::wstring>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
586
    static handle cast(const wchar_t *src, return_value_policy /* policy */, handle /* parent */) {
587
        if (src == nullptr) return handle(Py_None).inc_ref();
588
        return PyUnicode_FromWideChar(src, (ssize_t) wcslen(src));
Wenzel Jakob's avatar
Wenzel Jakob committed
589
    }
hulucc's avatar
hulucc committed
590

Wenzel Jakob's avatar
Wenzel Jakob committed
591
592
593
594
    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
595

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

Wenzel Jakob's avatar
Wenzel Jakob committed
599
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
hulucc's avatar
hulucc committed
600
601
};

Wenzel Jakob's avatar
Wenzel Jakob committed
602
603
604
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
605
    bool load(handle src, bool convert) {
606
607
608
        if (!src)
            return false;
        else if (!PyTuple_Check(src.ptr()) || PyTuple_Size(src.ptr()) != 2)
Wenzel Jakob's avatar
Wenzel Jakob committed
609
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
610
611
        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
612
613
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
614
    static handle cast(const type &src, return_value_policy policy, handle parent) {
615
616
        object o1 = object(make_caster<T1>::cast(src.first, policy, parent), false);
        object o2 = object(make_caster<T2>::cast(src.second, policy, parent), false);
617
        if (!o1 || !o2)
Wenzel Jakob's avatar
Wenzel Jakob committed
618
619
620
621
622
            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
623
624
    }

625
626
    static PYBIND11_DESCR name() {
        return type_descr(
627
628
            _("Tuple[") + make_caster<T1>::name() + _(", ") + make_caster<T2>::name() + _("]")
        );
Wenzel Jakob's avatar
Wenzel Jakob committed
629
630
    }

631
632
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
633
    operator type() {
634
635
        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
636
637
    }
protected:
638
639
    make_caster<T1> first;
    make_caster<T2> second;
Wenzel Jakob's avatar
Wenzel Jakob committed
640
641
};

642
template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
643
    typedef std::tuple<Tuple...> type;
644
    typedef std::tuple<intrinsic_t<Tuple>...> itype;
645
646
    typedef std::tuple<args> args_type;
    typedef std::tuple<args, kwargs> args_kwargs_type;
Wenzel Jakob's avatar
Wenzel Jakob committed
647
648
649
public:
    enum { size = sizeof...(Tuple) };

650
651
652
    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
653
    bool load(handle src, bool convert) {
654
655
        if (!src || !PyTuple_Check(src.ptr()) || PyTuple_GET_SIZE(src.ptr()) != size)
            return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
656
        return load(src, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
657
658
    }

659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
    template <typename T = itype, typename std::enable_if<
        !std::is_same<T, args_type>::value &&
        !std::is_same<T, args_kwargs_type>::value, int>::type = 0>
    bool load_args(handle args, handle, bool convert) {
        return load(args, convert, typename make_index_sequence<sizeof...(Tuple)>::type());
    }

    template <typename T = itype, typename std::enable_if<std::is_same<T, args_type>::value, int>::type = 0>
    bool load_args(handle args, handle, bool convert) {
        std::get<0>(value).load(args, convert);
        return true;
    }

    template <typename T = itype, typename std::enable_if<std::is_same<T, args_kwargs_type>::value, int>::type = 0>
    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;
    }
678

Wenzel Jakob's avatar
Wenzel Jakob committed
679
    static handle cast(const type &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
680
        return cast(src, policy, parent, typename make_index_sequence<size>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
681
682
    }

683
    static PYBIND11_DESCR element_names() {
684
        return detail::concat(make_caster<Tuple>::name()...);
685
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
686

687
    static PYBIND11_DESCR name() {
688
        return type_descr(_("Tuple[") + element_names() + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
689
690
    }

691
692
    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
693
694
    }

695
    template <typename ReturnValue, typename Func> typename std::enable_if<std::is_void<ReturnValue>::value, void_type>::type call(Func &&f) {
696
        call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
697
        return void_type();
Wenzel Jakob's avatar
Wenzel Jakob committed
698
699
    }

700
701
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
702
    operator type() {
Wenzel Jakob's avatar
Wenzel Jakob committed
703
        return cast(typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
704
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
705

Wenzel Jakob's avatar
Wenzel Jakob committed
706
protected:
707
    template <typename ReturnValue, typename Func, size_t ... Index> ReturnValue call(Func &&f, index_sequence<Index...>) {
708
        return f(std::get<Index>(value)
709
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
710
711
712
    }

    template <size_t ... Index> type cast(index_sequence<Index...>) {
713
        return type(std::get<Index>(value)
714
            .operator typename make_caster<Tuple>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
715
716
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
717
718
    template <size_t ... Indices> bool load(handle src, bool convert, index_sequence<Indices...>) {
        std::array<bool, size> success {{
719
            std::get<Indices>(value).load(PyTuple_GET_ITEM(src.ptr(), Indices), convert)...
Wenzel Jakob's avatar
Wenzel Jakob committed
720
        }};
721
        (void) convert; /* avoid a warning when the tuple is empty */
Wenzel Jakob's avatar
Wenzel Jakob committed
722
        for (bool r : success)
Wenzel Jakob's avatar
Wenzel Jakob committed
723
724
725
726
727
728
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
Wenzel Jakob's avatar
Wenzel Jakob committed
729
730
    template <size_t ... Indices> static handle cast(const type &src, return_value_policy policy, handle parent, index_sequence<Indices...>) {
        std::array<object, size> entries {{
731
            object(make_caster<Tuple>::cast(std::get<Indices>(src), policy, parent), false)...
Wenzel Jakob's avatar
Wenzel Jakob committed
732
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
733
734
735
736
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
737
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
738
739
740
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
741
742
743
    }

protected:
744
    std::tuple<make_caster<Tuple>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
745
746
747
};

/// Type caster for holder types like std::shared_ptr, etc.
Wenzel Jakob's avatar
Wenzel Jakob committed
748
template <typename type, typename holder_type> class type_caster_holder : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
749
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
750
751
752
753
    using type_caster_base<type>::cast;
    using type_caster_base<type>::typeinfo;
    using type_caster_base<type>::value;
    using type_caster_base<type>::temp;
754

Wenzel Jakob's avatar
Wenzel Jakob committed
755
    bool load(handle src, bool convert) {
756
        if (!src || !typeinfo) {
Wenzel Jakob's avatar
Wenzel Jakob committed
757
            return false;
758
759
760
761
        } else if (src.ptr() == Py_None) {
            value = nullptr;
            return true;
        } else if (PyType_IsSubtype(Py_TYPE(src.ptr()), typeinfo->type)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
762
            auto inst = (instance<type, holder_type> *) src.ptr();
763
            value = (void *) inst->value;
764
765
766
            holder = inst->holder;
            return true;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
767

768
769
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
770
771
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
772
773
774
775
                    return true;
            }
        }
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
776
    }
777

Wenzel Jakob's avatar
Wenzel Jakob committed
778
779
780
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type*() { return &holder; }
781

782
783
784
785
786
787
788
789
    // 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

790
    static handle cast(const holder_type &src, return_value_policy, handle) {
791
        return type_caster_generic::cast(
792
            src.get(), return_value_policy::take_ownership, handle(),
793
            src.get() ? &typeid(*src.get()) : nullptr, &typeid(type),
794
            nullptr, nullptr, &src);
795
796
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
797
798
799
800
protected:
    holder_type holder;
};

801
802
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); } };
803
804
template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
805

806
807
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
808
public:
809
810
    template <typename T = type, typename std::enable_if<!std::is_base_of<object, T>::value, int>::type = 0>
    bool load(handle src, bool /* convert */) { value = type(src); return value.check(); }
811

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

Wenzel Jakob's avatar
Wenzel Jakob committed
815
816
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
817
    }
818
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
Wenzel Jakob's avatar
Wenzel Jakob committed
819
820
};

821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
// 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 {};
template <typename T> struct move_is_plain_type<T, typename std::enable_if<
        !std::is_void<T>::value && !std::is_pointer<T>::value && !std::is_reference<T>::value && !std::is_const<T>::value
    >::type> : std::true_type {};
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
template <typename T> struct move_always<T, typename std::enable_if<
        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
    >::type> : std::true_type {};
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
template <typename T> struct move_if_unreferenced<T, typename std::enable_if<
        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
    >::type> : std::true_type {};
template <typename T> using move_never = std::integral_constant<bool, !move_always<T>::value && !move_if_unreferenced<T>::value>;

Wenzel Jakob's avatar
Wenzel Jakob committed
848
849
NAMESPACE_END(detail)

850
template <typename T> T cast(const handle &handle) {
851
    using type_caster = detail::make_caster<T>;
852
    type_caster conv;
853
854
855
856
857
858
859
860
    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
    }
861
    return conv.operator typename type_caster::template cast_op_type<T>();
Wenzel Jakob's avatar
Wenzel Jakob committed
862
863
}

864
865
866
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
867
868
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
869
870
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
871
    return object(detail::make_caster<T>::cast(value, policy, parent), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
872
873
}

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

877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
template <typename T>
typename std::enable_if<detail::move_always<T>::value || detail::move_if_unreferenced<T>::value, T>::type move(object &&obj) {
    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

    typedef detail::type_caster<T> type_caster;
    type_caster conv;
    if (!conv.load(obj, 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) obj.get_type().str() + " to C++ type '" + type_id<T>() + "''");
#endif

    // Move into a temporary and return that, because the reference may be a local value of `conv`
    T ret = std::move(conv.operator T&());
    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.
template <typename T> typename std::enable_if<detail::move_always<T>::value, T>::type cast(object &&object) {
    return move<T>(std::move(object));
}
template <typename T> typename std::enable_if<detail::move_if_unreferenced<T>::value, T>::type cast(object &&object) {
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
template <typename T> typename std::enable_if<detail::move_never<T>::value, T>::type cast(object &&object) {
    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; }



928
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
929
          typename... Args> tuple make_tuple(Args&&... args_) {
Wenzel Jakob's avatar
Wenzel Jakob committed
930
    const size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
931
    std::array<object, size> args {
932
        { object(detail::make_caster<Args>::cast(
933
            std::forward<Args>(args_), policy, nullptr), false)... }
Wenzel Jakob's avatar
Wenzel Jakob committed
934
    };
935
936
937
938
939
940
941
942
943
944
    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
        }
    }
945
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
946
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
947
    for (auto &arg_value : args)
948
949
950
951
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
/// 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)}; }

/// Alias for backward compatibility -- to be remove in version 2.0
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); }
}

990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
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>());
        }
    }

1085
    void process(list &/*args_list*/, arg_v a) {
1086
1087
1088
1089
1090
1091
1092
        if (m_kwargs[a.name]) {
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
1093
        if (!a.value) {
1094
1095
1096
#if defined(NDEBUG)
            argument_cast_error();
#else
1097
            argument_cast_error(a.name, a.type);
1098
1099
#endif
        }
1100
        m_kwargs[a.name] = a.value;
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
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
    }

    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"
    );
    return {std::forward<Args>(args)...};
}

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
1166
1167
}

1168
1169
1170
template <return_value_policy policy,
          typename... Args> object handle::call(Args &&... args) const {
    return operator()<policy>(std::forward<Args>(args)...);
1171
1172
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1173
1174
1175
1176
1177
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

1178
NAMESPACE_END(pybind11)