cast.h 88.3 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
#include "pytypes.h"
14
15
#include "detail/typeid.h"
#include "detail/descr.h"
16
#include "detail/internals.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
17
#include <array>
Wenzel Jakob's avatar
Wenzel Jakob committed
18
#include <limits>
19
#include <tuple>
20
#include <type_traits>
Wenzel Jakob's avatar
Wenzel Jakob committed
21

22
23
24
25
26
27
28
29
30
31
32
33
34
#if defined(PYBIND11_CPP17)
#  if defined(__has_include)
#    if __has_include(<string_view>)
#      define PYBIND11_HAS_STRING_VIEW
#    endif
#  elif defined(_MSC_VER)
#    define PYBIND11_HAS_STRING_VIEW
#  endif
#endif
#ifdef PYBIND11_HAS_STRING_VIEW
#include <string_view>
#endif

35
NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
Wenzel Jakob's avatar
Wenzel Jakob committed
36
NAMESPACE_BEGIN(detail)
37

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/// A life support system for temporary objects created by `type_caster::load()`.
/// Adding a patient will keep it alive up until the enclosing function returns.
class loader_life_support {
public:
    /// A new patient frame is created when a function is entered
    loader_life_support() {
        get_internals().loader_patient_stack.push_back(nullptr);
    }

    /// ... and destroyed after it returns
    ~loader_life_support() {
        auto &stack = get_internals().loader_patient_stack;
        if (stack.empty())
            pybind11_fail("loader_life_support: internal error");

        auto ptr = stack.back();
        stack.pop_back();
        Py_CLEAR(ptr);

        // A heuristic to reduce the stack's capacity (e.g. after long recursive calls)
        if (stack.capacity() > 16 && stack.size() != 0 && stack.capacity() / stack.size() > 2)
            stack.shrink_to_fit();
    }

    /// This can only be used inside a pybind11-bound function, either by `argument_loader`
    /// at argument preparation time or by `py::cast()` at execution time.
    PYBIND11_NOINLINE static void add_patient(handle h) {
        auto &stack = get_internals().loader_patient_stack;
        if (stack.empty())
            throw cast_error("When called outside a bound function, py::cast() cannot "
                             "do Python -> C++ conversions which require the creation "
                             "of temporary values");

        auto &list_ptr = stack.back();
        if (list_ptr == nullptr) {
            list_ptr = PyList_New(1);
            if (!list_ptr)
                pybind11_fail("loader_life_support: error allocating list");
            PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
        } else {
            auto result = PyList_Append(list_ptr, h.ptr());
            if (result == -1)
                pybind11_fail("loader_life_support: error adding patient");
        }
    }
};

85
86
87
88
89
90
91
92
93
94
95
// Gets the cache entry for the given type, creating it if necessary.  The return value is the pair
// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
// just created.
inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);

// Populates a just-created cache entry.
PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
    std::vector<PyTypeObject *> check;
    for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
        check.push_back((PyTypeObject *) parent.ptr());

Wenzel Jakob's avatar
Wenzel Jakob committed
96
    auto const &type_dict = get_internals().registered_types_py;
97
98
99
100
101
102
    for (size_t i = 0; i < check.size(); i++) {
        auto type = check[i];
        // Ignore Python2 old-style class super type:
        if (!PyType_Check((PyObject *) type)) continue;

        // Check `type` in the current set of registered python types:
Wenzel Jakob's avatar
Wenzel Jakob committed
103
        auto it = type_dict.find(type);
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
        if (it != type_dict.end()) {
            // We found a cache entry for it, so it's either pybind-registered or has pre-computed
            // pybind bases, but we have to make sure we haven't already seen the type(s) before: we
            // want to follow Python/virtual C++ rules that there should only be one instance of a
            // common base.
            for (auto *tinfo : it->second) {
                // NB: Could use a second set here, rather than doing a linear search, but since
                // having a large number of immediate pybind11-registered types seems fairly
                // unlikely, that probably isn't worthwhile.
                bool found = false;
                for (auto *known : bases) {
                    if (known == tinfo) { found = true; break; }
                }
                if (!found) bases.push_back(tinfo);
            }
        }
        else if (type->tp_bases) {
            // It's some python type, so keep follow its bases classes to look for one or more
            // registered types
            if (i + 1 == check.size()) {
                // When we're at the end, we can pop off the current element to avoid growing
125
                // `check` when adding just one base (which is typical--i.e. when there is no
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
                // multiple inheritance)
                check.pop_back();
                i--;
            }
            for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
                check.push_back((PyTypeObject *) parent.ptr());
        }
    }
}

/**
 * Extracts vector of type_info pointers of pybind-registered roots of the given Python type.  Will
 * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
 * derived class that uses single inheritance.  Will contain as many types as required for a Python
 * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
 * pybind-registered classes.  Will be empty if neither the type nor any base classes are
 * pybind-registered.
 *
 * The value is cached for the lifetime of the Python type.
 */
inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
    auto ins = all_type_info_get_cache(type);
    if (ins.second)
        // New cache entry: populate it
        all_type_info_populate(type, ins.first->second);

    return ins.first->second;
}

/**
 * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
 * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
 * `all_type_info` instead if you want to support multiple bases.
 */
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
    auto &bases = all_type_info(type);
    if (bases.size() == 0)
        return nullptr;
    if (bases.size() > 1)
        pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
    return bases.front();
Wenzel Jakob's avatar
Wenzel Jakob committed
167
168
}

169
inline detail::type_info *get_local_type_info(const std::type_index &tp) {
170
    auto &locals = registered_local_types_cpp();
171
    auto it = locals.find(tp);
172
    if (it != locals.end())
173
        return it->second;
174
175
176
177
178
179
180
    return nullptr;
}

inline detail::type_info *get_global_type_info(const std::type_index &tp) {
    auto &types = get_internals().registered_types_cpp;
    auto it = types.find(tp);
    if (it != types.end())
181
        return it->second;
182
183
184
185
186
187
188
189
190
191
192
    return nullptr;
}

/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
                                                          bool throw_if_missing = false) {
    if (auto ltype = get_local_type_info(tp))
        return ltype;
    if (auto gtype = get_global_type_info(tp))
        return gtype;

Wenzel Jakob's avatar
Wenzel Jakob committed
193
194
195
196
197
    if (throw_if_missing) {
        std::string tname = tp.name();
        detail::clean_type_id(tname);
        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
198
199
200
    return nullptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
201
202
PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
Wenzel Jakob's avatar
Wenzel Jakob committed
203
204
205
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

206
struct value_and_holder {
207
208
209
210
    instance *inst = nullptr;
    size_t index = 0u;
    const detail::type_info *type = nullptr;
    void **vh = nullptr;
211

212
    // Main constructor for a found value/holder:
213
214
215
216
217
    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) :
        inst{i}, index{index}, type{type},
        vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]}
    {}

218
    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
219
    value_and_holder() {}
220

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
    // Used for past-the-end iterator
    value_and_holder(size_t index) : index{index} {}

    template <typename V = void> V *&value_ptr() const {
        return reinterpret_cast<V *&>(vh[0]);
    }
    // True if this `value_and_holder` has a non-null value pointer
    explicit operator bool() const { return value_ptr(); }

    template <typename H> H &holder() const {
        return reinterpret_cast<H &>(vh[1]);
    }
    bool holder_constructed() const {
        return inst->simple_layout
            ? inst->simple_holder_constructed
236
            : inst->nonsimple.status[index] & instance::status_holder_constructed;
237
    }
238
    void set_holder_constructed(bool v = true) {
239
        if (inst->simple_layout)
240
241
            inst->simple_holder_constructed = v;
        else if (v)
242
            inst->nonsimple.status[index] |= instance::status_holder_constructed;
243
244
        else
            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
245
246
247
248
249
250
    }
    bool instance_registered() const {
        return inst->simple_layout
            ? inst->simple_instance_registered
            : inst->nonsimple.status[index] & instance::status_instance_registered;
    }
251
    void set_instance_registered(bool v = true) {
252
        if (inst->simple_layout)
253
254
            inst->simple_instance_registered = v;
        else if (v)
255
            inst->nonsimple.status[index] |= instance::status_instance_registered;
256
257
        else
            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
    }
};

