include/pybind11/pybind11.h

46 #include "detail/class.h"
47 #include "detail/init.h"
69               typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
72                    (detail::function_signature_t<Func> *) nullptr, extra...);
94     PYBIND11_NOINLINE detail::function_record *make_function_record() {
95         return new detail::function_record();
101         using namespace detail;
193     void initialize_generic(detail::function_record *rec, const char *text,
254                 if (auto tinfo = detail::get_type_info(*t)) {
267                     detail::clean_type_id(tname);
293         detail::function_record *chain = nullptr, *chain_start = rec;
297                 chain = (detail::function_record *) rec_capsule;
318                 destruct((detail::function_record *) ptr);
401     static void destruct(detail::function_record *rec) {
403             detail::function_record *next = rec->next;
425         using namespace detail;
885 NAMESPACE_BEGIN(detail)
904         auto *tinfo = new detail::type_info();
958         auto tinfo = detail::get_type_info(&type->ht_type);
974                                   detail::function_record *rec_func) {
1016 NAMESPACE_END(detail)
1025     static_assert(detail::is_accessible_base_of<Class, Derived>::value,
1032     static_assert(detail::is_accessible_base_of<Class, Derived>::value,
1038 class class_ : public detail::generic_type {
1039     template <typename T> using is_holder = detail::is_holder_type<type_, T>;
1040     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
1041     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
1044         detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
1048     using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
1050     using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
1052     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
1062         using namespace detail;
1081         record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
1099     template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
1100     static void add_base(detail::type_record &rec) {
1106     template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
1107     static void add_base(detail::type_record &) { }
1127     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
1128     class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1133     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
1134     class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1140     class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
1146     class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
1152     class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
1158     class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
1167             detail::make_caster<type> caster;
1268         static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
1274            detail::process_attributes<Extra...>::init(extra..., rec_fget);
1282             detail::process_attributes<Extra...>::init(extra..., rec_fset);
1296     static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
1313     static void init_holder_from_existing(const detail::value_and_holder &v_h,
1318     static void init_holder_from_existing(const detail::value_and_holder &v_h,
1324     static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
1329         } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
1339     static void init_instance(detail::instance *inst, const void *holder_ptr) {
1340         auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
1349     static void dealloc(detail::value_and_holder &v_h) {
1355             detail::call_operator_delete(v_h.value_ptr<type>(),
1363     static detail::function_record *get_function_record(handle h) {
1364         h = detail::get_function(h);
1365         return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
1371 template <typename... Args> detail::initimpl::constructor<Args...> init() { return {}; }
1374 template <typename... Args> detail::initimpl::alias_constructor<Args...> init_alias() { return {}; }
1377 template <typename Func, typename Ret = detail::initimpl::factory<Func>>
1382 template <typename CFunc, typename AFunc, typename Ret = detail::initimpl::factory<CFunc, AFunc>>
1390 detail::initimpl::pickle_factory<GetState, SetState> pickle(GetState &&g, SetState &&s) {
1394 NAMESPACE_BEGIN(detail)
1545 NAMESPACE_END(detail)
1560         constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
1592     detail::enum_base m_base;
1595 NAMESPACE_BEGIN(detail)
1644         .emplace(type, std::vector<detail::type_info *>());
1665 NAMESPACE_END(detail)
1674     typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
1676     if (!detail::get_type_info(typeid(state), false)) {
1703     typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
1705     if (!detail::get_type_info(typeid(state), false)) {
1749         if (!detail::make_caster<InputType>().load(obj, false))
1759     if (auto tinfo = detail::get_type_info(typeid(OutputType)))
1767     detail::get_internals().registered_exception_translators.push_front(
1798 NAMESPACE_BEGIN(detail)
1804 NAMESPACE_END(detail)
1816     auto &ex = detail::get_exception_object<CppException>();
1824             detail::get_exception_object<CppException>()(e.what());
1830 NAMESPACE_BEGIN(detail)
1861 NAMESPACE_END(detail)
1865     auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...);
1866     detail::print(c.args(), c.kwargs());
1896         auto const &internals = detail::get_internals();
1917             release = detail::get_thread_state_unchecked() != tstate;
1942             if (detail::get_thread_state_unchecked() != tstate)
1954             PYBIND11_TLS_DELETE_VALUE(detail::get_internals().tstate);
1975         const auto &internals = detail::get_internals();
1987             auto key = detail::get_internals().tstate;
2024 inline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name)  {
2025     handle self = detail::get_object_handle(this_ptr, this_type);
2033     auto &cache = detail::get_internals().inactive_overload_cache;
2090     auto tinfo = detail::get_type_info(typeid(T));
2099             if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
2100                 static pybind11::detail::overload_caster_t<ret_type> caster; \
2101                 return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
2103             else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \