cast.h 39.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
    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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
        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;
                } catch (const value_error &e)           { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } 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
73
74
75
76
    }
    return *internals_ptr;
}

77
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type, bool throw_if_missing = true) {
Wenzel Jakob's avatar
Wenzel Jakob committed
78
79
80
81
82
83
    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;
84
85
86
87
88
        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
89
90
91
92
93
94
    } while (true);
}

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

95
96
    auto it = types.find(std::type_index(tp));
    if (it != types.end())
Wenzel Jakob's avatar
Wenzel Jakob committed
97
98
99
100
101
102
103
104
105
106
        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() {
107
108
   PyObject *type, *value, *traceback;
   PyErr_Fetch(&type, &value, &traceback);
Wenzel Jakob's avatar
Wenzel Jakob committed
109

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

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

122
123
124
125
126
127
128
129
130
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
131
132
}

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

Wenzel Jakob's avatar
Wenzel Jakob committed
145
146
147
148
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
149

Wenzel Jakob's avatar
Wenzel Jakob committed
150
151
    PYBIND11_NOINLINE bool load(handle src, bool convert) {
        if (!src || !typeinfo)
Wenzel Jakob's avatar
Wenzel Jakob committed
152
            return false;
153
154
155
156
        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
157
            value = ((instance<void> *) src.ptr())->value;
Wenzel Jakob's avatar
Wenzel Jakob committed
158
159
160
161
            return true;
        }
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
162
163
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
164
165
166
167
168
169
                    return true;
            }
        }
        return false;
    }

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

180
        auto &internals = get_internals();
Wenzel Jakob's avatar
Wenzel Jakob committed
181

182
        auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
183
184
185
186
187
        if (it == internals.registered_types_cpp.end()) {
            type_info = type_info_backup;
            it = internals.registered_types_cpp.find(std::type_index(*type_info));
        }

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

196
        auto tinfo = (const detail::type_info *) it->second;
197
198
199
200
201
202
203
204

        auto it_instances = internals.registered_instances.equal_range(src);
        for (auto it = it_instances.first; it != it_instances.second; ++it) {
            auto instance_type = detail::get_type_info(Py_TYPE(it->second), false);
            if (instance_type && instance_type == tinfo)
                return handle((PyObject *) it->second).inc_ref();
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
205
206
207
208
209
210
211
212
        object inst(PyType_GenericAlloc(tinfo->type, 0), false);

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
213
214
        if (policy == return_value_policy::automatic)
            policy = return_value_policy::take_ownership;
215
216
        else if (policy == return_value_policy::automatic_reference)
            policy = return_value_policy::reference;
Wenzel Jakob's avatar
Wenzel Jakob committed
217

Wenzel Jakob's avatar
Wenzel Jakob committed
218
        if (policy == return_value_policy::copy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
219
220
            wrapper->value = copy_constructor(wrapper->value);
            if (wrapper->value == nullptr)
221
                throw cast_error("return_value_policy = copy, but the object is non-copyable!");
Wenzel Jakob's avatar
Wenzel Jakob committed
222
223
224
225
226
227
        } 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
228
        } else if (policy == return_value_policy::reference) {
Wenzel Jakob's avatar
Wenzel Jakob committed
229
            wrapper->owned = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
230
        } else if (policy == return_value_policy::reference_internal) {
Wenzel Jakob's avatar
Wenzel Jakob committed
231
232
            wrapper->owned = false;
            wrapper->parent = parent.inc_ref().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
233
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
234
235

        tinfo->init_holder(inst.ptr(), existing_holder);
236
237

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

        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
240
241
242
243
    }

protected:
    const type_info *typeinfo = nullptr;
244
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
245
246
247
    object temp;
};

248
249
/* Determine suitable casting operator */
template <typename T>
250
using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
251
252
253
    typename std::add_pointer<typename intrinsic_type<T>::type>::type,
    typename std::add_lvalue_reference<typename intrinsic_type<T>::type>::type>::type;

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

Wenzel Jakob's avatar
Wenzel Jakob committed
259
    type_caster_base() : type_caster_generic(typeid(type)) { }