// Container for accessing and iterating over an instance's values/holders
struct values_and_holders {
private:
    instance *inst;
    using type_vec = std::vector<detail::type_info *>;
    const type_vec &tinfo;

public:
    values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}

    struct iterator {
    private:
273
274
        instance *inst = nullptr;
        const type_vec *types = nullptr;
275
276
        value_and_holder curr;
        friend struct values_and_holders;
277
278
        iterator(instance *inst, const type_vec *tinfo)
            : inst{inst}, types{tinfo},
279
            curr(inst /* instance */,
280
                 types->empty() ? nullptr : (*types)[0] /* type info */,
281
282
283
284
285
286
287
288
289
                 0, /* vpos: (non-simple types only): the first vptr comes first */
                 0 /* index */)
        {}
        // Past-the-end iterator:
        iterator(size_t end) : curr(end) {}
    public:
        bool operator==(const iterator &other) { return curr.index == other.curr.index; }
        bool operator!=(const iterator &other) { return curr.index != other.curr.index; }
        iterator &operator++() {
290
291
            if (!inst->simple_layout)
                curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
292
            ++curr.index;
293
            curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
294
295
296
297
298
299
            return *this;
        }
        value_and_holder &operator*() { return curr; }
        value_and_holder *operator->() { return &curr; }
    };

300
    iterator begin() { return iterator(inst, &tinfo); }
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    iterator end() { return iterator(tinfo.size()); }

    iterator find(const type_info *find_type) {
        auto it = begin(), endit = end();
        while (it != endit && it->type != find_type) ++it;
        return it;
    }

    size_t size() { return tinfo.size(); }
};

/**
 * Extracts C++ value and holder pointer references from an instance (which may contain multiple
 * values/holders for python-side multiple inheritance) that match the given type.  Throws an error
 * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance.  If
 * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
 * regardless of type (and the resulting .type will be nullptr).
 *
 * The returned object should be short-lived: in particular, it must not outlive the called-upon
 * instance.
 */
322
PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
323
324
325
326
327
328
329
330
331
    // Optimize common case:
    if (!find_type || Py_TYPE(this) == find_type->type)
        return value_and_holder(this, find_type, 0, 0);

    detail::values_and_holders vhs(this);
    auto it = vhs.find(find_type);
    if (it != vhs.end())
        return *it;

332
333
334
    if (!throw_if_missing)
        return value_and_holder();

335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
#if defined(NDEBUG)
    pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
            "type is not a pybind11 base of the given instance "
            "(compile in debug mode for type details)");
#else
    pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
            std::string(find_type->type->tp_name) + "' is not a pybind11 base of the given `" +
            std::string(Py_TYPE(this)->tp_name) + "' instance");
#endif
}

PYBIND11_NOINLINE inline void instance::allocate_layout() {
    auto &tinfo = all_type_info(Py_TYPE(this));

    const size_t n_types = tinfo.size();

    if (n_types == 0)
        pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");

    simple_layout =
        n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();

    // Simple path: no python-side multiple inheritance, and a small-enough holder
    if (simple_layout) {
        simple_value_holder[0] = nullptr;
        simple_holder_constructed = false;
361
        simple_instance_registered = false;
362
363
364
365
366
367
368
369
370
371
372
373
    }
    else { // multiple base types or a too-large holder
        // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
        // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
        // values that tracks whether each associated holder has been initialized.  Each [block] is
        // padded, if necessary, to an integer multiple of sizeof(void *).
        size_t space = 0;
        for (auto t : tinfo) {
            space += 1; // value pointer
            space += t->holder_size_in_ptrs; // holder instance
        }
        size_t flags_at = space;
374
        space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
375
376
377
378
379
380
381
382
383
384
385
386
387
388

        // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
        // in particular, need to be 0).  Use Python's memory allocation functions: in Python 3.6
        // they default to using pymalloc, which is designed to be efficient for small allocations
        // like the one we're doing here; in earlier versions (and for larger allocations) they are
        // just wrappers around malloc.
#if PY_VERSION_HEX >= 0x03050000
        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
        if (!nonsimple.values_and_holders) throw std::bad_alloc();
#else
        nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
        if (!nonsimple.values_and_holders) throw std::bad_alloc();
        std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *));
#endif
389
        nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
390
391
392
393
394
395
396
397
398
    }
    owned = true;
}

PYBIND11_NOINLINE inline void instance::deallocate_layout() {
    if (!simple_layout)
        PyMem_Free(nonsimple.values_and_holders);
}

399
PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
Wenzel Jakob's avatar
Wenzel Jakob committed
400
    handle type = detail::get_type_handle(tp, false);
401
402
    if (!type)
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
403
    return isinstance(obj, type);
404
405
}

