#include <Python.h>
#include <frameobject.h>
#include <pythread.h>
#include <cstddef>
#include <cstring>
#include <forward_list>
#include <vector>
#include <string>
#include <stdexcept>
#include <exception>
#include <unordered_set>
#include <unordered_map>
#include <memory>
#include <typeindex>
#include <type_traits>

Include dependency graph for wrap/pybind11/include/pybind11/detail/common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	any_container< T >

struct	bools<... >
	Compile-time all/any/none of that check the boolean value of all template types. More...

class	builtin_exception
	C++ bindings of builtin Python exceptions. More...

struct	deferred_type< T,... >
	Defer the evaluation of type T until types Us are instantiated. More...

struct	error_scope
	RAII wrapper that temporarily clears any Python error state. More...

struct	exactly_one< Predicate, Default, Ts >

struct	exactly_one< P, Default >

struct	format_descriptor< T, SFINAE >

struct	format_descriptor< T, detail::enable_if_t< std::is_arithmetic< T >::value > >

struct	index_sequence<... >
	Index sequences. More...

struct	instance
	The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') More...

struct	intrinsic_type< T >
	Helper template to strip away type modifiers. More...

struct	intrinsic_type< const T >

struct	intrinsic_type< const T[N]>

struct	intrinsic_type< T & >

struct	intrinsic_type< T && >

struct	intrinsic_type< T * >

struct	intrinsic_type< T[N]>

struct	is_fmt_numeric< T, SFINAE >

struct	is_fmt_numeric< T, enable_if_t< std::is_arithmetic< T >::value > >

struct	is_input_iterator< T, typename >
	Check if T looks like an input iterator. More...

struct	is_instantiation< Class, T >

struct	is_instantiation< Class, Class< Us... > >

struct	is_template_base_of_impl< Base >

struct	make_index_sequence_impl< N, S >

struct	make_index_sequence_impl< 0, S... >

struct	negation< T >

struct	nodelete
	Dummy destructor wrapper that can be used to expose classes with a private destructor. More...

struct	nonsimple_values_and_holders

struct	overload_cast< Args >

struct	overload_cast_impl< Args >

struct	pack_element< N, T, Ts >
	Return the Nth element from the parameter pack. More...

struct	pack_element< 0, T, Ts... >

struct	remove_class< T >
	Strip the class from a method type. More...

struct	remove_class< R(C::*)(A...) const >

struct	remove_class< R(C::*)(A...)>

struct	select_indices_impl< ISeq, size_t,... >
	Make an index sequence of the indices of true arguments. More...

struct	select_indices_impl< index_sequence< IPrev... >, I, B, Bs... >

struct	strip_function_object< F >

struct	type_list<... >
	Helper template which holds a list of types. More...

struct	void_t_impl<... >

struct	void_type
	Helper type to replace 'void' in some expressions. More...

Macros
#define	PYBIND11_BOOL_ATTR "__nonzero__"

#define	PYBIND11_BYTES_AS_STRING PyString_AsString

#define	PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize

#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_NAME "str"

#define	PYBIND11_BYTES_SIZE PyString_Size

#define	PYBIND11_CATCH_INIT_EXCEPTIONS

#define	PYBIND11_CHECK_PYTHON_VERSION

#define	PYBIND11_CONCAT(first, second) first##second

#define	PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))

#define	PYBIND11_ENSURE_INTERNALS_READY pybind11::detail::get_internals();

#define	PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (void)pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false }

#define	PYBIND11_EXPORT __attribute__ ((visibility("default")))

#define	PYBIND11_FROM_STRING PyString_FromString

#define	PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check

#define	PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION

#define	PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_)
	Include Python header, disable linking to pythonX_d.lib on Windows in debug mode. More...

#define	PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))

#define	PYBIND11_LONG_CHECK(o) (PyInt_Check(o) \|\| PyLong_Check(o))

#define	PYBIND11_LONG_FROM_SIGNED(o) PyInt_FromSsize_t((ssize_t) o)

#define	PYBIND11_LONG_FROM_UNSIGNED(o) PyInt_FromSize_t((size_t) o)

#define	PYBIND11_MAYBE_UNUSED __attribute__ ((__unused__))

#define	PYBIND11_MODULE(name, variable)

#define	PYBIND11_NAMESPACE pybind11

#define	PYBIND11_NAMESPACE_BEGIN(name) namespace name {

#define	PYBIND11_NAMESPACE_END(name) }