260

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

Wenzel Jakob's avatar
Wenzel Jakob committed
267
268
269
270
271
272
    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
273
    static handle cast(const type *src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
274
275
        return type_caster_generic::cast(
            src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
276
            make_copy_constructor(src), make_move_constructor(src));
277
278
    }

279
280
    template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;

281
    operator type*() { return (type *) value; }
282
    operator type&() { if (!value) throw reference_cast_error(); return *((type *) value); }
283

284
protected:
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
    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; }
305
306
};

Wenzel Jakob's avatar
Wenzel Jakob committed
307
308
309
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };

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

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

330
331
332
333
334
335
336
#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
337
338
339
340
341
342
343
344
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
345

Wenzel Jakob's avatar
Wenzel Jakob committed
346
    bool load(handle src, bool) {
Wenzel Jakob's avatar
Wenzel Jakob committed
347
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
348

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

        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
376

Wenzel Jakob's avatar
Wenzel Jakob committed
377
378
379
380
        value = (T) py_value;
        return true;
    }

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

397
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
398
};
Wenzel Jakob's avatar
Wenzel Jakob committed
399

400
template <> class type_caster<void_type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
401
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
402
403
404
    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
405
    }
406
    PYBIND11_TYPE_CASTER(void_type, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
407
408
};

409
410
411
412
413
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
414
415
416
        if (!h) {
            return false;
        } else if (h.ptr() == Py_None) {
417
418
419
            value = nullptr;
            return true;
        }
420
421

        /* Check if this is a capsule */
422
        capsule c(h, true);
423
424
425
426
427
428
429
430
431
432
433
434
435
        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;
436
437
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
438
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
439
440
441
442
        if (ptr)
            return capsule(ptr).release();
        else
            return handle(Py_None).inc_ref();
443
    }
444

445
446
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
447
    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
448
private:
449
    void *value = nullptr;
450
451
};

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

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
489
    static handle cast(const std::string &src, return_value_policy /* policy */, handle /* parent */) {
490
        return PyUnicode_FromStringAndSize(src.c_str(), (ssize_t) src.length());
Wenzel Jakob's avatar
Wenzel Jakob committed
491
    }
492
493

    PYBIND11_TYPE_CASTER(std::string, _(PYBIND11_STRING_NAME));
494
495
protected:
    bool success = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
496
497
};

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

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

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

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

