cast.h 92.2 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
36
37
38
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
#  define PYBIND11_HAS_U8STRING
#endif

39
40
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
PYBIND11_NAMESPACE_BEGIN(detail)
41

42
43
44
// Forward-declaration; see detail/class.h
std::string get_fully_qualified_tp_name(PyTypeObject*);

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/// 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)
65
        if (stack.capacity() > 16 && !stack.empty() && stack.capacity() / stack.size() > 2)
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
            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");
        }
    }
};

92
93
94
95
96
97
98
99
100
101
102
// 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
103
    auto const &type_dict = get_internals().registered_types_py;
104
105
106
107
108
109
    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
110
        auto it = type_dict.find(type);
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
        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
132
                // `check` when adding just one base (which is typical--i.e. when there is no
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
167
168
                // 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);
169
    if (bases.empty())
170
171
172
173
        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
174
175
}

176
inline detail::type_info *get_local_type_info(const std::type_index &tp) {
177
    auto &locals = registered_local_types_cpp();
178
    auto it = locals.find(tp);
179
    if (it != locals.end())
180
        return it->second;
181
182
183
184
185
186
187
    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())
188
        return it->second;
189
190
191
192
193
194
195
196
197
198
199
    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
200
201
202
203
204
    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
205
206
207
    return nullptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
208
209
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
210
211
212
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

213
struct value_and_holder {
214
215
216
217
    instance *inst = nullptr;
    size_t index = 0u;
    const detail::type_info *type = nullptr;
    void **vh = nullptr;
218

219
    // Main constructor for a found value/holder:
220
221
222
223
224
    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]}
    {}

225
    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
226
    value_and_holder() = default;
227

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
    // 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
243
            : inst->nonsimple.status[index] & instance::status_holder_constructed;
244
    }
245
    void set_holder_constructed(bool v = true) {
246
        if (inst->simple_layout)
247
248
            inst->simple_holder_constructed = v;
        else if (v)
249
            inst->nonsimple.status[index] |= instance::status_holder_constructed;
250
251
        else
            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
252
253
254
255
256
257
    }
    bool instance_registered() const {
        return inst->simple_layout
            ? inst->simple_instance_registered
            : inst->nonsimple.status[index] & instance::status_instance_registered;
    }
258
    void set_instance_registered(bool v = true) {
259
        if (inst->simple_layout)
260
261
            inst->simple_instance_registered = v;
        else if (v)
262
            inst->nonsimple.status[index] |= instance::status_instance_registered;
263
264
        else
            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
    }
};

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

307
    iterator begin() { return iterator(inst, &tinfo); }
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
    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.
 */
329
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*/) {
330
331
332
333
334
335
336
337
338
    // 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;

339
340
341
    if (!throw_if_missing)
        return value_and_holder();

342
343
344
345
346
347
#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: `" +
348
349
            get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" +
            get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
#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;
368
        simple_instance_registered = false;
369
370
371
372
373
374
375
376
377
378
379
380
    }
    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;
381
        space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
382
383
384
385
386
387
388
389
390
391
392
393
394
395

        // 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
396
        nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
397
398
399
400
401
402
403
404
405
    }
    owned = true;
}

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

406
PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
Wenzel Jakob's avatar
Wenzel Jakob committed
407
    handle type = detail::get_type_handle(tp, false);
408
409
    if (!type)
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
410
    return isinstance(obj, type);
411
412
}