#define	PYBIND11_NB_BOOL(ptr) ((ptr)->nb_nonzero)

#define	PYBIND11_NOINLINE __attribute__ ((noinline))

#define	PYBIND11_PLUGIN(name)

#define	PYBIND11_PLUGIN_IMPL(name)

#define	PYBIND11_RUNTIME_EXCEPTION(name, type)

#define	PYBIND11_SLICE_OBJECT PySliceObject

#define	PYBIND11_STR_TYPE ::pybind11::bytes

#define	PYBIND11_STRING_NAME "unicode"

#define	PYBIND11_STRINGIFY(x) #x

#define	PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)

#define	PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1)

#define	PYBIND11_VERSION_MAJOR 2

#define	PYBIND11_VERSION_MINOR 6

#define	PYBIND11_VERSION_PATCH 0.dev1

Typedefs
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 >... >>

template<bool B>
using	bool_constant = std::integral_constant< bool, B >
	Backports of std::bool_constant and std::negation to accommodate older compilers. More...

template<bool B, typename T , typename F >
using	conditional_t = typename std::conditional< B, T, F >::type

template<typename T , typename... Us>
using	deferred_t = typename deferred_type< T, Us... >::type

template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
	from cpp_future import (convenient aliases from C++14/17) More...

template<template< typename > class Predicate, typename Default , typename... Ts>
using	exactly_one_t = typename exactly_one< Predicate, Default, Ts... >::type

using	expand_side_effects = bool[]
	Apply a function over each element of a parameter pack. More...

template<typename Function , typename F = remove_reference_t<Function>>
using	function_signature_t = conditional_t< std::is_function< F >::value, F, typename conditional_t< std::is_pointer< F >::value\|\|std::is_member_pointer< F >::value, std::remove_pointer< F >, strip_function_object< F > >::type >

template<typename T >
using	intrinsic_t = typename intrinsic_type< T >::type

template<typename Base , typename Derived >
using	is_accessible_base_of = bool_constant< std::is_base_of< Base, Derived >::value &&std::is_convertible< Derived , Base >::value >

template<typename T >
using	is_function_pointer = ())>> bool_constant< std::is_pointer< T >::value &&std::is_function< typename std::remove_pointer< T >::type >::value >

template<typename T >
using	is_lambda = satisfies_none_of< remove_reference_t< T >, std::is_function, std::is_pointer, std::is_member_pointer >

template<typename T >
using	is_shared_ptr = is_instantiation< std::shared_ptr, T >
	Check if T is std::shared_ptr<U> where U can be anything. More...

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, typename T >
using	is_template_base_of = decltype(is_template_base_of_impl< Base >::check((intrinsic_t< T > *) nullptr))

template<size_t N>
using	make_index_sequence = typename make_index_sequence_impl< N >::type

template<class... Ts>
using	none_of = negation< any_of< Ts... >>

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

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 >... >

template<bool... Bs>
using	select_indices = typename select_indices_impl< index_sequence<>, 0, Bs... >::type

using	size_t = std::size_t

using	ssize_t = Py_ssize_t

template<typename... Ts>
using	void_t = typename void_t_impl< Ts... >::type

Enumerations
enum	return_value_policy : uint8_t { return_value_policy::automatic = 0, return_value_policy::automatic_reference, return_value_policy::take_ownership, return_value_policy::copy, return_value_policy::move, return_value_policy::reference, return_value_policy::reference_internal }
	Approach used to cast a previously unknown C++ instance into a Python object. More...

Functions
template<template< typename > class Predicate, typename... Ts>
constexpr int	constexpr_first ()

template<template< typename > class Predicate, typename... Ts>
constexpr int	constexpr_last ()
	Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match. More...

constexpr size_t	constexpr_sum ()
	Compile-time integer sum. More...

template<typename T , typename... Ts>
constexpr size_t	constexpr_sum (T n, Ts...ns)

constexpr int	first (int i)
	Implementation details for constexpr functions. More...

template<typename T , typename... Ts>
constexpr int	first (int i, T v, Ts...vs)

void	ignore_unused (const int *)
	Ignore that a variable is unused in compiler warnings. More...

constexpr size_t	instance_simple_holder_in_ptrs ()

constexpr int	last (int, int result)

template<typename T , typename... Ts>
constexpr int	last (int i, int result, T v, Ts...vs)

static constexpr int	log2 (size_t n, int k=0)

PyExc_RuntimeError[[noreturn]] PYBIND11_NOINLINE void	pybind11_fail (const char *reason)
	Used internally. More...

