Classes | Namespaces | Macros | Typedefs | Functions
cast.h File Reference
#include "pytypes.h"
#include "detail/typeid.h"
#include "detail/descr.h"
#include "detail/internals.h"
#include <array>
#include <limits>
#include <tuple>
#include <type_traits>
Include dependency graph for cast.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  always_construct_holder< T, Value >
 
struct  arg
 
struct  arg_v
 
class  argument_loader< Args >
 Helper class which loads arguments for C++ functions called from Python. More...
 
struct  copyable_holder_caster< type, holder_type >
 Type caster for holder types like std::shared_ptr, etc. More...
 
struct  function_call
 Internal data associated with a single function call. More...
 
struct  handle_type_name< T >
 
struct  handle_type_name< args >
 
struct  handle_type_name< bytes >
 
struct  handle_type_name< int_ >
 
struct  handle_type_name< iterable >
 
struct  handle_type_name< iterator >
 
struct  handle_type_name< kwargs >
 
struct  handle_type_name< none >
 
struct  holder_helper< T >
 
struct  is_copy_assignable< T, SFINAE >
 
struct  is_copy_assignable< Container, enable_if_t< all_of< std::is_copy_assignable< Container >, std::is_same< typename Container::value_type &, typename Container::reference > >::value > >
 
struct  is_copy_assignable< std::pair< T1, T2 > >
 
struct  is_copy_constructible< T, SFINAE >
 
struct  is_copy_constructible< Container, enable_if_t< all_of< std::is_copy_constructible< Container >, std::is_same< typename Container::value_type &, typename Container::reference >, negation< std::is_same< Container, typename Container::value_type > > >::value > >
 
struct  is_copy_constructible< std::pair< T1, T2 > >
 
struct  is_holder_type< base, holder >
 
struct  is_holder_type< base, std::unique_ptr< base, deleter > >
 
struct  values_and_holders::iterator
 
struct  kw_only
 
class  loader_life_support
 
struct  move_always< T, SFINAE >
 
struct  move_always< T, enable_if_t< all_of< move_is_plain_type< T >, negation< is_copy_constructible< T > >, std::is_move_constructible< T >, std::is_same< decltype(std::declval< make_caster< T >>().operator T &()), T & >>::value > >
 
struct  move_if_unreferenced< T, SFINAE >
 
struct  move_if_unreferenced< T, enable_if_t< all_of< move_is_plain_type< T >, negation< move_always< T > >, std::is_move_constructible< T >, std::is_same< decltype(std::declval< make_caster< T >>().operator T &()), T & >>::value > >
 
struct  move_only_holder_caster< type, holder_type >
 
struct  override_unused
 
struct  polymorphic_type_hook< itype, SFINAE >
 
struct  polymorphic_type_hook_base< itype, SFINAE >
 
struct  polymorphic_type_hook_base< itype, detail::enable_if_t< std::is_polymorphic< itype >::value > >
 
struct  pos_only
 
struct  pyobject_caster< type >
 
struct  return_value_policy_override< Return, SFINAE >
 
struct  return_value_policy_override< Return, detail::enable_if_t< std::is_base_of< type_caster_generic, make_caster< Return > >::value, void > >
 
class  simple_collector< policy >
 
struct  string_caster< StringType, IsView >
 
class  tuple_caster< Tuple, Ts >
 
class  type_caster< type, SFINAE >
 
class  type_caster< bool >
 
struct  type_caster< CharT, enable_if_t< is_std_char_type< CharT >::value > >
 
struct  type_caster< std::basic_string< CharT, Traits, Allocator >, enable_if_t< is_std_char_type< CharT >::value > >
 
class  type_caster< std::nullptr_t >
 
class  type_caster< std::pair< T1, T2 > >
 
class  type_caster< std::reference_wrapper< type > >
 
class  type_caster< std::shared_ptr< T > >
 Specialize for the common std::shared_ptr, so users don't need to. More...
 
class  type_caster< std::tuple< Ts... > >
 
class  type_caster< std::unique_ptr< type, deleter > >
 
class  type_caster< T, enable_if_t< is_pyobject< T >::value > >
 
struct  type_caster< T, enable_if_t< std::is_arithmetic< T >::value &&!is_std_char_type< T >::value > >
 
class  type_caster< void >
 
class  type_caster< void_type >
 
class  type_caster_base< type >
 Generic type caster for objects stored on the heap. More...
 
class  type_caster_generic
 