Wenzel Jakob's avatar
Wenzel Jakob committed
413
PYBIND11_NOINLINE inline std::string error_string() {
414
415
416
417
418
    if (!PyErr_Occurred()) {
        PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
        return "Unknown internal error occurred";
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
419
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
420

421
    std::string errorString;
Wenzel Jakob's avatar
Wenzel Jakob committed
422
423
    if (scope.type) {
        errorString += handle(scope.type).attr("__name__").cast<std::string>();
Wenzel Jakob's avatar
Wenzel Jakob committed
424
425
        errorString += ": ";
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
426
    if (scope.value)
427
        errorString += (std::string) str(scope.value);
Wenzel Jakob's avatar
Wenzel Jakob committed
428

429
430
    PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);

431
432
433
434
435
#if PY_MAJOR_VERSION >= 3
    if (scope.trace != nullptr)
        PyException_SetTraceback(scope.value, scope.trace);
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
436
#if !defined(PYPY_VERSION)
437
    if (scope.trace) {
438
        auto *trace = (PyTracebackObject *) scope.trace;
439
440
441
442
443
444
445
446
447
448
449
450
451
452

        /* 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;
453
454
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
455
#endif
456

Wenzel Jakob's avatar
Wenzel Jakob committed
457
458
459
    return errorString;
}

460
461
462
463
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) {
464
        for (const auto &vh : values_and_holders(it->second)) {
465
466
467
            if (vh.type == type)
                return handle((PyObject *) it->second);
        }
468
469
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
470
471
}

472
inline PyThreadState *get_thread_state_unchecked() {
Wenzel Jakob's avatar
Wenzel Jakob committed
473
474
475
#if defined(PYPY_VERSION)
    return PyThreadState_GET();
#elif PY_VERSION_HEX < 0x03000000
476
477
478
479
480
481
482
483
484
485
    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
}

486
// Forward declarations
487
inline void keep_alive_impl(handle nurse, handle patient);
488
inline PyObject *make_new_instance(PyTypeObject *type);
489

Wenzel Jakob's avatar
Wenzel Jakob committed
490
491
492
class type_caster_generic {
public:
    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
493
        : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
Wenzel Jakob's avatar
Wenzel Jakob committed
494

495
496
    type_caster_generic(const type_info *typeinfo)
        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { }
497

498
499
    bool load(handle src, bool convert) {
        return load_impl<type_caster_generic>(src, convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
500
501
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
502
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
503
                                         const detail::type_info *tinfo,
Wenzel Jakob's avatar
Wenzel Jakob committed
504
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
505
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
506
                                         const void *existing_holder = nullptr) {
507
        if (!tinfo) // no type info: error will be set already
Wenzel Jakob's avatar
Wenzel Jakob committed
508
509
            return handle();

510
511
512
        void *src = const_cast<void *>(_src);
        if (src == nullptr)
            return none().release();
513

514
        auto it_instances = get_internals().registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
515
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
516
            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
517
                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
518
519
                    return handle((PyObject *) it_i->second).inc_ref();
            }
520
521
        }

522
        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
523
        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
524
        wrapper->owned = false;
525
        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
526
527

        switch (policy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
528
529
            case return_value_policy::automatic:
            case return_value_policy::take_ownership:
530
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
531
532
533
534
535
                wrapper->owned = true;
                break;

            case return_value_policy::automatic_reference:
            case return_value_policy::reference:
536
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
537
538
539
540
541
                wrapper->owned = false;
                break;

            case return_value_policy::copy:
                if (copy_constructor)
542
                    valueptr = copy_constructor(src);
543
544
545
546
547
548
549
550
551
552
553
                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
554
555
556
557
558
                wrapper->owned = true;
                break;

            case return_value_policy::move:
                if (move_constructor)
559
                    valueptr = move_constructor(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
560
                else if (copy_constructor)
561
                    valueptr = copy_constructor(src);
562
563
564
565
566
567
568
569
570
571
572
573
                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
574
575
576
577
                wrapper->owned = true;
                break;

            case return_value_policy::reference_internal:
578
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
579
                wrapper->owned = false;
580
                keep_alive_impl(inst, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
581
582
583
584
                break;

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

587
        tinfo->init_instance(wrapper, existing_holder);
588

Wenzel Jakob's avatar
Wenzel Jakob committed
589
        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
590
591
    }

592
    // Base methods for generic caster; there are overridden in copyable_holder_caster
593
594
595
596
597
    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;
598
599
600
            if (type->operator_new) {
                vptr = type->operator_new(type->type_size);
            } else {
601
                #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
602
603
                    if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
                        vptr = ::operator new(type->type_size,
604
                                              std::align_val_t(type->type_align));
605
606
607
608
                    else
                #endif
                vptr = ::operator new(type->type_size);
            }
609
610
        }
        value = vptr;
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
    }
    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() {}

631
632
633
634
635
636
637
638
639
640
    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) {
641
        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
642
        const auto pytype = type::handle_of(src);
643
644
645
646
647
648
        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
649
            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype)))
650
651
652
653
654
655
656
657
658
            return false;

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

659
660
661
662
663
    // 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) {
664
665
        if (!src) return false;
        if (!typeinfo) return try_load_foreign_module_local(src);
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
714
715
716
717
718
719
720
        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) {
721
722
723
                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
                if (load_impl<ThisT>(temp, false)) {
                    loader_life_support::add_patient(temp);
724
                    return true;
725
                }
726
727
728
729
            }
            if (this_.try_direct_conversions(src))
                return true;
        }
730
731
732
733
734
735
736
737
738
739
740

        // 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);
741
742
743
    }


744
745
746
747
    // 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(
748
            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
749
750
        if (auto *tpi = get_type_info(cast_type))
            return {src, const_cast<const type_info *>(tpi)};
751
752

        // Not found, set error:
753
        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
754
755
756
757
758
759
        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
760
    const type_info *typeinfo = nullptr;
761
    const std::type_info *cpptype = nullptr;
762
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
763
764
};

765
766
767
768
769
770
771
/**
 * 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.
 */
772
template <typename T>
773
using cast_op_type =
774
    conditional_t<std::is_pointer<remove_reference_t<T>>::value,
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
        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>>;
792

793
794
795
796
797
798
799
// 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.
800
801
template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
        std::is_copy_constructible<Container>,
802
803
804
        std::is_same<typename Container::value_type &, typename Container::reference>,
        // Avoid infinite recursion
        negation<std::is_same<Container, typename Container::value_type>>
805
806
    >::value>> : is_copy_constructible<typename Container::value_type> {};

807
808
809
// Likewise for std::pair
// (after C++17 it is mandatory that the copy constructor not exist when the two types aren't themselves
// copy constructible, but this can not be relied upon when T1 or T2 are themselves containers).
810
811
template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
812
813
814
815
816
817
818
819
820

// The same problems arise with std::is_copy_assignable, so we use the same workaround.
template <typename T, typename SFINAE = void> struct is_copy_assignable : std::is_copy_assignable<T> {};
template <typename Container> struct is_copy_assignable<Container, enable_if_t<all_of<
        std::is_copy_assignable<Container>,
        std::is_same<typename Container::value_type &, typename Container::reference>
    >::value>> : is_copy_assignable<typename Container::value_type> {};
template <typename T1, typename T2> struct is_copy_assignable<std::pair<T1, T2>>
    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
821

822
PYBIND11_NAMESPACE_END(detail)
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840

// 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.)
841
842
843
844
//
// polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with
// std::enable_if. User provided specializations will always have higher priority than
// the default implementation and specialization provided in polymorphic_type_hook_base.
845
template <typename itype, typename SFINAE = void>
846
struct polymorphic_type_hook_base
847
848
849
850
{
    static const void *get(const itype *src, const std::type_info*&) { return src; }
};
template <typename itype>
851
struct polymorphic_type_hook_base<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>>
852
853
854
855
856
857
{
    static const void *get(const itype *src, const std::type_info*& type) {
        type = src ? &typeid(*src) : nullptr;
        return dynamic_cast<const void*>(src);
    }
};
858
859
template <typename itype, typename SFINAE = void>
struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
860

861
PYBIND11_NAMESPACE_BEGIN(detail)
862

863
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
864
template <typename type> class type_caster_base : public type_caster_generic {
865
    using itype = intrinsic_t<type>;
866

867
public:
868
    static constexpr auto name = _<type>();
869

Wenzel Jakob's avatar
Wenzel Jakob committed
870
    type_caster_base() : type_caster_base(typeid(type)) { }
871
    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
872

873
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
874
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
875
            policy = return_value_policy::copy;
876
        return cast(&src, policy, parent);
877
878
    }

879
880
    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
881
882
    }

883
884
885
    // 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.
886
    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
887
        auto &cast_type = typeid(itype);
888
        const std::type_info *instance_type = nullptr;
889
890
891
892
893
894
895
896
897
898
899
900
        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};
901
902
903
        }
        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
        // don't do a cast
