Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-22 05:05:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'smart_holder' into native_enum_internals_sh

Browse Source
This commit is contained in:
Ralf W. Grosse-Kunstleve 2024-08-09 11:13:22 -07:00
commit 8581b4b42a
53 changed files with 123 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/emscripten.yaml vendored
View File

@ -20,7 +20,7 @@ jobs:
submodules: true submodules: true
fetch-depth: 0 fetch-depth: 0
- uses: pypa/cibuildwheel@v2.19 - uses: pypa/cibuildwheel@v2.20
env: env:
PYODIDE_BUILD_EXPORTS: whole_archive PYODIDE_BUILD_EXPORTS: whole_archive
CFLAGS: -fexceptions CFLAGS: -fexceptions

2
.github/workflows/pip.yml vendored
View File

@ -103,7 +103,7 @@ jobs:
- uses: actions/download-artifact@v4 - uses: actions/download-artifact@v4
- name: Generate artifact attestation for sdist and wheel - name: Generate artifact attestation for sdist and wheel
uses: actions/attest-build-provenance@5e9cb68e95676991667494a6a4e59b8a2f13e1d0 # v1.3.3 uses: actions/attest-build-provenance@210c1913531870065f03ce1f9440dd87bc0938cd # v1.4.0
with: with:
subject-path: "*/pybind11*" subject-path: "*/pybind11*"

8
.pre-commit-config.yaml
View File

@ -32,7 +32,7 @@ repos:
# Ruff, the Python auto-correcting linter/formatter written in Rust # Ruff, the Python auto-correcting linter/formatter written in Rust
- repo: https://github.com/astral-sh/ruff-pre-commit - repo: https://github.com/astral-sh/ruff-pre-commit
rev: v0.5.0 rev: v0.5.6
hooks: hooks:
- id: ruff - id: ruff
args: ["--fix", "--show-fixes"] args: ["--fix", "--show-fixes"]
@ -40,7 +40,7 @@ repos:
# Check static types with mypy # Check static types with mypy
- repo: https://github.com/pre-commit/mirrors-mypy - repo: https://github.com/pre-commit/mirrors-mypy
rev: "v1.10.1" rev: "v1.11.1"
hooks: hooks:
- id: mypy - id: mypy
args: [] args: []
@ -144,14 +144,14 @@ repos:
# PyLint has native support - not always usable, but works for us # PyLint has native support - not always usable, but works for us
- repo: https://github.com/PyCQA/pylint - repo: https://github.com/PyCQA/pylint
rev: "v3.2.4" rev: "v3.2.6"
hooks: hooks:
- id: pylint - id: pylint
files: ^pybind11 files: ^pybind11
# Check schemas on some of our YAML files # Check schemas on some of our YAML files
- repo: https://github.com/python-jsonschema/check-jsonschema - repo: https://github.com/python-jsonschema/check-jsonschema
rev: 0.28.6 rev: 0.29.1
hooks: hooks:
- id: check-readthedocs - id: check-readthedocs
- id: check-github-workflows - id: check-github-workflows

2
docs/compiling.rst
View File

@ -25,7 +25,7 @@ A Python extension module can be created with just a few lines of code:
find_package(pybind11 CONFIG REQUIRED) find_package(pybind11 CONFIG REQUIRED)
pybind11_add_module(example example.cpp) pybind11_add_module(example example.cpp)
install(TARGET example DESTINATION .) install(TARGETS example DESTINATION .)
(You use the ``add_subdirectory`` instead, see the example in :ref:`cmake`.) In (You use the ``add_subdirectory`` instead, see the example in :ref:`cmake`.) In
this example, the code is located in a file named :file:`example.cpp`. Either this example, the code is located in a file named :file:`example.cpp`. Either

2
include/pybind11/attr.h
View File

@ -331,7 +331,7 @@ struct type_record {
/// Is the class inheritable from python classes? /// Is the class inheritable from python classes?
bool is_final : 1; bool is_final : 1;
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
holder_enum_t holder_enum_v = holder_enum_t::undefined; holder_enum_t holder_enum_v = holder_enum_t::undefined;
#endif #endif

10
include/pybind11/cast.h
View File

@ -935,7 +935,7 @@ protected:
holder_type holder; holder_type holder;
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename, typename SFINAE = void> template <typename, typename SFINAE = void>
struct copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled : std::true_type {}; struct copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled : std::true_type {};
@ -1062,7 +1062,7 @@ protected:
smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl
}; };
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
/// Specialize for the common std::shared_ptr, so users don't need to /// Specialize for the common std::shared_ptr, so users don't need to
template <typename T> template <typename T>
@ -1084,7 +1084,7 @@ struct move_only_holder_caster {
static constexpr auto name = type_caster_base<type>::name; static constexpr auto name = type_caster_base<type>::name;
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename, typename SFINAE = void> template <typename, typename SFINAE = void>
struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled : std::true_type {}; struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled : std::true_type {};
@ -1188,7 +1188,7 @@ public:
smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl
}; };
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename type, typename deleter> template <typename type, typename deleter>
class type_caster<std::unique_ptr<type, deleter>> class type_caster<std::unique_ptr<type, deleter>>
@ -1226,7 +1226,7 @@ struct is_holder_type
template <typename base, typename deleter> template <typename base, typename deleter>
struct is_holder_type<base, std::unique_ptr<base, deleter>> : std::true_type {}; struct is_holder_type<base, std::unique_ptr<base, deleter>> : std::true_type {};
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename base> template <typename base>
struct is_holder_type<base, smart_holder> : std::true_type {}; struct is_holder_type<base, smart_holder> : std::true_type {};
#endif #endif