PYBIND11_NOINLINE void	pybind11_fail (const std::string &reason)

	PYBIND11_RUNTIME_EXCEPTION (cast_error, PyExc_RuntimeError) PYBIND11_RUNTIME_EXCEPTION(reference_cast_error
	Thrown when pybind11::cast or handle::call fail due to a type casting error. More...

static constexpr size_t	size_in_ptrs (size_t s)

Variables
static constexpr auto	const_ = std::true_type{}

Macro Definition Documentation

#define PYBIND11_BOOL_ATTR "__nonzero__"

Definition at line 210 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_AS_STRING PyString_AsString

Definition at line 199 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize

Definition at line 198 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_CHECK PyString_Check

Definition at line 195 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_FROM_STRING PyString_FromString

Definition at line 196 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize

Definition at line 197 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_NAME "str"

Definition at line 205 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_BYTES_SIZE PyString_Size

Definition at line 200 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_CATCH_INIT_EXCEPTIONS

Value:

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;                                                    \
        }                                                                      \

Definition at line 253 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_CHECK_PYTHON_VERSION

Value:

{                                                                          \
        const char *compiled_ver = PYBIND11_TOSTRING(PY_MAJOR_VERSION)         \
            "." PYBIND11_TOSTRING(PY_MINOR_VERSION);                           \
        const char *runtime_ver = Py_GetVersion();                             \
        size_t len = std::strlen(compiled_ver);                                \
        if (std::strncmp(runtime_ver, compiled_ver, len) != 0                  \
                || (runtime_ver[len] >= '0' && runtime_ver[len] <= '9')) {     \
            PyErr_Format(PyExc_ImportError,                                    \
                "Python version mismatch: module was compiled for Python %s, " \
                "but the interpreter version is incompatible: %s.",            \
                compiled_ver, runtime_ver);                                    \
            return nullptr;                                                    \
        }                                                                      \
    }

Definition at line 237 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_CONCAT	(	first,
		second
	)	first##second

Definition at line 233 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_DEPRECATED ( reason ) __attribute__((deprecated(reason)))

Definition at line 92 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_ENSURE_INTERNALS_READY pybind11::detail::get_internals();

Definition at line 234 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_EXPAND_SIDE_EFFECTS ( PATTERN ) (void)pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false }

Definition at line 688 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_EXPORT __attribute__ ((visibility("default")))

Definition at line 79 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_FROM_STRING PyString_FromString

Definition at line 208 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check

Definition at line 193 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION

Definition at line 194 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_INSTANCE_METHOD_NEW	(	ptr,
		class_
	)	PyMethod_New(ptr, nullptr, class_)

Include Python header, disable linking to pythonX_d.lib on Windows in debug mode.

Compatibility macros for various Python versions

Definition at line 192 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_LONG_AS_LONGLONG ( o ) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))

Definition at line 202 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_LONG_CHECK ( o ) (PyInt_Check(o) || PyLong_Check(o))

Definition at line 201 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_LONG_FROM_SIGNED ( o ) PyInt_FromSsize_t((ssize_t) o)

Definition at line 203 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_LONG_FROM_UNSIGNED ( o ) PyInt_FromSize_t((size_t) o)

Definition at line 204 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_MAYBE_UNUSED __attribute__ ((__unused__))

Definition at line 100 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_MODULE	(	name,
		variable
	)

Value:

PYBIND11_MAYBE_UNUSED                                                      \
    static void PYBIND11_CONCAT(pybind11_init_, name)(pybind11::module &);     \
    PYBIND11_PLUGIN_IMPL(name) {                                               \
        PYBIND11_CHECK_PYTHON_VERSION                                          \
        PYBIND11_ENSURE_INTERNALS_READY                                        \
        auto m = pybind11::module(PYBIND11_TOSTRING(name));                    \
        try {                                                                  \
            PYBIND11_CONCAT(pybind11_init_, name)(m);                          \
            return m.ptr();                                                    \
        } PYBIND11_CATCH_INIT_EXCEPTIONS                                       \
    }                                                                          \
    void PYBIND11_CONCAT(pybind11_init_, name)(pybind11::module &variable)

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.

The entry point is marked as "maybe unused" to aid dead-code detection analysis: since the entry point is typically only looked up at runtime and not referenced during translation, it would otherwise appear as unused ("dead") code.

.. code-block:: cpp