904
        return type_caster_generic::src_and_type(src, cast_type, instance_type);
905
906
    }

907
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
908
        auto st = src_and_type(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
909
        return type_caster_generic::cast(
910
            st.first, policy, parent, st.second,
911
            make_copy_constructor(src), make_move_constructor(src));
912
913
    }

914
    static handle cast_holder(const itype *src, const void *holder) {
915
        auto st = src_and_type(src);
916
        return type_caster_generic::cast(
917
            st.first, return_value_policy::take_ownership, {}, st.second,
918
919
920
            nullptr, nullptr, holder);
    }

921
    template <typename T> using cast_op_type = detail::cast_op_type<T>;
922

923
924
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
925

926
protected:
927
928
    using Constructor = void *(*)(const void *);

929
    /* Only enabled when the types are {copy,move}-constructible *and* when the type
930
931
932
933
934
935
936
937
938
       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>>
939
    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
940
941
942
943
        return [](const void *arg) -> void * {
            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
        };
    }
944

945
946
    static Constructor make_copy_constructor(...) { return nullptr; }
    static Constructor make_move_constructor(...) { return nullptr; }
947
948
};

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

952
// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
953
template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
954
955
    return caster.operator typename make_caster<T>::template cast_op_type<T>();
}
956
957
958
959
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>();
960
961
}

962
963
964
965
966
967
968
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");
969
public:
970
    bool load(handle src, bool convert) { return subcaster.load(src, convert); }
971
    static constexpr auto name = caster_t::name;
972
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
973
974
975
976
        // 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);
977
    }
978
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
979
    operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type&(); }
980
981
};

982
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
983
984
985
    protected: \
        type value; \
    public: \
986
        static constexpr auto name = py_name; \
987
988
        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) { \
989
            if (!src) return none().release(); \
990
991
992
993
994
            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
995
996
        } \
        operator type*() { return &value; } \
997
        operator type&() { return value; } \
998
        operator type&&() && { return std::move(value); } \
999
        template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
Wenzel Jakob's avatar
Wenzel Jakob committed
1000

1001

1002
1003
template <typename CharT> using is_std_char_type = any_of<
    std::is_same<CharT, char>, /* std::string */
1004
1005
1006
#if defined(PYBIND11_HAS_U8STRING)
    std::is_same<CharT, char8_t>, /* std::u8string */
#endif
1007
1008
1009
1010
1011
    std::is_same<CharT, char16_t>, /* std::u16string */
    std::is_same<CharT, char32_t>, /* std::u32string */
    std::is_same<CharT, wchar_t> /* std::wstring */
>;

1012

Wenzel Jakob's avatar
Wenzel Jakob committed
1013
template <typename T>
1014
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
1015
1016
1017
    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
1018
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1019

1020
    bool load(handle src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1021
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
1022

1023
        if (!src)
1024
            return false;
1025
1026
1027
1028
1029
1030

        if (std::is_floating_point<T>::value) {
            if (convert || PyFloat_Check(src.ptr()))
                py_value = (py_type) PyFloat_AsDouble(src.ptr());
            else
                return false;
1031
1032
1033
1034
1035
1036
1037
1038
        } 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
1039
1040
        }

1041
        // Python API reported an error
1042
        bool py_err = py_value == (py_type) -1 && PyErr_Occurred();
1043