4
include/pybind11/detail/init.h
View File

@ -198,7 +198,7 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
v_h.value_ptr() = new Alias<Class>(std::move(result)); v_h.value_ptr() = new Alias<Class>(std::move(result));
} }
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename T, typename D> template <typename T, typename D>
smart_holder init_smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr, smart_holder init_smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr,
@ -268,7 +268,7 @@ void construct(value_and_holder &v_h,
v_h.type->init_instance(v_h.inst, &smhldr); v_h.type->init_instance(v_h.inst, &smhldr);
} }
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
// Implementing class for py::init<...>() // Implementing class for py::init<...>()
template <typename... Args> template <typename... Args>

4
include/pybind11/detail/internals.h
View File

@ -244,7 +244,7 @@ struct internals {
#if PYBIND11_INTERNALS_VERSION >= 6 #if PYBIND11_INTERNALS_VERSION >= 6
# define PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT # define PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
enum class holder_enum_t : uint8_t { enum class holder_enum_t : uint8_t {
undefined, undefined,
@ -284,7 +284,7 @@ struct type_info {
bool default_holder : 1; bool default_holder : 1;
/* true if this is a type registered with py::module_local */ /* true if this is a type registered with py::module_local */
bool module_local : 1; bool module_local : 1;
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
holder_enum_t holder_enum_v = holder_enum_t::undefined; holder_enum_t holder_enum_v = holder_enum_t::undefined;
#endif #endif
}; };

6
include/pybind11/detail/type_caster_base.h
View File

@ -472,7 +472,7 @@ inline PyThreadState *get_thread_state_unchecked() {
void keep_alive_impl(handle nurse, handle patient); void keep_alive_impl(handle nurse, handle patient);
inline PyObject *make_new_instance(PyTypeObject *type); inline PyObject *make_new_instance(PyTypeObject *type);
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
// SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code. // SMART_HOLDER_WIP: Needs refactoring of existing pybind11 code.
inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo); inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
@ -823,7 +823,7 @@ struct load_helper : value_and_holder_helper {
PYBIND11_NAMESPACE_END(smart_holder_type_caster_support) PYBIND11_NAMESPACE_END(smart_holder_type_caster_support)
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
class type_caster_generic { class type_caster_generic {
public: public:
@ -929,7 +929,7 @@ public:
// Base methods for generic caster; there are overridden in copyable_holder_caster // Base methods for generic caster; there are overridden in copyable_holder_caster
void load_value(value_and_holder &&v_h) { void load_value(value_and_holder &&v_h) {
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) { if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
smart_holder_type_caster_support::value_and_holder_helper v_h_helper; smart_holder_type_caster_support::value_and_holder_helper v_h_helper;
v_h_helper.loaded_v_h = v_h; v_h_helper.loaded_v_h = v_h;

6
include/pybind11/detail/using_smart_holder.h
View File

@ -9,19 +9,19 @@
#include <type_traits> #include <type_traits>
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
# include "smart_holder_poc.h" # include "smart_holder_poc.h"
#endif #endif
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
using pybindit::memory::smart_holder; using pybindit::memory::smart_holder;
#endif #endif
PYBIND11_NAMESPACE_BEGIN(detail) PYBIND11_NAMESPACE_BEGIN(detail)
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename H> template <typename H>
using is_smart_holder = std::is_same<H, smart_holder>; using is_smart_holder = std::is_same<H, smart_holder>;
#else #else

16
include/pybind11/pybind11.h
View File

@ -1430,7 +1430,7 @@ protected:
tinfo->simple_ancestors = true; tinfo->simple_ancestors = true;
tinfo->default_holder = rec.default_holder; tinfo->default_holder = rec.default_holder;
tinfo->module_local = rec.module_local; tinfo->module_local = rec.module_local;
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
tinfo->holder_enum_v = rec.holder_enum_v; tinfo->holder_enum_v = rec.holder_enum_v;
#endif #endif
@ -1637,7 +1637,7 @@ PYBIND11_NAMESPACE_END(detail)
template <typename T, typename D, typename SFINAE = void> template <typename T, typename D, typename SFINAE = void>
struct property_cpp_function : detail::property_cpp_function_classic<T, D> {}; struct property_cpp_function : detail::property_cpp_function_classic<T, D> {};
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
PYBIND11_NAMESPACE_BEGIN(detail) PYBIND11_NAMESPACE_BEGIN(detail)
@ -1816,10 +1816,10 @@ struct property_cpp_function<
detail::both_t_and_d_use_type_caster_base<T, typename D::element_type>>::value>> detail::both_t_and_d_use_type_caster_base<T, typename D::element_type>>::value>>
: detail::property_cpp_function_sh_unique_ptr_member<T, D> {}; : detail::property_cpp_function_sh_unique_ptr_member<T, D> {};
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
#if defined(PYBIND11_USE_SMART_HOLDER_AS_DEFAULT) \ #if defined(PYBIND11_USE_SMART_HOLDER_AS_DEFAULT) \
&& defined(PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT) && defined(PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT)
// NOTE: THIS IS MEANT FOR STRESS-TESTING ONLY! // NOTE: THIS IS MEANT FOR STRESS-TESTING ONLY!
// As of PR #5257, for production use, there is no longer a strong reason to make // As of PR #5257, for production use, there is no longer a strong reason to make
// smart_holder the default holder: // smart_holder the default holder:
@ -1887,7 +1887,7 @@ public:
// A more fitting name would be uses_unique_ptr_holder. // A more fitting name would be uses_unique_ptr_holder.
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value; record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
if (detail::is_instantiation<std::unique_ptr, holder_type>::value) { if (detail::is_instantiation<std::unique_ptr, holder_type>::value) {
record.holder_enum_v = detail::holder_enum_t::std_unique_ptr; record.holder_enum_v = detail::holder_enum_t::std_unique_ptr;
} else if (detail::is_instantiation<std::shared_ptr, holder_type>::value) { } else if (detail::is_instantiation<std::shared_ptr, holder_type>::value) {
@ -2237,7 +2237,7 @@ private:
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>()); init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
} }
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename WrappedType> template <typename WrappedType>
static bool try_initialization_using_shared_from_this(holder_type *, WrappedType *, ...) { static bool try_initialization_using_shared_from_this(holder_type *, WrappedType *, ...) {
@ -2299,7 +2299,7 @@ private:
v_h.set_holder_constructed(); v_h.set_holder_constructed();
} }
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
/// Deallocates an instance; via holder, if constructed; otherwise via operator delete. /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
static void dealloc(detail::value_and_holder &v_h) { static void dealloc(detail::value_and_holder &v_h) {
@ -2341,7 +2341,7 @@ private:
} }
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
// Supports easier switching between py::class_<T> and py::class_<T, py::smart_holder>: // Supports easier switching between py::class_<T> and py::class_<T, py::smart_holder>:
// users can simply replace the `_` in `class_` with `h` or vice versa. // users can simply replace the `_` in `class_` with `h` or vice versa.

4
include/pybind11/trampoline_self_life_support.h
View File

@ -6,7 +6,7 @@
#include "detail/internals.h" #include "detail/internals.h"
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
# include "detail/common.h" # include "detail/common.h"
# include "detail/using_smart_holder.h" # include "detail/using_smart_holder.h"
@ -64,4 +64,4 @@ struct trampoline_self_life_support {
PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT

6
tests/class_sh_module_local_0.cpp
View File

@ -19,8 +19,8 @@ atyp rtrn_valu_atyp() { return atyp(); }
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
PYBIND11_MODULE(class_sh_module_local_0, m) { PYBIND11_MODULE(class_sh_module_local_0, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -30,5 +30,5 @@ PYBIND11_MODULE(class_sh_module_local_0, m) {
m.def("get_mtxt", get_mtxt); m.def("get_mtxt", get_mtxt);
m.def("rtrn_valu_atyp", rtrn_valu_atyp); m.def("rtrn_valu_atyp", rtrn_valu_atyp);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

6
tests/class_sh_module_local_1.cpp
View File

@ -18,8 +18,8 @@ std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
PYBIND11_MODULE(class_sh_module_local_1, m) { PYBIND11_MODULE(class_sh_module_local_1, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -36,5 +36,5 @@ PYBIND11_MODULE(class_sh_module_local_1, m) {
.def("tag", [](const atyp &) { return 1; }); .def("tag", [](const atyp &) { return 1; });
m.def("get_mtxt", get_mtxt); m.def("get_mtxt", get_mtxt);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

6
tests/class_sh_module_local_2.cpp
View File

@ -18,8 +18,8 @@ std::string get_mtxt(const atyp &obj) { return obj.mtxt; }
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_module_local::atyp)
PYBIND11_MODULE(class_sh_module_local_2, m) { PYBIND11_MODULE(class_sh_module_local_2, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -36,5 +36,5 @@ PYBIND11_MODULE(class_sh_module_local_2, m) {
.def("tag", [](const atyp &) { return 2; }); .def("tag", [](const atyp &) { return 2; });
m.def("get_mtxt", get_mtxt); m.def("get_mtxt", get_mtxt);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class.cpp
View File

@ -93,7 +93,7 @@ TEST_SUBMODULE(class_, m) {
struct ToBeHeldByUniquePtr {}; struct ToBeHeldByUniquePtr {};
py::class_<ToBeHeldByUniquePtr, std::unique_ptr<ToBeHeldByUniquePtr>>(m, "ToBeHeldByUniquePtr") py::class_<ToBeHeldByUniquePtr, std::unique_ptr<ToBeHeldByUniquePtr>>(m, "ToBeHeldByUniquePtr")
.def(py::init<>()); .def(py::init<>());
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
m.def("pass_unique_ptr", [](std::unique_ptr<ToBeHeldByUniquePtr> &&) {}); m.def("pass_unique_ptr", [](std::unique_ptr<ToBeHeldByUniquePtr> &&) {});
#else #else
m.attr("pass_unique_ptr") = py::none(); m.attr("pass_unique_ptr") = py::none();

6
tests/test_class_sh_basic.cpp
View File

@ -145,8 +145,8 @@ namespace pybind11_tests {
namespace class_sh_basic { namespace class_sh_basic {
TEST_SUBMODULE(class_sh_basic, m) { TEST_SUBMODULE(class_sh_basic, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -246,7 +246,7 @@ TEST_SUBMODULE(class_sh_basic, m) {
[]() { return CastUnusualOpRefConstRef(LocalUnusualOpRef()); }); []() { return CastUnusualOpRefConstRef(LocalUnusualOpRef()); });
m.def("CallCastUnusualOpRefMovable", m.def("CallCastUnusualOpRefMovable",
[]() { return CastUnusualOpRefMovable(LocalUnusualOpRef()); }); []() { return CastUnusualOpRefMovable(LocalUnusualOpRef()); });
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }
} // namespace class_sh_basic } // namespace class_sh_basic

2
tests/test_class_sh_basic.py
View File

@ -7,7 +7,7 @@ import pytest
from pybind11_tests import class_sh_basic as m from pybind11_tests import class_sh_basic as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_disowning.cpp
View File

@ -32,8 +32,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning::Atype<1>)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning::Atype<2>) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning::Atype<2>)
TEST_SUBMODULE(class_sh_disowning, m) { TEST_SUBMODULE(class_sh_disowning, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -49,5 +49,5 @@ TEST_SUBMODULE(class_sh_disowning, m) {
m.def("overloaded", (int (*)(std::unique_ptr<Atype<1>>, int)) & overloaded); m.def("overloaded", (int (*)(std::unique_ptr<Atype<1>>, int)) & overloaded);
m.def("overloaded", (int (*)(std::unique_ptr<Atype<2>>, int)) & overloaded); m.def("overloaded", (int (*)(std::unique_ptr<Atype<2>>, int)) & overloaded);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_disowning.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_disowning as m from pybind11_tests import class_sh_disowning as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_disowning_mi.cpp
View File

@ -57,8 +57,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning_mi::Base1)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning_mi::Base2) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_disowning_mi::Base2)
TEST_SUBMODULE(class_sh_disowning_mi, m) { TEST_SUBMODULE(class_sh_disowning_mi, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -98,5 +98,5 @@ TEST_SUBMODULE(class_sh_disowning_mi, m) {
py::classh<Base2>(m, "Base2").def(py::init<int>()).def("bar", &Base2::bar); py::classh<Base2>(m, "Base2").def(py::init<int>()).def("bar", &Base2::bar);
m.def("disown_base1", disown_base1); m.def("disown_base1", disown_base1);
m.def("disown_base2", disown_base2); m.def("disown_base2", disown_base2);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_disowning_mi.py
View File

@ -5,7 +5,7 @@ import pytest
import env # noqa: F401 import env # noqa: F401
from pybind11_tests import class_sh_disowning_mi as m from pybind11_tests import class_sh_disowning_mi as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_factory_constructors.cpp
View File

@ -87,8 +87,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_factory_constructors
PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_factory_constructors::with_alias) PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_factory_constructors::with_alias)
TEST_SUBMODULE(class_sh_factory_constructors, m) { TEST_SUBMODULE(class_sh_factory_constructors, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -183,5 +183,5 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
[](int, int, int, int, int) { [](int, int, int, int, int) {
return std::make_shared<with_alias>(); // Invalid alias factory. return std::make_shared<with_alias>(); // Invalid alias factory.
})); }));
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_factory_constructors.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_factory_constructors as m from pybind11_tests import class_sh_factory_constructors as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_inheritance.cpp
View File

@ -73,8 +73,8 @@ namespace pybind11_tests {
namespace class_sh_inheritance { namespace class_sh_inheritance {
TEST_SUBMODULE(class_sh_inheritance, m) { TEST_SUBMODULE(class_sh_inheritance, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -105,7 +105,7 @@ TEST_SUBMODULE(class_sh_inheritance, m) {
m.def("pass_cptr_base1", pass_cptr_base1); m.def("pass_cptr_base1", pass_cptr_base1);
m.def("pass_cptr_base2", pass_cptr_base2); m.def("pass_cptr_base2", pass_cptr_base2);
m.def("pass_cptr_drvd2", pass_cptr_drvd2); m.def("pass_cptr_drvd2", pass_cptr_drvd2);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }
} // namespace class_sh_inheritance } // namespace class_sh_inheritance

2
tests/test_class_sh_inheritance.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_inheritance as m from pybind11_tests import class_sh_inheritance as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_mi_thunks.cpp
View File

@ -40,8 +40,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_mi_thunks::Base1)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_mi_thunks::Derived) PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_mi_thunks::Derived)
TEST_SUBMODULE(class_sh_mi_thunks, m) { TEST_SUBMODULE(class_sh_mi_thunks, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -103,5 +103,5 @@ TEST_SUBMODULE(class_sh_mi_thunks, m) {
} }
return obj_der->vec.size(); return obj_der->vec.size();
}); });
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_mi_thunks.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_mi_thunks as m from pybind11_tests import class_sh_mi_thunks as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

2
tests/test_class_sh_module_local.py
View File

@ -5,7 +5,7 @@ import class_sh_module_local_1 as m1
import class_sh_module_local_2 as m2 import class_sh_module_local_2 as m2
import pytest import pytest
if not m0.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m0.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_property.cpp
View File

@ -58,8 +58,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_property::WithCharArrayMember)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_property::WithConstCharPtrMember) PYBIND11_SMART_HOLDER_TYPE_CASTERS(test_class_sh_property::WithConstCharPtrMember)
TEST_SUBMODULE(class_sh_property, m) { TEST_SUBMODULE(class_sh_property, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -109,5 +109,5 @@ TEST_SUBMODULE(class_sh_property, m) {
py::classh<WithConstCharPtrMember>(m, "WithConstCharPtrMember") py::classh<WithConstCharPtrMember>(m, "WithConstCharPtrMember")
.def(py::init<>()) .def(py::init<>())
.def_readonly("const_char_ptr_member", &WithConstCharPtrMember::const_char_ptr_member); .def_readonly("const_char_ptr_member", &WithConstCharPtrMember::const_char_ptr_member);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_property.py
View File

@ -7,7 +7,7 @@ import pytest
import env # noqa: F401 import env # noqa: F401
from pybind11_tests import class_sh_property as m from pybind11_tests import class_sh_property as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_property_non_owning.cpp
View File

@ -51,8 +51,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(DataField)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(DataFieldsHolder) PYBIND11_SMART_HOLDER_TYPE_CASTERS(DataFieldsHolder)
TEST_SUBMODULE(class_sh_property_non_owning, m) { TEST_SUBMODULE(class_sh_property_non_owning, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -71,5 +71,5 @@ TEST_SUBMODULE(class_sh_property_non_owning, m) {
py::classh<DataFieldsHolder>(m, "DataFieldsHolder") py::classh<DataFieldsHolder>(m, "DataFieldsHolder")
.def(py::init<std::size_t>()) .def(py::init<std::size_t>())
.def("vec_at", &DataFieldsHolder::vec_at, py::return_value_policy::reference_internal); .def("vec_at", &DataFieldsHolder::vec_at, py::return_value_policy::reference_internal);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_property_non_owning.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_property_non_owning as m from pybind11_tests import class_sh_property_non_owning as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_shared_ptr_copy_move.cpp
View File

@ -50,8 +50,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::FooSmHld)
namespace pybind11_tests { namespace pybind11_tests {
TEST_SUBMODULE(class_sh_shared_ptr_copy_move, m) { TEST_SUBMODULE(class_sh_shared_ptr_copy_move, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -113,7 +113,7 @@ TEST_SUBMODULE(class_sh_shared_ptr_copy_move, m) {
l.append(std::move(o)); l.append(std::move(o));
return l; return l;
}); });
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }
} // namespace pybind11_tests } // namespace pybind11_tests

2
tests/test_class_sh_shared_ptr_copy_move.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_shared_ptr_copy_move as m from pybind11_tests import class_sh_shared_ptr_copy_move as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

12
tests/test_class_sh_trampoline_basic.cpp
View File

@ -34,7 +34,7 @@ struct AbaseAlias : Abase<SerNo> {
} }
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <> template <>
struct AbaseAlias<1> : Abase<1>, py::trampoline_self_life_support { struct AbaseAlias<1> : Abase<1>, py::trampoline_self_life_support {
using Abase<1>::Abase; using Abase<1>::Abase;
@ -46,7 +46,7 @@ struct AbaseAlias<1> : Abase<1>, py::trampoline_self_life_support {
other_val); other_val);
} }
}; };
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <int SerNo> template <int SerNo>
int AddInCppRawPtr(const Abase<SerNo> *obj, int other_val) { int AddInCppRawPtr(const Abase<SerNo> *obj, int other_val) {
@ -65,7 +65,7 @@ int AddInCppUniquePtr(std::unique_ptr<Abase<SerNo>> obj, int other_val) {
template <int SerNo> template <int SerNo>
void wrap(py::module_ m, const char *py_class_name) { void wrap(py::module_ m, const char *py_class_name) {
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
py::classh<Abase<SerNo>, AbaseAlias<SerNo>>(m, py_class_name) py::classh<Abase<SerNo>, AbaseAlias<SerNo>>(m, py_class_name)
.def(py::init<int>(), py::arg("val")) .def(py::init<int>(), py::arg("val"))
.def("Get", &Abase<SerNo>::Get) .def("Get", &Abase<SerNo>::Get)
@ -86,13 +86,13 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(Abase<0>)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(Abase<1>) PYBIND11_SMART_HOLDER_TYPE_CASTERS(Abase<1>)
TEST_SUBMODULE(class_sh_trampoline_basic, m) { TEST_SUBMODULE(class_sh_trampoline_basic, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
wrap<0>(m, "Abase0"); wrap<0>(m, "Abase0");
wrap<1>(m, "Abase1"); wrap<1>(m, "Abase1");
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_trampoline_basic.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_trampoline_basic as m from pybind11_tests import class_sh_trampoline_basic as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

8
tests/test_class_sh_trampoline_self_life_support.cpp
View File

@ -38,7 +38,7 @@ protected:
Big5() : history{"DefaultConstructor"} {} Big5() : history{"DefaultConstructor"} {}
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
struct Big5Trampoline : Big5, py::trampoline_self_life_support { struct Big5Trampoline : Big5, py::trampoline_self_life_support {
using Big5::Big5; using Big5::Big5;
}; };
@ -52,8 +52,8 @@ using namespace pybind11_tests::class_sh_trampoline_self_life_support;
PYBIND11_SMART_HOLDER_TYPE_CASTERS(Big5) PYBIND11_SMART_HOLDER_TYPE_CASTERS(Big5)
TEST_SUBMODULE(class_sh_trampoline_self_life_support, m) { TEST_SUBMODULE(class_sh_trampoline_self_life_support, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -94,5 +94,5 @@ TEST_SUBMODULE(class_sh_trampoline_self_life_support, m) {
py::object o1 = py::cast(std::move(obj)); py::object o1 = py::cast(std::move(obj));
return py::make_tuple(o1, o2); return py::make_tuple(o1, o2);
}); });
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_trampoline_self_life_support.py
View File

@ -4,7 +4,7 @@ import pytest
import pybind11_tests.class_sh_trampoline_self_life_support as m import pybind11_tests.class_sh_trampoline_self_life_support as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

8
tests/test_class_sh_trampoline_shared_from_this.cpp
View File

@ -71,7 +71,7 @@ struct SftSharedPtrStash {
} }
}; };
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
struct SftTrampoline : Sft, py::trampoline_self_life_support { struct SftTrampoline : Sft, py::trampoline_self_life_support {
using Sft::Sft; using Sft::Sft;
}; };
@ -110,8 +110,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(Sft)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(SftSharedPtrStash) PYBIND11_SMART_HOLDER_TYPE_CASTERS(SftSharedPtrStash)
TEST_SUBMODULE(class_sh_trampoline_shared_from_this, m) { TEST_SUBMODULE(class_sh_trampoline_shared_from_this, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -140,5 +140,5 @@ TEST_SUBMODULE(class_sh_trampoline_shared_from_this, m) {
m.def("make_pure_cpp_sft_unq_ptr", make_pure_cpp_sft_unq_ptr); m.def("make_pure_cpp_sft_unq_ptr", make_pure_cpp_sft_unq_ptr);
m.def("make_pure_cpp_sft_shd_ptr", make_pure_cpp_sft_shd_ptr); m.def("make_pure_cpp_sft_shd_ptr", make_pure_cpp_sft_shd_ptr);
m.def("pass_through_shd_ptr", pass_through_shd_ptr); m.def("pass_through_shd_ptr", pass_through_shd_ptr);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_trampoline_shared_from_this.py
View File

@ -8,7 +8,7 @@ import pytest
import env import env
import pybind11_tests.class_sh_trampoline_shared_from_this as m import pybind11_tests.class_sh_trampoline_shared_from_this as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_trampoline_shared_ptr_cpp_arg.cpp
View File

@ -63,8 +63,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(SpGoAway)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(SpGoAwayTester) PYBIND11_SMART_HOLDER_TYPE_CASTERS(SpGoAwayTester)
TEST_SUBMODULE(class_sh_trampoline_shared_ptr_cpp_arg, m) { TEST_SUBMODULE(class_sh_trampoline_shared_ptr_cpp_arg, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -101,5 +101,5 @@ TEST_SUBMODULE(class_sh_trampoline_shared_ptr_cpp_arg, m) {
py::classh<SpGoAwayTester>(m, "SpGoAwayTester") py::classh<SpGoAwayTester>(m, "SpGoAwayTester")
.def(py::init<>()) .def(py::init<>())
.def_readwrite("obj", &SpGoAwayTester::m_obj); .def_readwrite("obj", &SpGoAwayTester::m_obj);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_trampoline_shared_ptr_cpp_arg.py
View File

@ -4,7 +4,7 @@ import pytest
import pybind11_tests.class_sh_trampoline_shared_ptr_cpp_arg as m import pybind11_tests.class_sh_trampoline_shared_ptr_cpp_arg as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

8
tests/test_class_sh_trampoline_unique_ptr.cpp
View File

@ -39,7 +39,7 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::class_sh_trampoline_unique_pt
namespace pybind11_tests { namespace pybind11_tests {
namespace class_sh_trampoline_unique_ptr { namespace class_sh_trampoline_unique_ptr {
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
class PyClass : public Class, public py::trampoline_self_life_support { class PyClass : public Class, public py::trampoline_self_life_support {
public: public:
std::unique_ptr<Class> clone() const override { std::unique_ptr<Class> clone() const override {
@ -54,8 +54,8 @@ public:
} // namespace pybind11_tests } // namespace pybind11_tests
TEST_SUBMODULE(class_sh_trampoline_unique_ptr, m) { TEST_SUBMODULE(class_sh_trampoline_unique_ptr, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -71,5 +71,5 @@ TEST_SUBMODULE(class_sh_trampoline_unique_ptr, m) {
m.def("clone", [](const Class &obj) { return obj.clone(); }); m.def("clone", [](const Class &obj) { return obj.clone(); });
m.def("clone_and_foo", [](const Class &obj) { return obj.clone()->foo(); }); m.def("clone_and_foo", [](const Class &obj) { return obj.clone()->foo(); });
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_trampoline_unique_ptr.py
View File

@ -4,7 +4,7 @@ import pytest
import pybind11_tests.class_sh_trampoline_unique_ptr as m import pybind11_tests.class_sh_trampoline_unique_ptr as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_unique_ptr_custom_deleter.cpp
View File

@ -31,8 +31,8 @@ namespace pybind11_tests {
namespace class_sh_unique_ptr_custom_deleter { namespace class_sh_unique_ptr_custom_deleter {
TEST_SUBMODULE(class_sh_unique_ptr_custom_deleter, m) { TEST_SUBMODULE(class_sh_unique_ptr_custom_deleter, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -40,7 +40,7 @@ TEST_SUBMODULE(class_sh_unique_ptr_custom_deleter, m) {
py::classh<Pet>(m, "Pet").def_readwrite("name", &Pet::name); py::classh<Pet>(m, "Pet").def_readwrite("name", &Pet::name);
m.def("create", &Pet::New); m.def("create", &Pet::New);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }
} // namespace class_sh_unique_ptr_custom_deleter } // namespace class_sh_unique_ptr_custom_deleter

2
tests/test_class_sh_unique_ptr_custom_deleter.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_unique_ptr_custom_deleter as m from pybind11_tests import class_sh_unique_ptr_custom_deleter as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

6
tests/test_class_sh_unique_ptr_member.cpp
View File

@ -45,8 +45,8 @@ namespace pybind11_tests {
namespace class_sh_unique_ptr_member { namespace class_sh_unique_ptr_member {
TEST_SUBMODULE(class_sh_unique_ptr_member, m) { TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -60,7 +60,7 @@ TEST_SUBMODULE(class_sh_unique_ptr_member, m) {
.def("is_owner", &ptr_owner::is_owner) .def("is_owner", &ptr_owner::is_owner)
.def("give_up_ownership_via_unique_ptr", &ptr_owner::give_up_ownership_via_unique_ptr) .def("give_up_ownership_via_unique_ptr", &ptr_owner::give_up_ownership_via_unique_ptr)
.def("give_up_ownership_via_shared_ptr", &ptr_owner::give_up_ownership_via_shared_ptr); .def("give_up_ownership_via_shared_ptr", &ptr_owner::give_up_ownership_via_shared_ptr);
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }
} // namespace class_sh_unique_ptr_member } // namespace class_sh_unique_ptr_member

2
tests/test_class_sh_unique_ptr_member.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_unique_ptr_member as m from pybind11_tests import class_sh_unique_ptr_member as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

8
tests/test_class_sh_virtual_py_cpp_mix.cpp
View File

@ -31,7 +31,7 @@ int get_from_cpp_plainc_ptr(const Base *b) { return b->get() + 4000; }
int get_from_cpp_unique_ptr(std::unique_ptr<Base> b) { return b->get() + 5000; } int get_from_cpp_unique_ptr(std::unique_ptr<Base> b) { return b->get() + 5000; }
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
struct BaseVirtualOverrider : Base, py::trampoline_self_life_support { struct BaseVirtualOverrider : Base, py::trampoline_self_life_support {
using Base::Base; using Base::Base;
@ -57,8 +57,8 @@ PYBIND11_SMART_HOLDER_TYPE_CASTERS(CppDerivedPlain)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(CppDerived) PYBIND11_SMART_HOLDER_TYPE_CASTERS(CppDerived)
TEST_SUBMODULE(class_sh_virtual_py_cpp_mix, m) { TEST_SUBMODULE(class_sh_virtual_py_cpp_mix, m) {
m.attr("defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT") = m.attr("defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT") =
#ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
false; false;
#else #else
true; true;
@ -71,5 +71,5 @@ TEST_SUBMODULE(class_sh_virtual_py_cpp_mix, m) {
m.def("get_from_cpp_plainc_ptr", get_from_cpp_plainc_ptr, py::arg("b")); m.def("get_from_cpp_plainc_ptr", get_from_cpp_plainc_ptr, py::arg("b"));
m.def("get_from_cpp_unique_ptr", get_from_cpp_unique_ptr, py::arg("b")); m.def("get_from_cpp_unique_ptr", get_from_cpp_unique_ptr, py::arg("b"));
#endif // PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #endif // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
} }

2
tests/test_class_sh_virtual_py_cpp_mix.py
View File

@ -4,7 +4,7 @@ import pytest
from pybind11_tests import class_sh_virtual_py_cpp_mix as m from pybind11_tests import class_sh_virtual_py_cpp_mix as m
if not m.defined_PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT: if not m.defined_PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT:
pytest.skip("smart_holder not available.", allow_module_level=True) pytest.skip("smart_holder not available.", allow_module_level=True)

2
tests/test_classh_mock.cpp
View File

@ -11,7 +11,7 @@
#else #else
# include <pybind11/pybind11.h> # include <pybind11/pybind11.h>
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
# ifndef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT # ifndef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename type_, typename... options> template <typename type_, typename... options>
using classh = class_<type_, options...>; using classh = class_<type_, options...>;
# endif # endif

6
ubench/holder_comparison.cpp
View File

@ -22,7 +22,7 @@ void wrap_number_bucket(py::module m, const char *class_name) {
.def("add", &WrappedType::add, py::arg("other")); .def("add", &WrappedType::add, py::arg("other"));
} }
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
template <typename T> template <typename T>
class padded_unique_ptr { class padded_unique_ptr {
@ -41,7 +41,7 @@ static_assert(sizeof(padded_unique_ptr<nb_pu>) == sizeof(py::smart_holder),
} // namespace hc } // namespace hc
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
PYBIND11_DECLARE_HOLDER_TYPE(T, hc::padded_unique_ptr<T>); PYBIND11_DECLARE_HOLDER_TYPE(T, hc::padded_unique_ptr<T>);
#endif #endif
@ -49,7 +49,7 @@ PYBIND11_MODULE(pybind11_ubench_holder_comparison, m) {
using namespace hc; using namespace hc;
wrap_number_bucket<nb_up, std::unique_ptr<nb_up>>(m, "number_bucket_up"); wrap_number_bucket<nb_up, std::unique_ptr<nb_up>>(m, "number_bucket_up");
wrap_number_bucket<nb_sp, std::shared_ptr<nb_sp>>(m, "number_bucket_sp"); wrap_number_bucket<nb_sp, std::shared_ptr<nb_sp>>(m, "number_bucket_sp");
#ifdef PYBIND11_HAVE_INTERNALS_WITH_SMART_HOLDER_SUPPORT #ifdef PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
m.def("sizeof_smart_holder", []() { return sizeof(py::smart_holder); }); m.def("sizeof_smart_holder", []() { return sizeof(py::smart_holder); });
wrap_number_bucket<nb_pu, padded_unique_ptr<nb_pu>>(m, "number_bucket_pu"); wrap_number_bucket<nb_pu, padded_unique_ptr<nb_pu>>(m, "number_bucket_pu");
wrap_number_bucket<nb_sh, py::smart_holder>(m, "number_bucket_sh"); wrap_number_bucket<nb_sh, py::smart_holder>(m, "number_bucket_sh");