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