PYBIND11_MODULE(example, m) {
    m.doc() = "pybind11 example module";

Add bindings here m.def("foo", []() { return "Hello, World!"; }); }

Definition at line 310 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_NAMESPACE pybind11

Definition at line 26 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_NAMESPACE_BEGIN ( name ) namespace name {

Definition at line 16 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_NAMESPACE_END ( name ) }

Definition at line 17 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_NB_BOOL ( ptr ) ((ptr)->nb_nonzero)

Definition at line 211 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_NOINLINE __attribute__ ((noinline))

Definition at line 86 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_PLUGIN ( name )

Value:

PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE")  \
    static PyObject *pybind11_init();                                          \
    PYBIND11_PLUGIN_IMPL(name) {                                               \
        PYBIND11_CHECK_PYTHON_VERSION                                          \
        PYBIND11_ENSURE_INTERNALS_READY                                        \
        try {                                                                  \
            return pybind11_init();                                            \
        } PYBIND11_CATCH_INIT_EXCEPTIONS                                       \
    }                                                                          \
    PyObject *pybind11_init()

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(); }

Definition at line 277 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_PLUGIN_IMPL ( name )

Value:

static PyObject *pybind11_init_wrapper();                           \
    extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT void init##name(); \
    extern "C" PYBIND11_EXPORT void init##name() {                      \
        (void)pybind11_init_wrapper();                                  \
    }                                                                   \
    PyObject *pybind11_init_wrapper()

Definition at line 214 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_RUNTIME_EXCEPTION	(	name,
		type
	)

Value:

class name : public builtin_exception { public: \
        using builtin_exception::builtin_exception; \
        name() : name("") { } \
        void set_error() const override { PyErr_SetString(type, what()); } \
    };

Definition at line 701 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_SLICE_OBJECT PySliceObject

Definition at line 207 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_STR_TYPE ::pybind11::bytes

Definition at line 209 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_STRING_NAME "unicode"

Definition at line 206 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_STRINGIFY ( x ) #x

Definition at line 231 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_TOSTRING ( x ) PYBIND11_STRINGIFY(x)

Definition at line 232 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1)

Definition at line 230 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_VERSION_MAJOR 2

Definition at line 12 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_VERSION_MINOR 6

Definition at line 13 of file wrap/pybind11/include/pybind11/detail/common.h.

#define PYBIND11_VERSION_PATCH 0.dev1

Definition at line 14 of file wrap/pybind11/include/pybind11/detail/common.h.

Typedef Documentation

template<class... Ts>

using all_of = std::is_same< bools<Ts::value..., true>, bools<true, Ts::value...>>

Definition at line 524 of file wrap/pybind11/include/pybind11/detail/common.h.

template<class... Ts>

using any_of = negation<all_of<negation<Ts>...>>

Definition at line 525 of file wrap/pybind11/include/pybind11/detail/common.h.

template<bool B>

using bool_constant = std::integral_constant<bool, B>

Backports of std::bool_constant and std::negation to accommodate older compilers.

Definition at line 502 of file wrap/pybind11/include/pybind11/detail/common.h.

template<bool B, typename T , typename F >

using conditional_t = typename std::conditional<B, T, F>::type

Definition at line 479 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T , typename... Us>

using deferred_t = typename deferred_type<T, Us...>::type

Definition at line 612 of file wrap/pybind11/include/pybind11/detail/common.h.

template<bool B, typename T = void>

using enable_if_t = typename std::enable_if<B, T>::type

from cpp_future import (convenient aliases from C++14/17)

Definition at line 478 of file wrap/pybind11/include/pybind11/detail/common.h.

template<template< typename > class Predicate, typename Default , typename... Ts>

using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type

Definition at line 608 of file wrap/pybind11/include/pybind11/detail/common.h.

using expand_side_effects = bool[]

Apply a function over each element of a parameter pack.

Definition at line 687 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename Function , typename F = remove_reference_t<Function>>

using function_signature_t = conditional_t< std::is_function<F>::value, F, typename conditional_t< std::is_pointer<F>::value || std::is_member_pointer<F>::value, std::remove_pointer<F>, strip_function_object<F> >::type >

Definition at line 672 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using intrinsic_t = typename intrinsic_type<T>::type

Definition at line 551 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename Base , typename Derived >

using is_accessible_base_of = bool_constant< std::is_base_of<Base, Derived>::value && std::is_convertible<Derived *, Base *>::value>

Like is_base_of, but also requires that the base type is accessible (i.e. that a Derived pointer can be converted to a Base pointer)