1044
1045
1046
        // Check to see if the conversion is valid (integers should match exactly)
        // Signed/unsigned checks happen elsewhere
        if (py_err || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) && py_value != (py_type) (T) py_value)) {
1047
            bool type_error = py_err && PyErr_ExceptionMatches(
1048
#if PY_VERSION_HEX < 0x03000000 && !defined(PYPY_VERSION)
1049
                PyExc_SystemError
1050
#else
1051
                PyExc_TypeError
1052
#endif
1053
            );
Wenzel Jakob's avatar
Wenzel Jakob committed
1054
            PyErr_Clear();
1055
            if (type_error && convert && PyNumber_Check(src.ptr())) {
1056
1057
1058
                auto tmp = reinterpret_steal<object>(std::is_floating_point<T>::value
                                                     ? PyNumber_Float(src.ptr())
                                                     : PyNumber_Long(src.ptr()));
1059
1060
1061
                PyErr_Clear();
                return load(tmp, false);
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
1062
1063
            return false;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1064

Wenzel Jakob's avatar
Wenzel Jakob committed
1065
1066
1067
1068
        value = (T) py_value;
        return true;
    }

1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
    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
1097
1098
    }

1099
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1100
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1101

1102
template<typename T> struct void_caster {
Wenzel Jakob's avatar
Wenzel Jakob committed
1103
public:
1104
1105
1106
1107
1108
    bool load(handle src, bool) {
        if (src && src.is_none())
            return true;
        return false;
    }
1109
    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1110
        return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1111
    }
1112
    PYBIND11_TYPE_CASTER(T, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1113
1114
};

1115
1116
template <> class type_caster<void_type> : public void_caster<void_type> {};

1117
1118
1119
1120
1121
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
1122
1123
        if (!h) {
            return false;
1124
        } else if (h.is_none()) {
1125
1126
1127
            value = nullptr;
            return true;
        }
1128
1129

        /* Check if this is a capsule */
1130
        if (isinstance<capsule>(h)) {
1131
            value = reinterpret_borrow<capsule>(h);
1132
1133
1134
1135
            return true;
        }

        /* Check if this is a C++ type */
1136
        auto &bases = all_type_info((PyTypeObject *) type::handle_of(h).ptr());
1137
1138
        if (bases.size() == 1) { // Only allowing loading from a single-value type
            value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
1139
1140
1141
1142
1143
            return true;
        }

        /* Fail */
        return false;
1144
1145
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1146
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
1147
1148
1149
        if (ptr)
            return capsule(ptr).release();
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
1150
            return none().inc_ref();
1151
    }
1152

1153
1154
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
1155
    static constexpr auto name = _("capsule");
1156
private:
1157
    void *value = nullptr;
1158
1159
};

1160
template <> class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> { };
1161

Wenzel Jakob's avatar
Wenzel Jakob committed
1162
1163
template <> class type_caster<bool> {
public:
1164
    bool load(handle src, bool convert) {
1165
1166
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1167
        else if (src.ptr() == Py_False) { value = false; return true; }
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
        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;
1192
1193
            } else {
                PyErr_Clear();
1194
1195
1196
            }
        }
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1197
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1198
1199
    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
1200
    }
1201
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1202
1203
};

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

1208
    // Simplify life by being able to assume standard char sizes (the standard only guarantees
1209
    // minimums, but Python requires exact sizes)
1210
    static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1");
1211
1212
1213
#if defined(PYBIND11_HAS_U8STRING)
    static_assert(!std::is_same<CharT, char8_t>::value || sizeof(CharT) == 1, "Unsupported char8_t size != 1");
#endif
1214
1215
1216
1217
1218
1219
1220
    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
1221
    bool load(handle src, bool) {
eirrgang's avatar
eirrgang committed
1222
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
1223
        object temp;
1224
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1225
        handle load_src = src;
1226
1227
1228
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
eirrgang's avatar
eirrgang committed
1229
#if PY_MAJOR_VERSION >= 3
1230
            return load_bytes(load_src);
1231
#else
1232
            if (std::is_same<CharT, char>::value) {
1233
1234
1235
                return load_bytes(load_src);
            }

1236
            // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false
1237
1238
            if (!PYBIND11_BYTES_CHECK(load_src.ptr()))
                return false;
1239

1240
            temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
Wenzel Jakob's avatar
Wenzel Jakob committed
1241
1242
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
1243
#endif
1244
1245
1246
        }

        object utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString(
1247
            load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
1248
1249
        if (!utfNbytes) { PyErr_Clear(); return false; }

1250
        const auto *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
1251
1252
1253
        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);
1254
1255
1256

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

Wenzel Jakob's avatar
Wenzel Jakob committed
1259
1260
        return true;
    }
hulucc's avatar
hulucc committed
1261

1262
    static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
1263
        const char *buffer = reinterpret_cast<const char *>(src.data());
1264
        auto nbytes = ssize_t(src.size() * sizeof(CharT));
1265
        handle s = decode_utfN(buffer, nbytes);
1266
1267
        if (!s) throw error_already_set();
        return s;
Wenzel Jakob's avatar
Wenzel Jakob committed
1268
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1269

1270
    PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME));
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281

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
1282
        // non-const char * arguments, which is also a nuisance, so bypass the whole thing by just
1283
1284
1285
1286
        // 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
    }
1287

1288
1289
    // 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.
1290
1291
    // which supports loading a unicode from a str, doesn't take this path.
    template <typename C = CharT>
1292
    bool load_bytes(enable_if_t<std::is_same<C, char>::value, handle> src) {
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
        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;
    }
1305

1306
    template <typename C = CharT>
1307
    bool load_bytes(enable_if_t<!std::is_same<C, char>::value, handle>) { return false; }
hulucc's avatar
hulucc committed
1308
1309
};

1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
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