class  unpacking_collector< policy >
 Helper class which collects positional, keyword, * and ** arguments for a Python function call. More...
 
struct  value_and_holder
 
struct  values_and_holders
 
struct  void_caster< T >
 

Namespaces

 literals
 

Macros

#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...)
 Create a specialization for custom holder types (silently ignores std::shared_ptr) More...
 
#define PYBIND11_MAKE_OPAQUE(...)
 
#define PYBIND11_TYPE(...)   __VA_ARGS__
 
#define PYBIND11_TYPE_CASTER(type, py_name)
 

Typedefs

template<typename >
using arg_t = arg_v
 Alias for backward compatibility – to be removed in version 2.0. More...
 
template<typename type >
using cast_is_temporary_value_reference = bool_constant< (std::is_reference< type >::value||std::is_pointer< type >::value)&&!std::is_base_of< type_caster_generic, make_caster< type >>::value &&!std::is_same< intrinsic_t< type >, void >::value >
 
template<typename T >
using cast_op_type = conditional_t< std::is_pointer< remove_reference_t< T >>::value, typename std::add_pointer< intrinsic_t< T >>::type, typename std::add_lvalue_reference< intrinsic_t< T >>::type >
 
template<typename CharT >
using is_std_char_type = any_of< std::is_same< CharT, char >, std::is_same< CharT, char16_t >, std::is_same< CharT, char32_t >, std::is_same< CharT, wchar_t > >
 
template<typename type >
using make_caster = type_caster< intrinsic_t< type >>
 
template<typename T >
using movable_cast_op_type = conditional_t< std::is_pointer< typename std::remove_reference< T >::type >::value, typename std::add_pointer< intrinsic_t< T >>::type, conditional_t< std::is_rvalue_reference< T >::value, typename std::add_rvalue_reference< intrinsic_t< T >>::type, typename std::add_lvalue_reference< intrinsic_t< T >>::type >>
 
template<typename T >
using move_is_plain_type = satisfies_none_of< T, std::is_void, std::is_pointer, std::is_reference, std::is_const >
 
template<typename T >
using move_never = none_of< move_always< T >, move_if_unreferenced< T >>
 
template<typename ret_type >
using override_caster_t = conditional_t< cast_is_temporary_value_reference< ret_type >::value, make_caster< ret_type >, override_unused >
 
template<typename type , typename holder_type >
using type_caster_holder = conditional_t< is_copy_constructible< holder_type >::value, copyable_holder_caster< type, holder_type >, move_only_holder_caster< type, holder_type >>
 

Functions

const std::vector< detail::type_info * > & all_type_info (PyTypeObject *type)
 
std::pair< decltype(internals::registered_types_py)::iterator, bool > all_type_info_get_cache (PyTypeObject *type)
 
PYBIND11_NOINLINE void all_type_info_populate (PyTypeObject *t, std::vector< type_info * > &bases)
 
template<typename T , detail::enable_if_t<!detail::is_pyobject< T >::value, int > = 0>
T cast (const handle &handle)
 
template<typename T , detail::enable_if_t<!detail::is_pyobject< T >::value, int > = 0>
object cast (T &&value, return_value_policy policy=return_value_policy::automatic_reference, handle parent=handle())
 
template<typename T >
detail::enable_if_t< detail::move_always< T >::value, T > cast (object &&object)
 
template<typename T >
detail::enable_if_t< detail::move_if_unreferenced< T >::value, T > cast (object &&object)
 
template<typename T >
detail::enable_if_t< detail::move_never< T >::value, T > cast (object &&object)
 
template<typename T >
make_caster< T >::template cast_op_type< T > cast_op (make_caster< T > &caster)
 
template<typename T >
make_caster< T >::template cast_op_type< typename std::add_rvalue_reference< T >::type > cast_op (make_caster< T > &&caster)
 
template<typename T >
enable_if_t< cast_is_temporary_value_reference< T >::value, T > cast_ref (object &&o, make_caster< T > &caster)
 
template<typename T >
enable_if_t<!cast_is_temporary_value_reference< T >::value, T > cast_ref (object &&, override_unused &)
 
template<typename T >
enable_if_t<!cast_is_temporary_value_reference< T >::value, T > cast_safe (object &&o)
 
template<typename T >
enable_if_t< cast_is_temporary_value_reference< T >::value, T > cast_safe (object &&)
 
template<>
void cast_safe< void > (object &&)
 