Definition at line 622 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using is_function_pointer = ())>> bool_constant< std::is_pointer<T>::value && std::is_function<typename std::remove_pointer<T>::type>::value>

Definition at line 656 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using is_lambda = satisfies_none_of<remove_reference_t<T>, std::is_function, std::is_pointer, std::is_member_pointer>

Returns true if the type looks like a lambda: that is, isn't a function, pointer or member pointer. Note that this can catch all sorts of other things, too; this is intended to be used in a place where passing a lambda makes sense.

Definition at line 678 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using is_shared_ptr = is_instantiation<std::shared_ptr, T>

Check if T is std::shared_ptr<U> where U can be anything.

Definition at line 647 of file wrap/pybind11/include/pybind11/detail/common.h.

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>

Like is_base_of, but requires a strict base (i.e. is_strict_base_of<T, T>::value == false, unlike std::is_base_of)

Definition at line 617 of file wrap/pybind11/include/pybind11/detail/common.h.

template<template< typename... > class Base, typename T >

using is_template_base_of = decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T>*)nullptr))

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

Definition at line 634 of file wrap/pybind11/include/pybind11/detail/common.h.

template<size_t N>

using make_index_sequence = typename make_index_sequence_impl<N>::type

Definition at line 492 of file wrap/pybind11/include/pybind11/detail/common.h.

template<class... Ts>

using none_of = negation<any_of<Ts...>>

Definition at line 532 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using remove_cv_t = typename std::remove_cv<T>::type

Definition at line 480 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T >

using remove_reference_t = typename std::remove_reference<T>::type

Definition at line 481 of file wrap/pybind11/include/pybind11/detail/common.h.

template<class T , template< class > class... Predicates>

using satisfies_all_of = all_of<Predicates<T>...>

Definition at line 534 of file wrap/pybind11/include/pybind11/detail/common.h.

template<class T , template< class > class... Predicates>

using satisfies_any_of = any_of<Predicates<T>...>

Definition at line 535 of file wrap/pybind11/include/pybind11/detail/common.h.

template<class T , template< class > class... Predicates>

using satisfies_none_of = none_of<Predicates<T>...>

Definition at line 536 of file wrap/pybind11/include/pybind11/detail/common.h.

template<bool... Bs>

using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type

Definition at line 499 of file wrap/pybind11/include/pybind11/detail/common.h.

using size_t = std::size_t

Definition at line 328 of file wrap/pybind11/include/pybind11/detail/common.h.

using ssize_t = Py_ssize_t

Definition at line 327 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename... Ts>

using void_t = typename void_t_impl<Ts...>::type

Definition at line 512 of file wrap/pybind11/include/pybind11/detail/common.h.

Enumeration Type Documentation

enum return_value_policy : uint8_t

strong

Approach used to cast a previously unknown C++ instance into a Python object.

Enumerator
automatic	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_reference	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.
take_ownership	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..
copy	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.
move	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.
reference	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_internal	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

Definition at line 331 of file wrap/pybind11/include/pybind11/detail/common.h.

Function Documentation

template<template< typename > class Predicate, typename... Ts>

constexpr int constexpr_first ( )

Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if none match.

Definition at line 582 of file wrap/pybind11/include/pybind11/detail/common.h.

template<template< typename > class Predicate, typename... Ts>

constexpr int constexpr_last ( )

Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.

Definition at line 586 of file wrap/pybind11/include/pybind11/detail/common.h.

constexpr size_t constexpr_sum ( )

Compile-time integer sum.

Definition at line 563 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T , typename... Ts>

constexpr size_t constexpr_sum	(	T	n,
		Ts...	ns
	)

Definition at line 565 of file wrap/pybind11/include/pybind11/detail/common.h.

constexpr int first ( int i )

Implementation details for constexpr functions.

Definition at line 570 of file wrap/pybind11/include/pybind11/detail/common.h.

template<typename T , typename... Ts>

constexpr int first	(	int	i,
		T	v,
		Ts...	vs
	)

Definition at line 572 of file wrap/pybind11/include/pybind11/detail/common.h.

void ignore_unused ( const int * )

inline

Ignore that a variable is unused in compiler warnings.

Definition at line 681 of file wrap/pybind11/include/pybind11/detail/common.h.

constexpr size_t instance_simple_holder_in_ptrs ( )

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>)).

Definition at line 395 of file wrap/pybind11/include/pybind11/detail/common.h.