2 pybind11/detail/common.h -- Basic macros
4 Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
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.
12 #if !defined(NAMESPACE_BEGIN)
13 # define NAMESPACE_BEGIN(name) namespace name {
15 #if !defined(NAMESPACE_END)
16 # define NAMESPACE_END(name) }
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)
24 # define PYBIND11_NAMESPACE pybind11 __attribute__((visibility("hidden")))
26 # define PYBIND11_NAMESPACE pybind11
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
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
48 // Compiler version assertions
49 #if defined(__INTEL_COMPILER)
50 # if __INTEL_COMPILER < 1700
51 # error pybind11 requires Intel C++ compiler v17 or newer
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
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
63 #elif defined(__GNUG__)
64 # if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
65 # error pybind11 requires gcc 4.8 or newer
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
75 #if !defined(PYBIND11_EXPORT)
76 # if defined(WIN32) || defined(_WIN32)
77 # define PYBIND11_EXPORT __declspec(dllexport)
79 # define PYBIND11_EXPORT __attribute__ ((visibility("default")))
84 # define PYBIND11_NOINLINE __declspec(noinline)
86 # define PYBIND11_NOINLINE __attribute__ ((noinline))
89 #if defined(PYBIND11_CPP14)
90 # define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
92 # define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
95 #define PYBIND11_VERSION_MAJOR 2
96 #define PYBIND11_VERSION_MINOR 4
97 #define PYBIND11_VERSION_PATCH 3
99 /// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
100 #if defined(_MSC_VER)
101 # if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 4)
102 # define HAVE_ROUND 1
104 # pragma warning(push)
105 # pragma warning(disable: 4510 4610 4512 4005)
107 # define PYBIND11_DEBUG_MARKER
113 #include <frameobject.h>
114 #include <pythread.h>
126 #if defined(_MSC_VER)
127 # if defined(PYBIND11_DEBUG_MARKER)
129 # undef PYBIND11_DEBUG_MARKER
131 # pragma warning(pop)
136 #include <forward_list>
140 #include <unordered_set>
141 #include <unordered_map>
144 #include <type_traits>
146 #if PY_MAJOR_VERSION >= 3 /// Compatibility macros for various Python versions
147 #define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
148 #define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check
149 #define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION
150 #define PYBIND11_BYTES_CHECK PyBytes_Check
151 #define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
152 #define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize
153 #define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize
154 #define PYBIND11_BYTES_AS_STRING PyBytes_AsString
155 #define PYBIND11_BYTES_SIZE PyBytes_Size
156 #define PYBIND11_LONG_CHECK(o) PyLong_Check(o)
157 #define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o)
158 #define PYBIND11_LONG_FROM_SIGNED(o) PyLong_FromSsize_t((ssize_t) o)
159 #define PYBIND11_LONG_FROM_UNSIGNED(o) PyLong_FromSize_t((size_t) o)
160 #define PYBIND11_BYTES_NAME "bytes"
161 #define PYBIND11_STRING_NAME "str"
162 #define PYBIND11_SLICE_OBJECT PyObject
163 #define PYBIND11_FROM_STRING PyUnicode_FromString
164 #define PYBIND11_STR_TYPE ::pybind11::str
165 #define PYBIND11_BOOL_ATTR "__bool__"
166 #define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_bool)
167 // Providing a separate declaration to make Clang's -Wmissing-prototypes happy
168 #define PYBIND11_PLUGIN_IMPL(name) \
169 extern "C" PYBIND11_EXPORT PyObject *PyInit_##name(); \
170 extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
173 #define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_)
174 #define PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check
175 #define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION
176 #define PYBIND11_BYTES_CHECK PyString_Check
177 #define PYBIND11_BYTES_FROM_STRING PyString_FromString
178 #define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize
179 #define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize
180 #define PYBIND11_BYTES_AS_STRING PyString_AsString
181 #define PYBIND11_BYTES_SIZE PyString_Size
182 #define PYBIND11_LONG_CHECK(o) (PyInt_Check(o) || PyLong_Check(o))
183 #define PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))
184 #define PYBIND11_LONG_FROM_SIGNED(o) PyInt_FromSsize_t((ssize_t) o) // Returns long if needed.
185 #define PYBIND11_LONG_FROM_UNSIGNED(o) PyInt_FromSize_t((size_t) o) // Returns long if needed.
186 #define PYBIND11_BYTES_NAME "str"
187 #define PYBIND11_STRING_NAME "unicode"
188 #define PYBIND11_SLICE_OBJECT PySliceObject
189 #define PYBIND11_FROM_STRING PyString_FromString
190 #define PYBIND11_STR_TYPE ::pybind11::bytes
191 #define PYBIND11_BOOL_ATTR "__nonzero__"
192 #define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_nonzero)
193 // Providing a separate PyInit decl to make Clang's -Wmissing-prototypes happy
194 #define PYBIND11_PLUGIN_IMPL(name) \
195 static PyObject *pybind11_init_wrapper(); \
196 extern "C" PYBIND11_EXPORT void init##name(); \
197 extern "C" PYBIND11_EXPORT void init##name() { \
198 (void)pybind11_init_wrapper(); \
200 PyObject *pybind11_init_wrapper()
203 #if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200
205 struct _Py_atomic_address { void *value; };
206 PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current;
210 #define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
211 #define PYBIND11_STRINGIFY(x) #x
212 #define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)
213 #define PYBIND11_CONCAT(first, second) first##second
215 #define PYBIND11_CHECK_PYTHON_VERSION \
217 const char *compiled_ver = PYBIND11_TOSTRING(PY_MAJOR_VERSION) \
218 "." PYBIND11_TOSTRING(PY_MINOR_VERSION); \
219 const char *runtime_ver = Py_GetVersion(); \
220 size_t len = std::strlen(compiled_ver); \
221 if (std::strncmp(runtime_ver, compiled_ver, len) != 0 \
222 || (runtime_ver[len] >= '0' && runtime_ver[len] <= '9')) { \
223 PyErr_Format(PyExc_ImportError, \
224 "Python version mismatch: module was compiled for Python %s, " \
225 "but the interpreter version is incompatible: %s.", \
226 compiled_ver, runtime_ver); \
231 #define PYBIND11_CATCH_INIT_EXCEPTIONS \
232 catch (pybind11::error_already_set &e) { \
233 PyErr_SetString(PyExc_ImportError, e.what()); \
235 } catch (const std::exception &e) { \
236 PyErr_SetString(PyExc_ImportError, e.what()); \
241 ***Deprecated in favor of PYBIND11_MODULE***
243 This macro creates the entry point that will be invoked when the Python interpreter
244 imports a plugin library. Please create a `module` in the function body and return
245 the pointer to its underlying Python object at the end.
249 PYBIND11_PLUGIN(example) {
250 pybind11::module m("example", "pybind11 example plugin");
251 /// Set up bindings here
255 #define PYBIND11_PLUGIN(name) \
256 PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE") \
257 static PyObject *pybind11_init(); \
258 PYBIND11_PLUGIN_IMPL(name) { \
259 PYBIND11_CHECK_PYTHON_VERSION \
261 return pybind11_init(); \
262 } PYBIND11_CATCH_INIT_EXCEPTIONS \
264 PyObject *pybind11_init()
267 This macro creates the entry point that will be invoked when the Python interpreter
268 imports an extension module. The module name is given as the fist argument and it
269 should not be in quotes. The second macro argument defines a variable of type
270 `py::module` which can be used to initialize the module.
274 PYBIND11_MODULE(example, m) {
275 m.doc() = "pybind11 example module";
279 return "Hello, World!";
283 #define PYBIND11_MODULE(name, variable) \
284 static void PYBIND11_CONCAT(pybind11_init_, name)(pybind11::module &); \
285 PYBIND11_PLUGIN_IMPL(name) { \
286 PYBIND11_CHECK_PYTHON_VERSION \
287 auto m = pybind11::module(PYBIND11_TOSTRING(name)); \
289 PYBIND11_CONCAT(pybind11_init_, name)(m); \
291 } PYBIND11_CATCH_INIT_EXCEPTIONS \
293 void PYBIND11_CONCAT(pybind11_init_, name)(pybind11::module &variable)
296 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
298 using ssize_t = Py_ssize_t;
299 using size_t = std::size_t;
301 /// Approach used to cast a previously unknown C++ instance into a Python object
302 enum class return_value_policy : uint8_t {
303 /** This is the default return value policy, which falls back to the policy
304 return_value_policy::take_ownership when the return value is a pointer.
305 Otherwise, it uses return_value::move or return_value::copy for rvalue
306 and lvalue references, respectively. See below for a description of what
307 all of these different policies do. */
310 /** As above, but use policy return_value_policy::reference when the return
311 value is a pointer. This is the default conversion policy for function
312 arguments when calling Python functions manually from C++ code (i.e. via
313 handle::operator()). You probably won't need to use this. */
316 /** Reference an existing object (i.e. do not create a new copy) and take
317 ownership. Python will call the destructor and delete operator when the
318 object’s reference count reaches zero. Undefined behavior ensues when
319 the C++ side does the same.. */
322 /** Create a new copy of the returned object, which will be owned by
323 Python. This policy is comparably safe because the lifetimes of the two
324 instances are decoupled. */
327 /** Use std::move to move the return value contents into a new instance
328 that will be owned by Python. This policy is comparably safe because the
329 lifetimes of the two instances (move source and destination) are
333 /** Reference an existing object, but do not take ownership. The C++ side
334 is responsible for managing the object’s lifetime and deallocating it
335 when it is no longer used. Warning: undefined behavior will ensue when
336 the C++ side deletes an object that is still referenced and used by
340 /** This policy only applies to methods and properties. It references the
341 object without taking ownership similar to the above
342 return_value_policy::reference policy. In contrast to that policy, the
343 function or property’s implicit this argument (called the parent) is
344 considered to be the the owner of the return value (the child).
345 pybind11 then couples the lifetime of the parent to the child via a
346 reference relationship that ensures that the parent cannot be garbage
347 collected while Python is still using the child. More advanced
348 variations of this scheme are also possible using combinations of
349 return_value_policy::reference and the keep_alive call policy */
353 NAMESPACE_BEGIN(detail)
355 inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); }
357 // Returns the size as a multiple of sizeof(void *), rounded up.
358 inline static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> log2(sizeof(void *))); }
361 * The space to allocate for simple layout instance holders (see below) in multiple of the size of
362 * a pointer (e.g. 2 means 16 bytes on 64-bit architectures). The default is the minimum required
363 * to holder either a std::unique_ptr or std::shared_ptr (which is almost always
364 * sizeof(std::shared_ptr<T>)).
366 constexpr size_t instance_simple_holder_in_ptrs() {
367 static_assert(sizeof(std::shared_ptr<int>) >= sizeof(std::unique_ptr<int>),
368 "pybind assumes std::shared_ptrs are at least as big as std::unique_ptrs");
369 return size_in_ptrs(sizeof(std::shared_ptr<int>));
372 // Forward declarations
374 struct value_and_holder;
376 struct nonsimple_values_and_holders {
377 void **values_and_holders;
381 /// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')
384 /// Storage for pointers and holder; see simple_layout, below, for a description
386 void *simple_value_holder[1 + instance_simple_holder_in_ptrs()];
387 nonsimple_values_and_holders nonsimple;
391 /// If true, the pointer is owned which means we're free to manage it with a holder.
394 * An instance has two possible value/holder layouts.
396 * Simple layout (when this flag is true), means the `simple_value_holder` is set with a pointer
397 * and the holder object governing that pointer, i.e. [val1*][holder]. This layout is applied
398 * whenever there is no python-side multiple inheritance of bound C++ types *and* the type's
399 * holder will fit in the default space (which is large enough to hold either a std::unique_ptr
400 * or std::shared_ptr).
402 * Non-simple layout applies when using custom holders that require more space than `shared_ptr`
403 * (which is typically the size of two pointers), or when multiple inheritance is used on the
404 * python side. Non-simple layout allocates the required amount of memory to have multiple
405 * bound C++ classes as parents. Under this layout, `nonsimple.values_and_holders` is set to a
406 * pointer to allocated space of the required space to hold a sequence of value pointers and
407 * holders followed `status`, a set of bit flags (1 byte each), i.e.
408 * [val1*][holder1][val2*][holder2]...[bb...] where each [block] is rounded up to a multiple of
409 * `sizeof(void *)`. `nonsimple.status` is, for convenience, a pointer to the
410 * beginning of the [bb...] block (but not independently allocated).
412 * Status bits indicate whether the associated holder is constructed (&
413 * status_holder_constructed) and whether the value pointer is registered (&
414 * status_instance_registered) in `registered_instances`.
416 bool simple_layout : 1;
417 /// For simple layout, tracks whether the holder has been constructed
418 bool simple_holder_constructed : 1;
419 /// For simple layout, tracks whether the instance is registered in `registered_instances`
420 bool simple_instance_registered : 1;
421 /// If true, get_internals().patients has an entry for this object
422 bool has_patients : 1;
424 /// Initializes all of the above type/values/holders data (but not the instance values themselves)
425 void allocate_layout();
427 /// Destroys/deallocates all of the above
428 void deallocate_layout();
430 /// Returns the value_and_holder wrapper for the given type (or the first, if `find_type`
431 /// omitted). Returns a default-constructed (with `.inst = nullptr`) object on failure if
432 /// `throw_if_missing` is false.
433 value_and_holder get_value_and_holder(const type_info *find_type = nullptr, bool throw_if_missing = true);
435 /// Bit values for the non-simple status flags
436 static constexpr uint8_t status_holder_constructed = 1;
437 static constexpr uint8_t status_instance_registered = 2;
440 static_assert(std::is_standard_layout<instance>::value, "Internal error: `pybind11::detail::instance` is not standard layout!");
442 /// from __cpp_future__ import (convenient aliases from C++14/17)
443 #if defined(PYBIND11_CPP14) && (!defined(_MSC_VER) || _MSC_VER >= 1910)
444 using std::enable_if_t;
445 using std::conditional_t;
446 using std::remove_cv_t;
447 using std::remove_reference_t;
449 template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
450 template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
451 template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
452 template <typename T> using remove_reference_t = typename std::remove_reference<T>::type;
456 #if defined(PYBIND11_CPP14)
457 using std::index_sequence;
458 using std::make_index_sequence;
460 template<size_t ...> struct index_sequence { };
461 template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { };
462 template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; };
463 template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type;
466 /// Make an index sequence of the indices of true arguments
467 template <typename ISeq, size_t, bool...> struct select_indices_impl { using type = ISeq; };
468 template <size_t... IPrev, size_t I, bool B, bool... Bs> struct select_indices_impl<index_sequence<IPrev...>, I, B, Bs...>
469 : select_indices_impl<conditional_t<B, index_sequence<IPrev..., I>, index_sequence<IPrev...>>, I + 1, Bs...> {};
470 template <bool... Bs> using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type;
472 /// Backports of std::bool_constant and std::negation to accommodate older compilers
473 template <bool B> using bool_constant = std::integral_constant<bool, B>;
474 template <typename T> struct negation : bool_constant<!T::value> { };
476 template <typename...> struct void_t_impl { using type = void; };
477 template <typename... Ts> using void_t = typename void_t_impl<Ts...>::type;
479 /// Compile-time all/any/none of that check the boolean value of all template types
480 #if defined(__cpp_fold_expressions) && !(defined(_MSC_VER) && (_MSC_VER < 1916))
481 template <class... Ts> using all_of = bool_constant<(Ts::value && ...)>;
482 template <class... Ts> using any_of = bool_constant<(Ts::value || ...)>;
483 #elif !defined(_MSC_VER)
484 template <bool...> struct bools {};
485 template <class... Ts> using all_of = std::is_same<
486 bools<Ts::value..., true>,
487 bools<true, Ts::value...>>;
488 template <class... Ts> using any_of = negation<all_of<negation<Ts>...>>;
490 // MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit
491 // at a slight loss of compilation efficiency).
492 template <class... Ts> using all_of = std::conjunction<Ts...>;
493 template <class... Ts> using any_of = std::disjunction<Ts...>;
495 template <class... Ts> using none_of = negation<any_of<Ts...>>;
497 template <class T, template<class> class... Predicates> using satisfies_all_of = all_of<Predicates<T>...>;
498 template <class T, template<class> class... Predicates> using satisfies_any_of = any_of<Predicates<T>...>;
499 template <class T, template<class> class... Predicates> using satisfies_none_of = none_of<Predicates<T>...>;
501 /// Strip the class from a method type
502 template <typename T> struct remove_class { };
503 template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); };
504 template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { typedef R type(A...); };
506 /// Helper template to strip away type modifiers
507 template <typename T> struct intrinsic_type { typedef T type; };
508 template <typename T> struct intrinsic_type<const T> { typedef typename intrinsic_type<T>::type type; };
509 template <typename T> struct intrinsic_type<T*> { typedef typename intrinsic_type<T>::type type; };
510 template <typename T> struct intrinsic_type<T&> { typedef typename intrinsic_type<T>::type type; };
511 template <typename T> struct intrinsic_type<T&&> { typedef typename intrinsic_type<T>::type type; };
512 template <typename T, size_t N> struct intrinsic_type<const T[N]> { typedef typename intrinsic_type<T>::type type; };
513 template <typename T, size_t N> struct intrinsic_type<T[N]> { typedef typename intrinsic_type<T>::type type; };
514 template <typename T> using intrinsic_t = typename intrinsic_type<T>::type;
516 /// Helper type to replace 'void' in some expressions
517 struct void_type { };
519 /// Helper template which holds a list of types
520 template <typename...> struct type_list { };
522 /// Compile-time integer sum
523 #ifdef __cpp_fold_expressions
524 template <typename... Ts> constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); }
526 constexpr size_t constexpr_sum() { return 0; }
527 template <typename T, typename... Ts>
528 constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
531 NAMESPACE_BEGIN(constexpr_impl)
532 /// Implementation details for constexpr functions
533 constexpr int first(int i) { return i; }
534 template <typename T, typename... Ts>
535 constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }
537 constexpr int last(int /*i*/, int result) { return result; }
538 template <typename T, typename... Ts>
539 constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
540 NAMESPACE_END(constexpr_impl)
542 /// Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if
544 template <template<typename> class Predicate, typename... Ts>
545 constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }
547 /// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
548 template <template<typename> class Predicate, typename... Ts>
549 constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }
551 /// Return the Nth element from the parameter pack
552 template <size_t N, typename T, typename... Ts>
553 struct pack_element { using type = typename pack_element<N - 1, Ts...>::type; };
554 template <typename T, typename... Ts>
555 struct pack_element<0, T, Ts...> { using type = T; };
557 /// Return the one and only type which matches the predicate, or Default if none match.
558 /// If more than one type matches the predicate, fail at compile-time.
559 template <template<typename> class Predicate, typename Default, typename... Ts>
561 static constexpr auto found = constexpr_sum(Predicate<Ts>::value...);
562 static_assert(found <= 1, "Found more than one type matching the predicate");
564 static constexpr auto index = found ? constexpr_first<Predicate, Ts...>() : 0;
565 using type = conditional_t<found, typename pack_element<index, Ts...>::type, Default>;
567 template <template<typename> class P, typename Default>
568 struct exactly_one<P, Default> { using type = Default; };
570 template <template<typename> class Predicate, typename Default, typename... Ts>
571 using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type;
573 /// Defer the evaluation of type T until types Us are instantiated
574 template <typename T, typename... /*Us*/> struct deferred_type { using type = T; };
575 template <typename T, typename... Us> using deferred_t = typename deferred_type<T, Us...>::type;
577 /// Like is_base_of, but requires a strict base (i.e. `is_strict_base_of<T, T>::value == false`,
578 /// unlike `std::is_base_of`)
579 template <typename Base, typename Derived> using is_strict_base_of = bool_constant<
580 std::is_base_of<Base, Derived>::value && !std::is_same<Base, Derived>::value>;
582 /// Like is_base_of, but also requires that the base type is accessible (i.e. that a Derived pointer
583 /// can be converted to a Base pointer)
584 template <typename Base, typename Derived> using is_accessible_base_of = bool_constant<
585 std::is_base_of<Base, Derived>::value && std::is_convertible<Derived *, Base *>::value>;
587 template <template<typename...> class Base>
588 struct is_template_base_of_impl {
589 template <typename... Us> static std::true_type check(Base<Us...> *);
590 static std::false_type check(...);
593 /// Check if a template is the base of a type. For example:
594 /// `is_template_base_of<Base, T>` is true if `struct T : Base<U> {}` where U can be anything
595 template <template<typename...> class Base, typename T>
596 #if !defined(_MSC_VER)
597 using is_template_base_of = decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T>*)nullptr));
598 #else // MSVC2015 has trouble with decltype in template aliases
599 struct is_template_base_of : decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T>*)nullptr)) { };
602 /// Check if T is an instantiation of the template `Class`. For example:
603 /// `is_instantiation<shared_ptr, T>` is true if `T == shared_ptr<U>` where U can be anything.
604 template <template<typename...> class Class, typename T>
605 struct is_instantiation : std::false_type { };
606 template <template<typename...> class Class, typename... Us>
607 struct is_instantiation<Class, Class<Us...>> : std::true_type { };
609 /// Check if T is std::shared_ptr<U> where U can be anything
610 template <typename T> using is_shared_ptr = is_instantiation<std::shared_ptr, T>;
612 /// Check if T looks like an input iterator
613 template <typename T, typename = void> struct is_input_iterator : std::false_type {};
614 template <typename T>
615 struct is_input_iterator<T, void_t<decltype(*std::declval<T &>()), decltype(++std::declval<T &>())>>
618 template <typename T> using is_function_pointer = bool_constant<
619 std::is_pointer<T>::value && std::is_function<typename std::remove_pointer<T>::type>::value>;
621 template <typename F> struct strip_function_object {
622 using type = typename remove_class<decltype(&F::operator())>::type;
625 // Extracts the function signature from a function, function pointer or lambda.
626 template <typename Function, typename F = remove_reference_t<Function>>
627 using function_signature_t = conditional_t<
628 std::is_function<F>::value,
630 typename conditional_t<
631 std::is_pointer<F>::value || std::is_member_pointer<F>::value,
632 std::remove_pointer<F>,
633 strip_function_object<F>
637 /// Returns true if the type looks like a lambda: that is, isn't a function, pointer or member
638 /// pointer. Note that this can catch all sorts of other things, too; this is intended to be used
639 /// in a place where passing a lambda makes sense.
640 template <typename T> using is_lambda = satisfies_none_of<remove_reference_t<T>,
641 std::is_function, std::is_pointer, std::is_member_pointer>;
643 /// Ignore that a variable is unused in compiler warnings
644 inline void ignore_unused(const int *) { }
646 /// Apply a function over each element of a parameter pack
647 #ifdef __cpp_fold_expressions
648 #define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (((PATTERN), void()), ...)
650 using expand_side_effects = bool[];
651 #define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false }
654 NAMESPACE_END(detail)
656 /// C++ bindings of builtin Python exceptions
657 class builtin_exception : public std::runtime_error {
659 using std::runtime_error::runtime_error;
660 /// Set the error using the Python C API
661 virtual void set_error() const = 0;
664 #define PYBIND11_RUNTIME_EXCEPTION(name, type) \
665 class name : public builtin_exception { public: \
666 using builtin_exception::builtin_exception; \
667 name() : name("") { } \
668 void set_error() const override { PyErr_SetString(type, what()); } \
671 PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration)
672 PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError)
673 PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError)
674 PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError)
675 PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError)
676 PYBIND11_RUNTIME_EXCEPTION(buffer_error, PyExc_BufferError)
677 PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
678 PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
680 [[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
681 [[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
683 template <typename T, typename SFINAE = void> struct format_descriptor { };
685 NAMESPACE_BEGIN(detail)
686 // Returns the index of the given type in the type char array below, and in the list in numpy.h
687 // The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double;
688 // complex float,double,long double. Note that the long double types only participate when long
689 // double is actually longer than double (it isn't under MSVC).
690 // NB: not only the string below but also complex.h and numpy.h rely on this order.
691 template <typename T, typename SFINAE = void> struct is_fmt_numeric { static constexpr bool value = false; };
692 template <typename T> struct is_fmt_numeric<T, enable_if_t<std::is_arithmetic<T>::value>> {
693 static constexpr bool value = true;
694 static constexpr int index = std::is_same<T, bool>::value ? 0 : 1 + (
695 std::is_integral<T>::value ? detail::log2(sizeof(T))*2 + std::is_unsigned<T>::value : 8 + (
696 std::is_same<T, double>::value ? 1 : std::is_same<T, long double>::value ? 2 : 0));
698 NAMESPACE_END(detail)
700 template <typename T> struct format_descriptor<T, detail::enable_if_t<std::is_arithmetic<T>::value>> {
701 static constexpr const char c = "?bBhHiIqQfdg"[detail::is_fmt_numeric<T>::index];
702 static constexpr const char value[2] = { c, '\0' };
703 static std::string format() { return std::string(1, c); }
706 #if !defined(PYBIND11_CPP17)
708 template <typename T> constexpr const char format_descriptor<
709 T, detail::enable_if_t<std::is_arithmetic<T>::value>>::value[2];
713 /// RAII wrapper that temporarily clears any Python error state
715 PyObject *type, *value, *trace;
716 error_scope() { PyErr_Fetch(&type, &value, &trace); }
717 ~error_scope() { PyErr_Restore(type, value, trace); }
720 /// Dummy destructor wrapper that can be used to expose classes with a private destructor
721 struct nodelete { template <typename T> void operator()(T*) { } };
723 NAMESPACE_BEGIN(detail)
724 template <typename... Args>
725 struct overload_cast_impl {
726 constexpr overload_cast_impl() {} // MSVC 2015 needs this
728 template <typename Return>
729 constexpr auto operator()(Return (*pf)(Args...)) const noexcept
730 -> decltype(pf) { return pf; }
732 template <typename Return, typename Class>
733 constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
734 -> decltype(pmf) { return pmf; }
736 template <typename Return, typename Class>
737 constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
738 -> decltype(pmf) { return pmf; }
740 NAMESPACE_END(detail)
742 // overload_cast requires variable templates: C++14
743 #if defined(PYBIND11_CPP14)
744 #define PYBIND11_OVERLOAD_CAST 1
745 /// Syntax sugar for resolving overloaded function pointers:
746 /// - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
747 /// - sweet: overload_cast<Arg0, Arg1, Arg2>(&Class::func)
748 template <typename... Args>
749 static constexpr detail::overload_cast_impl<Args...> overload_cast = {};
750 // MSVC 2015 only accepts this particular initialization syntax for this variable template.
753 /// Const member function selector for overload_cast
754 /// - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
755 /// - sweet: overload_cast<Arg>(&Class::func, const_)
756 static constexpr auto const_ = std::true_type{};
758 #if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails:
759 template <typename... Args> struct overload_cast {
760 static_assert(detail::deferred_t<std::false_type, Args...>::value,
761 "pybind11::overload_cast<...> requires compiling in C++14 mode");
763 #endif // overload_cast
765 NAMESPACE_BEGIN(detail)
767 // Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from
768 // any standard container (or C-style array) supporting std::begin/std::end, any singleton
769 // arithmetic type (if T is arithmetic), or explicitly constructible from an iterator pair.
770 template <typename T>
771 class any_container {
774 any_container() = default;
776 // Can construct from a pair of iterators
777 template <typename It, typename = enable_if_t<is_input_iterator<It>::value>>
778 any_container(It first, It last) : v(first, last) { }
780 // Implicit conversion constructor from any arbitrary container type with values convertible to T
781 template <typename Container, typename = enable_if_t<std::is_convertible<decltype(*std::begin(std::declval<const Container &>())), T>::value>>
782 any_container(const Container &c) : any_container(std::begin(c), std::end(c)) { }
784 // initializer_list's aren't deducible, so don't get matched by the above template; we need this
785 // to explicitly allow implicit conversion from one:
786 template <typename TIn, typename = enable_if_t<std::is_convertible<TIn, T>::value>>
787 any_container(const std::initializer_list<TIn> &c) : any_container(c.begin(), c.end()) { }
789 // Avoid copying if given an rvalue vector of the correct type.
790 any_container(std::vector<T> &&v) : v(std::move(v)) { }
792 // Moves the vector out of an rvalue any_container
793 operator std::vector<T> &&() && { return std::move(v); }
795 // Dereferencing obtains a reference to the underlying vector
796 std::vector<T> &operator*() { return v; }
797 const std::vector<T> &operator*() const { return v; }
799 // -> lets you call methods on the underlying vector
800 std::vector<T> *operator->() { return &v; }
801 const std::vector<T> *operator->() const { return &v; }
804 NAMESPACE_END(detail)
808 NAMESPACE_END(PYBIND11_NAMESPACE)