Wenzel Jakob's avatar
Wenzel Jakob committed
406
PYBIND11_NOINLINE inline std::string error_string() {
407
408
409
410
411
    if (!PyErr_Occurred()) {
        PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
        return "Unknown internal error occurred";
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
412
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
413

414
    std::string errorString;
Wenzel Jakob's avatar
Wenzel Jakob committed
415
416
    if (scope.type) {
        errorString += handle(scope.type).attr("__name__").cast<std::string>();
Wenzel Jakob's avatar
Wenzel Jakob committed
417
418
        errorString += ": ";
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
419
    if (scope.value)
420
        errorString += (std::string) str(scope.value);
Wenzel Jakob's avatar
Wenzel Jakob committed
421

422
423
    PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);

424
425
426
427
428
#if PY_MAJOR_VERSION >= 3
    if (scope.trace != nullptr)
        PyException_SetTraceback(scope.value, scope.trace);
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
429
#if !defined(PYPY_VERSION)
430
    if (scope.trace) {
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
        PyTracebackObject *trace = (PyTracebackObject *) scope.trace;

        /* Get the deepest trace possible */
        while (trace->tb_next)
            trace = trace->tb_next;

        PyFrameObject *frame = trace->tb_frame;
        errorString += "\n\nAt:\n";
        while (frame) {
            int lineno = PyFrame_GetLineNumber(frame);
            errorString +=
                "  " + handle(frame->f_code->co_filename).cast<std::string>() +
                "(" + std::to_string(lineno) + "): " +
                handle(frame->f_code->co_name).cast<std::string>() + "\n";
            frame = frame->f_back;
446
447
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
448
#endif
449

Wenzel Jakob's avatar
Wenzel Jakob committed
450
451
452
    return errorString;
}

453
454
455
456
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) {
457
458
459
460
        for (auto vh : values_and_holders(it->second)) {
            if (vh.type == type)
                return handle((PyObject *) it->second);
        }
461
462
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
463
464
}

465
inline PyThreadState *get_thread_state_unchecked() {
Wenzel Jakob's avatar
Wenzel Jakob committed
466
467
468
#if defined(PYPY_VERSION)
    return PyThreadState_GET();
#elif PY_VERSION_HEX < 0x03000000
469
470
471
472
473
474
475
476
477
478
    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
}

479
// Forward declarations
480
inline void keep_alive_impl(handle nurse, handle patient);
481
inline PyObject *make_new_instance(PyTypeObject *type);
482

Wenzel Jakob's avatar
Wenzel Jakob committed
483
484
485
class type_caster_generic {
public:
    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
486
        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
Wenzel Jakob's avatar
Wenzel Jakob committed
487

488
489
    type_caster_generic(const type_info *typeinfo)
        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
490

491
492
    bool load(handle src, bool convert) {
        return load_impl<type_caster_generic>(src, convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
493
494
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
495
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
496
                                         const detail::type_info *tinfo,
Wenzel Jakob's avatar
Wenzel Jakob committed
497
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
498
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
499
                                         const void *existing_holder = nullptr) {
500
        if (!tinfo) // no type info: error will be set already
Wenzel Jakob's avatar
Wenzel Jakob committed
501
502
            return handle();

503
504
505
        void *src = const_cast<void *>(_src);
        if (src == nullptr)
            return none().release();
506

507
        auto it_instances = get_internals().registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
508
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
509
            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
510
                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
511
512
                    return handle((PyObject *) it_i->second).inc_ref();
            }
513
514
        }

515
        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
516
        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
517
        wrapper->owned = false;
518
        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
519
520

        switch (policy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
521
522
            case return_value_policy::automatic:
            case return_value_policy::take_ownership:
523
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
524
525
526
527
528
                wrapper->owned = true;
                break;

            case return_value_policy::automatic_reference:
            case return_value_policy::reference:
529
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
530
531
532
533
534
                wrapper->owned = false;
                break;

            case return_value_policy::copy:
                if (copy_constructor)
535
                    valueptr = copy_constructor(src);
536
537
538
539
540
541
542
543
544
545
546
                else {
#if defined(NDEBUG)
                    throw cast_error("return_value_policy = copy, but type is "
                                     "non-copyable! (compile in debug mode for details)");
#else
                    std::string type_name(tinfo->cpptype->name());
                    detail::clean_type_id(type_name);
                    throw cast_error("return_value_policy = copy, but type " +
                                     type_name + " is non-copyable!");
#endif
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
547
548
549
550
551
                wrapper->owned = true;
                break;

            case return_value_policy::move:
                if (move_constructor)
552
                    valueptr = move_constructor(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
553
                else if (copy_constructor)
554
                    valueptr = copy_constructor(src);
555
556
557
558
559
560
561
562
563
564
565
566
                else {
#if defined(NDEBUG)
                    throw cast_error("return_value_policy = move, but type is neither "
                                     "movable nor copyable! "
                                     "(compile in debug mode for details)");
#else
                    std::string type_name(tinfo->cpptype->name());
                    detail::clean_type_id(type_name);
                    throw cast_error("return_value_policy = move, but type " +
                                     type_name + " is neither movable nor copyable!");
#endif
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
567
568
569
570
                wrapper->owned = true;
                break;

            case return_value_policy::reference_internal:
571
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
572
                wrapper->owned = false;
573
                keep_alive_impl(inst, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
574
575
576
577
                break;

            default:
                throw cast_error("unhandled return_value_policy: should not happen!");
Wenzel Jakob's avatar
Wenzel Jakob committed
578
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
579

580
        tinfo->init_instance(wrapper, existing_holder);
581

Wenzel Jakob's avatar
Wenzel Jakob committed
582
        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
583
584
    }

585
    // Base methods for generic caster; there are overridden in copyable_holder_caster
586
587
588
589
590
    void load_value(value_and_holder &&v_h) {
        auto *&vptr = v_h.value_ptr();
        // Lazy allocation for unallocated values:
        if (vptr == nullptr) {
            auto *type = v_h.type ? v_h.type : typeinfo;
591
592
593
            if (type->operator_new) {
                vptr = type->operator_new(type->type_size);
            } else {
594
                #ifdef __cpp_aligned_new
595
596
                    if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
                        vptr = ::operator new(type->type_size,
597
                                              std::align_val_t(type->type_align));
598
599
600
601
                    else
                #endif
                vptr = ::operator new(type->type_size);
            }
602
603
        }
        value = vptr;
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
    }
    bool try_implicit_casts(handle src, bool convert) {
        for (auto &cast : typeinfo->implicit_casts) {
            type_caster_generic sub_caster(*cast.first);
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                return true;
            }
        }
        return false;
    }
    bool try_direct_conversions(handle src) {
        for (auto &converter : *typeinfo->direct_conversions) {
            if (converter(src.ptr(), value))
                return true;
        }
        return false;
    }
    void check_holder_compat() {}

624
625
626
627
628
629
630
631
632
633
    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
        auto caster = type_caster_generic(ti);
        if (caster.load(src, false))
            return caster.value;
        return nullptr;
    }

    /// Try to load with foreign typeinfo, if available. Used when there is no
    /// native typeinfo, or when the native one wasn't able to produce a value.
    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
634
        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
635
636
637
638
639
640
641
        const auto pytype = src.get_type();
        if (!hasattr(pytype, local_key))
            return false;

        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type
        if (foreign_typeinfo->module_local_load == &local_load
642
            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
643
644
645
646
647
648
649
650
651
            return false;

        if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
            value = result;
            return true;
        }
        return false;
    }

652
653
654
655
656
    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
    // bits of code between here and copyable_holder_caster where the two classes need different
    // logic (without having to resort to virtual inheritance).
    template <typename ThisT>
    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
657
658
        if (!src) return false;
        if (!typeinfo) return try_load_foreign_module_local(src);
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
        if (src.is_none()) {
            // Defer accepting None to other overloads (if we aren't in convert mode):
            if (!convert) return false;
            value = nullptr;
            return true;
        }

        auto &this_ = static_cast<ThisT &>(*this);
        this_.check_holder_compat();

        PyTypeObject *srctype = Py_TYPE(src.ptr());

        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
        // the instance's value pointer to the target type:
        if (srctype == typeinfo->type) {
            this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
            return true;
        }
        // Case 2: We have a derived class
        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
            auto &bases = all_type_info(srctype);
            bool no_cpp_mi = typeinfo->simple_type;

            // Case 2a: the python type is a Python-inherited derived class that inherits from just
            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
            // the right type and we can use reinterpret_cast.
            // (This is essentially the same as case 2b, but because not using multiple inheritance
            // is extremely common, we handle it specially to avoid the loop iterator and type
            // pointer lookup overhead)
            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
                this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
                return true;
            }
            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
            // can safely reinterpret_cast to the relevant pointer.
            else if (bases.size() > 1) {
                for (auto base : bases) {
                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                        this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
                        return true;
                    }
                }
            }

            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
            // when MI is involved).
            if (this_.try_implicit_casts(src, convert))
                return true;
        }

        // Perform an implicit conversion
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
714
715
716
                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
                if (load_impl<ThisT>(temp, false)) {
                    loader_life_support::add_patient(temp);
717
                    return true;
718
                }
719
720
721
722
            }
            if (this_.try_direct_conversions(src))
                return true;
        }
723
724
725
726
727
728
729
730
731
732
733

        // Failed to match local typeinfo. Try again with global.
        if (typeinfo->module_local) {
            if (auto gtype = get_global_type_info(*typeinfo->cpptype)) {
                typeinfo = gtype;
                return load(src, false);
            }
        }

        // Global typeinfo has precedence over foreign module_local
        return try_load_foreign_module_local(src);
734
735
736
    }


737
738
739
740
    // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
    // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
    // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
    PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
741
            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
742
743
        if (auto *tpi = get_type_info(cast_type))
            return {src, const_cast<const type_info *>(tpi)};
744
745

        // Not found, set error:
746
        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
747
748
749
750
751
752
        detail::clean_type_id(tname);
        std::string msg = "Unregistered type : " + tname;
        PyErr_SetString(PyExc_TypeError, msg.c_str());
        return {nullptr, nullptr};
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
753
    const type_info *typeinfo = nullptr;
754
    const std::type_info *cpptype = nullptr;
755
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
756
757
};

758
759
760
761
762
763
764
/**
 * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
 * needs to provide `operator T*()` and `operator T&()` operators.
 *
 * If the type supports moving the value away via an `operator T&&() &&` method, it should use
 * `movable_cast_op_type` instead.
 */
765
template <typename T>
766
using cast_op_type =
767
    conditional_t<std::is_pointer<remove_reference_t<T>>::value,
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
        typename std::add_pointer<intrinsic_t<T>>::type,
        typename std::add_lvalue_reference<intrinsic_t<T>>::type>;

/**
 * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
 * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`.  The latter will be
 * called in appropriate contexts where the value can be moved rather than copied.
 *
 * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
 */
template <typename T>
using movable_cast_op_type =
    conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
        typename std::add_pointer<intrinsic_t<T>>::type,
    conditional_t<std::is_rvalue_reference<T>::value,
        typename std::add_rvalue_reference<intrinsic_t<T>>::type,
        typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
785

786
787
788
789
790
791
792
// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
// T is non-copyable, but code containing such a copy constructor fails to actually compile.
template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};

// Specialization for types that appear to be copy constructible but also look like stl containers
// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
// so, copy constructability depends on whether the value_type is copy constructible.
793
794
template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
        std::is_copy_constructible<Container>,
795
796
797
        std::is_same<typename Container::value_type &, typename Container::reference>,
        // Avoid infinite recursion
        negation<std::is_same<Container, typename Container::value_type>>
798
799
800
801
802
803
804
805
    >::value>> : is_copy_constructible<typename Container::value_type> {};

#if !defined(PYBIND11_CPP17)
// Likewise for std::pair before C++17 (which mandates that the copy constructor not exist when the
// two types aren't themselves copy constructible).
template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
#endif
806

807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
NAMESPACE_END(detail)

// polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
// to by `src` actually is an instance of some class derived from `itype`.
// If so, it sets `tinfo` to point to the std::type_info representing that derived
// type, and returns a pointer to the start of the most-derived object of that type
// (in which `src` is a subobject; this will be the same address as `src` in most
// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
// and leaves `tinfo` at its default value of nullptr.
//
// The default polymorphic_type_hook just returns src. A specialization for polymorphic
// types determines the runtime type of the passed object and adjusts the this-pointer
// appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear
// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is
// registered with pybind11, and this Animal is in fact a Dog).
//
// You may specialize polymorphic_type_hook yourself for types that want to appear
// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern
// in performance-sensitive applications, used most notably in LLVM.)
template <typename itype, typename SFINAE = void>
struct polymorphic_type_hook
{
    static const void *get(const itype *src, const std::type_info*&) { return src; }
};
template <typename itype>
struct polymorphic_type_hook<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>>
{
    static const void *get(const itype *src, const std::type_info*& type) {
        type = src ? &typeid(*src) : nullptr;
        return dynamic_cast<const void*>(src);
    }
};

