1 /*
2 pybind11/detail/common.h -- Basic macros
3
4 Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
5
6 All rights reserved. Use of this source code is governed by a
7 BSD-style license that can be found in the LICENSE file.
8 */
9
10 #pragma once
11
12 #define PYBIND11_VERSION_MAJOR 2
13 #define PYBIND11_VERSION_MINOR 6
14 #define PYBIND11_VERSION_PATCH 0
15
16 #define PYBIND11_NAMESPACE_BEGIN(name) namespace name {
17 #define PYBIND11_NAMESPACE_END(name) }
18
19 // Robust support for some features and loading modules compiled against different pybind versions
20 // requires forcing hidden visibility on pybind code, so we enforce this by setting the attribute on
21 // the main `pybind11` namespace.
22 #if !defined(PYBIND11_NAMESPACE)
23 # ifdef __GNUG__
24 # define PYBIND11_NAMESPACE pybind11 __attribute__((visibility("hidden")))
25 # else
26 # define PYBIND11_NAMESPACE pybind11
27 # endif
28 #endif
29
30 #if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)
31 # if __cplusplus >= 201402L
32 # define PYBIND11_CPP14
33 # if __cplusplus >= 201703L
34 # define PYBIND11_CPP17
35 # endif
36 # endif
37 #elif defined(_MSC_VER) && __cplusplus == 199711L
38 // MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
39 // Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer
40 # if _MSVC_LANG >= 201402L
41 # define PYBIND11_CPP14
42 # if _MSVC_LANG > 201402L && _MSC_VER >= 1910
43 # define PYBIND11_CPP17
44 # endif
45 # endif
46 #endif
47
48 // Compiler version assertions
49 #if defined(__INTEL_COMPILER)
50 # if __INTEL_COMPILER < 1800
51 # error pybind11 requires Intel C++ compiler v18 or newer
52 # endif
53 #elif defined(__clang__) && !defined(__apple_build_version__)
54 # if __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 3)
55 # error pybind11 requires clang 3.3 or newer
56 # endif
57 #elif defined(__clang__)
58 // Apple changes clang version macros to its Xcode version; the first Xcode release based on
59 // (upstream) clang 3.3 was Xcode 5:
60 # if __clang_major__ < 5
61 # error pybind11 requires Xcode/clang 5.0 or newer
62 # endif
63 #elif defined(__GNUG__)
64 # if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
65 # error pybind11 requires gcc 4.8 or newer
66 # endif
67 #elif defined(_MSC_VER)
68 // Pybind hits various compiler bugs in 2015u2 and earlier, and also makes use of some stl features
69 // (e.g. std::negation) added in 2015u3:
70 # if _MSC_FULL_VER < 190024210
71 # error pybind11 requires MSVC 2015 update 3 or newer
72 # endif
73 #endif
74
75 #if !defined(PYBIND11_EXPORT)
76 # if defined(WIN32) || defined(_WIN32)
77 # define PYBIND11_EXPORT __declspec(dllexport)
78 # else
79 # define PYBIND11_EXPORT __attribute__ ((visibility("default")))
80 # endif
81 #endif
82
83 #if defined(_MSC_VER)
84 # define PYBIND11_NOINLINE __declspec(noinline)
85 #else
86 # define PYBIND11_NOINLINE __attribute__ ((noinline))
87 #endif
88
89 #if defined(PYBIND11_CPP14)
90 # define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
91 #else
92 # define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
93 #endif
94
95 #if defined(PYBIND11_CPP17)
96 # define PYBIND11_MAYBE_UNUSED [[maybe_unused]]
97 #elif defined(_MSC_VER) && !defined(__clang__)
98 # define PYBIND11_MAYBE_UNUSED
99 #else
100 # define PYBIND11_MAYBE_UNUSED __attribute__ ((__unused__))
101 #endif
102
103 /* Don't let Python.h #define (v)snprintf as macro because they are implemented
104 properly in Visual Studio since 2015. */
105 #if defined(_MSC_VER) && _MSC_VER >= 1900
106 # define HAVE_SNPRINTF 1
107 #endif
108
109 /// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
110 #if defined(_MSC_VER)
111 # if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 4)
112 # define HAVE_ROUND 1
113 # endif
114 # pragma warning(push)
115 # pragma warning(disable: 4510 4610 4512 4005)
116 # if defined(_DEBUG) && !defined(Py_DEBUG)
117 # define PYBIND11_DEBUG_MARKER
118 # undef _DEBUG
119 # endif
120 #endif
121
122 #include <Python.h>
123 #include <frameobject.h>
124 #include <pythread.h>
125
126 /* Python #defines overrides on all sorts of core functions, which
127 tends to weak havok in C++ codebases that expect these to work
128 like regular functions (potentially with several overloads) */
129 #if defined(isalnum)
130 # undef isalnum
131 # undef isalpha
132 # undef islower
133 # undef isspace
134 # undef isupper
135 # undef tolower
136 # undef toupper
137 #endif
138
139 #if defined(copysign)
140 # undef copysign
141 #endif
142
143 #if defined(_MSC_VER)
144 # if defined(PYBIND11_DEBUG_MARKER)
145 # define _DEBUG
146 # undef PYBIND11_DEBUG_MARKER
147 # endif
148 # pragma warning(pop)
149 #endif
150
151 #include <cstddef>
152 #include <cstring>
153 #include <forward_list>
154 #include <vector>
155 #include <string>
156 #include <stdexcept>
157 #include <exception>
158 #include <unordered_set>
159 #include <unordered_map>
160 #include <memory>
161 #include <typeindex>
162 #include <type_traits>
163
164 #if PY_MAJOR_VERSION >= 3 /// Compatibility macros for various Python versions
165 #define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
166 #define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check
167 #define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION
168 #define PYBIND11_BYTES_CHECK PyBytes_Check
169 #define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
170 #define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize
171 #define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize
172 #define PYBIND11_BYTES_AS_STRING PyBytes_AsString
173 #define PYBIND11_BYTES_SIZE PyBytes_Size
174 #define PYBIND11_LONG_CHECK(o) PyLong_Check(o)
175 #define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o)
176 #define PYBIND11_LONG_FROM_SIGNED(o) PyLong_FromSsize_t((ssize_t) o)
177 #define PYBIND11_LONG_FROM_UNSIGNED(o) PyLong_FromSize_t((size_t) o)
178 #define PYBIND11_BYTES_NAME "bytes"
179 #define PYBIND11_STRING_NAME "str"
180 #define PYBIND11_SLICE_OBJECT PyObject
181 #define PYBIND11_FROM_STRING PyUnicode_FromString
182 #define PYBIND11_STR_TYPE ::pybind11::str
183 #define PYBIND11_BOOL_ATTR "__bool__"
184 #define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_bool)
185 #define PYBIND11_BUILTINS_MODULE "builtins"
186 // Providing a separate declaration to make Clang's -Wmissing-prototypes happy.
187 // See comment for PYBIND11_MODULE below for why this is marked "maybe unused".
188 #define PYBIND11_PLUGIN_IMPL(name) \
189 extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT PyObject *PyInit_##name(); \
190 extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
191
192 #else
193 #define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_)
194 #define PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check
195 #define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION
196 #define PYBIND11_BYTES_CHECK PyString_Check
197 #define PYBIND11_BYTES_FROM_STRING PyString_FromString
198 #define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize
199 #define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize
200 #define PYBIND11_BYTES_AS_STRING PyString_AsString
201 #define PYBIND11_BYTES_SIZE PyString_Size
202 #define PYBIND11_LONG_CHECK(o) (PyInt_Check(o) || PyLong_Check(o))
203 #define PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))
204 #define PYBIND11_LONG_FROM_SIGNED(o) PyInt_FromSsize_t((ssize_t) o) // Returns long if needed.
205 #define PYBIND11_LONG_FROM_UNSIGNED(o) PyInt_FromSize_t((size_t) o) // Returns long if needed.
206 #define PYBIND11_BYTES_NAME "str"
207 #define PYBIND11_STRING_NAME "unicode"
208 #define PYBIND11_SLICE_OBJECT PySliceObject
209 #define PYBIND11_FROM_STRING PyString_FromString
210 #define PYBIND11_STR_TYPE ::pybind11::bytes
211 #define PYBIND11_BOOL_ATTR "__nonzero__"
212 #define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_nonzero)
213 #define PYBIND11_BUILTINS_MODULE "__builtin__"
214 // Providing a separate PyInit decl to make Clang's -Wmissing-prototypes happy.
215 // See comment for PYBIND11_MODULE below for why this is marked "maybe unused".
216 #define PYBIND11_PLUGIN_IMPL(name) \
217 static PyObject *pybind11_init_wrapper(); \
218 extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT void init##name(); \
219 extern "C" PYBIND11_EXPORT void init##name() { \
220 (void)pybind11_init_wrapper(); \
221 } \
222 PyObject *pybind11_init_wrapper()
223 #endif
224
225 #if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200
226 extern "C" {
227 struct _Py_atomic_address { void *value; };
228 PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current;
229 }
230 #endif
231
232 #define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
233 #define PYBIND11_STRINGIFY(x) #x
234 #define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)
235 #define PYBIND11_CONCAT(first, second) first##second
236 #define PYBIND11_ENSURE_INTERNALS_READY \
237 pybind11::detail::get_internals();
238
239 #define PYBIND11_CHECK_PYTHON_VERSION \
240 { \
241 const char *compiled_ver = PYBIND11_TOSTRING(PY_MAJOR_VERSION) \
242 "." PYBIND11_TOSTRING(PY_MINOR_VERSION); \
243 const char *runtime_ver = Py_GetVersion(); \
244 size_t len = std::strlen(compiled_ver); \
245 if (std::strncmp(runtime_ver, compiled_ver, len) != 0 \
246 || (runtime_ver[len] >= '0' && runtime_ver[len] <= '9')) { \
247 PyErr_Format(PyExc_ImportError, \
248 "Python version mismatch: module was compiled for Python %s, " \
249 "but the interpreter version is incompatible: %s.", \
250 compiled_ver, runtime_ver); \
251 return nullptr; \
252 } \
253 }
254
255 #define PYBIND11_CATCH_INIT_EXCEPTIONS \
256 catch (pybind11::error_already_set &e) { \
257 PyErr_SetString(PyExc_ImportError, e.what()); \
258 return nullptr; \
259 } catch (const std::exception &e) { \
260 PyErr_SetString(PyExc_ImportError, e.what()); \
261 return nullptr; \
262 } \
263
264 /** \rst
265 ***Deprecated in favor of PYBIND11_MODULE***
266
267 This macro creates the entry point that will be invoked when the Python interpreter
268 imports a plugin library. Please create a `module_` in the function body and return
269 the pointer to its underlying Python object at the end.
270
271 .. code-block:: cpp
272
273 PYBIND11_PLUGIN(example) {
274 pybind11::module_ m("example", "pybind11 example plugin");
275 /// Set up bindings here
276 return m.ptr();
277 }
278 \endrst */
279 #define PYBIND11_PLUGIN(name) \
280 PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE") \
281 static PyObject *pybind11_init(); \
282 PYBIND11_PLUGIN_IMPL(name) { \
283 PYBIND11_CHECK_PYTHON_VERSION \
284 PYBIND11_ENSURE_INTERNALS_READY \
285 try { \
286 return pybind11_init(); \
287 } PYBIND11_CATCH_INIT_EXCEPTIONS \
288 } \
289 PyObject *pybind11_init()
290
291 /** \rst
292 This macro creates the entry point that will be invoked when the Python interpreter
293 imports an extension module. The module name is given as the fist argument and it
294 should not be in quotes. The second macro argument defines a variable of type
295 `py::module_` which can be used to initialize the module.
296
297 The entry point is marked as "maybe unused" to aid dead-code detection analysis:
298 since the entry point is typically only looked up at runtime and not referenced
299 during translation, it would otherwise appear as unused ("dead") code.
300
301 .. code-block:: cpp
302
303 PYBIND11_MODULE(example, m) {
304 m.doc() = "pybind11 example module";
305
306 // Add bindings here
307 m.def("foo", []() {
308 return "Hello, World!";
309 });
310 }
311 \endrst */
312 #define PYBIND11_MODULE(name, variable) \
313 static ::pybind11::module_::module_def \
314 PYBIND11_CONCAT(pybind11_module_def_, name); \
315 PYBIND11_MAYBE_UNUSED \
316 static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &); \
317 PYBIND11_PLUGIN_IMPL(name) { \
318 PYBIND11_CHECK_PYTHON_VERSION \
319 PYBIND11_ENSURE_INTERNALS_READY \
320 auto m = ::pybind11::module_::create_extension_module( \
321 PYBIND11_TOSTRING(name), nullptr, \
322 &PYBIND11_CONCAT(pybind11_module_def_, name)); \
323 try { \
324 PYBIND11_CONCAT(pybind11_init_, name)(m); \
325 return m.ptr(); \
326 } PYBIND11_CATCH_INIT_EXCEPTIONS \
327 } \
328 void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &variable)
329
330
331 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
332
333 using ssize_t = Py_ssize_t;
334 using size_t = std::size_t;
335
336 /// Approach used to cast a previously unknown C++ instance into a Python object
337 enum class return_value_policy : uint8_t {
338 /** This is the default return value policy, which falls back to the policy
339 return_value_policy::take_ownership when the return value is a pointer.
340 Otherwise, it uses return_value::move or return_value::copy for rvalue
341 and lvalue references, respectively. See below for a description of what
342 all of these different policies do. */
343 automatic = 0,
344
345 /** As above, but use policy return_value_policy::reference when the return
346 value is a pointer. This is the default conversion policy for function
347 arguments when calling Python functions manually from C++ code (i.e. via
348 handle::operator()). You probably won't need to use this. */
349 automatic_reference,
350
351 /** Reference an existing object (i.e. do not create a new copy) and take
352 ownership. Python will call the destructor and delete operator when the
353 object’s reference count reaches zero. Undefined behavior ensues when
354 the C++ side does the same.. */
355 take_ownership,
356
357 /** Create a new copy of the returned object, which will be owned by
358 Python. This policy is comparably safe because the lifetimes of the two
359 instances are decoupled. */
360 copy,
361
362 /** Use std::move to move the return value contents into a new instance
363 that will be owned by Python. This policy is comparably safe because the
364 lifetimes of the two instances (move source and destination) are
365 decoupled. */
366 move,
367
368 /** Reference an existing object, but do not take ownership. The C++ side
369 is responsible for managing the object’s lifetime and deallocating it
370 when it is no longer used. Warning: undefined behavior will ensue when
371 the C++ side deletes an object that is still referenced and used by
372 Python. */
373 reference,
374
375 /** This policy only applies to methods and properties. It references the
376 object without taking ownership similar to the above
377 return_value_policy::reference policy. In contrast to that policy, the
378 function or property’s implicit this argument (called the parent) is
379 considered to be the the owner of the return value (the child).
380 pybind11 then couples the lifetime of the parent to the child via a
381 reference relationship that ensures that the parent cannot be garbage
382 collected while Python is still using the child. More advanced
383 variations of this scheme are also possible using combinations of
384 return_value_policy::reference and the keep_alive call policy */
385 reference_internal
386 };
387
PYBIND11_NAMESPACE_BEGIN(detail)388 PYBIND11_NAMESPACE_BEGIN(detail)
389
390 inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); }
391
392 // Returns the size as a multiple of sizeof(void *), rounded up.
size_in_ptrs(size_t s)393 inline static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> log2(sizeof(void *))); }
394
395 /**
396 * The space to allocate for simple layout instance holders (see below) in multiple of the size of
397 * a pointer (e.g. 2 means 16 bytes on 64-bit architectures). The default is the minimum required
398 * to holder either a std::unique_ptr or std::shared_ptr (which is almost always
399 * sizeof(std::shared_ptr<T>)).
400 */
instance_simple_holder_in_ptrs()401 constexpr size_t instance_simple_holder_in_ptrs() {
402 static_assert(sizeof(std::shared_ptr<int>) >= sizeof(std::unique_ptr<int>),
403 "pybind assumes std::shared_ptrs are at least as big as std::unique_ptrs");
404 return size_in_ptrs(sizeof(std::shared_ptr<int>));
405 }
406
407 // Forward declarations
408 struct type_info;
409 struct value_and_holder;
410
411 struct nonsimple_values_and_holders {
412 void **values_and_holders;
413 uint8_t *status;
414 };
415
416 /// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')
417 struct instance {
418 PyObject_HEAD
419 /// Storage for pointers and holder; see simple_layout, below, for a description
420 union {
421 void *simple_value_holder[1 + instance_simple_holder_in_ptrs()];
422 nonsimple_values_and_holders nonsimple;
423 };
424 /// Weak references
425 PyObject *weakrefs;
426 /// If true, the pointer is owned which means we're free to manage it with a holder.
427 bool owned : 1;
428 /**
429 * An instance has two possible value/holder layouts.
430 *
431 * Simple layout (when this flag is true), means the `simple_value_holder` is set with a pointer
432 * and the holder object governing that pointer, i.e. [val1*][holder]. This layout is applied
433 * whenever there is no python-side multiple inheritance of bound C++ types *and* the type's
434 * holder will fit in the default space (which is large enough to hold either a std::unique_ptr
435 * or std::shared_ptr).
436 *
437 * Non-simple layout applies when using custom holders that require more space than `shared_ptr`
438 * (which is typically the size of two pointers), or when multiple inheritance is used on the
439 * python side. Non-simple layout allocates the required amount of memory to have multiple
440 * bound C++ classes as parents. Under this layout, `nonsimple.values_and_holders` is set to a
441 * pointer to allocated space of the required space to hold a sequence of value pointers and
442 * holders followed `status`, a set of bit flags (1 byte each), i.e.
443 * [val1*][holder1][val2*][holder2]...[bb...] where each [block] is rounded up to a multiple of
444 * `sizeof(void *)`. `nonsimple.status` is, for convenience, a pointer to the
445 * beginning of the [bb...] block (but not independently allocated).
446 *
447 * Status bits indicate whether the associated holder is constructed (&
448 * status_holder_constructed) and whether the value pointer is registered (&
449 * status_instance_registered) in `registered_instances`.
450 */
451 bool simple_layout : 1;
452 /// For simple layout, tracks whether the holder has been constructed
453 bool simple_holder_constructed : 1;
454 /// For simple layout, tracks whether the instance is registered in `registered_instances`
455 bool simple_instance_registered : 1;
456 /// If true, get_internals().patients has an entry for this object
457 bool has_patients : 1;
458
459 /// Initializes all of the above type/values/holders data (but not the instance values themselves)
460 void allocate_layout();
461
462 /// Destroys/deallocates all of the above
463 void deallocate_layout();
464
465 /// Returns the value_and_holder wrapper for the given type (or the first, if `find_type`
466 /// omitted). Returns a default-constructed (with `.inst = nullptr`) object on failure if
467 /// `throw_if_missing` is false.
468 value_and_holder get_value_and_holder(const type_info *find_type = nullptr, bool throw_if_missing = true);
469
470 /// Bit values for the non-simple status flags
471 static constexpr uint8_t status_holder_constructed = 1;
472 static constexpr uint8_t status_instance_registered = 2;
473 };
474
475 static_assert(std::is_standard_layout<instance>::value, "Internal error: `pybind11::detail::instance` is not standard layout!");
476
477 /// from __cpp_future__ import (convenient aliases from C++14/17)
478 #if defined(PYBIND11_CPP14) && (!defined(_MSC_VER) || _MSC_VER >= 1910)
479 using std::enable_if_t;
480 using std::conditional_t;
481 using std::remove_cv_t;
482 using std::remove_reference_t;
483 #else
484 template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
485 template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
486 template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
487 template <typename T> using remove_reference_t = typename std::remove_reference<T>::type;
488 #endif
489
490 /// Index sequences
491 #if defined(PYBIND11_CPP14)
492 using std::index_sequence;
493 using std::make_index_sequence;
494 #else
495 template<size_t ...> struct index_sequence { };
496 template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { };
497 template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; };
498 template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type;
499 #endif
500
501 /// Make an index sequence of the indices of true arguments
502 template <typename ISeq, size_t, bool...> struct select_indices_impl { using type = ISeq; };
503 template <size_t... IPrev, size_t I, bool B, bool... Bs> struct select_indices_impl<index_sequence<IPrev...>, I, B, Bs...>
504 : select_indices_impl<conditional_t<B, index_sequence<IPrev..., I>, index_sequence<IPrev...>>, I + 1, Bs...> {};
505 template <bool... Bs> using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type;
506
507 /// Backports of std::bool_constant and std::negation to accommodate older compilers
508 template <bool B> using bool_constant = std::integral_constant<bool, B>;
509 template <typename T> struct negation : bool_constant<!T::value> { };
510
511 // PGI/Intel cannot detect operator delete with the "compatible" void_t impl, so
512 // using the new one (C++14 defect, so generally works on newer compilers, even
513 // if not in C++17 mode)
514 #if defined(__PGIC__) || defined(__INTEL_COMPILER)
515 template<typename... > using void_t = void;
516 #else
517 template <typename...> struct void_t_impl { using type = void; };
518 template <typename... Ts> using void_t = typename void_t_impl<Ts...>::type;
519 #endif
520
521
522 /// Compile-time all/any/none of that check the boolean value of all template types
523 #if defined(__cpp_fold_expressions) && !(defined(_MSC_VER) && (_MSC_VER < 1916))
524 template <class... Ts> using all_of = bool_constant<(Ts::value && ...)>;
525 template <class... Ts> using any_of = bool_constant<(Ts::value || ...)>;
526 #elif !defined(_MSC_VER)
527 template <bool...> struct bools {};
528 template <class... Ts> using all_of = std::is_same<
529 bools<Ts::value..., true>,
530 bools<true, Ts::value...>>;
531 template <class... Ts> using any_of = negation<all_of<negation<Ts>...>>;
532 #else
533 // MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit
534 // at a slight loss of compilation efficiency).
535 template <class... Ts> using all_of = std::conjunction<Ts...>;
536 template <class... Ts> using any_of = std::disjunction<Ts...>;
537 #endif
538 template <class... Ts> using none_of = negation<any_of<Ts...>>;
539
540 template <class T, template<class> class... Predicates> using satisfies_all_of = all_of<Predicates<T>...>;
541 template <class T, template<class> class... Predicates> using satisfies_any_of = any_of<Predicates<T>...>;
542 template <class T, template<class> class... Predicates> using satisfies_none_of = none_of<Predicates<T>...>;
543
544 /// Strip the class from a method type
545 template <typename T> struct remove_class { };
546 template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { using type = R (A...); };
547 template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { using type = R (A...); };
548
549 /// Helper template to strip away type modifiers
550 template <typename T> struct intrinsic_type { using type = T; };
551 template <typename T> struct intrinsic_type<const T> { using type = typename intrinsic_type<T>::type; };
552 template <typename T> struct intrinsic_type<T*> { using type = typename intrinsic_type<T>::type; };
553 template <typename T> struct intrinsic_type<T&> { using type = typename intrinsic_type<T>::type; };
554 template <typename T> struct intrinsic_type<T&&> { using type = typename intrinsic_type<T>::type; };
555 template <typename T, size_t N> struct intrinsic_type<const T[N]> { using type = typename intrinsic_type<T>::type; };
556 template <typename T, size_t N> struct intrinsic_type<T[N]> { using type = typename intrinsic_type<T>::type; };
557 template <typename T> using intrinsic_t = typename intrinsic_type<T>::type;
558
559 /// Helper type to replace 'void' in some expressions
560 struct void_type { };
561
562 /// Helper template which holds a list of types
563 template <typename...> struct type_list { };
564
565 /// Compile-time integer sum
566 #ifdef __cpp_fold_expressions
567 template <typename... Ts> constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); }
568 #else
569 constexpr size_t constexpr_sum() { return 0; }
570 template <typename T, typename... Ts>
571 constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
572 #endif
573
574 PYBIND11_NAMESPACE_BEGIN(constexpr_impl)
575 /// Implementation details for constexpr functions
576 constexpr int first(int i) { return i; }
577 template <typename T, typename... Ts>
578 constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }
579
580 constexpr int last(int /*i*/, int result) { return result; }
581 template <typename T, typename... Ts>
582 constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
583 PYBIND11_NAMESPACE_END(constexpr_impl)
584
585 /// Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if
586 /// none match.
587 template <template<typename> class Predicate, typename... Ts>
588 constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }
589
590 /// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
591 template <template<typename> class Predicate, typename... Ts>
592 constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }
593
594 /// Return the Nth element from the parameter pack
595 template <size_t N, typename T, typename... Ts>
596 struct pack_element { using type = typename pack_element<N - 1, Ts...>::type; };
597 template <typename T, typename... Ts>
598 struct pack_element<0, T, Ts...> { using type = T; };
599
600 /// Return the one and only type which matches the predicate, or Default if none match.
601 /// If more than one type matches the predicate, fail at compile-time.
602 template <template<typename> class Predicate, typename Default, typename... Ts>
603 struct exactly_one {
604 static constexpr auto found = constexpr_sum(Predicate<Ts>::value...);
605 static_assert(found <= 1, "Found more than one type matching the predicate");
606
607 static constexpr auto index = found ? constexpr_first<Predicate, Ts...>() : 0;
608 using type = conditional_t<found, typename pack_element<index, Ts...>::type, Default>;
609 };
610 template <template<typename> class P, typename Default>
611 struct exactly_one<P, Default> { using type = Default; };
612
613 template <template<typename> class Predicate, typename Default, typename... Ts>
614 using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type;
615
616 /// Defer the evaluation of type T until types Us are instantiated
617 template <typename T, typename... /*Us*/> struct deferred_type { using type = T; };
618 template <typename T, typename... Us> using deferred_t = typename deferred_type<T, Us...>::type;
619
620 /// Like is_base_of, but requires a strict base (i.e. `is_strict_base_of<T, T>::value == false`,
621 /// unlike `std::is_base_of`)
622 template <typename Base, typename Derived> using is_strict_base_of = bool_constant<
623 std::is_base_of<Base, Derived>::value && !std::is_same<Base, Derived>::value>;
624
625 /// Like is_base_of, but also requires that the base type is accessible (i.e. that a Derived pointer
626 /// can be converted to a Base pointer)
627 /// For unions, `is_base_of<T, T>::value` is False, so we need to check `is_same` as well.
628 template <typename Base, typename Derived> using is_accessible_base_of = bool_constant<
629 (std::is_same<Base, Derived>::value || std::is_base_of<Base, Derived>::value) && std::is_convertible<Derived *, Base *>::value>;
630
631 template <template<typename...> class Base>
632 struct is_template_base_of_impl {
633 template <typename... Us> static std::true_type check(Base<Us...> *);
634 static std::false_type check(...);
635 };
636
637 /// Check if a template is the base of a type. For example:
638 /// `is_template_base_of<Base, T>` is true if `struct T : Base<U> {}` where U can be anything
639 template <template<typename...> class Base, typename T>
640 #if !defined(_MSC_VER)
641 using is_template_base_of = decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T>*)nullptr));
642 #else // MSVC2015 has trouble with decltype in template aliases
643 struct is_template_base_of : decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T>*)nullptr)) { };
644 #endif
645
646 /// Check if T is an instantiation of the template `Class`. For example:
647 /// `is_instantiation<shared_ptr, T>` is true if `T == shared_ptr<U>` where U can be anything.
648 template <template<typename...> class Class, typename T>
649 struct is_instantiation : std::false_type { };
650 template <template<typename...> class Class, typename... Us>
651 struct is_instantiation<Class, Class<Us...>> : std::true_type { };
652
653 /// Check if T is std::shared_ptr<U> where U can be anything
654 template <typename T> using is_shared_ptr = is_instantiation<std::shared_ptr, T>;
655
656 /// Check if T looks like an input iterator
657 template <typename T, typename = void> struct is_input_iterator : std::false_type {};
658 template <typename T>
659 struct is_input_iterator<T, void_t<decltype(*std::declval<T &>()), decltype(++std::declval<T &>())>>
660 : std::true_type {};
661
662 template <typename T> using is_function_pointer = bool_constant<
663 std::is_pointer<T>::value && std::is_function<typename std::remove_pointer<T>::type>::value>;
664
665 template <typename F> struct strip_function_object {
666 using type = typename remove_class<decltype(&F::operator())>::type;
667 };
668
669 // Extracts the function signature from a function, function pointer or lambda.
670 template <typename Function, typename F = remove_reference_t<Function>>
671 using function_signature_t = conditional_t<
672 std::is_function<F>::value,
673 F,
674 typename conditional_t<
675 std::is_pointer<F>::value || std::is_member_pointer<F>::value,
676 std::remove_pointer<F>,
677 strip_function_object<F>
678 >::type
679 >;
680
681 /// Returns true if the type looks like a lambda: that is, isn't a function, pointer or member
682 /// pointer. Note that this can catch all sorts of other things, too; this is intended to be used
683 /// in a place where passing a lambda makes sense.
684 template <typename T> using is_lambda = satisfies_none_of<remove_reference_t<T>,
685 std::is_function, std::is_pointer, std::is_member_pointer>;
686
687 /// Ignore that a variable is unused in compiler warnings
688 inline void ignore_unused(const int *) { }
689
690 /// Apply a function over each element of a parameter pack
691 #ifdef __cpp_fold_expressions
692 #define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (((PATTERN), void()), ...)
693 #else
694 using expand_side_effects = bool[];
695 #define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (void)pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false }
696 #endif
697
698 PYBIND11_NAMESPACE_END(detail)
699
700 /// C++ bindings of builtin Python exceptions
701 class builtin_exception : public std::runtime_error {
702 public:
703 using std::runtime_error::runtime_error;
704 /// Set the error using the Python C API
705 virtual void set_error() const = 0;
706 };
707
708 #define PYBIND11_RUNTIME_EXCEPTION(name, type) \
709 class name : public builtin_exception { public: \
710 using builtin_exception::builtin_exception; \
711 name() : name("") { } \
712 void set_error() const override { PyErr_SetString(type, what()); } \
713 };
714
715 PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration)
716 PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError)
717 PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError)
718 PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError)
719 PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError)
720 PYBIND11_RUNTIME_EXCEPTION(buffer_error, PyExc_BufferError)
721 PYBIND11_RUNTIME_EXCEPTION(import_error, PyExc_ImportError)
722 PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
723 PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
724
725 [[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
726 [[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
727
728 template <typename T, typename SFINAE = void> struct format_descriptor { };
729
730 PYBIND11_NAMESPACE_BEGIN(detail)
731 // Returns the index of the given type in the type char array below, and in the list in numpy.h
732 // The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double;
733 // complex float,double,long double. Note that the long double types only participate when long
734 // double is actually longer than double (it isn't under MSVC).
735 // NB: not only the string below but also complex.h and numpy.h rely on this order.
736 template <typename T, typename SFINAE = void> struct is_fmt_numeric { static constexpr bool value = false; };
737 template <typename T> struct is_fmt_numeric<T, enable_if_t<std::is_arithmetic<T>::value>> {
738 static constexpr bool value = true;
739 static constexpr int index = std::is_same<T, bool>::value ? 0 : 1 + (
740 std::is_integral<T>::value ? detail::log2(sizeof(T))*2 + std::is_unsigned<T>::value : 8 + (
741 std::is_same<T, double>::value ? 1 : std::is_same<T, long double>::value ? 2 : 0));
742 };
743 PYBIND11_NAMESPACE_END(detail)
744
745 template <typename T> struct format_descriptor<T, detail::enable_if_t<std::is_arithmetic<T>::value>> {
746 static constexpr const char c = "?bBhHiIqQfdg"[detail::is_fmt_numeric<T>::index];
747 static constexpr const char value[2] = { c, '\0' };
748 static std::string format() { return std::string(1, c); }
749 };
750
751 #if !defined(PYBIND11_CPP17)
752
753 template <typename T> constexpr const char format_descriptor<
754 T, detail::enable_if_t<std::is_arithmetic<T>::value>>::value[2];
755
756 #endif
757
758 /// RAII wrapper that temporarily clears any Python error state
759 struct error_scope {
760 PyObject *type, *value, *trace;
761 error_scope() { PyErr_Fetch(&type, &value, &trace); }
762 ~error_scope() { PyErr_Restore(type, value, trace); }
763 };
764
765 /// Dummy destructor wrapper that can be used to expose classes with a private destructor
766 struct nodelete { template <typename T> void operator()(T*) { } };
767
768 PYBIND11_NAMESPACE_BEGIN(detail)
769 template <typename... Args>
770 struct overload_cast_impl {
771 constexpr overload_cast_impl() {}; // NOLINT(modernize-use-equals-default): MSVC 2015 needs this
772
773 template <typename Return>
774 constexpr auto operator()(Return (*pf)(Args...)) const noexcept
775 -> decltype(pf) { return pf; }
776
777 template <typename Return, typename Class>
778 constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
779 -> decltype(pmf) { return pmf; }
780
781 template <typename Return, typename Class>
782 constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
783 -> decltype(pmf) { return pmf; }
784 };
785 PYBIND11_NAMESPACE_END(detail)
786
787 // overload_cast requires variable templates: C++14
788 #if defined(PYBIND11_CPP14)
789 #define PYBIND11_OVERLOAD_CAST 1
790 /// Syntax sugar for resolving overloaded function pointers:
791 /// - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
792 /// - sweet: overload_cast<Arg0, Arg1, Arg2>(&Class::func)
793 template <typename... Args>
794 static constexpr detail::overload_cast_impl<Args...> overload_cast = {};
795 // MSVC 2015 only accepts this particular initialization syntax for this variable template.
796 #endif
797
798 /// Const member function selector for overload_cast
799 /// - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
800 /// - sweet: overload_cast<Arg>(&Class::func, const_)
801 static constexpr auto const_ = std::true_type{};
802
803 #if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails:
804 template <typename... Args> struct overload_cast {
805 static_assert(detail::deferred_t<std::false_type, Args...>::value,
806 "pybind11::overload_cast<...> requires compiling in C++14 mode");
807 };
808 #endif // overload_cast
809
810 PYBIND11_NAMESPACE_BEGIN(detail)
811
812 // Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from
813 // any standard container (or C-style array) supporting std::begin/std::end, any singleton
814 // arithmetic type (if T is arithmetic), or explicitly constructible from an iterator pair.
815 template <typename T>
816 class any_container {
817 std::vector<T> v;
818 public:
819 any_container() = default;
820
821 // Can construct from a pair of iterators
822 template <typename It, typename = enable_if_t<is_input_iterator<It>::value>>
823 any_container(It first, It last) : v(first, last) { }
824
825 // Implicit conversion constructor from any arbitrary container type with values convertible to T
826 template <typename Container, typename = enable_if_t<std::is_convertible<decltype(*std::begin(std::declval<const Container &>())), T>::value>>
827 any_container(const Container &c) : any_container(std::begin(c), std::end(c)) { }
828
829 // initializer_list's aren't deducible, so don't get matched by the above template; we need this
830 // to explicitly allow implicit conversion from one:
831 template <typename TIn, typename = enable_if_t<std::is_convertible<TIn, T>::value>>
832 any_container(const std::initializer_list<TIn> &c) : any_container(c.begin(), c.end()) { }
833
834 // Avoid copying if given an rvalue vector of the correct type.
835 any_container(std::vector<T> &&v) : v(std::move(v)) { }
836
837 // Moves the vector out of an rvalue any_container
838 operator std::vector<T> &&() && { return std::move(v); }
839
840 // Dereferencing obtains a reference to the underlying vector
841 std::vector<T> &operator*() { return v; }
842 const std::vector<T> &operator*() const { return v; }
843
844 // -> lets you call methods on the underlying vector
845 std::vector<T> *operator->() { return &v; }
846 const std::vector<T> *operator->() const { return &v; }
847 };
848
849 // Forward-declaration; see detail/class.h
850 std::string get_fully_qualified_tp_name(PyTypeObject*);
851
852 PYBIND11_NAMESPACE_END(detail)
853 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
854