1320
1321
1322
1323
1324
1325
1326
// 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;
1327
    CharT one_char = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1328
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1329
    bool load(handle src, bool convert) {
1330
1331
1332
1333
1334
1335
1336
1337
        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);
1338
1339
    }

1340
1341
1342
    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
1343
1344
    }

1345
1346
1347
1348
1349
1350
1351
    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
1352
1353
    }

1354
    operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
1355
    operator CharT&() {
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
        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) {
1370
            auto v0 = static_cast<unsigned char>(value[0]);
1371
1372
1373
1374
1375
1376
1377
1378
            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
1379
1380
                    one_char = static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F));
                    return one_char;
1381
1382
1383
1384
1385
                }
                // 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
1386

1387
1388
1389
1390
        // 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) {
1391
1392
            one_char = static_cast<CharT>(value[0]);
            if (one_char >= 0xD800 && one_char < 0xE000)
1393
1394
                throw value_error("Character code point not in range(0x10000)");
        }
1395

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

1399
1400
        one_char = value[0];
        return one_char;
Wenzel Jakob's avatar
Wenzel Jakob committed
1401
    }
hulucc's avatar
hulucc committed
1402

1403
    static constexpr auto name = _(PYBIND11_STRING_NAME);
1404
    template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>;
hulucc's avatar
hulucc committed
1405
1406
};

1407
// Base implementation for std::tuple and std::pair
1408
1409
1410
template <template<typename...> class Tuple, typename... Ts> class tuple_caster {
    using type = Tuple<Ts...>;
    static constexpr auto size = sizeof...(Ts);
1411
    using indices = make_index_sequence<size>;
1412
public:
1413

Wenzel Jakob's avatar
Wenzel Jakob committed
1414
    bool load(handle src, bool convert) {
1415
1416
1417
1418
        if (!isinstance<sequence>(src))
            return false;
        const auto seq = reinterpret_borrow<sequence>(src);
        if (seq.size() != size)
1419
            return false;
1420
        return load_impl(seq, convert, indices{});
1421
    }
1422

1423
1424
1425
    template <typename T>
    static handle cast(T &&src, return_value_policy policy, handle parent) {
        return cast_impl(std::forward<T>(src), policy, parent, indices{});
1426
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1427

1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
    // copied from the PYBIND11_TYPE_CASTER macro
    template <typename T>
    static handle cast(T *src, return_value_policy policy, handle parent) {
        if (!src) return none().release();
        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);
        }
    }

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

1441
1442
    template <typename T> using cast_op_type = type;

1443
1444
    operator type() & { return implicit_cast(indices{}); }
    operator type() && { return std::move(*this).implicit_cast(indices{}); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1445

Wenzel Jakob's avatar
Wenzel Jakob committed
1446
protected:
1447
    template <size_t... Is>
1448
    type implicit_cast(index_sequence<Is...>) & { return type(cast_op<Ts>(std::get<Is>(subcasters))...); }
1449
    template <size_t... Is>
1450
    type implicit_cast(index_sequence<Is...>) && { return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...); }
1451

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

1454
    template <size_t... Is>
1455
    bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
1456
1457
1458
1459
#ifdef __cpp_fold_expressions
        if ((... || !std::get<Is>(subcasters).load(seq[Is], convert)))
            return false;
#else
1460
        for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...})
Wenzel Jakob's avatar
Wenzel Jakob committed
1461
1462
            if (!r)
                return false;
1463
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1464
1465
1466
1467
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
1468
1469
1470
1471
    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
1472
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
1473
1474
1475
1476
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
1477
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1478
1479
1480
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
1481
1482
    }

1483
    Tuple<make_caster<Ts>...> subcasters;
Wenzel Jakob's avatar
Wenzel Jakob committed
1484
1485
};

1486
1487
1488
template <typename T1, typename T2> class type_caster<std::pair<T1, T2>>
    : public tuple_caster<std::pair, T1, T2> {};

1489
1490
template <typename... Ts> class type_caster<std::tuple<Ts...>>
    : public tuple_caster<std::tuple, Ts...> {};
1491

1492
1493
1494
1495
1496
1497
1498
/// 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
1499
/// Type caster for holder types like std::shared_ptr, etc.
1500
1501
template <typename type, typename holder_type>
struct copyable_holder_caster : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
1502
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1503
    using base = type_caster_base<type>;
1504
1505
    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
1506
1507
1508
1509
    using base::base;
    using base::cast;
    using base::typeinfo;
    using base::value;
1510

1511
1512
    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
1513
1514
    }

1515
    explicit operator type*() { return this->value; }
1516
1517
1518
    // static_cast works around compiler error with MSVC 17 and CUDA 10.2
    // see issue #2180
    explicit operator type&() { return *(static_cast<type *>(this->value)); }
1519
    explicit operator holder_type*() { return std::addressof(holder); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1520

1521
1522
1523
1524
1525
1526
1527
    // 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
1528

1529
1530
1531
1532
    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
1533

1534
1535
1536
1537
1538
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
1539
1540
    }

1541
    bool load_value(value_and_holder &&v_h) {
1542
1543
        if (v_h.holder_constructed()) {
            value = v_h.value_ptr();
1544
            holder = v_h.template holder<holder_type>();
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
            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
1556
1557
1558
1559
1560
1561
    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) {
1562
            copyable_holder_caster sub_caster(*cast.first);
Wenzel Jakob's avatar
Wenzel Jakob committed
1563
1564
1565
1566
1567
1568
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                holder = holder_type(sub_caster.holder, (type *) value);
                return true;
            }
        }