NAMESPACE_BEGIN(detail)

842
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
843
template <typename type> class type_caster_base : public type_caster_generic {
844
    using itype = intrinsic_t<type>;
845

846
public:
847
    static constexpr auto name = _<type>();
848

Wenzel Jakob's avatar
Wenzel Jakob committed
849
    type_caster_base() : type_caster_base(typeid(type)) { }
850
    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
851

852
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
853
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
854
            policy = return_value_policy::copy;
855
        return cast(&src, policy, parent);
856
857
    }

858
859
    static handle cast(itype &&src, return_value_policy, handle parent) {
        return cast(&src, return_value_policy::move, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
860
861
    }

862
863
864
    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
    // polymorphic type (using RTTI by default, but can be overridden by specializing
    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
865
    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
866
        auto &cast_type = typeid(itype);
867
        const std::type_info *instance_type = nullptr;
868
869
870
871
872
873
874
875
876
877
878
879
        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
        if (instance_type && !same_type(cast_type, *instance_type)) {
            // This is a base pointer to a derived type. If the derived type is registered
            // with pybind11, we want to make the full derived object available.
            // In the typical case where itype is polymorphic, we get the correct
            // derived pointer (which may be != base pointer) by a dynamic_cast to
            // most derived type. If itype is not polymorphic, we won't get here
            // except via a user-provided specialization of polymorphic_type_hook,
            // and the user has promised that no this-pointer adjustment is
            // required in that case, so it's OK to use static_cast.
            if (const auto *tpi = get_type_info(*instance_type))
                return {vsrc, tpi};
880
881
882
        }
        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
        // don't do a cast
883
        return type_caster_generic::src_and_type(src, cast_type, instance_type);
884
885
    }

886
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
887
        auto st = src_and_type(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
888
        return type_caster_generic::cast(
889
            st.first, policy, parent, st.second,
890
            make_copy_constructor(src), make_move_constructor(src));
891
892
    }

893
    static handle cast_holder(const itype *src, const void *holder) {
894
        auto st = src_and_type(src);
895
        return type_caster_generic::cast(
896
            st.first, return_value_policy::take_ownership, {}, st.second,
897
898
899
            nullptr, nullptr, holder);
    }

900
    template <typename T> using cast_op_type = detail::cast_op_type<T>;
901

902
903
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
904

905
protected:
906
907
    using Constructor = void *(*)(const void *);

908
    /* Only enabled when the types are {copy,move}-constructible *and* when the type
909
910
911
912
913
914
915
916
917
       does not have a private operator new implementation. */
    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
        return [](const void *arg) -> void * {
            return new T(*reinterpret_cast<const T *>(arg));
        };
    }

    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
918
    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
919
920
921
922
        return [](const void *arg) -> void * {
            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
        };
    }
923

924
925
    static Constructor make_copy_constructor(...) { return nullptr; }
    static Constructor make_move_constructor(...) { return nullptr; }
926
927
};

Wenzel Jakob's avatar
Wenzel Jakob committed
928
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
929
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
930

931
// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
932
template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
933
934
    return caster.operator typename make_caster<T>::template cast_op_type<T>();
}
935
936
937
938
template <typename T> typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
cast_op(make_caster<T> &&caster) {
    return std::move(caster).operator
        typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>();
939
940
}

941
942
943
944
945
946
947
template <typename type> class type_caster<std::reference_wrapper<type>> {
private:
    using caster_t = make_caster<type>;
    caster_t subcaster;
    using subcaster_cast_op_type = typename caster_t::template cast_op_type<type>;
    static_assert(std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value,
            "std::reference_wrapper<T> caster requires T to have a caster with an `T &` operator");
948
public:
949
    bool load(handle src, bool convert) { return subcaster.load(src, convert); }
950
    static constexpr auto name = caster_t::name;
951
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
952
953
954
955
        // It is definitely wrong to take ownership of this pointer, so mask that rvp
        if (policy == return_value_policy::take_ownership || policy == return_value_policy::automatic)
            policy = return_value_policy::automatic_reference;
        return caster_t::cast(&src.get(), policy, parent);
956
    }
957
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
958
    operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type&(); }
959
960
};

961
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
962
963
964
    protected: \
        type value; \
    public: \
965
        static constexpr auto name = py_name; \
966
967
        template <typename T_, enable_if_t<std::is_same<type, remove_cv_t<T_>>::value, int> = 0> \
        static handle cast(T_ *src, return_value_policy policy, handle parent) { \
968
            if (!src) return none().release(); \
969
970
971
972
973
            if (policy == return_value_policy::take_ownership) { \
                auto h = cast(std::move(*src), policy, parent); delete src; return h; \
            } else { \
                return cast(*src, policy, parent); \
            } \
Wenzel Jakob's avatar
Wenzel Jakob committed
974
975
        } \
        operator type*() { return &value; } \
976
        operator type&() { return value; } \
977
        operator type&&() && { return std::move(value); } \
978
        template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
Wenzel Jakob's avatar
Wenzel Jakob committed
979

980

981
982
983
984
985
986
987
template <typename CharT> using is_std_char_type = any_of<
    std::is_same<CharT, char>, /* std::string */
    std::is_same<CharT, char16_t>, /* std::u16string */
    std::is_same<CharT, char32_t>, /* std::u32string */
    std::is_same<CharT, wchar_t> /* std::wstring */
>;

Wenzel Jakob's avatar
Wenzel Jakob committed
988
template <typename T>
989
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
990
991
992
    using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
    using _py_type_1 = conditional_t<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>;
    using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
Wenzel Jakob's avatar
Wenzel Jakob committed
993
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
994

995
    bool load(handle src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
996
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
997

998
        if (!src)
999
            return false;
1000
1001
1002
1003
1004
1005

        if (std::is_floating_point<T>::value) {
            if (convert || PyFloat_Check(src.ptr()))
                py_value = (py_type) PyFloat_AsDouble(src.ptr());
            else
                return false;
1006
1007
1008
1009
1010
1011
1012
1013
        } else if (PyFloat_Check(src.ptr())) {
            return false;
        } else if (std::is_unsigned<py_type>::value) {
            py_value = as_unsigned<py_type>(src.ptr());
        } else { // signed integer:
            py_value = sizeof(T) <= sizeof(long)
                ? (py_type) PyLong_AsLong(src.ptr())
                : (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
1014
1015
        }

1016
        bool py_err = py_value == (py_type) -1 && PyErr_Occurred();
1017
1018

        // Protect std::numeric_limits::min/max with parentheses
1019
        if (py_err || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) &&
1020
1021
                       (py_value < (py_type) (std::numeric_limits<T>::min)() ||
                        py_value > (py_type) (std::numeric_limits<T>::max)()))) {
1022
            bool type_error = py_err && PyErr_ExceptionMatches(
1023
#if PY_VERSION_HEX < 0x03000000 && !defined(PYPY_VERSION)
1024
                PyExc_SystemError
1025
#else
1026
                PyExc_TypeError
1027
#endif
1028
            );
Wenzel Jakob's avatar
Wenzel Jakob committed
1029
            PyErr_Clear();
1030
            if (type_error && convert && PyNumber_Check(src.ptr())) {
1031
1032
1033
                auto tmp = reinterpret_steal<object>(std::is_floating_point<T>::value
                                                     ? PyNumber_Float(src.ptr())
                                                     : PyNumber_Long(src.ptr()));
1034
1035
1036
                PyErr_Clear();
                return load(tmp, false);
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
1037
1038
            return false;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1039

Wenzel Jakob's avatar
Wenzel Jakob committed
1040
1041
1042
1043
        value = (T) py_value;
        return true;
    }

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
    template<typename U = T>
    static typename std::enable_if<std::is_floating_point<U>::value, handle>::type
    cast(U src, return_value_policy /* policy */, handle /* parent */) {
        return PyFloat_FromDouble((double) src);
    }

    template<typename U = T>
    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) <= sizeof(long)), handle>::type
    cast(U src, return_value_policy /* policy */, handle /* parent */) {
        return PYBIND11_LONG_FROM_SIGNED((long) src);
    }

    template<typename U = T>
    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) <= sizeof(unsigned long)), handle>::type
    cast(U src, return_value_policy /* policy */, handle /* parent */) {
        return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src);
    }

    template<typename U = T>
    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value && (sizeof(U) > sizeof(long)), handle>::type
    cast(U src, return_value_policy /* policy */, handle /* parent */) {
        return PyLong_FromLongLong((long long) src);
    }

    template<typename U = T>
    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) > sizeof(unsigned long)), handle>::type
    cast(U src, return_value_policy /* policy */, handle /* parent */) {
        return PyLong_FromUnsignedLongLong((unsigned long long) src);
Wenzel Jakob's avatar
Wenzel Jakob committed
1072
1073
    }

