common.h revision 14299:2fbea9df56d2
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 4 97#define PYBIND11_VERSION_PATCH 1 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(isalnum) 117# undef isalnum 118# undef isalpha 119# undef islower 120# undef isspace 121# undef isupper 122# undef tolower 123# undef toupper 124#endif 125 126#if defined(_MSC_VER) 127# if defined(PYBIND11_DEBUG_MARKER) 128# define _DEBUG 129# undef PYBIND11_DEBUG_MARKER 130# endif 131# pragma warning(pop) 132#endif 133 134#include <cstddef> 135#include <cstring> 136#include <forward_list> 137#include <vector> 138#include <string> 139#include <stdexcept> 140#include <unordered_set> 141#include <unordered_map> 142#include <memory> 143#include <typeindex> 144#include <type_traits> 145 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() 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_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(); \ 199 } \ 200 PyObject *pybind11_init_wrapper() 201#endif 202 203#if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200 204extern "C" { 205 struct _Py_atomic_address { void *value; }; 206 PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current; 207} 208#endif 209 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 214 215#define PYBIND11_CHECK_PYTHON_VERSION \ 216 { \ 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); \ 227 return nullptr; \ 228 } \ 229 } 230 231#define PYBIND11_CATCH_INIT_EXCEPTIONS \ 232 catch (pybind11::error_already_set &e) { \ 233 PyErr_SetString(PyExc_ImportError, e.what()); \ 234 return nullptr; \ 235 } catch (const std::exception &e) { \ 236 PyErr_SetString(PyExc_ImportError, e.what()); \ 237 return nullptr; \ 238 } \ 239 240/** \rst 241 ***Deprecated in favor of PYBIND11_MODULE*** 242 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. 246 247 .. code-block:: cpp 248 249 PYBIND11_PLUGIN(example) { 250 pybind11::module m("example", "pybind11 example plugin"); 251 /// Set up bindings here 252 return m.ptr(); 253 } 254\endrst */ 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 \ 260 try { \ 261 return pybind11_init(); \ 262 } PYBIND11_CATCH_INIT_EXCEPTIONS \ 263 } \ 264 PyObject *pybind11_init() 265 266/** \rst 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. 271 272 .. code-block:: cpp 273 274 PYBIND11_MODULE(example, m) { 275 m.doc() = "pybind11 example module"; 276 277 // Add bindings here 278 m.def("foo", []() { 279 return "Hello, World!"; 280 }); 281 } 282\endrst */ 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)); \ 288 try { \ 289 PYBIND11_CONCAT(pybind11_init_, name)(m); \ 290 return m.ptr(); \ 291 } PYBIND11_CATCH_INIT_EXCEPTIONS \ 292 } \ 293 void PYBIND11_CONCAT(pybind11_init_, name)(pybind11::module &variable) 294 295 296NAMESPACE_BEGIN(PYBIND11_NAMESPACE) 297 298using ssize_t = Py_ssize_t; 299using size_t = std::size_t; 300 301/// Approach used to cast a previously unknown C++ instance into a Python object 302enum 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. */ 308 automatic = 0, 309 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. */ 314 automatic_reference, 315 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.. */ 320 take_ownership, 321 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. */ 325 copy, 326 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 330 decoupled. */ 331 move, 332 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 337 Python. */ 338 reference, 339 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 */ 350 reference_internal 351}; 352 353NAMESPACE_BEGIN(detail) 354 355inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); } 356 357// Returns the size as a multiple of sizeof(void *), rounded up. 358inline static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> log2(sizeof(void *))); } 359 360/** 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>)). 365 */ 366constexpr 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>)); 370} 371 372// Forward declarations 373struct type_info; 374struct value_and_holder; 375 376struct nonsimple_values_and_holders { 377 void **values_and_holders; 378 uint8_t *status; 379}; 380 381/// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') 382struct instance { 383 PyObject_HEAD 384 /// Storage for pointers and holder; see simple_layout, below, for a description 385 union { 386 void *simple_value_holder[1 + instance_simple_holder_in_ptrs()]; 387 nonsimple_values_and_holders nonsimple; 388 }; 389 /// Weak references 390 PyObject *weakrefs; 391 /// If true, the pointer is owned which means we're free to manage it with a holder. 392 bool owned : 1; 393 /** 394 * An instance has two possible value/holder layouts. 395 * 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). 401 * 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). 411 * 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`. 415 */ 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; 423 424 /// Initializes all of the above type/values/holders data (but not the instance values themselves) 425 void allocate_layout(); 426 427 /// Destroys/deallocates all of the above 428 void deallocate_layout(); 429 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); 434 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; 438}; 439 440static_assert(std::is_standard_layout<instance>::value, "Internal error: `pybind11::detail::instance` is not standard layout!"); 441 442/// from __cpp_future__ import (convenient aliases from C++14/17) 443#if defined(PYBIND11_CPP14) && (!defined(_MSC_VER) || _MSC_VER >= 1910) 444using std::enable_if_t; 445using std::conditional_t; 446using std::remove_cv_t; 447using std::remove_reference_t; 448#else 449template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type; 450template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type; 451template <typename T> using remove_cv_t = typename std::remove_cv<T>::type; 452template <typename T> using remove_reference_t = typename std::remove_reference<T>::type; 453#endif 454 455/// Index sequences 456#if defined(PYBIND11_CPP14) 457using std::index_sequence; 458using std::make_index_sequence; 459#else 460template<size_t ...> struct index_sequence { }; 461template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { }; 462template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; }; 463template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type; 464#endif 465 466/// Make an index sequence of the indices of true arguments 467template <typename ISeq, size_t, bool...> struct select_indices_impl { using type = ISeq; }; 468template <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...> {}; 470template <bool... Bs> using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type; 471 472/// Backports of std::bool_constant and std::negation to accommodate older compilers 473template <bool B> using bool_constant = std::integral_constant<bool, B>; 474template <typename T> struct negation : bool_constant<!T::value> { }; 475 476template <typename...> struct void_t_impl { using type = void; }; 477template <typename... Ts> using void_t = typename void_t_impl<Ts...>::type; 478 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)) 481template <class... Ts> using all_of = bool_constant<(Ts::value && ...)>; 482template <class... Ts> using any_of = bool_constant<(Ts::value || ...)>; 483#elif !defined(_MSC_VER) 484template <bool...> struct bools {}; 485template <class... Ts> using all_of = std::is_same< 486 bools<Ts::value..., true>, 487 bools<true, Ts::value...>>; 488template <class... Ts> using any_of = negation<all_of<negation<Ts>...>>; 489#else 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). 492template <class... Ts> using all_of = std::conjunction<Ts...>; 493template <class... Ts> using any_of = std::disjunction<Ts...>; 494#endif 495template <class... Ts> using none_of = negation<any_of<Ts...>>; 496 497template <class T, template<class> class... Predicates> using satisfies_all_of = all_of<Predicates<T>...>; 498template <class T, template<class> class... Predicates> using satisfies_any_of = any_of<Predicates<T>...>; 499template <class T, template<class> class... Predicates> using satisfies_none_of = none_of<Predicates<T>...>; 500 501/// Strip the class from a method type 502template <typename T> struct remove_class { }; 503template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); }; 504template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { typedef R type(A...); }; 505 506/// Helper template to strip away type modifiers 507template <typename T> struct intrinsic_type { typedef T type; }; 508template <typename T> struct intrinsic_type<const T> { typedef typename intrinsic_type<T>::type type; }; 509template <typename T> struct intrinsic_type<T*> { typedef typename intrinsic_type<T>::type type; }; 510template <typename T> struct intrinsic_type<T&> { typedef typename intrinsic_type<T>::type type; }; 511template <typename T> struct intrinsic_type<T&&> { typedef typename intrinsic_type<T>::type type; }; 512template <typename T, size_t N> struct intrinsic_type<const T[N]> { typedef typename intrinsic_type<T>::type type; }; 513template <typename T, size_t N> struct intrinsic_type<T[N]> { typedef typename intrinsic_type<T>::type type; }; 514template <typename T> using intrinsic_t = typename intrinsic_type<T>::type; 515 516/// Helper type to replace 'void' in some expressions 517struct void_type { }; 518 519/// Helper template which holds a list of types 520template <typename...> struct type_list { }; 521 522/// Compile-time integer sum 523#ifdef __cpp_fold_expressions 524template <typename... Ts> constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); } 525#else 526constexpr size_t constexpr_sum() { return 0; } 527template <typename T, typename... Ts> 528constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); } 529#endif 530 531NAMESPACE_BEGIN(constexpr_impl) 532/// Implementation details for constexpr functions 533constexpr int first(int i) { return i; } 534template <typename T, typename... Ts> 535constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); } 536 537constexpr int last(int /*i*/, int result) { return result; } 538template <typename T, typename... Ts> 539constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); } 540NAMESPACE_END(constexpr_impl) 541 542/// Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if 543/// none match. 544template <template<typename> class Predicate, typename... Ts> 545constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); } 546 547/// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match. 548template <template<typename> class Predicate, typename... Ts> 549constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); } 550 551/// Return the Nth element from the parameter pack 552template <size_t N, typename T, typename... Ts> 553struct pack_element { using type = typename pack_element<N - 1, Ts...>::type; }; 554template <typename T, typename... Ts> 555struct pack_element<0, T, Ts...> { using type = T; }; 556 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. 559template <template<typename> class Predicate, typename Default, typename... Ts> 560struct exactly_one { 561 static constexpr auto found = constexpr_sum(Predicate<Ts>::value...); 562 static_assert(found <= 1, "Found more than one type matching the predicate"); 563 564 static constexpr auto index = found ? constexpr_first<Predicate, Ts...>() : 0; 565 using type = conditional_t<found, typename pack_element<index, Ts...>::type, Default>; 566}; 567template <template<typename> class P, typename Default> 568struct exactly_one<P, Default> { using type = Default; }; 569 570template <template<typename> class Predicate, typename Default, typename... Ts> 571using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type; 572 573/// Defer the evaluation of type T until types Us are instantiated 574template <typename T, typename... /*Us*/> struct deferred_type { using type = T; }; 575template <typename T, typename... Us> using deferred_t = typename deferred_type<T, Us...>::type; 576 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`) 579template <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>; 581 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) 584template <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>; 586 587template <template<typename...> class Base> 588struct 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 595template <template<typename...> class Base, typename T> 596#if !defined(_MSC_VER) 597using 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 599struct 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. 604template <template<typename...> class Class, typename T> 605struct is_instantiation : std::false_type { }; 606template <template<typename...> class Class, typename... Us> 607struct is_instantiation<Class, Class<Us...>> : std::true_type { }; 608 609/// Check if T is std::shared_ptr<U> where U can be anything 610template <typename T> using is_shared_ptr = is_instantiation<std::shared_ptr, T>; 611 612/// Check if T looks like an input iterator 613template <typename T, typename = void> struct is_input_iterator : std::false_type {}; 614template <typename T> 615struct is_input_iterator<T, void_t<decltype(*std::declval<T &>()), decltype(++std::declval<T &>())>> 616 : std::true_type {}; 617 618template <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 621template <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. 626template <typename Function, typename F = remove_reference_t<Function>> 627using 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. 640template <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 644inline 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 650using expand_side_effects = bool[]; 651#define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false } 652#endif 653 654NAMESPACE_END(detail) 655 656/// C++ bindings of builtin Python exceptions 657class builtin_exception : public std::runtime_error { 658public: 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 671PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration) 672PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError) 673PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError) 674PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError) 675PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError) 676PYBIND11_RUNTIME_EXCEPTION(buffer_error, PyExc_BufferError) 677PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error 678PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally 679 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); } 682 683template <typename T, typename SFINAE = void> struct format_descriptor { }; 684 685NAMESPACE_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. 691template <typename T, typename SFINAE = void> struct is_fmt_numeric { static constexpr bool value = false; }; 692template <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)); 697}; 698NAMESPACE_END(detail) 699 700template <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); } 704}; 705 706#if !defined(PYBIND11_CPP17) 707 708template <typename T> constexpr const char format_descriptor< 709 T, detail::enable_if_t<std::is_arithmetic<T>::value>>::value[2]; 710 711#endif 712 713/// RAII wrapper that temporarily clears any Python error state 714struct error_scope { 715 PyObject *type, *value, *trace; 716 error_scope() { PyErr_Fetch(&type, &value, &trace); } 717 ~error_scope() { PyErr_Restore(type, value, trace); } 718}; 719 720/// Dummy destructor wrapper that can be used to expose classes with a private destructor 721struct nodelete { template <typename T> void operator()(T*) { } }; 722 723NAMESPACE_BEGIN(detail) 724template <typename... Args> 725struct overload_cast_impl { 726 constexpr overload_cast_impl() {} // MSVC 2015 needs this 727 728 template <typename Return> 729 constexpr auto operator()(Return (*pf)(Args...)) const noexcept 730 -> decltype(pf) { return pf; } 731 732 template <typename Return, typename Class> 733 constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept 734 -> decltype(pmf) { return pmf; } 735 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; } 739}; 740NAMESPACE_END(detail) 741 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) 748template <typename... Args> 749static constexpr detail::overload_cast_impl<Args...> overload_cast = {}; 750// MSVC 2015 only accepts this particular initialization syntax for this variable template. 751#endif 752 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_) 756static constexpr auto const_ = std::true_type{}; 757 758#if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails: 759template <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"); 762}; 763#endif // overload_cast 764 765NAMESPACE_BEGIN(detail) 766 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. 770template <typename T> 771class any_container { 772 std::vector<T> v; 773public: 774 any_container() = default; 775 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) { } 779 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)) { } 783 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()) { } 788 789 // Avoid copying if given an rvalue vector of the correct type. 790 any_container(std::vector<T> &&v) : v(std::move(v)) { } 791 792 // Moves the vector out of an rvalue any_container 793 operator std::vector<T> &&() && { return std::move(v); } 794 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; } 798 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; } 802}; 803 804NAMESPACE_END(detail) 805 806 807 808NAMESPACE_END(PYBIND11_NAMESPACE) 809