template<return_value_policy policy, typename... Args, typename = enable_if_t<all_of<is_positional<Args>...>::value>>
simple_collector< policy > collect_arguments (Args &&...args)
 Collect only positional arguments for a Python function call. More...
 
template<return_value_policy policy, typename... Args, typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
unpacking_collector< policy > collect_arguments (Args &&...args)
 Collect all arguments, including keywords and unpacking (only instantiated when needed) More...
 
PYBIND11_NOINLINE std::string error_string ()
 
detail::type_info * get_global_type_info (const std::type_index &tp)
 
detail::type_info * get_local_type_info (const std::type_index &tp)
 
PYBIND11_NOINLINE handle get_object_handle (const void *ptr, const detail::type_info *type)
 
PyThreadState * get_thread_state_unchecked ()
 
PYBIND11_NOINLINE handle get_type_handle (const std::type_info &tp, bool throw_if_missing)
 
PYBIND11_NOINLINE detail::type_info * get_type_info (PyTypeObject *type)
 
PYBIND11_NOINLINE detail::type_info * get_type_info (const std::type_index &tp, bool throw_if_missing=false)
 Return the type info for a given C++ type; on lookup failure can either throw or return nullptr. More...
 
PYBIND11_NOINLINE bool isinstance_generic (handle obj, const std::type_info &tp)
 
void keep_alive_impl (handle nurse, handle patient)
 
template<typename T , typename SFINAE >
type_caster< T, SFINAE > & load_type (type_caster< T, SFINAE > &conv, const handle &handle)
 
template<typename T >
make_caster< T > load_type (const handle &handle)
 
PyObject * make_new_instance (PyTypeObject *type)
 
template<return_value_policy policy = return_value_policy::automatic_reference>
tuple make_tuple ()
 
template<return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
tuple make_tuple (Args &&...args_)
 
template<typename T >
detail::enable_if_t<!detail::move_never< T >::value, T > move (object &&obj)
 
template<typename T , enable_if_t<!is_pyobject< T >::value, int > >
object object_or_cast (T &&o)
 
constexpr arg literals::operator""_a (const char *name, size_t)
 

Macro Definition Documentation

#define PYBIND11_DECLARE_HOLDER_TYPE (   type,
  holder_type,
  ... 
)
Value:
namespace pybind11 { namespace detail { \
template <typename type> \
struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__> { }; \
template <typename type> \
class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
: public type_caster_holder<type, holder_type> { }; \
}}
type_caster
Definition: cast.h:946
type_caster_holder
conditional_t< is_copy_constructible< holder_type >::value, copyable_holder_caster< type, holder_type >, move_only_holder_caster< type, holder_type >> type_caster_holder
Definition: cast.h:1598
always_construct_holder
Definition: cast.h:1600

Create a specialization for custom holder types (silently ignores std::shared_ptr)

Definition at line 1603 of file cast.h.

#define PYBIND11_MAKE_OPAQUE (   ...)
Value:
namespace pybind11 { namespace detail { \
template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \
}}
type_caster
Definition: cast.h:946
type_caster_base
Generic type caster for objects stored on the heap.
Definition: cast.h:861

Definition at line 2219 of file cast.h.

#define PYBIND11_TYPE (   ...)    __VA_ARGS__

Lets you pass a type containing a , through a macro parameter without needing a separate typedef, e.g.: PYBIND11_OVERRIDE(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)

Definition at line 2226 of file cast.h.

#define PYBIND11_TYPE_CASTER (   type,
  py_name 
)
Value:
protected: \
type value; \
public: \
static constexpr auto name = py_name; \
template <typename T_, enable_if_t<std::is_same<type, remove_cv_t<T_>>::value, int> = 0> \
static handle cast(T_ *src, return_value_policy policy, handle parent) { \
if (!src) return none().release(); \
if (policy == return_value_policy::take_ownership) { \
auto h = cast(std::move(*src), policy, parent); delete src; return h; \
} else { \
return cast(*src, policy, parent); \
} \
} \
operator type*() { return &value; } \
operator type&() { return value; } \
operator type&&() && { return std::move(value); } \
template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
if
if((m *x).isApprox(y))
Definition: FullPivLU_solve.cpp:6
return
if n return
Definition: level1_cplx_impl.h:33
test_callbacks.value
value
Definition: test_callbacks.py:116
h
const double h
Definition: testSimpleHelicopter.cpp:16
cast_op_type
conditional_t< std::is_pointer< remove_reference_t< T >>::value, typename std::add_pointer< intrinsic_t< T >>::type, typename std::add_lvalue_reference< intrinsic_t< T >>::type > cast_op_type
Definition: cast.h:773
cast
T cast(const handle &handle)
Definition: cast.h:1727
name
Annotation for function names.
Definition: attr.h:36
return_value_policy
return_value_policy
Approach used to cast a previously unknown C++ instance into a Python object.
Definition: wrap/pybind11/include/pybind11/detail/common.h:331