1074
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1075
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1076

1077
template<typename T> struct void_caster {
Wenzel Jakob's avatar
Wenzel Jakob committed
1078
public:
1079
1080
1081
1082
1083
    bool load(handle src, bool) {
        if (src && src.is_none())
            return true;
        return false;
    }
1084
    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1085
        return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1086
    }
1087
    PYBIND11_TYPE_CASTER(T, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1088
1089
};

1090
1091
template <> class type_caster<void_type> : public void_caster<void_type> {};

1092
1093
1094
1095
1096
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
1097
1098
        if (!h) {
            return false;
1099
        } else if (h.is_none()) {
1100
1101
1102
            value = nullptr;
            return true;
        }
1103
1104

        /* Check if this is a capsule */
1105
        if (isinstance<capsule>(h)) {
1106
            value = reinterpret_borrow<capsule>(h);
1107
1108
1109
1110
            return true;
        }

        /* Check if this is a C++ type */
1111
1112
1113
        auto &bases = all_type_info((PyTypeObject *) h.get_type().ptr());
        if (bases.size() == 1) { // Only allowing loading from a single-value type
            value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
1114
1115
1116
1117
1118
            return true;
        }

        /* Fail */
        return false;
1119
1120
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1121
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
1122
1123
1124
        if (ptr)
            return capsule(ptr).release();
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
1125
            return none().inc_ref();
1126
    }
1127

1128
1129
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
1130
    static constexpr auto name = _("capsule");
1131
private:
1132
    void *value = nullptr;
1133
1134
};

1135
template <> class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> { };
1136

Wenzel Jakob's avatar
Wenzel Jakob committed
1137
1138
template <> class type_caster<bool> {
public:
1139
    bool load(handle src, bool convert) {
1140
1141
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1142
        else if (src.ptr() == Py_False) { value = false; return true; }
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
        else if (convert || !strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name)) {
            // (allow non-implicit conversion for numpy booleans)

            Py_ssize_t res = -1;
            if (src.is_none()) {
                res = 0;  // None is implicitly converted to False
            }
            #if defined(PYPY_VERSION)
            // On PyPy, check that "__bool__" (or "__nonzero__" on Python 2.7) attr exists
            else if (hasattr(src, PYBIND11_BOOL_ATTR)) {
                res = PyObject_IsTrue(src.ptr());
            }
            #else
            // Alternate approach for CPython: this does the same as the above, but optimized
            // using the CPython API so as to avoid an unneeded attribute lookup.
            else if (auto tp_as_number = src.ptr()->ob_type->tp_as_number) {
                if (PYBIND11_NB_BOOL(tp_as_number)) {
                    res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr());
                }
            }
            #endif
            if (res == 0 || res == 1) {
                value = (bool) res;
                return true;
            }
        }
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1170
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1171
1172
    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
1173
    }
1174
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1175
1176
};

1177
// Helper class for UTF-{8,16,32} C++ stl strings:
1178
1179
1180
template <typename StringType, bool IsView = false> struct string_caster {
    using CharT = typename StringType::value_type;

1181
    // Simplify life by being able to assume standard char sizes (the standard only guarantees
1182
    // minimums, but Python requires exact sizes)
1183
1184
1185
1186
1187
1188
1189
1190
    static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1");
    static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2");
    static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4");
    // wchar_t can be either 16 bits (Windows) or 32 (everywhere else)
    static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4,
            "Unsupported wchar_t size != 2/4");
    static constexpr size_t UTF_N = 8 * sizeof(CharT);

Wenzel Jakob's avatar
Wenzel Jakob committed
1191
    bool load(handle src, bool) {
eirrgang's avatar
eirrgang committed
1192
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
1193
        object temp;
1194
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1195
        handle load_src = src;
1196
1197
1198
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
eirrgang's avatar
eirrgang committed
1199
#if PY_MAJOR_VERSION >= 3
1200
            return load_bytes(load_src);
1201
#else
1202
1203
1204
1205
            if (sizeof(CharT) == 1) {
                return load_bytes(load_src);
            }

1206
            // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false
1207
1208
            if (!PYBIND11_BYTES_CHECK(load_src.ptr()))
                return false;
1209

1210
            temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
Wenzel Jakob's avatar
Wenzel Jakob committed
1211
1212
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
1213
#endif
1214
1215
1216
        }

        object utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString(
1217
            load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
1218
1219
1220
1221
1222
1223
        if (!utfNbytes) { PyErr_Clear(); return false; }

        const CharT *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
        size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
        if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32
        value = StringType(buffer, length);
1224
1225
1226

        // If we're loading a string_view we need to keep the encoded Python object alive:
        if (IsView)
1227
            loader_life_support::add_patient(utfNbytes);
1228

Wenzel Jakob's avatar
Wenzel Jakob committed
1229
1230
        return true;
    }
hulucc's avatar
hulucc committed
1231

1232
    static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
1233
        const char *buffer = reinterpret_cast<const char *>(src.data());
1234
        ssize_t nbytes = ssize_t(src.size() * sizeof(CharT));
1235
        handle s = decode_utfN(buffer, nbytes);
1236
1237
        if (!s) throw error_already_set();
        return s;
Wenzel Jakob's avatar
Wenzel Jakob committed
1238
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1239

1240
    PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME));
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251

private:
    static handle decode_utfN(const char *buffer, ssize_t nbytes) {
#if !defined(PYPY_VERSION)
        return
            UTF_N == 8  ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) :
            UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) :
                          PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
#else
        // PyPy seems to have multiple problems related to PyUnicode_UTF*: the UTF8 version
        // sometimes segfaults for unknown reasons, while the UTF16 and 32 versions require a
luzpaz's avatar
luzpaz committed
1252
        // non-const char * arguments, which is also a nuisance, so bypass the whole thing by just
1253
1254
1255
1256
        // passing the encoding as a string value, which works properly:
        return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr);
#endif
    }
1257

1258
1259
    // When loading into a std::string or char*, accept a bytes object as-is (i.e.
    // without any encoding/decoding attempt).  For other C++ char sizes this is a no-op.
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
    // which supports loading a unicode from a str, doesn't take this path.
    template <typename C = CharT>
    bool load_bytes(enable_if_t<sizeof(C) == 1, handle> src) {
        if (PYBIND11_BYTES_CHECK(src.ptr())) {
            // We were passed a Python 3 raw bytes; accept it into a std::string or char*
            // without any encoding attempt.
            const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr());
            if (bytes) {
                value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr()));
                return true;
            }
        }

        return false;
    }
1275

1276
1277
    template <typename C = CharT>
    bool load_bytes(enable_if_t<sizeof(C) != 1, handle>) { return false; }
hulucc's avatar
hulucc committed
1278
1279
};

1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
template <typename CharT, class Traits, class Allocator>
struct type_caster<std::basic_string<CharT, Traits, Allocator>, enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string<CharT, Traits, Allocator>> {};

#ifdef PYBIND11_HAS_STRING_VIEW
template <typename CharT, class Traits>
struct type_caster<std::basic_string_view<CharT, Traits>, enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string_view<CharT, Traits>, true> {};
#endif

1290
1291
1292
1293
1294
1295
1296
// Type caster for C-style strings.  We basically use a std::string type caster, but also add the
// ability to use None as a nullptr char* (which the string caster doesn't allow).
template <typename CharT> struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
    using StringType = std::basic_string<CharT>;
    using StringCaster = type_caster<StringType>;
    StringCaster str_caster;
    bool none = false;
1297
    CharT one_char = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1298
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1299
    bool load(handle src, bool convert) {
1300
1301
1302
1303
1304
1305
1306
1307
        if (!src) return false;
        if (src.is_none()) {
            // Defer accepting None to other overloads (if we aren't in convert mode):
            if (!convert) return false;
            none = true;
            return true;
        }
        return str_caster.load(src, convert);
1308
1309
    }

