858 lines
39 KiB
C
858 lines
39 KiB
C
|
/*
|
|||
|
|
pybind11/common.h -- Basic macros
|
|||
|
|
|
|||
|
|
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
|
|||
|
|
|
|||
|
|
All rights reserved. Use of this source code is governed by a
|
|||
|
|
BSD-style license that can be found in the LICENSE file.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#pragma once
|
|||
|
|
|
|||
|
|
#if !defined(NAMESPACE_BEGIN)
|
|||
|
|
# define NAMESPACE_BEGIN(name) namespace name {
|
|||
|
|
#endif
|
|||
|
|
#if !defined(NAMESPACE_END)
|
|||
|
|
# define NAMESPACE_END(name) }
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
|
|||
|
|
# if __cplusplus >= 201402L
|
|||
|
|
# define PYBIND11_CPP14
|
|||
|
|
# if __cplusplus > 201402L /* Temporary: should be updated to >= the final C++17 value once known */
|
|||
|
|
# define PYBIND11_CPP17
|
|||
|
|
# endif
|
|||
|
|
# endif
|
|||
|
|
#elif defined(_MSC_VER)
|
|||
|
|
// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
|
|||
|
|
# if _MSVC_LANG >= 201402L
|
|||
|
|
# define PYBIND11_CPP14
|
|||
|
|
# if _MSVC_LANG > 201402L && _MSC_VER >= 1910
|
|||
|
|
# define PYBIND11_CPP17
|
|||
|
|
# endif
|
|||
|
|
# endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Compiler version assertions
|
|||
|
|
#if defined(__INTEL_COMPILER)
|
|||
|
|
# if __INTEL_COMPILER < 1500
|
|||
|
|
# error pybind11 requires Intel C++ compiler v15 or newer
|
|||
|
|
# endif
|
|||
|
|
#elif defined(__clang__) && !defined(__apple_build_version__)
|
|||
|
|
# if __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 3)
|
|||
|
|
# error pybind11 requires clang 3.3 or newer
|
|||
|
|
# endif
|
|||
|
|
#elif defined(__clang__)
|
|||
|
|
// Apple changes clang version macros to its Xcode version; the first Xcode release based on
|
|||
|
|
// (upstream) clang 3.3 was Xcode 5:
|
|||
|
|
# if __clang_major__ < 5
|
|||
|
|
# error pybind11 requires Xcode/clang 5.0 or newer
|
|||
|
|
# endif
|
|||
|
|
#elif defined(__GNUG__)
|
|||
|
|
# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
|
|||
|
|
# error pybind11 requires gcc 4.8 or newer
|
|||
|
|
# endif
|
|||
|
|
#elif defined(_MSC_VER)
|
|||
|
|
// Pybind hits various compiler bugs in 2015u2 and earlier, and also makes use of some stl features
|
|||
|
|
// (e.g. std::negation) added in 2015u3:
|
|||
|
|
# if _MSC_FULL_VER < 190024210
|
|||
|
|
# error pybind11 requires MSVC 2015 update 3 or newer
|
|||
|
|
# endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if !defined(PYBIND11_EXPORT)
|
|||
|
|
# if defined(WIN32) || defined(_WIN32)
|
|||
|
|
# define PYBIND11_EXPORT __declspec(dllexport)
|
|||
|
|
# else
|
|||
|
|
# define PYBIND11_EXPORT __attribute__ ((visibility("default")))
|
|||
|
|
# endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined(_MSC_VER)
|
|||
|
|
# define PYBIND11_NOINLINE __declspec(noinline)
|
|||
|
|
#else
|
|||
|
|
# define PYBIND11_NOINLINE __attribute__ ((noinline))
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined(PYBIND11_CPP14)
|
|||
|
|
# define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
|
|||
|
|
#else
|
|||
|
|
# define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#define PYBIND11_VERSION_MAJOR 2
|
|||
|
|
#define PYBIND11_VERSION_MINOR 2
|
|||
|
|
#define PYBIND11_VERSION_PATCH dev0
|
|||
|
|
|
|||
|
|
/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
|
|||
|
|
#if defined(_MSC_VER)
|
|||
|
|
# if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 4)
|
|||
|
|
# define HAVE_ROUND 1
|
|||
|
|
# endif
|
|||
|
|
# pragma warning(push)
|
|||
|
|
# pragma warning(disable: 4510 4610 4512 4005)
|
|||
|
|
# if defined(_DEBUG)
|
|||
|
|
# define PYBIND11_DEBUG_MARKER
|
|||
|
|
# undef _DEBUG
|
|||
|
|
# endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#include <Python.h>
|
|||
|
|
#include <frameobject.h>
|
|||
|
|
#include <pythread.h>
|
|||
|
|
|
|||
|
|
#if defined(_WIN32) && (defined(min) || defined(max))
|
|||
|
|
# error Macro clash with min and max -- define NOMINMAX when compiling your program on Windows
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined(isalnum)
|
|||
|
|
# undef isalnum
|
|||
|
|
# undef isalpha
|
|||
|
|
# undef islower
|
|||
|
|
# undef isspace
|
|||
|
|
# undef isupper
|
|||
|
|
# undef tolower
|
|||
|
|
# undef toupper
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined(_MSC_VER)
|
|||
|
|
# if defined(PYBIND11_DEBUG_MARKER)
|
|||
|
|
# define _DEBUG
|
|||
|
|
# undef PYBIND11_DEBUG_MARKER
|
|||
|
|
# endif
|
|||
|
|
# pragma warning(pop)
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#include <cstddef>
|
|||
|
|
#include <cstring>
|
|||
|
|
#include <forward_list>
|
|||
|
|
#include <vector>
|
|||
|
|
#include <string>
|
|||
|
|
#include <stdexcept>
|
|||
|
|
#include <unordered_set>
|
|||
|
|
#include <unordered_map>
|
|||
|
|
#include <memory>
|
|||
|
|
#include <typeindex>
|
|||
|
|
#include <type_traits>
|
|||
|
|
|
|||
|
|
#if PY_MAJOR_VERSION >= 3 /// Compatibility macros for various Python versions
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION
|
|||
|
|
#define PYBIND11_BYTES_CHECK PyBytes_Check
|
|||
|
|
#define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
|
|||
|
|
#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize
|
|||
|
|
#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize
|
|||
|
|
#define PYBIND11_BYTES_AS_STRING PyBytes_AsString
|
|||
|
|
#define PYBIND11_BYTES_SIZE PyBytes_Size
|
|||
|
|
#define PYBIND11_LONG_CHECK(o) PyLong_Check(o)
|
|||
|
|
#define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o)
|
|||
|
|
#define PYBIND11_BYTES_NAME "bytes"
|
|||
|
|
#define PYBIND11_STRING_NAME "str"
|
|||
|
|
#define PYBIND11_SLICE_OBJECT PyObject
|
|||
|
|
#define PYBIND11_FROM_STRING PyUnicode_FromString
|
|||
|
|
#define PYBIND11_STR_TYPE ::pybind11::str
|
|||
|
|
#define PYBIND11_BOOL_ATTR "__bool__"
|
|||
|
|
#define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_bool)
|
|||
|
|
#define PYBIND11_PLUGIN_IMPL(name) \
|
|||
|
|
extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
|
|||
|
|
|
|||
|
|
#else
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_)
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check
|
|||
|
|
#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION
|
|||
|
|
#define PYBIND11_BYTES_CHECK PyString_Check
|
|||
|
|
#define PYBIND11_BYTES_FROM_STRING PyString_FromString
|
|||
|
|
#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize
|
|||
|
|
#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize
|
|||
|
|
#define PYBIND11_BYTES_AS_STRING PyString_AsString
|
|||
|
|
#define PYBIND11_BYTES_SIZE PyString_Size
|
|||
|
|
#define PYBIND11_LONG_CHECK(o) (PyInt_Check(o) || PyLong_Check(o))
|
|||
|
|
#define PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))
|
|||
|
|
#define PYBIND11_BYTES_NAME "str"
|
|||
|
|
#define PYBIND11_STRING_NAME "unicode"
|
|||
|
|
#define PYBIND11_SLICE_OBJECT PySliceObject
|
|||
|
|
#define PYBIND11_FROM_STRING PyString_FromString
|
|||
|
|
#define PYBIND11_STR_TYPE ::pybind11::bytes
|
|||
|
|
#define PYBIND11_BOOL_ATTR "__nonzero__"
|
|||
|
|
#define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_nonzero)
|
|||
|
|
#define PYBIND11_PLUGIN_IMPL(name) \
|
|||
|
|
static PyObject *pybind11_init_wrapper(); \
|
|||
|
|
extern "C" PYBIND11_EXPORT void init##name() { \
|
|||
|
|
(void)pybind11_init_wrapper(); \
|
|||
|
|
} \
|
|||
|
|
PyObject *pybind11_init_wrapper()
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200
|
|||
|
|
extern "C" {
|
|||
|
|
struct _Py_atomic_address { void *value; };
|
|||
|
|
PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
|
|||
|
|
#define PYBIND11_STRINGIFY(x) #x
|
|||
|
|
#define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)
|
|||
|
|
#define PYBIND11_INTERNALS_ID "__pybind11_" \
|
|||
|
|
PYBIND11_TOSTRING(PYBIND11_VERSION_MAJOR) "_" PYBIND11_TOSTRING(PYBIND11_VERSION_MINOR) "__"
|
|||
|
|
|
|||
|
|
/** \rst
|
|||
|
|
***Deprecated in favor of PYBIND11_MODULE***
|
|||
|
|
|
|||
|
|
This macro creates the entry point that will be invoked when the Python interpreter
|
|||
|
|
imports a plugin library. Please create a `module` in the function body and return
|
|||
|
|
the pointer to its underlying Python object at the end.
|
|||
|
|
|
|||
|
|
.. code-block:: cpp
|
|||
|
|
|
|||
|
|
PYBIND11_PLUGIN(example) {
|
|||
|
|
pybind11::module m("example", "pybind11 example plugin");
|
|||
|
|
/// Set up bindings here
|
|||
|
|
return m.ptr();
|
|||
|
|
}
|
|||
|
|
\endrst */
|
|||
|
|
#define PYBIND11_PLUGIN(name) \
|
|||
|
|
PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE") \
|
|||
|
|
static PyObject *pybind11_init(); \
|
|||
|
|
PYBIND11_PLUGIN_IMPL(name) { \
|
|||
|
|
int major, minor; \
|
|||
|
|
if (sscanf(Py_GetVersion(), "%i.%i", &major, &minor) != 2) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, "Can't parse Python version."); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} else if (major != PY_MAJOR_VERSION || minor != PY_MINOR_VERSION) { \
|
|||
|
|
PyErr_Format(PyExc_ImportError, \
|
|||
|
|
"Python version mismatch: module was compiled for " \
|
|||
|
|
"version %i.%i, while the interpreter is running " \
|
|||
|
|
"version %i.%i.", PY_MAJOR_VERSION, PY_MINOR_VERSION, \
|
|||
|
|
major, minor); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} \
|
|||
|
|
try { \
|
|||
|
|
return pybind11_init(); \
|
|||
|
|
} catch (pybind11::error_already_set &e) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, e.what()); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} catch (const std::exception &e) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, e.what()); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} \
|
|||
|
|
} \
|
|||
|
|
PyObject *pybind11_init()
|
|||
|
|
|
|||
|
|
/** \rst
|
|||
|
|
This macro creates the entry point that will be invoked when the Python interpreter
|
|||
|
|
imports an extension module. The module name is given as the fist argument and it
|
|||
|
|
should not be in quotes. The second macro argument defines a variable of type
|
|||
|
|
`py::module` which can be used to initialize the module.
|
|||
|
|
|
|||
|
|
.. code-block:: cpp
|
|||
|
|
|
|||
|
|
PYBIND11_MODULE(example, m) {
|
|||
|
|
m.doc() = "pybind11 example module";
|
|||
|
|
|
|||
|
|
// Add bindings here
|
|||
|
|
m.def("foo", []() {
|
|||
|
|
return "Hello, World!";
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
\endrst */
|
|||
|
|
#define PYBIND11_MODULE(name, variable) \
|
|||
|
|
static void pybind11_init_##name(pybind11::module &); \
|
|||
|
|
PYBIND11_PLUGIN_IMPL(name) { \
|
|||
|
|
int major, minor; \
|
|||
|
|
if (sscanf(Py_GetVersion(), "%i.%i", &major, &minor) != 2) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, "Can't parse Python version."); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} else if (major != PY_MAJOR_VERSION || minor != PY_MINOR_VERSION) { \
|
|||
|
|
PyErr_Format(PyExc_ImportError, \
|
|||
|
|
"Python version mismatch: module was compiled for " \
|
|||
|
|
"version %i.%i, while the interpreter is running " \
|
|||
|
|
"version %i.%i.", PY_MAJOR_VERSION, PY_MINOR_VERSION, \
|
|||
|
|
major, minor); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} \
|
|||
|
|
auto m = pybind11::module(#name); \
|
|||
|
|
try { \
|
|||
|
|
pybind11_init_##name(m); \
|
|||
|
|
return m.ptr(); \
|
|||
|
|
} catch (pybind11::error_already_set &e) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, e.what()); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} catch (const std::exception &e) { \
|
|||
|
|
PyErr_SetString(PyExc_ImportError, e.what()); \
|
|||
|
|
return nullptr; \
|
|||
|
|
} \
|
|||
|
|
} \
|
|||
|
|
void pybind11_init_##name(pybind11::module &variable)
|
|||
|
|
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(pybind11)
|
|||
|
|
|
|||
|
|
using ssize_t = Py_ssize_t;
|
|||
|
|
using size_t = std::size_t;
|
|||
|
|
|
|||
|
|
/// Approach used to cast a previously unknown C++ instance into a Python object
|
|||
|
|
enum class return_value_policy : uint8_t {
|
|||
|
|
/** This is the default return value policy, which falls back to the policy
|
|||
|
|
return_value_policy::take_ownership when the return value is a pointer.
|
|||
|
|
Otherwise, it uses return_value::move or return_value::copy for rvalue
|
|||
|
|
and lvalue references, respectively. See below for a description of what
|
|||
|
|
all of these different policies do. */
|
|||
|
|
automatic = 0,
|
|||
|
|
|
|||
|
|
/** As above, but use policy return_value_policy::reference when the return
|
|||
|
|
value is a pointer. This is the default conversion policy for function
|
|||
|
|
arguments when calling Python functions manually from C++ code (i.e. via
|
|||
|
|
handle::operator()). You probably won't need to use this. */
|
|||
|
|
automatic_reference,
|
|||
|
|
|
|||
|
|
/** Reference an existing object (i.e. do not create a new copy) and take
|
|||
|
|
ownership. Python will call the destructor and delete operator when the
|
|||
|
|
object’s reference count reaches zero. Undefined behavior ensues when
|
|||
|
|
the C++ side does the same.. */
|
|||
|
|
take_ownership,
|
|||
|
|
|
|||
|
|
/** Create a new copy of the returned object, which will be owned by
|
|||
|
|
Python. This policy is comparably safe because the lifetimes of the two
|
|||
|
|
instances are decoupled. */
|
|||
|
|
copy,
|
|||
|
|
|
|||
|
|
/** Use std::move to move the return value contents into a new instance
|
|||
|
|
that will be owned by Python. This policy is comparably safe because the
|
|||
|
|
lifetimes of the two instances (move source and destination) are
|
|||
|
|
decoupled. */
|
|||
|
|
move,
|
|||
|
|
|
|||
|
|
/** Reference an existing object, but do not take ownership. The C++ side
|
|||
|
|
is responsible for managing the object’s lifetime and deallocating it
|
|||
|
|
when it is no longer used. Warning: undefined behavior will ensue when
|
|||
|
|
the C++ side deletes an object that is still referenced and used by
|
|||
|
|
Python. */
|
|||
|
|
reference,
|
|||
|
|
|
|||
|
|
/** This policy only applies to methods and properties. It references the
|
|||
|
|
object without taking ownership similar to the above
|
|||
|
|
return_value_policy::reference policy. In contrast to that policy, the
|
|||
|
|
function or property’s implicit this argument (called the parent) is
|
|||
|
|
considered to be the the owner of the return value (the child).
|
|||
|
|
pybind11 then couples the lifetime of the parent to the child via a
|
|||
|
|
reference relationship that ensures that the parent cannot be garbage
|
|||
|
|
collected while Python is still using the child. More advanced
|
|||
|
|
variations of this scheme are also possible using combinations of
|
|||
|
|
return_value_policy::reference and the keep_alive call policy */
|
|||
|
|
reference_internal
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(detail)
|
|||
|
|
|
|||
|
|
inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); }
|
|||
|
|
|
|||
|
|
// Returns the size as a multiple of sizeof(void *), rounded up.
|
|||
|
|
inline static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> log2(sizeof(void *))); }
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* The space to allocate for simple layout instance holders (see below) in multiple of the size of
|
|||
|
|
* a pointer (e.g. 2 means 16 bytes on 64-bit architectures). The default is the minimum required
|
|||
|
|
* to holder either a std::unique_ptr or std::shared_ptr (which is almost always
|
|||
|
|
* sizeof(std::shared_ptr<T>)).
|
|||
|
|
*/
|
|||
|
|
constexpr size_t instance_simple_holder_in_ptrs() {
|
|||
|
|
static_assert(sizeof(std::shared_ptr<int>) >= sizeof(std::unique_ptr<int>),
|
|||
|
|
"pybind assumes std::shared_ptrs are at least as big as std::unique_ptrs");
|
|||
|
|
return size_in_ptrs(sizeof(std::shared_ptr<int>));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Forward declarations
|
|||
|
|
struct type_info;
|
|||
|
|
struct value_and_holder;
|
|||
|
|
|
|||
|
|
/// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')
|
|||
|
|
struct instance {
|
|||
|
|
PyObject_HEAD
|
|||
|
|
/// Storage for pointers and holder; see simple_layout, below, for a description
|
|||
|
|
union {
|
|||
|
|
void *simple_value_holder[1 + instance_simple_holder_in_ptrs()];
|
|||
|
|
struct {
|
|||
|
|
void **values_and_holders;
|
|||
|
|
uint8_t *status;
|
|||
|
|
} nonsimple;
|
|||
|
|
};
|
|||
|
|
/// Weak references (needed for keep alive):
|
|||
|
|
PyObject *weakrefs;
|
|||
|
|
/// If true, the pointer is owned which means we're free to manage it with a holder.
|
|||
|
|
bool owned : 1;
|
|||
|
|
/**
|
|||
|
|
* An instance has two possible value/holder layouts.
|
|||
|
|
*
|
|||
|
|
* Simple layout (when this flag is true), means the `simple_value_holder` is set with a pointer
|
|||
|
|
* and the holder object governing that pointer, i.e. [val1*][holder]. This layout is applied
|
|||
|
|
* whenever there is no python-side multiple inheritance of bound C++ types *and* the type's
|
|||
|
|
* holder will fit in the default space (which is large enough to hold either a std::unique_ptr
|
|||
|
|
* or std::shared_ptr).
|
|||
|
|
*
|
|||
|
|
* Non-simple layout applies when using custom holders that require more space than `shared_ptr`
|
|||
|
|
* (which is typically the size of two pointers), or when multiple inheritance is used on the
|
|||
|
|
* python side. Non-simple layout allocates the required amount of memory to have multiple
|
|||
|
|
* bound C++ classes as parents. Under this layout, `nonsimple.values_and_holders` is set to a
|
|||
|
|
* pointer to allocated space of the required space to hold a a sequence of value pointers and
|
|||
|
|
* holders followed `status`, a set of bit flags (1 byte each), i.e.
|
|||
|
|
* [val1*][holder1][val2*][holder2]...[bb...] where each [block] is rounded up to a multiple of
|
|||
|
|
* `sizeof(void *)`. `nonsimple.holder_constructed` is, for convenience, a pointer to the
|
|||
|
|
* beginning of the [bb...] block (but not independently allocated).
|
|||
|
|
*
|
|||
|
|
* Status bits indicate whether the associated holder is constructed (&
|
|||
|
|
* status_holder_constructed) and whether the value pointer is registered (&
|
|||
|
|
* status_instance_registered) in `registered_instances`.
|
|||
|
|
*/
|
|||
|
|
bool simple_layout : 1;
|
|||
|
|
/// For simple layout, tracks whether the holder has been constructed
|
|||
|
|
bool simple_holder_constructed : 1;
|
|||
|
|
/// For simple layout, tracks whether the instance is registered in `registered_instances`
|
|||
|
|
bool simple_instance_registered : 1;
|
|||
|
|
/// If true, get_internals().patients has an entry for this object
|
|||
|
|
bool has_patients : 1;
|
|||
|
|
|
|||
|
|
/// Initializes all of the above type/values/holders data
|
|||
|
|
void allocate_layout();
|
|||
|
|
|
|||
|
|
/// Destroys/deallocates all of the above
|
|||
|
|
void deallocate_layout();
|
|||
|
|
|
|||
|
|
/// Returns the value_and_holder wrapper for the given type (or the first, if `find_type`
|
|||
|
|
/// omitted)
|
|||
|
|
value_and_holder get_value_and_holder(const type_info *find_type = nullptr);
|
|||
|
|
|
|||
|
|
/// Bit values for the non-simple status flags
|
|||
|
|
static constexpr uint8_t status_holder_constructed = 1;
|
|||
|
|
static constexpr uint8_t status_instance_registered = 2;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
static_assert(std::is_standard_layout<instance>::value, "Internal error: `pybind11::detail::instance` is not standard layout!");
|
|||
|
|
|
|||
|
|
struct overload_hash {
|
|||
|
|
inline size_t operator()(const std::pair<const PyObject *, const char *>& v) const {
|
|||
|
|
size_t value = std::hash<const void *>()(v.first);
|
|||
|
|
value ^= std::hash<const void *>()(v.second) + 0x9e3779b9 + (value<<6) + (value>>2);
|
|||
|
|
return value;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly
|
|||
|
|
// other stls, this means `typeid(A)` from one module won't equal `typeid(A)` from another module
|
|||
|
|
// even when `A` is the same, non-hidden-visibility type (e.g. from a common include). Under
|
|||
|
|
// stdlibc++, this doesn't happen: equality and the type_index hash are based on the type name,
|
|||
|
|
// which works. If not under a known-good stl, provide our own name-based hasher and equality
|
|||
|
|
// functions that use the type name.
|
|||
|
|
#if defined(__GLIBCXX__)
|
|||
|
|
inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
|
|||
|
|
using type_hash = std::hash<std::type_index>;
|
|||
|
|
using type_equal_to = std::equal_to<std::type_index>;
|
|||
|
|
#else
|
|||
|
|
inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) {
|
|||
|
|
return lhs.name() == rhs.name() ||
|
|||
|
|
std::strcmp(lhs.name(), rhs.name()) == 0;
|
|||
|
|
}
|
|||
|
|
struct type_hash {
|
|||
|
|
size_t operator()(const std::type_index &t) const {
|
|||
|
|
size_t hash = 5381;
|
|||
|
|
const char *ptr = t.name();
|
|||
|
|
while (auto c = static_cast<unsigned char>(*ptr++))
|
|||
|
|
hash = (hash * 33) ^ c;
|
|||
|
|
return hash;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
struct type_equal_to {
|
|||
|
|
bool operator()(const std::type_index &lhs, const std::type_index &rhs) const {
|
|||
|
|
return lhs.name() == rhs.name() ||
|
|||
|
|
std::strcmp(lhs.name(), rhs.name()) == 0;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
template <typename value_type>
|
|||
|
|
using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
|
|||
|
|
|
|||
|
|
/// Internal data structure used to track registered instances and types
|
|||
|
|
struct internals {
|
|||
|
|
type_map<void *> registered_types_cpp; // std::type_index -> type_info
|
|||
|
|
std::unordered_map<PyTypeObject *, std::vector<type_info *>> registered_types_py; // PyTypeObject* -> base type_info(s)
|
|||
|
|
std::unordered_multimap<const void *, instance*> registered_instances; // void * -> instance*
|
|||
|
|
std::unordered_set<std::pair<const PyObject *, const char *>, overload_hash> inactive_overload_cache;
|
|||
|
|
type_map<std::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
|
|||
|
|
std::unordered_map<const PyObject *, std::vector<PyObject *>> patients;
|
|||
|
|
std::forward_list<void (*) (std::exception_ptr)> registered_exception_translators;
|
|||
|
|
std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across extensions
|
|||
|
|
std::vector<PyObject *> loader_patient_stack; // Used by `loader_life_support`
|
|||
|
|
PyTypeObject *static_property_type;
|
|||
|
|
PyTypeObject *default_metaclass;
|
|||
|
|
PyObject *instance_base;
|
|||
|
|
#if defined(WITH_THREAD)
|
|||
|
|
decltype(PyThread_create_key()) tstate = 0; // Usually an int but a long on Cygwin64 with Python 3.x
|
|||
|
|
PyInterpreterState *istate = nullptr;
|
|||
|
|
#endif
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// Return a reference to the current 'internals' information
|
|||
|
|
inline internals &get_internals();
|
|||
|
|
|
|||
|
|
/// from __cpp_future__ import (convenient aliases from C++14/17)
|
|||
|
|
#if defined(PYBIND11_CPP14) && (!defined(_MSC_VER) || _MSC_VER >= 1910)
|
|||
|
|
using std::enable_if_t;
|
|||
|
|
using std::conditional_t;
|
|||
|
|
using std::remove_cv_t;
|
|||
|
|
using std::remove_reference_t;
|
|||
|
|
#else
|
|||
|
|
template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
|
|||
|
|
template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
|
|||
|
|
template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
|
|||
|
|
template <typename T> using remove_reference_t = typename std::remove_reference<T>::type;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/// Index sequences
|
|||
|
|
#if defined(PYBIND11_CPP14)
|
|||
|
|
using std::index_sequence;
|
|||
|
|
using std::make_index_sequence;
|
|||
|
|
#else
|
|||
|
|
template<size_t ...> struct index_sequence { };
|
|||
|
|
template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { };
|
|||
|
|
template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; };
|
|||
|
|
template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/// Make an index sequence of the indices of true arguments
|
|||
|
|
template <typename ISeq, size_t, bool...> struct select_indices_impl { using type = ISeq; };
|
|||
|
|
template <size_t... IPrev, size_t I, bool B, bool... Bs> struct select_indices_impl<index_sequence<IPrev...>, I, B, Bs...>
|
|||
|
|
: select_indices_impl<conditional_t<B, index_sequence<IPrev..., I>, index_sequence<IPrev...>>, I + 1, Bs...> {};
|
|||
|
|
template <bool... Bs> using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type;
|
|||
|
|
|
|||
|
|
/// Backports of std::bool_constant and std::negation to accomodate older compilers
|
|||
|
|
template <bool B> using bool_constant = std::integral_constant<bool, B>;
|
|||
|
|
template <typename T> struct negation : bool_constant<!T::value> { };
|
|||
|
|
|
|||
|
|
template <typename...> struct void_t_impl { using type = void; };
|
|||
|
|
template <typename... Ts> using void_t = typename void_t_impl<Ts...>::type;
|
|||
|
|
|
|||
|
|
/// Compile-time all/any/none of that check the boolean value of all template types
|
|||
|
|
#ifdef __cpp_fold_expressions
|
|||
|
|
template <class... Ts> using all_of = bool_constant<(Ts::value && ...)>;
|
|||
|
|
template <class... Ts> using any_of = bool_constant<(Ts::value || ...)>;
|
|||
|
|
#elif !defined(_MSC_VER)
|
|||
|
|
template <bool...> struct bools {};
|
|||
|
|
template <class... Ts> using all_of = std::is_same<
|
|||
|
|
bools<Ts::value..., true>,
|
|||
|
|
bools<true, Ts::value...>>;
|
|||
|
|
template <class... Ts> using any_of = negation<all_of<negation<Ts>...>>;
|
|||
|
|
#else
|
|||
|
|
// MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit
|
|||
|
|
// at a slight loss of compilation efficiency).
|
|||
|
|
template <class... Ts> using all_of = std::conjunction<Ts...>;
|
|||
|
|
template <class... Ts> using any_of = std::disjunction<Ts...>;
|
|||
|
|
#endif
|
|||
|
|
template <class... Ts> using none_of = negation<any_of<Ts...>>;
|
|||
|
|
|
|||
|
|
template <class T, template<class> class... Predicates> using satisfies_all_of = all_of<Predicates<T>...>;
|
|||
|
|
template <class T, template<class> class... Predicates> using satisfies_any_of = any_of<Predicates<T>...>;
|
|||
|
|
template <class T, template<class> class... Predicates> using satisfies_none_of = none_of<Predicates<T>...>;
|
|||
|
|
|
|||
|
|
/// Strip the class from a method type
|
|||
|
|
template <typename T> struct remove_class { };
|
|||
|
|
template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); };
|
|||
|
|
template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { typedef R type(A...); };
|
|||
|
|
|
|||
|
|
/// Helper template to strip away type modifiers
|
|||
|
|
template <typename T> struct intrinsic_type { typedef T type; };
|
|||
|
|
template <typename T> struct intrinsic_type<const T> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T> struct intrinsic_type<T*> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T> struct intrinsic_type<T&> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T> struct intrinsic_type<T&&> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T, size_t N> struct intrinsic_type<const T[N]> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T, size_t N> struct intrinsic_type<T[N]> { typedef typename intrinsic_type<T>::type type; };
|
|||
|
|
template <typename T> using intrinsic_t = typename intrinsic_type<T>::type;
|
|||
|
|
|
|||
|
|
/// Helper type to replace 'void' in some expressions
|
|||
|
|
struct void_type { };
|
|||
|
|
|
|||
|
|
/// Helper template which holds a list of types
|
|||
|
|
template <typename...> struct type_list { };
|
|||
|
|
|
|||
|
|
/// Compile-time integer sum
|
|||
|
|
#ifdef __cpp_fold_expressions
|
|||
|
|
template <typename... Ts> constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); }
|
|||
|
|
#else
|
|||
|
|
constexpr size_t constexpr_sum() { return 0; }
|
|||
|
|
template <typename T, typename... Ts>
|
|||
|
|
constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(constexpr_impl)
|
|||
|
|
/// Implementation details for constexpr functions
|
|||
|
|
constexpr int first(int i) { return i; }
|
|||
|
|
template <typename T, typename... Ts>
|
|||
|
|
constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }
|
|||
|
|
|
|||
|
|
constexpr int last(int /*i*/, int result) { return result; }
|
|||
|
|
template <typename T, typename... Ts>
|
|||
|
|
constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
|
|||
|
|
NAMESPACE_END(constexpr_impl)
|
|||
|
|
|
|||
|
|
/// Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if
|
|||
|
|
/// none match.
|
|||
|
|
template <template<typename> class Predicate, typename... Ts>
|
|||
|
|
constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }
|
|||
|
|
|
|||
|
|
/// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
|
|||
|
|
template <template<typename> class Predicate, typename... Ts>
|
|||
|
|
constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }
|
|||
|
|
|
|||
|
|
/// Return the Nth element from the parameter pack
|
|||
|
|
template <size_t N, typename T, typename... Ts>
|
|||
|
|
struct pack_element { using type = typename pack_element<N - 1, Ts...>::type; };
|
|||
|
|
template <typename T, typename... Ts>
|
|||
|
|
struct pack_element<0, T, Ts...> { using type = T; };
|
|||
|
|
|
|||
|
|
/// Return the one and only type which matches the predicate, or Default if none match.
|
|||
|
|
/// If more than one type matches the predicate, fail at compile-time.
|
|||
|
|
template <template<typename> class Predicate, typename Default, typename... Ts>
|
|||
|
|
struct exactly_one {
|
|||
|
|
static constexpr auto found = constexpr_sum(Predicate<Ts>::value...);
|
|||
|
|
static_assert(found <= 1, "Found more than one type matching the predicate");
|
|||
|
|
|
|||
|
|
static constexpr auto index = found ? constexpr_first<Predicate, Ts...>() : 0;
|
|||
|
|
using type = conditional_t<found, typename pack_element<index, Ts...>::type, Default>;
|
|||
|
|
};
|
|||
|
|
template <template<typename> class P, typename Default>
|
|||
|
|
struct exactly_one<P, Default> { using type = Default; };
|
|||
|
|
|
|||
|
|
template <template<typename> class Predicate, typename Default, typename... Ts>
|
|||
|
|
using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type;
|
|||
|
|
|
|||
|
|
/// Defer the evaluation of type T until types Us are instantiated
|
|||
|
|
template <typename T, typename... /*Us*/> struct deferred_type { using type = T; };
|
|||
|
|
template <typename T, typename... Us> using deferred_t = typename deferred_type<T, Us...>::type;
|
|||
|
|
|
|||
|
|
/// Like is_base_of, but requires a strict base (i.e. `is_strict_base_of<T, T>::value == false`,
|
|||
|
|
/// unlike `std::is_base_of`)
|
|||
|
|
template <typename Base, typename Derived> using is_strict_base_of = bool_constant<
|
|||
|
|
std::is_base_of<Base, Derived>::value && !std::is_same<Base, Derived>::value>;
|
|||
|
|
|
|||
|
|
template <template<typename...> class Base>
|
|||
|
|
struct is_template_base_of_impl {
|
|||
|
|
template <typename... Us> static std::true_type check(Base<Us...> *);
|
|||
|
|
static std::false_type check(...);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// Check if a template is the base of a type. For example:
|
|||
|
|
/// `is_template_base_of<Base, T>` is true if `struct T : Base<U> {}` where U can be anything
|
|||
|
|
template <template<typename...> class Base, typename T>
|
|||
|
|
#if !defined(_MSC_VER)
|
|||
|
|
using is_template_base_of = decltype(is_template_base_of_impl<Base>::check((remove_cv_t<T>*)nullptr));
|
|||
|
|
#else // MSVC2015 has trouble with decltype in template aliases
|
|||
|
|
struct is_template_base_of : decltype(is_template_base_of_impl<Base>::check((remove_cv_t<T>*)nullptr)) { };
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/// Check if T is an instantiation of the template `Class`. For example:
|
|||
|
|
/// `is_instantiation<shared_ptr, T>` is true if `T == shared_ptr<U>` where U can be anything.
|
|||
|
|
template <template<typename...> class Class, typename T>
|
|||
|
|
struct is_instantiation : std::false_type { };
|
|||
|
|
template <template<typename...> class Class, typename... Us>
|
|||
|
|
struct is_instantiation<Class, Class<Us...>> : std::true_type { };
|
|||
|
|
|
|||
|
|
/// Check if T is std::shared_ptr<U> where U can be anything
|
|||
|
|
template <typename T> using is_shared_ptr = is_instantiation<std::shared_ptr, T>;
|
|||
|
|
|
|||
|
|
/// Check if T looks like an input iterator
|
|||
|
|
template <typename T, typename = void> struct is_input_iterator : std::false_type {};
|
|||
|
|
template <typename T>
|
|||
|
|
struct is_input_iterator<T, void_t<decltype(*std::declval<T &>()), decltype(++std::declval<T &>())>>
|
|||
|
|
: std::true_type {};
|
|||
|
|
|
|||
|
|
/// Ignore that a variable is unused in compiler warnings
|
|||
|
|
inline void ignore_unused(const int *) { }
|
|||
|
|
|
|||
|
|
/// Apply a function over each element of a parameter pack
|
|||
|
|
#ifdef __cpp_fold_expressions
|
|||
|
|
#define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (((PATTERN), void()), ...)
|
|||
|
|
#else
|
|||
|
|
using expand_side_effects = bool[];
|
|||
|
|
#define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false }
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
NAMESPACE_END(detail)
|
|||
|
|
|
|||
|
|
/// Returns a named pointer that is shared among all extension modules (using the same
|
|||
|
|
/// pybind11 version) running in the current interpreter. Names starting with underscores
|
|||
|
|
/// are reserved for internal usage. Returns `nullptr` if no matching entry was found.
|
|||
|
|
inline PYBIND11_NOINLINE void* get_shared_data(const std::string& name) {
|
|||
|
|
auto& internals = detail::get_internals();
|
|||
|
|
auto it = internals.shared_data.find(name);
|
|||
|
|
return it != internals.shared_data.end() ? it->second : nullptr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Set the shared data that can be later recovered by `get_shared_data()`.
|
|||
|
|
inline PYBIND11_NOINLINE void *set_shared_data(const std::string& name, void *data) {
|
|||
|
|
detail::get_internals().shared_data[name] = data;
|
|||
|
|
return data;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if
|
|||
|
|
/// such entry exists. Otherwise, a new object of default-constructible type `T` is
|
|||
|
|
/// added to the shared data under the given name and a reference to it is returned.
|
|||
|
|
template<typename T> T& get_or_create_shared_data(const std::string& name) {
|
|||
|
|
auto& internals = detail::get_internals();
|
|||
|
|
auto it = internals.shared_data.find(name);
|
|||
|
|
T* ptr = (T*) (it != internals.shared_data.end() ? it->second : nullptr);
|
|||
|
|
if (!ptr) {
|
|||
|
|
ptr = new T();
|
|||
|
|
internals.shared_data[name] = ptr;
|
|||
|
|
}
|
|||
|
|
return *ptr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// C++ bindings of builtin Python exceptions
|
|||
|
|
class builtin_exception : public std::runtime_error {
|
|||
|
|
public:
|
|||
|
|
using std::runtime_error::runtime_error;
|
|||
|
|
/// Set the error using the Python C API
|
|||
|
|
virtual void set_error() const = 0;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
#define PYBIND11_RUNTIME_EXCEPTION(name, type) \
|
|||
|
|
class name : public builtin_exception { public: \
|
|||
|
|
using builtin_exception::builtin_exception; \
|
|||
|
|
name() : name("") { } \
|
|||
|
|
void set_error() const override { PyErr_SetString(type, what()); } \
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration)
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError)
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError)
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError)
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError)
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
|
|||
|
|
PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
|
|||
|
|
|
|||
|
|
[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
|
|||
|
|
[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
|
|||
|
|
|
|||
|
|
template <typename T, typename SFINAE = void> struct format_descriptor { };
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(detail)
|
|||
|
|
// Returns the index of the given type in the type char array below, and in the list in numpy.h
|
|||
|
|
// The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double;
|
|||
|
|
// complex float,double,long double. Note that the long double types only participate when long
|
|||
|
|
// double is actually longer than double (it isn't under MSVC).
|
|||
|
|
// NB: not only the string below but also complex.h and numpy.h rely on this order.
|
|||
|
|
template <typename T, typename SFINAE = void> struct is_fmt_numeric { static constexpr bool value = false; };
|
|||
|
|
template <typename T> struct is_fmt_numeric<T, enable_if_t<std::is_arithmetic<T>::value>> {
|
|||
|
|
static constexpr bool value = true;
|
|||
|
|
static constexpr int index = std::is_same<T, bool>::value ? 0 : 1 + (
|
|||
|
|
std::is_integral<T>::value ? detail::log2(sizeof(T))*2 + std::is_unsigned<T>::value : 8 + (
|
|||
|
|
std::is_same<T, double>::value ? 1 : std::is_same<T, long double>::value ? 2 : 0));
|
|||
|
|
};
|
|||
|
|
NAMESPACE_END(detail)
|
|||
|
|
|
|||
|
|
template <typename T> struct format_descriptor<T, detail::enable_if_t<std::is_arithmetic<T>::value>> {
|
|||
|
|
static constexpr const char c = "?bBhHiIqQfdg"[detail::is_fmt_numeric<T>::index];
|
|||
|
|
static constexpr const char value[2] = { c, '\0' };
|
|||
|
|
static std::string format() { return std::string(1, c); }
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
template <typename T> constexpr const char format_descriptor<
|
|||
|
|
T, detail::enable_if_t<std::is_arithmetic<T>::value>>::value[2];
|
|||
|
|
|
|||
|
|
/// RAII wrapper that temporarily clears any Python error state
|
|||
|
|
struct error_scope {
|
|||
|
|
PyObject *type, *value, *trace;
|
|||
|
|
error_scope() { PyErr_Fetch(&type, &value, &trace); }
|
|||
|
|
~error_scope() { PyErr_Restore(type, value, trace); }
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// Dummy destructor wrapper that can be used to expose classes with a private destructor
|
|||
|
|
struct nodelete { template <typename T> void operator()(T*) { } };
|
|||
|
|
|
|||
|
|
// overload_cast requires variable templates: C++14
|
|||
|
|
#if defined(PYBIND11_CPP14)
|
|||
|
|
#define PYBIND11_OVERLOAD_CAST 1
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(detail)
|
|||
|
|
template <typename... Args>
|
|||
|
|
struct overload_cast_impl {
|
|||
|
|
template <typename Return>
|
|||
|
|
constexpr auto operator()(Return (*pf)(Args...)) const noexcept
|
|||
|
|
-> decltype(pf) { return pf; }
|
|||
|
|
|
|||
|
|
template <typename Return, typename Class>
|
|||
|
|
constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
|
|||
|
|
-> decltype(pmf) { return pmf; }
|
|||
|
|
|
|||
|
|
template <typename Return, typename Class>
|
|||
|
|
constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
|
|||
|
|
-> decltype(pmf) { return pmf; }
|
|||
|
|
};
|
|||
|
|
NAMESPACE_END(detail)
|
|||
|
|
|
|||
|
|
/// Syntax sugar for resolving overloaded function pointers:
|
|||
|
|
/// - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
|
|||
|
|
/// - sweet: overload_cast<Arg0, Arg1, Arg2>(&Class::func)
|
|||
|
|
template <typename... Args>
|
|||
|
|
static constexpr detail::overload_cast_impl<Args...> overload_cast = {};
|
|||
|
|
// MSVC 2015 only accepts this particular initialization syntax for this variable template.
|
|||
|
|
|
|||
|
|
/// Const member function selector for overload_cast
|
|||
|
|
/// - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
|
|||
|
|
/// - sweet: overload_cast<Arg>(&Class::func, const_)
|
|||
|
|
static constexpr auto const_ = std::true_type{};
|
|||
|
|
|
|||
|
|
#else // no overload_cast: providing something that static_assert-fails:
|
|||
|
|
template <typename... Args> struct overload_cast {
|
|||
|
|
static_assert(detail::deferred_t<std::false_type, Args...>::value,
|
|||
|
|
"pybind11::overload_cast<...> requires compiling in C++14 mode");
|
|||
|
|
};
|
|||
|
|
#endif // overload_cast
|
|||
|
|
|
|||
|
|
NAMESPACE_BEGIN(detail)
|
|||
|
|
|
|||
|
|
// Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from
|
|||
|
|
// any standard container (or C-style array) supporting std::begin/std::end, any singleton
|
|||
|
|
// arithmetic type (if T is arithmetic), or explicitly constructible from an iterator pair.
|
|||
|
|
template <typename T>
|
|||
|
|
class any_container {
|
|||
|
|
std::vector<T> v;
|
|||
|
|
public:
|
|||
|
|
any_container() = default;
|
|||
|
|
|
|||
|
|
// Can construct from a pair of iterators
|
|||
|
|
template <typename It, typename = enable_if_t<is_input_iterator<It>::value>>
|
|||
|
|
any_container(It first, It last) : v(first, last) { }
|
|||
|
|
|
|||
|
|
// Implicit conversion constructor from any arbitrary container type with values convertible to T
|
|||
|
|
template <typename Container, typename = enable_if_t<std::is_convertible<decltype(*std::begin(std::declval<const Container &>())), T>::value>>
|
|||
|
|
any_container(const Container &c) : any_container(std::begin(c), std::end(c)) { }
|
|||
|
|
|
|||
|
|
// initializer_list's aren't deducible, so don't get matched by the above template; we need this
|
|||
|
|
// to explicitly allow implicit conversion from one:
|
|||
|
|
template <typename TIn, typename = enable_if_t<std::is_convertible<TIn, T>::value>>
|
|||
|
|
any_container(const std::initializer_list<TIn> &c) : any_container(c.begin(), c.end()) { }
|
|||
|
|
|
|||
|
|
// Avoid copying if given an rvalue vector of the correct type.
|
|||
|
|
any_container(std::vector<T> &&v) : v(std::move(v)) { }
|
|||
|
|
|
|||
|
|
// Moves the vector out of an rvalue any_container
|
|||
|
|
operator std::vector<T> &&() && { return std::move(v); }
|
|||
|
|
|
|||
|
|
// Dereferencing obtains a reference to the underlying vector
|
|||
|
|
std::vector<T> &operator*() { return v; }
|
|||
|
|
const std::vector<T> &operator*() const { return v; }
|
|||
|
|
|
|||
|
|
// -> lets you call methods on the underlying vector
|
|||
|
|
std::vector<T> *operator->() { return &v; }
|
|||
|
|
const std::vector<T> *operator->() const { return &v; }
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
NAMESPACE_END(detail)
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
NAMESPACE_END(pybind11)
|