Definition at line 979 of file cast.h.

Typedef Documentation

template<typename >
using arg_t = arg_v

Alias for backward compatibility – to be removed in version 2.0.

Definition at line 1925 of file cast.h.

template<typename type >
using cast_is_temporary_value_reference = bool_constant< (std::is_reference<type>::value || std::is_pointer<type>::value) && !std::is_base_of<type_caster_generic, make_caster<type>>::value && !std::is_same<intrinsic_t<type>, void>::value >

Definition at line 1686 of file cast.h.

template<typename T >
using cast_op_type = conditional_t<std::is_pointer<remove_reference_t<T>>::value, typename std::add_pointer<intrinsic_t<T>>::type, typename std::add_lvalue_reference<intrinsic_t<T>>::type>

Determine suitable casting operator for pointer-or-lvalue-casting type casters. The type caster needs to provide operator T*() and operator T&() operators.

If the type supports moving the value away via an operator T&&() && method, it should use movable_cast_op_type instead.

Definition at line 773 of file cast.h.

template<typename CharT >
using is_std_char_type = any_of< std::is_same<CharT, char>, std::is_same<CharT, char16_t>, std::is_same<CharT, char32_t>, std::is_same<CharT, wchar_t> >

Definition at line 1007 of file cast.h.

template<typename type >
using make_caster = type_caster<intrinsic_t<type>>

Definition at line 947 of file cast.h.

template<typename T >
using movable_cast_op_type = conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value, typename std::add_pointer<intrinsic_t<T>>::type, conditional_t<std::is_rvalue_reference<T>::value, typename std::add_rvalue_reference<intrinsic_t<T>>::type, typename std::add_lvalue_reference<intrinsic_t<T>>::type>>

Determine suitable casting operator for a type caster with a movable value. Such a type caster needs to provide operator T*(), operator T&(), and operator T&&() &&. The latter will be called in appropriate contexts where the value can be moved rather than copied.

These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.

Definition at line 788 of file cast.h.

template<typename T >
using move_is_plain_type = satisfies_none_of<T, std::is_void, std::is_pointer, std::is_reference, std::is_const >

Definition at line 1661 of file cast.h.

template<typename T >
using move_never = none_of<move_always<T>, move_if_unreferenced<T>>

Definition at line 1676 of file cast.h.

template<typename ret_type >
using override_caster_t = conditional_t< cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, override_unused>

Definition at line 1802 of file cast.h.

template<typename type , typename holder_type >
using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value, copyable_holder_caster<type, holder_type>, move_only_holder_caster<type, holder_type>>

Definition at line 1598 of file cast.h.

Function Documentation

const std::vector<detail::type_info *>& all_type_info ( PyTypeObject *  type)
inline

Extracts vector of type_info pointers of pybind-registered roots of the given Python type. Will be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side derived class that uses single inheritance. Will contain as many types as required for a Python class that uses multiple inheritance to inherit (directly or indirectly) from multiple pybind-registered classes. Will be empty if neither the type nor any base classes are pybind-registered.

The value is cached for the lifetime of the Python type.

Definition at line 150 of file cast.h.

std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache ( PyTypeObject *  type)
inline

Definition at line 1730 of file pybind11.h.

PYBIND11_NOINLINE void all_type_info_populate ( PyTypeObject *  t,
std::vector< type_info * > &  bases 
)
inline

Definition at line 95 of file cast.h.

template<typename T , detail::enable_if_t<!detail::is_pyobject< T >::value, int > = 0>
T cast ( const handle &  handle)

Definition at line 1727 of file cast.h.

template<typename T , detail::enable_if_t<!detail::is_pyobject< T >::value, int > = 0>
object cast ( T &&  value,
return_value_policy  policy = return_value_policy::automatic_reference,
handle  parent = handle() 
)

Definition at line 1740 of file cast.h.

template<typename T >
detail::enable_if_t<detail::move_always<T>::value, T> cast ( object &&  object)