1310
1311
1312
    static handle cast(const CharT *src, return_value_policy policy, handle parent) {
        if (src == nullptr) return pybind11::none().inc_ref();
        return StringCaster::cast(StringType(src), policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
1313
1314
    }

1315
1316
1317
1318
1319
1320
1321
    static handle cast(CharT src, return_value_policy policy, handle parent) {
        if (std::is_same<char, CharT>::value) {
            handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
            if (!s) throw error_already_set();
            return s;
        }
        return StringCaster::cast(StringType(1, src), policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
1322
1323
    }

1324
    operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
1325
    operator CharT&() {
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
        if (none)
            throw value_error("Cannot convert None to a character");

        auto &value = static_cast<StringType &>(str_caster);
        size_t str_len = value.size();
        if (str_len == 0)
            throw value_error("Cannot convert empty string to a character");

        // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that
        // is too high, and one for multiple unicode characters (caught later), so we need to figure
        // out how long the first encoded character is in bytes to distinguish between these two
        // errors.  We also allow want to allow unicode characters U+0080 through U+00FF, as those
        // can fit into a single char value.
        if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) {
            unsigned char v0 = static_cast<unsigned char>(value[0]);
            size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127
                (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence
                (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence
                4; // 0b11110xxx - start of 4-byte sequence

            if (char0_bytes == str_len) {
                // If we have a 128-255 value, we can decode it into a single char:
                if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx
1349
1350
                    one_char = static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F));
                    return one_char;
1351
1352
1353
1354
1355
                }
                // Otherwise we have a single character, but it's > U+00FF
                throw value_error("Character code point not in range(0x100)");
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1356

1357
1358
1359
1360
        // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a
        // surrogate pair with total length 2 instantly indicates a range error (but not a "your
        // string was too long" error).
        else if (StringCaster::UTF_N == 16 && str_len == 2) {
1361
1362
            one_char = static_cast<CharT>(value[0]);
            if (one_char >= 0xD800 && one_char < 0xE000)
1363
1364
                throw value_error("Character code point not in range(0x10000)");
        }
1365

1366
1367
        if (str_len != 1)
            throw value_error("Expected a character, but multi-character string found");
hulucc's avatar
hulucc committed
1368

1369
1370
        one_char = value[0];
        return one_char;
Wenzel Jakob's avatar
Wenzel Jakob committed
1371
    }
hulucc's avatar
hulucc committed
1372

1373
    static constexpr auto name = _(PYBIND11_STRING_NAME);
1374
    template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>;
hulucc's avatar
hulucc committed
1375
1376
};

1377
// Base implementation for std::tuple and std::pair
1378
1379
1380
template <template<typename...> class Tuple, typename... Ts> class tuple_caster {
    using type = Tuple<Ts...>;
    static constexpr auto size = sizeof...(Ts);
1381
    using indices = make_index_sequence<size>;
1382
public:
1383

Wenzel Jakob's avatar
Wenzel Jakob committed
1384
    bool load(handle src, bool convert) {
1385
1386
1387
1388
        if (!isinstance<sequence>(src))
            return false;
        const auto seq = reinterpret_borrow<sequence>(src);
        if (seq.size() != size)
1389
            return false;
1390
        return load_impl(seq, convert, indices{});
1391
    }
1392

1393
1394
1395
    template <typename T>
    static handle cast(T &&src, return_value_policy policy, handle parent) {
        return cast_impl(std::forward<T>(src), policy, parent, indices{});
1396
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1397

1398
    static constexpr auto name = _("Tuple[") + concat(make_caster<Ts>::name...) + _("]");
Wenzel Jakob's avatar
Wenzel Jakob committed
1399

1400
1401
    template <typename T> using cast_op_type = type;

1402
1403
    operator type() & { return implicit_cast(indices{}); }
    operator type() && { return std::move(*this).implicit_cast(indices{}); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1404

Wenzel Jakob's avatar
Wenzel Jakob committed
1405
protected:
1406
    template <size_t... Is>
1407
    type implicit_cast(index_sequence<Is...>) & { return type(cast_op<Ts>(std::get<Is>(subcasters))...); }
1408
    template <size_t... Is>
1409
    type implicit_cast(index_sequence<Is...>) && { return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...); }
1410

1411
    static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1412

1413
    template <size_t... Is>
1414
    bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
1415
        for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...})
Wenzel Jakob's avatar
Wenzel Jakob committed
1416
1417
1418
1419
1420
1421
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
1422
1423
1424
1425
    template <typename T, size_t... Is>
    static handle cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence<Is...>) {
        std::array<object, size> entries{{
            reinterpret_steal<object>(make_caster<Ts>::cast(std::get<Is>(std::forward<T>(src)), policy, parent))...
Wenzel Jakob's avatar
Wenzel Jakob committed
1426
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
1427
1428
1429
1430
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
1431
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1432
1433
1434
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
1435
1436
    }

1437
    Tuple<make_caster<Ts>...> subcasters;
Wenzel Jakob's avatar
Wenzel Jakob committed
1438
1439
};

1440
1441
1442
template <typename T1, typename T2> class type_caster<std::pair<T1, T2>>
    : public tuple_caster<std::pair, T1, T2> {};

1443
1444
template <typename... Ts> class type_caster<std::tuple<Ts...>>
    : public tuple_caster<std::tuple, Ts...> {};
1445

1446
1447
1448
1449
1450
1451
1452
/// Helper class which abstracts away certain actions. Users can provide specializations for
/// custom holders, but it's only necessary if the type has a non-standard interface.
template <typename T>
struct holder_helper {
    static auto get(const T &p) -> decltype(p.get()) { return p.get(); }
};

Wenzel Jakob's avatar
Wenzel Jakob committed
1453
/// Type caster for holder types like std::shared_ptr, etc.
1454
1455
template <typename type, typename holder_type>
struct copyable_holder_caster : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
1456
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1457
    using base = type_caster_base<type>;
1458
1459
    static_assert(std::is_base_of<base, type_caster<type>>::value,
            "Holder classes are only supported for custom types");
Wenzel Jakob's avatar
Wenzel Jakob committed
1460
1461
1462
1463
    using base::base;
    using base::cast;
    using base::typeinfo;
    using base::value;
1464

1465
1466
    bool load(handle src, bool convert) {
        return base::template load_impl<copyable_holder_caster<type, holder_type>>(src, convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
1467
1468
    }

1469
1470
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
1471
    explicit operator holder_type*() { return std::addressof(holder); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1472

1473
1474
1475
1476
1477
1478
1479
    // 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
Wenzel Jakob's avatar
Wenzel Jakob committed
1480

1481
1482
1483
1484
    static handle cast(const holder_type &src, return_value_policy, handle) {
        const auto *ptr = holder_helper<holder_type>::get(src);
        return type_caster_base<type>::cast_holder(ptr, &src);
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1485

1486
1487
1488
1489
1490
protected:
    friend class type_caster_generic;
    void check_holder_compat() {
        if (typeinfo->default_holder)
            throw cast_error("Unable to load a custom holder type from a default-holder instance");
Wenzel Jakob's avatar
Wenzel Jakob committed
1491
1492
    }

1493
    bool load_value(value_and_holder &&v_h) {
1494
1495
        if (v_h.holder_constructed()) {
            value = v_h.value_ptr();
1496
            holder = v_h.template holder<holder_type>();
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
            return true;
        } else {
            throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
#if defined(NDEBUG)
                             "(compile in debug mode for type information)");
#else
                             "of type '" + type_id<holder_type>() + "''");
#endif
        }
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1508
1509
1510
1511
1512
1513
    template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle, bool) { return false; }

    template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle src, bool convert) {
        for (auto &cast : typeinfo->implicit_casts) {
1514
            copyable_holder_caster sub_caster(*cast.first);
Wenzel Jakob's avatar
Wenzel Jakob committed
1515
1516
1517
1518
1519
1520
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                holder = holder_type(sub_caster.holder, (type *) value);
                return true;
            }
        }
1521
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1522
    }
1523

1524
    static bool try_direct_conversions(handle) { return false; }
1525

1526

Wenzel Jakob's avatar
Wenzel Jakob committed
1527
1528
1529
    holder_type holder;
};

1530
1531
/// Specialize for the common std::shared_ptr, so users don't need to
template <typename T>
1532
1533
1534
1535
class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };

template <typename type, typename holder_type>
struct move_only_holder_caster {
1536
1537
1538
    static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
            "Holder classes are only supported for custom types");

1539
1540
    static handle cast(holder_type &&src, return_value_policy, handle) {
        auto *ptr = holder_helper<holder_type>::get(src);
1541
        return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
1542
    }
1543
    static constexpr auto name = type_caster_base<type>::name;