1569
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1570
    }
1571

1572
    static bool try_direct_conversions(handle) { return false; }
1573

1574

Wenzel Jakob's avatar
Wenzel Jakob committed
1575
1576
1577
    holder_type holder;
};

1578
1579
/// Specialize for the common std::shared_ptr, so users don't need to
template <typename T>
1580
1581
1582
1583
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 {
1584
1585
1586
    static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
            "Holder classes are only supported for custom types");

1587
1588
    static handle cast(holder_type &&src, return_value_policy, handle) {
        auto *ptr = holder_helper<holder_type>::get(src);
1589
        return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
1590
    }
1591
    static constexpr auto name = type_caster_base<type>::name;
1592
1593
1594
1595
1596
1597
1598
};

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>
1599
using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
1600
1601
                                         copyable_holder_caster<type, holder_type>,
                                         move_only_holder_caster<type, holder_type>>;
1602

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

1605
/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
1606
#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \
1607
1608
    namespace pybind11 { namespace detail { \
    template <typename type> \
1609
1610
    struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__>  { }; \
    template <typename type> \
1611
1612
1613
1614
    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
        : public type_caster_holder<type, holder_type> { }; \
    }}

1615
// PYBIND11_DECLARE_HOLDER_TYPE holder types:
1616
template <typename base, typename holder> struct is_holder_type :
1617
1618
1619
1620
    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 {};
1621

1622
1623
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); };
1624
template <> struct handle_type_name<int_> { static constexpr auto name = _("int"); };
1625
1626
template <> struct handle_type_name<iterable> { static constexpr auto name = _("Iterable"); };
template <> struct handle_type_name<iterator> { static constexpr auto name = _("Iterator"); };
1627
template <> struct handle_type_name<none> { static constexpr auto name = _("None"); };
1628
1629
template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
template <> struct handle_type_name<kwargs> { static constexpr auto name = _("**kwargs"); };
1630

1631
template <typename type>
1632
1633
1634
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); }
1635

1636
    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
1637
1638
1639
    bool load(handle src, bool /* convert */) {
        if (!isinstance<type>(src))
            return false;
1640
        value = reinterpret_borrow<type>(src);
1641
1642
        return true;
    }
1643

Wenzel Jakob's avatar
Wenzel Jakob committed
1644
1645
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1646
    }
1647
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
Wenzel Jakob's avatar
Wenzel Jakob committed
1648
1649
};

1650
1651
1652
template <typename T>
class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };

1653
1654
1655
1656
1657
1658
1659
1660
1661
// 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.
1662
1663
template <typename T> using move_is_plain_type = satisfies_none_of<T,
    std::is_void, std::is_pointer, std::is_reference, std::is_const
1664
>;
1665
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
1666
1667
template <typename T> struct move_always<T, enable_if_t<all_of<
    move_is_plain_type<T>,
1668
    negation<is_copy_constructible<T>>,
1669
    std::is_move_constructible<T>,
1670
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1671
>::value>> : std::true_type {};
1672
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
1673
1674
1675
1676
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>,
1677
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1678
1679
>::value>> : std::true_type {};
template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
1680

1681
1682
1683
1684
1685
1686
// 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
1687
1688
    !std::is_base_of<type_caster_generic, make_caster<type>>::value &&
    !std::is_same<intrinsic_t<type>, void>::value
1689
1690
>;

1691
1692
// 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
1693
// with.
1694
template <typename Return, typename SFINAE = void> struct return_value_policy_override {
1695
1696
1697
1698
1699
    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>> {
1700
    static return_value_policy policy(return_value_policy p) {
1701
1702
1703
        return !std::is_lvalue_reference<Return>::value &&
               !std::is_pointer<Return>::value
                   ? return_value_policy::move : p;
1704
1705
1706
    }
};

1707
// Basic python -> C++ casting; throws if casting fails
Jason Rhinelander's avatar
Jason Rhinelander committed
1708
template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1709
1710
1711
1712
1713
    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 " +
1714
            (std::string) str(type::handle_of(handle)) + " to C++ type '" + type_id<T>() + "'");
1715
1716
#endif
    }
1717
1718
    return conv;
}
1719
1720
1721
1722
1723
1724
// 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;
}
1725

1726
PYBIND11_NAMESPACE_END(detail)
1727

1728
// pytype -> C++ type
1729
1730
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
T cast(const handle &handle) {
1731
1732
    using namespace detail;
    static_assert(!cast_is_temporary_value_reference<T>::value,
1733
            "Unable to cast type to reference: value is local to type caster");
1734
    return cast_op<T>(load_type<T>(handle));
Wenzel Jakob's avatar
Wenzel Jakob committed
1735
1736
}

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

1741
// C++ type -> py::object
1742
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
1743
object cast(T &&value, return_value_policy policy = return_value_policy::automatic_reference,
1744
            handle parent = handle()) {
1745
    using no_ref_T = typename std::remove_reference<T>::type;
Wenzel Jakob's avatar
Wenzel Jakob committed
1746
    if (policy == return_value_policy::automatic)
1747
1748
        policy = std::is_pointer<no_ref_T>::value ? return_value_policy::take_ownership :
                 std::is_lvalue_reference<T>::value ? return_value_policy::copy : return_value_policy::move;
1749
    else if (policy == return_value_policy::automatic_reference)
1750
1751
1752
        policy = std::is_pointer<no_ref_T>::value ? return_value_policy::reference :
                 std::is_lvalue_reference<T>::value ? return_value_policy::copy : return_value_policy::move;
    return reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(value), policy, parent));
