python_packaging/src/external/pybind/include/pybind11/detail/common.h

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