1544
1545
1546
1547
1548
1549
1550
};

template <typename type, typename deleter>
class type_caster<std::unique_ptr<type, deleter>>
    : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { };

template <typename type, typename holder_type>
1551
using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
1552
1553
                                         copyable_holder_caster<type, holder_type>,
                                         move_only_holder_caster<type, holder_type>>;
1554

1555
1556
template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };

1557
/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
1558
#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \
1559
1560
    namespace pybind11 { namespace detail { \
    template <typename type> \
1561
1562
    struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__>  { }; \
    template <typename type> \
1563
1564
1565
1566
    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
        : public type_caster_holder<type, holder_type> { }; \
    }}

1567
// PYBIND11_DECLARE_HOLDER_TYPE holder types:
1568
template <typename base, typename holder> struct is_holder_type :
1569
1570
1571
1572
    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
// Specialization for always-supported unique_ptr holders:
template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
    std::true_type {};
1573

1574
1575
1576
1577
template <typename T> struct handle_type_name { static constexpr auto name = _<T>(); };
template <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); };
template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
template <> struct handle_type_name<kwargs> { static constexpr auto name = _("**kwargs"); };
1578

1579
template <typename type>
1580
1581
1582
struct pyobject_caster {
    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
    bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); }
1583

1584
    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
1585
1586
1587
    bool load(handle src, bool /* convert */) {
        if (!isinstance<type>(src))
            return false;
1588
        value = reinterpret_borrow<type>(src);
1589
1590
        return true;
    }
1591

Wenzel Jakob's avatar
Wenzel Jakob committed
1592
1593
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1594
    }
1595
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
Wenzel Jakob's avatar
Wenzel Jakob committed
1596
1597
};

1598
1599
1600
template <typename T>
class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };

1601
1602
1603
1604
1605
1606
1607
1608
1609
// 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.
1610
1611
template <typename T> using move_is_plain_type = satisfies_none_of<T,
    std::is_void, std::is_pointer, std::is_reference, std::is_const
1612
>;
1613
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
1614
1615
template <typename T> struct move_always<T, enable_if_t<all_of<
    move_is_plain_type<T>,
1616
    negation<is_copy_constructible<T>>,
1617
    std::is_move_constructible<T>,
1618
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1619
>::value>> : std::true_type {};
1620
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
1621
1622
1623
1624
template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
    move_is_plain_type<T>,
    negation<move_always<T>>,
    std::is_move_constructible<T>,
1625
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1626
1627
>::value>> : std::true_type {};
template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
1628

1629
1630
1631
1632
1633
1634
// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
// reference or pointer to a local variable of the type_caster.  Basically, only
// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
// everything else returns a reference/pointer to a local variable.
template <typename type> using cast_is_temporary_value_reference = bool_constant<
    (std::is_reference<type>::value || std::is_pointer<type>::value) &&
Wenzel Jakob's avatar
Wenzel Jakob committed
1635
1636
    !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
    !std::is_same<intrinsic_t<type>, void>::value
1637
1638
>;

1639
1640
// When a value returned from a C++ function is being cast back to Python, we almost always want to
// force `policy = move`, regardless of the return value policy the function/method was declared
1641
// with.
1642
template <typename Return, typename SFINAE = void> struct return_value_policy_override {
1643
1644
1645
1646
1647
    static return_value_policy policy(return_value_policy p) { return p; }
};

template <typename Return> struct return_value_policy_override<Return,
        detail::enable_if_t<std::is_base_of<type_caster_generic, make_caster<Return>>::value, void>> {
1648
    static return_value_policy policy(return_value_policy p) {
1649
1650
1651
        return !std::is_lvalue_reference<Return>::value &&
               !std::is_pointer<Return>::value
                   ? return_value_policy::move : p;
1652
1653
1654
    }
};

1655
// Basic python -> C++ casting; throws if casting fails
Jason Rhinelander's avatar
Jason Rhinelander committed
1656
template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1657
1658
1659
1660
1661
    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 " +
1662
            (std::string) str(handle.get_type()) + " to C++ type '" + type_id<T>() + "'");
1663
1664
#endif
    }
1665
1666
    return conv;
}
1667
1668
1669
1670
1671
1672
// Wrapper around the above that also constructs and returns a type_caster
template <typename T> make_caster<T> load_type(const handle &handle) {
    make_caster<T> conv;
    load_type(conv, handle);
    return conv;
}
1673
1674
1675

NAMESPACE_END(detail)

1676
// pytype -> C++ type
1677
1678
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
T cast(const handle &handle) {
1679
1680
    using namespace detail;
    static_assert(!cast_is_temporary_value_reference<T>::value,
1681
            "Unable to cast type to reference: value is local to type caster");
1682
    return cast_op<T>(load_type<T>(handle));
Wenzel Jakob's avatar
Wenzel Jakob committed
1683
1684
}

1685
// pytype -> pytype (calls converting constructor)
1686
template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
1687
T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); }
1688

1689
// C++ type -> py::object
1690
1691
1692
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
object cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference,
            handle parent = handle()) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1693
1694
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
1695
1696
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
1697
    return reinterpret_steal<object>(detail::make_caster<T>::cast(value, policy, parent));
Wenzel Jakob's avatar
Wenzel Jakob committed
1698
1699
}

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

1703
template <typename T>
1704
detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
1705
1706
1707
1708
1709
    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
1710
        throw cast_error("Unable to move from Python " + (std::string) str(obj.get_type()) +
1711
1712
1713
1714
                " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
#endif

    // Move into a temporary and return that, because the reference may be a local value of `conv`
1715
    T ret = std::move(detail::load_type<T>(obj).operator T&());
1716
1717
1718
1719
1720
1721
1722
1723
    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.
1724
template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1725
1726
    return move<T>(std::move(object));
}
1727
template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1728
1729
1730
1731
1732
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
1733
template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1734
1735
1736
1737
1738
1739
1740
1741
    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; }

1742
1743
NAMESPACE_BEGIN(detail)

1744
1745
1746
1747
// Declared in pytypes.h:
template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
object object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); }

1748
1749
1750
struct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro
template <typename ret_type> using overload_caster_t = conditional_t<
    cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>;
1751
1752
1753

// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
// store the result in the given variable.  For other types, this is a no-op.
1754
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
1755
    return cast_op<T>(load_type(caster, o));
1756
}
1757
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
    pybind11_fail("Internal error: cast_ref fallback invoked"); }

// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
// cases where pybind11::cast is valid.
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
    return pybind11::cast<T>(std::move(o)); }
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
    pybind11_fail("Internal error: cast_safe fallback invoked"); }
template <> inline void cast_safe<void>(object &&) {}

NAMESPACE_END(detail)
1770

1771
1772
1773
template <return_value_policy policy = return_value_policy::automatic_reference>
tuple make_tuple() { return tuple(0); }

1774
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
1775
          typename... Args> tuple make_tuple(Args&&... args_) {
1776
    constexpr size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
1777
    std::array<object, size> args {
1778
1779
        { reinterpret_steal<object>(detail::make_caster<Args>::cast(
            std::forward<Args>(args_), policy, nullptr))... }
Wenzel Jakob's avatar
Wenzel Jakob committed
1780
    };
1781
1782
    for (size_t i = 0; i < args.size(); i++) {
        if (!args[i]) {
1783
1784
1785
#if defined(NDEBUG)
            throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
Ivan Smirnov's avatar
Ivan Smirnov committed
1786
            std::array<std::string, size> argtypes { {type_id<Args>()...} };
1787
1788
            throw cast_error("make_tuple(): unable to convert argument of type '" +
                argtypes[i] + "' to Python object");
1789
1790
1791
#endif
        }
    }
1792
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
1793
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1794
    for (auto &arg_value : args)
1795
1796
1797
1798
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

1799
/// \ingroup annotations
1800
/// Annotation for arguments
1801
struct arg {
1802
    /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument.
1803
    constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { }
1804
    /// Assign a value to this argument
1805
    template <typename T> arg_v operator=(T &&value) const;
1806
1807
    /// Indicate that the type should not be converted in the type caster
    arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; }
1808
1809
    /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args)
    arg &none(bool flag = true) { flag_none = flag; return *this; }
1810

1811
1812
    const char *name; ///< If non-null, this is a named kwargs argument
    bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!)
1813
    bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument
1814
1815
};