551
template <> class type_caster<char> : public type_caster<std::string> {
Wenzel Jakob's avatar
Wenzel Jakob committed
552
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
553
    bool load(handle src, bool convert) {
554
        if (src.ptr() == Py_None) return true;
555
556
557
        return type_caster<std::string>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
558
    static handle cast(const char *src, return_value_policy /* policy */, handle /* parent */) {
559
        if (src == nullptr) return handle(Py_None).inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
560
561
562
        return PyUnicode_FromString(src);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
563
    static handle cast(char src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
564
565
566
567
        char str[2] = { src, '\0' };
        return PyUnicode_DecodeLatin1(str, 1, nullptr);
    }

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

571
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
Wenzel Jakob's avatar
Wenzel Jakob committed
572
573
};

574
template <> class type_caster<wchar_t> : public type_caster<std::wstring> {
hulucc's avatar
hulucc committed
575
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
576
    bool load(handle src, bool convert) {
577
        if (src.ptr() == Py_None) return true;
578
579
580
        return type_caster<std::wstring>::load(src, convert);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
581
    static handle cast(const wchar_t *src, return_value_policy /* policy */, handle /* parent */) {
582
        if (src == nullptr) return handle(Py_None).inc_ref();
583
        return PyUnicode_FromWideChar(src, (ssize_t) wcslen(src));
Wenzel Jakob's avatar
Wenzel Jakob committed
584
    }
hulucc's avatar
hulucc committed
585

Wenzel Jakob's avatar
Wenzel Jakob committed
586
587
588
589
    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
590

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

Wenzel Jakob's avatar
Wenzel Jakob committed
594
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
hulucc's avatar
hulucc committed
595
596
};

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

Wenzel Jakob's avatar
Wenzel Jakob committed
609
610
611
    static handle cast(const type &src, return_value_policy policy, handle parent) {
        object o1 = object(type_caster<typename intrinsic_type<T1>::type>::cast(src.first, policy, parent), false);
        object o2 = object(type_caster<typename intrinsic_type<T2>::type>::cast(src.second, policy, parent), false);
612
        if (!o1 || !o2)
Wenzel Jakob's avatar
Wenzel Jakob committed
613
614
615
616
617
            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
618
619
    }

620
621
    static PYBIND11_DESCR name() {
        return type_descr(
622
623
            _("Tuple[") + type_caster<typename intrinsic_type<T1>::type>::name() +
            _(", ") + type_caster<typename intrinsic_type<T2>::type>::name() + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
624
625
    }

626
627
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
628
    operator type() {
629
630
        return type(first .operator typename type_caster<typename intrinsic_type<T1>::type>::template cast_op_type<T1>(),
                    second.operator typename type_caster<typename intrinsic_type<T2>::type>::template cast_op_type<T2>());
Wenzel Jakob's avatar
Wenzel Jakob committed
631
632
    }
protected:
633
634
    type_caster<typename intrinsic_type<T1>::type> first;
    type_caster<typename intrinsic_type<T2>::type> second;
Wenzel Jakob's avatar
Wenzel Jakob committed
635
636
};

637
template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
Wenzel Jakob's avatar
Wenzel Jakob committed
638
    typedef std::tuple<Tuple...> type;
639
640
641
    typedef std::tuple<typename intrinsic_type<Tuple>::type...> itype;
    typedef std::tuple<args> args_type;
    typedef std::tuple<args, kwargs> args_kwargs_type;
Wenzel Jakob's avatar
Wenzel Jakob committed
642
643
644
public:
    enum { size = sizeof...(Tuple) };

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

654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
    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;
    }
673

Wenzel Jakob's avatar
Wenzel Jakob committed
674
    static handle cast(const type &src, return_value_policy policy, handle parent) {
Wenzel Jakob's avatar
Wenzel Jakob committed
675
        return cast(src, policy, parent, typename make_index_sequence<size>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
676
677
    }

678
679
680
681
    static PYBIND11_DESCR element_names() {
        return detail::concat(type_caster<typename intrinsic_type<Tuple>::type>::name()...);
    }
    
682
    static PYBIND11_DESCR name() {
683
        return type_descr(_("Tuple[") + element_names() + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
684
685
    }

686
687
    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
688
689
    }

690
    template <typename ReturnValue, typename Func> typename std::enable_if<std::is_void<ReturnValue>::value, void_type>::type call(Func &&f) {
691
        call<ReturnValue>(std::forward<Func>(f), typename make_index_sequence<sizeof...(Tuple)>::type());
692
        return void_type();
Wenzel Jakob's avatar
Wenzel Jakob committed
693
694
    }

695
696
    template <typename T> using cast_op_type = type;

Wenzel Jakob's avatar
Wenzel Jakob committed
697
    operator type() {
Wenzel Jakob's avatar
Wenzel Jakob committed
698
        return cast(typename make_index_sequence<sizeof...(Tuple)>::type());
Wenzel Jakob's avatar
Wenzel Jakob committed
699
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
700

Wenzel Jakob's avatar
Wenzel Jakob committed
701
protected:
702
    template <typename ReturnValue, typename Func, size_t ... Index> ReturnValue call(Func &&f, index_sequence<Index...>) {
703
704
        return f(std::get<Index>(value)
            .operator typename type_caster<typename intrinsic_type<Tuple>::type>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
705
706
707
    }

    template <size_t ... Index> type cast(index_sequence<Index...>) {
708
709
        return type(std::get<Index>(value)
            .operator typename type_caster<typename intrinsic_type<Tuple>::type>::template cast_op_type<Tuple>()...);
Wenzel Jakob's avatar
Wenzel Jakob committed
710
711
    }

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

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

protected:
739
    std::tuple<type_caster<typename intrinsic_type<Tuple>::type>...> value;
Wenzel Jakob's avatar
Wenzel Jakob committed
740
741
742
};

/// Type caster for holder types like std::shared_ptr, etc.
Wenzel Jakob's avatar
Wenzel Jakob committed
743
template <typename type, typename holder_type> class type_caster_holder : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
744
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
745
746
747
748
    using type_caster_base<type>::cast;
    using type_caster_base<type>::typeinfo;
    using type_caster_base<type>::value;
    using type_caster_base<type>::temp;
749

Wenzel Jakob's avatar
Wenzel Jakob committed
750
    bool load(handle src, bool convert) {
751
        if (!src || !typeinfo) {
Wenzel Jakob's avatar
Wenzel Jakob committed
752
            return false;
753
754
755
756
        } 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
757
            auto inst = (instance<type, holder_type> *) src.ptr();
758
            value = (void *) inst->value;
759
760
761
            holder = inst->holder;
            return true;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
762

763
764
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
Wenzel Jakob's avatar
Wenzel Jakob committed
765
766
                temp = object(converter(src.ptr(), typeinfo->type), false);
                if (load(temp, false))
767
768
769
770
                    return true;
            }
        }
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
771
    }
772

Wenzel Jakob's avatar
Wenzel Jakob committed
773
774
775
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type*() { return &holder; }
776

777
778
779
780
781
782
783
784
    // 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

785
    static handle cast(const holder_type &src, return_value_policy, handle) {
786
        return type_caster_generic::cast(
787
            src.get(), return_value_policy::take_ownership, handle(),
788
            src.get() ? &typeid(*src.get()) : nullptr, &typeid(type),
789
            nullptr, nullptr, &src);
790
791
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
792
793
794
795
protected:
    holder_type holder;
};

796
797
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); } };
798
799
template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
800