Wenzel Jakob's avatar
Wenzel Jakob committed
1753
1754
}

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

1758
template <typename T>
1759
detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
1760
1761
1762
1763
1764
    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
1765
        throw cast_error("Unable to move from Python " + (std::string) str(type::handle_of(obj)) +
1766
1767
1768
1769
                " 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`
1770
    T ret = std::move(detail::load_type<T>(obj).operator T&());
1771
1772
1773
    return ret;
}

1774
// Calling cast() on an rvalue calls pybind11::cast with the object rvalue, which does:
1775
1776
1777
1778
// - 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.
1779
template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1780
1781
    return move<T>(std::move(object));
}
1782
template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1783
1784
1785
1786
1787
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
1788
template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1789
1790
1791
1792
1793
1794
1795
1796
    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; }

1797
PYBIND11_NAMESPACE_BEGIN(detail)
1798

1799
1800
1801
1802
// 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)); }

1803
1804
1805
struct override_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the PYBIND11_OVERRIDE_OVERRIDE macro
template <typename ret_type> using override_caster_t = conditional_t<
    cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, override_unused>;
1806
1807
1808

// 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.
1809
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
1810
    return cast_op<T>(load_type(caster, o));
1811
}
1812
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, override_unused &) {
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
    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 &&) {}

1824
PYBIND11_NAMESPACE_END(detail)
1825

1826
1827
1828
template <return_value_policy policy = return_value_policy::automatic_reference>
tuple make_tuple() { return tuple(0); }

1829
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
1830
          typename... Args> tuple make_tuple(Args&&... args_) {
1831
    constexpr size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
1832
    std::array<object, size> args {
1833
1834
        { reinterpret_steal<object>(detail::make_caster<Args>::cast(
            std::forward<Args>(args_), policy, nullptr))... }
Wenzel Jakob's avatar
Wenzel Jakob committed
1835
    };
1836
1837
    for (size_t i = 0; i < args.size(); i++) {
        if (!args[i]) {
1838
1839
1840
#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
1841
            std::array<std::string, size> argtypes { {type_id<Args>()...} };
1842
1843
            throw cast_error("make_tuple(): unable to convert argument of type '" +
                argtypes[i] + "' to Python object");
1844
1845
1846
#endif
        }
    }
1847
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
1848
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1849
    for (auto &arg_value : args)
1850
1851
1852
1853
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

1854
/// \ingroup annotations
1855
/// Annotation for arguments
1856
struct arg {
1857
    /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument.
1858
    constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { }
1859
    /// Assign a value to this argument
1860
    template <typename T> arg_v operator=(T &&value) const;
1861
1862
    /// Indicate that the type should not be converted in the type caster
    arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; }
1863
1864
    /// 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; }
1865

1866
1867
    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!)
1868
    bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument
1869
1870
};

1871
/// \ingroup annotations
1872
/// Annotation for arguments with values
1873
struct arg_v : arg {
1874
private:
1875
    template <typename T>
1876
1877
    arg_v(arg &&base, T &&x, const char *descr = nullptr)
        : arg(base),
1878
1879
1880
          value(reinterpret_steal<object>(
              detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
          )),
1881
1882
1883
1884
1885
1886
          descr(descr)
#if !defined(NDEBUG)
        , type(type_id<T>())
#endif
    { }

1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
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; }
1900
1901
1902

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

    /// The default value
1905
    object value;
1906
    /// The (optional) description of the default value
1907
1908
    const char *descr;
#if !defined(NDEBUG)
1909
    /// The C++ type name of the default value (only available when compiled in debug mode)
1910
1911
1912
1913
    std::string type;
#endif
};

1914
1915
1916
/// \ingroup annotations
/// Annotation indicating that all following arguments are keyword-only; the is the equivalent of an
/// unnamed '*' argument (in Python 3)
Henry Schreiner's avatar
Henry Schreiner committed
1917
1918
1919
1920
1921
1922
struct kw_only {};

/// \ingroup annotations
/// Annotation indicating that all previous arguments are positional-only; the is the equivalent of an
/// unnamed '/' argument (in Python 3.8)
struct pos_only {};
1923

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

Wenzel Jakob's avatar
Wenzel Jakob committed
1927
/// Alias for backward compatibility -- to be removed in version 2.0
1928
1929
1930
template <typename /*unused*/> using arg_t = arg_v;

inline namespace literals {
1931
1932
1933
/** \rst
    String literal version of `arg`
 \endrst */
1934
constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
1935
} // namespace literals
1936

1937
PYBIND11_NAMESPACE_BEGIN(detail)
1938

1939
// forward declaration (definition in attr.h)
1940
1941
struct function_record;

1942
1943
/// Internal data associated with a single function call
struct function_call {
1944
    function_call(const function_record &f, handle p); // Implementation in attr.h
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954

    /// 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;

1955
1956
1957
1958
    /// 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;

1959
1960
    /// The parent, if any
    handle parent;
1961
1962
1963

    /// If this is a call to an initializer, this argument contains `self`
    handle init_self;
1964
1965
1966
};