Definition at line 1776 of file cast.h.

template<typename T >
detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast ( object &&  object)

Definition at line 1779 of file cast.h.

template<typename T >
detail::enable_if_t<detail::move_never<T>::value, T> cast ( object &&  object)

Definition at line 1785 of file cast.h.

template<typename T >
make_caster<T>::template cast_op_type<T> cast_op ( make_caster< T > &  caster)

Definition at line 950 of file cast.h.

template<typename T >
make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type> cast_op ( make_caster< T > &&  caster)

Definition at line 954 of file cast.h.

template<typename T >
enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref ( object &&  o,
make_caster< T > &  caster 
)

Definition at line 1806 of file cast.h.

template<typename T >
enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref ( object &&  ,
override_unused &   
)

Definition at line 1809 of file cast.h.

template<typename T >
enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe ( object &&  o)

Definition at line 1815 of file cast.h.

template<typename T >
enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe ( object &&  )

Definition at line 1817 of file cast.h.

template<>
void cast_safe< void > ( object &&  )
inline

Definition at line 1819 of file cast.h.

template<return_value_policy policy, typename... Args, typename = enable_if_t<all_of<is_positional<Args>...>::value>>
simple_collector<policy> collect_arguments ( Args &&...  args)

Collect only positional arguments for a Python function call.

Definition at line 2175 of file cast.h.

template<return_value_policy policy, typename... Args, typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
unpacking_collector<policy> collect_arguments ( Args &&...  args)

Collect all arguments, including keywords and unpacking (only instantiated when needed)

Definition at line 2182 of file cast.h.

PYBIND11_NOINLINE std::string error_string ( )
inline

Definition at line 410 of file cast.h.

detail::type_info* get_global_type_info ( const std::type_index &  tp)
inline

Definition at line 181 of file cast.h.

detail::type_info* get_local_type_info ( const std::type_index &  tp)
inline

Definition at line 173 of file cast.h.

PYBIND11_NOINLINE handle get_object_handle ( const void *  ptr,
const detail::type_info *  type 
)
inline

Definition at line 457 of file cast.h.

PyThreadState* get_thread_state_unchecked ( )
inline

Definition at line 469 of file cast.h.

PYBIND11_NOINLINE handle get_type_handle ( const std::type_info &  tp,
bool  throw_if_missing 
)
inline

Definition at line 205 of file cast.h.

PYBIND11_NOINLINE detail::type_info* get_type_info ( PyTypeObject *  type)
inline

Gets a single pybind11 type info for a python type. Returns nullptr if neither the type nor any ancestors are pybind11-registered. Throws an exception if there are multiple bases–use all_type_info instead if you want to support multiple bases.

Definition at line 164 of file cast.h.

PYBIND11_NOINLINE detail::type_info* get_type_info ( const std::type_index &  tp,
bool  throw_if_missing = false 
)
inline

Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.

Definition at line 190 of file cast.h.

PYBIND11_NOINLINE bool isinstance_generic ( handle  obj,
const std::type_info &  tp 
)
inline

Definition at line 403 of file cast.h.

void keep_alive_impl ( handle  nurse,
handle  patient 
)
inline

Definition at line 1689 of file pybind11.h.

template<typename T , typename SFINAE >
type_caster<T, SFINAE>& load_type ( type_caster< T, SFINAE > &  conv,
const handle &  handle 
)

Definition at line 1705 of file cast.h.

template<typename T >
make_caster<T> load_type ( const handle &  handle)

Definition at line 1717 of file cast.h.

PyObject* make_new_instance ( PyTypeObject *  type)
inline

Instance creation function for all pybind11 types. It allocates the internal instance layout for holding C++ objects and holders. Allocation is done lazily (the first time the instance is cast to a reference or pointer), and initialization is done by an __init__ function.

Definition at line 277 of file class.h.

template<return_value_policy policy = return_value_policy::automatic_reference>
tuple make_tuple ( )

Definition at line 1824 of file cast.h.

template<return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
tuple make_tuple ( Args &&...  args_)

Definition at line 1827 of file cast.h.

template<typename T >
detail::enable_if_t<!detail::move_never<T>::value, T> move ( object &&  obj)

Definition at line 1756 of file cast.h.

template<typename T , enable_if_t<!is_pyobject< T >::value, int > >
object object_or_cast ( T &&  o)

Definition at line 1798 of file cast.h.


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:51:28