801
802
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
803
public:
804
805
    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(); }
806

807
    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
808
    bool load(handle src, bool /* convert */) { value = type(src, true); return value.check(); }
809

Wenzel Jakob's avatar
Wenzel Jakob committed
810
811
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
812
    }
813
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
Wenzel Jakob's avatar
Wenzel Jakob committed
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
// 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
843
844
NAMESPACE_END(detail)

845
template <typename T> T cast(const handle &handle) {
846
847
    typedef detail::type_caster<typename detail::intrinsic_type<T>::type> type_caster;
    type_caster conv;
848
849
850
851
852
853
854
855
    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
    }
856
    return conv.operator typename type_caster::template cast_op_type<T>();
Wenzel Jakob's avatar
Wenzel Jakob committed
857
858
}

859
860
861
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
862
863
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
864
865
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
866
    return object(detail::type_caster<typename detail::intrinsic_type<T>::type>::cast(value, policy, parent), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
867
868
}

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

872
873
874
875
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
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; }



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

947
948
949
template <return_value_policy policy,
          typename... Args> object handle::operator()(Args&&... args) const {
    tuple args_tuple = pybind11::make_tuple<policy>(std::forward<Args>(args)...);
Wenzel Jakob's avatar
Wenzel Jakob committed
950
951
    object result(PyObject_CallObject(m_ptr, args_tuple.ptr()), false);
    if (!result)
952
        throw error_already_set();
Wenzel Jakob's avatar
Wenzel Jakob committed
953
    return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
954
955
}

956
957
958
template <return_value_policy policy,
          typename... Args> object handle::call(Args &&... args) const {
    return operator()<policy>(std::forward<Args>(args)...);
959
960
}

961
inline object handle::operator()(detail::args_proxy args) const {
962
963
964
965
966
967
    object result(PyObject_CallObject(m_ptr, args.ptr()), false);
    if (!result)
        throw error_already_set();
    return result;
}

968
inline object handle::operator()(detail::args_proxy args, detail::kwargs_proxy kwargs) const {
969
970
971
972
973
974
    object result(PyObject_Call(m_ptr, args.ptr(), kwargs.ptr()), false);
    if (!result)
        throw error_already_set();
    return result;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
975
976
977
978
979
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

980
NAMESPACE_END(pybind11)