1967
1968
1969
/// Helper class which loads arguments for C++ functions called from Python
template <typename... Args>
class argument_loader {
1970
    using indices = make_index_sequence<sizeof...(Args)>;
1971

1972
1973
1974
1975
1976
1977
1978
1979
1980
    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
1981

1982
public:
1983
1984
    static constexpr bool has_kwargs = kwargs_pos < 0;
    static constexpr bool has_args = args_pos < 0;
1985

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

1988
1989
    bool load_args(function_call &call) {
        return load_impl_sequence(call, indices{});
1990
1991
    }

Dean Moldovan's avatar
Dean Moldovan committed
1992
    template <typename Return, typename Guard, typename Func>
1993
1994
    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{});
1995
1996
    }

Dean Moldovan's avatar
Dean Moldovan committed
1997
    template <typename Return, typename Guard, typename Func>
1998
1999
    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{});
2000
2001
2002
2003
2004
        return void_type();
    }

private:

2005
    static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
2006
2007

    template <size_t... Is>
2008
    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
2009
2010
2011
2012
#ifdef __cpp_fold_expressions
        if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
            return false;
#else
2013
        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
2014
2015
            if (!r)
                return false;
2016
#endif
2017
2018
2019
        return true;
    }

Dean Moldovan's avatar
Dean Moldovan committed
2020
    template <typename Return, typename Func, size_t... Is, typename Guard>
2021
    Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) && {
2022
        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
2023
2024
    }

2025
    std::tuple<make_caster<Args>...> argcasters;
2026
2027
};

2028
2029
2030
2031
2032
2033
/// 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>
2034
    explicit simple_collector(Ts &&...values)
2035
2036
2037
2038
2039
2040
2041
2042
2043
        : 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 {
2044
        PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
2045
2046
        if (!result)
            throw error_already_set();
2047
        return reinterpret_steal<object>(result);
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
    }

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>
2059
    explicit unpacking_collector(Ts &&...values) {
2060
2061
2062
2063
2064
2065
        // 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(_);

2066
        m_args = std::move(args_list);
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
    }

    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 {
2077
        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
2078
2079
        if (!result)
            throw error_already_set();
2080
        return reinterpret_steal<object>(result);
2081
2082
2083
2084
2085
    }

private:
    template <typename T>
    void process(list &args_list, T &&x) {
2086
        auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
        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) {
2098
        for (auto a : ap)
2099
            args_list.append(a);
2100
2101
    }

2102
    void process(list &/*args_list*/, arg_v a) {
2103
2104
2105
2106
2107
2108
2109
        if (!a.name)
#if defined(NDEBUG)
            nameless_argument_error();
#else
            nameless_argument_error(a.type);
#endif

2110
        if (m_kwargs.contains(a.name)) {
2111
2112
2113
2114
2115
2116
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
2117
        if (!a.value) {
2118
2119
2120
#if defined(NDEBUG)
            argument_cast_error();
#else
2121
            argument_cast_error(a.name, a.type);
2122
2123
#endif
        }
2124
        m_kwargs[a.name] = a.value;
2125
2126
2127
    }

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
2128
2129
        if (!kp)
            return;
2130
        for (auto k : reinterpret_borrow<dict>(kp)) {
2131
            if (m_kwargs.contains(k.first)) {
2132
2133
2134
#if defined(NDEBUG)
                multiple_values_error();
#else
2135
                multiple_values_error(str(k.first));
2136
2137
2138
2139
2140
2141
#endif
            }
            m_kwargs[k.first] = k.second;
        }
    }

2142
2143
2144
2145
2146
2147
2148
2149
2150
    [[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. ");
    }
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
    [[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,
2177
          typename = enable_if_t<all_of<is_positional<Args>...>::value>>
2178
simple_collector<policy> collect_arguments(Args &&...args) {
2179
    return simple_collector<policy>(std::forward<Args>(args)...);
2180
2181
2182
2183
}

/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
template <return_value_policy policy, typename... Args,
2184
          typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
2185
2186
2187
2188
2189
2190
2191
2192
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"
    );
2193
    return unpacking_collector<policy>(std::forward<Args>(args)...);
2194
2195
}

2196
template <typename Derived>
2197
template <return_value_policy policy, typename... Args>
2198
2199
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
2200
2201
}

2202
2203
2204
template <typename Derived>
template <return_value_policy policy, typename... Args>
object object_api<Derived>::call(Args &&...args) const {
2205
    return operator()<policy>(std::forward<Args>(args)...);
2206
2207
}

2208
PYBIND11_NAMESPACE_END(detail)
2209

2210
2211

template<typename T>
2212
handle type::handle_of() {
2213
2214
2215
2216
2217
   static_assert(
      std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>::value,
      "py::type::of<T> only supports the case where T is a registered C++ types."
    );

2218
    return detail::get_type_handle(typeid(T), true);
2219
2220
2221
}


2222
#define PYBIND11_MAKE_OPAQUE(...) \
Wenzel Jakob's avatar
Wenzel Jakob committed
2223
    namespace pybind11 { namespace detail { \
2224
        template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \
Wenzel Jakob's avatar
Wenzel Jakob committed
2225
2226
    }}

2227
/// Lets you pass a type containing a `,` through a macro parameter without needing a separate
2228
/// typedef, e.g.: `PYBIND11_OVERRIDE(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)`
2229
2230
#define PYBIND11_TYPE(...) __VA_ARGS__

2231
PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)