1816
/// \ingroup annotations
1817
/// Annotation for arguments with values
1818
struct arg_v : arg {
1819
private:
1820
    template <typename T>
1821
1822
    arg_v(arg &&base, T &&x, const char *descr = nullptr)
        : arg(base),
1823
1824
1825
          value(reinterpret_steal<object>(
              detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
          )),
1826
1827
1828
1829
1830
1831
          descr(descr)
#if !defined(NDEBUG)
        , type(type_id<T>())
#endif
    { }

1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
public:
    /// Direct construction with name, default, and description
    template <typename T>
    arg_v(const char *name, T &&x, const char *descr = nullptr)
        : arg_v(arg(name), std::forward<T>(x), descr) { }

    /// Called internally when invoking `py::arg("a") = value`
    template <typename T>
    arg_v(const arg &base, T &&x, const char *descr = nullptr)
        : arg_v(arg(base), std::forward<T>(x), descr) { }

    /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg&
    arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; }
1845
1846
1847

    /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg&
    arg_v &none(bool flag = true) { arg::none(flag); return *this; }
1848
1849

    /// The default value
1850
    object value;
1851
    /// The (optional) description of the default value
1852
1853
    const char *descr;
#if !defined(NDEBUG)
1854
    /// The C++ type name of the default value (only available when compiled in debug mode)
1855
1856
1857
1858
1859
    std::string type;
#endif
};

template <typename T>
1860
arg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward<T>(value)}; }
1861

Wenzel Jakob's avatar
Wenzel Jakob committed
1862
/// Alias for backward compatibility -- to be removed in version 2.0
1863
1864
1865
template <typename /*unused*/> using arg_t = arg_v;

inline namespace literals {
1866
1867
1868
/** \rst
    String literal version of `arg`
 \endrst */
1869
1870
1871
constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
}

1872
NAMESPACE_BEGIN(detail)
1873

1874
// forward declaration (definition in attr.h)
1875
1876
struct function_record;

1877
1878
/// Internal data associated with a single function call
struct function_call {
1879
    function_call(const function_record &f, handle p); // Implementation in attr.h
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889

    /// The function data:
    const function_record &func;

    /// Arguments passed to the function:
    std::vector<handle> args;

    /// The `convert` value the arguments should be loaded with
    std::vector<bool> args_convert;

1890
1891
1892
1893
    /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if
    /// present, are also in `args` but without a reference).
    object args_ref, kwargs_ref;

1894
1895
    /// The parent, if any
    handle parent;
1896
1897
1898

    /// If this is a call to an initializer, this argument contains `self`
    handle init_self;
1899
1900
1901
};


1902
1903
1904
/// Helper class which loads arguments for C++ functions called from Python
template <typename... Args>
class argument_loader {
1905
    using indices = make_index_sequence<sizeof...(Args)>;
1906

1907
1908
1909
1910
1911
1912
1913
1914
1915
    template <typename Arg> using argument_is_args   = std::is_same<intrinsic_t<Arg>, args>;
    template <typename Arg> using argument_is_kwargs = std::is_same<intrinsic_t<Arg>, kwargs>;
    // Get args/kwargs argument positions relative to the end of the argument list:
    static constexpr auto args_pos = constexpr_first<argument_is_args, Args...>() - (int) sizeof...(Args),
                        kwargs_pos = constexpr_first<argument_is_kwargs, Args...>() - (int) sizeof...(Args);

    static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1;

    static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function");
Jason Rhinelander's avatar
Jason Rhinelander committed
1916

1917
public:
1918
1919
    static constexpr bool has_kwargs = kwargs_pos < 0;
    static constexpr bool has_args = args_pos < 0;
1920

1921
    static constexpr auto arg_names = concat(type_descr(make_caster<Args>::name)...);
1922

1923
1924
    bool load_args(function_call &call) {
        return load_impl_sequence(call, indices{});
1925
1926
    }

Dean Moldovan's avatar
Dean Moldovan committed
1927
    template <typename Return, typename Guard, typename Func>
1928
1929
    enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
1930
1931
    }

Dean Moldovan's avatar
Dean Moldovan committed
1932
    template <typename Return, typename Guard, typename Func>
1933
1934
    enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) && {
        std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
1935
1936
1937
1938
1939
        return void_type();
    }

private:

1940
    static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
1941
1942

    template <size_t... Is>
1943
    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
1944
        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
1945
1946
1947
1948
1949
            if (!r)
                return false;
        return true;
    }

Dean Moldovan's avatar
Dean Moldovan committed
1950
1951
    template <typename Return, typename Func, size_t... Is, typename Guard>
    Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) {
1952
        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
1953
1954
    }

1955
    std::tuple<make_caster<Args>...> argcasters;
1956
1957
};

1958
1959
1960
1961
1962
1963
/// 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>
1964
    explicit simple_collector(Ts &&...values)
1965
1966
1967
1968
1969
1970
1971
1972
1973
        : 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 {
1974
        PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
1975
1976
        if (!result)
            throw error_already_set();
1977
        return reinterpret_steal<object>(result);
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
    }

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>
1989
    explicit unpacking_collector(Ts &&...values) {
1990
1991
1992
1993
1994
1995
        // 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(_);

1996
        m_args = std::move(args_list);
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
    }

    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 {
2007
        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
2008
2009
        if (!result)
            throw error_already_set();
2010
        return reinterpret_steal<object>(result);
2011
2012
2013
2014
2015
    }

private:
    template <typename T>
    void process(list &args_list, T &&x) {
2016
        auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
        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) {
2028
        for (const auto &a : ap)
2029
            args_list.append(a);
2030
2031
    }

2032
    void process(list &/*args_list*/, arg_v a) {
2033
2034
2035
2036
2037
2038
2039
        if (!a.name)
#if defined(NDEBUG)
            nameless_argument_error();
#else
            nameless_argument_error(a.type);
#endif

2040
        if (m_kwargs.contains(a.name)) {
2041
2042
2043
2044
2045
2046
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
2047
        if (!a.value) {
2048
2049
2050
#if defined(NDEBUG)
            argument_cast_error();
#else
2051
            argument_cast_error(a.name, a.type);
2052
2053
#endif
        }
2054
        m_kwargs[a.name] = a.value;
2055
2056
2057
    }

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
2058
2059
        if (!kp)
            return;
2060
        for (const auto &k : reinterpret_borrow<dict>(kp)) {
2061
            if (m_kwargs.contains(k.first)) {
2062
2063
2064
#if defined(NDEBUG)
                multiple_values_error();
#else
2065
                multiple_values_error(str(k.first));
2066
2067
2068
2069
2070
2071
#endif
            }
            m_kwargs[k.first] = k.second;
        }
    }

2072
2073
2074
2075
2076
2077
2078
2079
2080
    [[noreturn]] static void nameless_argument_error() {
        throw type_error("Got kwargs without a name; only named arguments "
                         "may be passed via py::arg() to a python function call. "
                         "(compile in debug mode for details)");
    }
    [[noreturn]] static void nameless_argument_error(std::string type) {
        throw type_error("Got kwargs without a name of type '" + type + "'; only named "
                         "arguments may be passed via py::arg() to a python function call. ");
    }
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
    [[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,
2107
          typename = enable_if_t<all_of<is_positional<Args>...>::value>>
2108
simple_collector<policy> collect_arguments(Args &&...args) {
2109
    return simple_collector<policy>(std::forward<Args>(args)...);
2110
2111
2112
2113
}

/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
template <return_value_policy policy, typename... Args,
2114
          typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
2115
2116
2117
2118
2119
2120
2121
2122
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"
    );
2123
    return unpacking_collector<policy>(std::forward<Args>(args)...);
2124
2125
}

2126
template <typename Derived>
2127
template <return_value_policy policy, typename... Args>
2128
2129
object object_api<Derived>::operator()(Args &&...args) const {
    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
2130
2131
}

2132
2133
2134
template <typename Derived>
template <return_value_policy policy, typename... Args>
object object_api<Derived>::call(Args &&...args) const {
2135
    return operator()<policy>(std::forward<Args>(args)...);
2136
2137
}

2138
2139
NAMESPACE_END(detail)

2140
#define PYBIND11_MAKE_OPAQUE(...) \
Wenzel Jakob's avatar
Wenzel Jakob committed
2141
    namespace pybind11 { namespace detail { \
2142
        template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \
Wenzel Jakob's avatar
Wenzel Jakob committed
2143
2144
    }}

2145
2146
2147
2148
/// Lets you pass a type containing a `,` through a macro parameter without needing a separate
/// typedef, e.g.: `PYBIND11_OVERLOAD(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)`
#define PYBIND11_TYPE(...) __VA_ARGS__

2149
NAMESPACE_END(PYBIND11_NAMESPACE)