Renaming is_smart_holder_type_caster -> type_uses_smart_holder_type_caster for clarity.

3a303ee2 · Ralf W. Grosse-Kunstleve · 658cf3ba · 3a303ee2 · 3a303ee2 · 3a303ee2
Commit 3a303ee2 authored Feb 23, 2021 by Ralf W. Grosse-Kunstleve
Showing with 27 additions and 22 deletions

include/pybind11/cast.h
+3 -3

include/pybind11/detail/init.h
+13 -9

include/pybind11/detail/smart_holder_sfinae_hooks_only.h
+2 -2

include/pybind11/detail/smart_holder_type_casters.h
+1 -1

include/pybind11/pybind11.h
+8 -7

No files found.
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -66,7 +66,7 @@ template <typename type>
 using make_caster = type_caster<intrinsic_t<type>>;
 template <typename T>
-struct is_smart_holder_type_caster {
+struct type_uses_smart_holder_type_caster {
    static constexpr bool value
        = std::is_base_of<is_smart_holder_type_caster_base_tag, make_caster<T>>::value;
 };
@@ -846,7 +846,7 @@ template <typename T> using move_never = none_of<move_always<T>, move_if_unrefer
 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 &&
-    !is_smart_holder_type_caster<intrinsic_t<type>>::value &&
+    !type_uses_smart_holder_type_caster<intrinsic_t<type>>::value &&
    !std::is_same<intrinsic_t<type>, void>::value
 >;
@@ -1391,7 +1391,7 @@ template<typename T>
 handle type::handle_of() {
    static_assert(
        detail::any_of<std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>,
-                       detail::is_smart_holder_type_caster<T>>::value,
+                       detail::type_uses_smart_holder_type_caster<T>>::value,
        "py::type::of<T> only supports the case where T is a registered C++ types.");
    return detail::get_type_handle(typeid(T), true);

--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -133,7 +133,7 @@ void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
 // holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
 // derived type (through those holder's implicit conversion from derived class holder constructors).
 template <typename Class,
-          detail::enable_if_t<!detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+          detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
    auto *ptr = holder_helper<Holder<Class>>::get(holder);
    no_nullptr(ptr);
@@ -171,9 +171,10 @@ void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
 }
 // clang-format on
-template <typename Class,
+template <
+    typename Class,
    typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
    auto *ptr = unq_ptr.get();
    no_nullptr(ptr);
@@ -186,9 +187,10 @@ void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, 
    v_h.type->init_instance(v_h.inst, &smhldr);
 }
-template <typename Class,
+template <
+    typename Class,
    typename D = std::default_delete<Alias<Class>>,
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h,
               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
               bool /*need_alias*/) {
@@ -200,8 +202,9 @@ void construct(value_and_holder &v_h,
    v_h.type->init_instance(v_h.inst, &smhldr);
 }
-template <typename Class,
+template <
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
+    typename Class,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Cpp<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
    auto *ptr = shd_ptr.get();
    no_nullptr(ptr);
@@ -213,8 +216,9 @@ void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, boo
    v_h.type->init_instance(v_h.inst, &smhldr);
 }
-template <typename Class,
+template <
-          detail::enable_if_t<detail::is_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
+    typename Class,
+    detail::enable_if_t<detail::type_uses_smart_holder_type_caster<Alias<Class>>::value, int> = 0>
 void construct(value_and_holder &v_h,
               std::shared_ptr<Alias<Class>> &&shd_ptr,
               bool /*need_alias*/) {

--- a/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
+++ b/include/pybind11/detail/smart_holder_sfinae_hooks_only.h
@@ -19,11 +19,11 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 template <typename T>
 struct is_smart_holder_type : std::false_type {};
-// Tag to be used as base class, inspected by is_smart_holder_type_caster<T> test.
+// Tag to be used as base class, inspected by type_uses_smart_holder_type_caster<T> test.
 struct is_smart_holder_type_caster_base_tag {};
 template <typename T>
-struct is_smart_holder_type_caster;
+struct type_uses_smart_holder_type_caster;
 PYBIND11_NAMESPACE_END(detail)
 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
--- a/include/pybind11/detail/smart_holder_type_casters.h
+++ b/include/pybind11/detail/smart_holder_type_casters.h
@@ -287,7 +287,7 @@ struct smart_holder_type_caster_load {
    using holder_type = pybindit::memory::smart_holder;
    bool load(handle src, bool convert) {
-        static_assert(is_smart_holder_type_caster<T>::value, "Internal consistency error.");
+        static_assert(type_uses_smart_holder_type_caster<T>::value, "Internal consistency error.");
        load_impl = modified_type_caster_generic_load_impl(typeid(T));
        if (!load_impl.load(src, convert))
            return false;

--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1275,10 +1275,11 @@ class class_ : public detail::generic_type {
    template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
    template <typename T>
    // clang-format on
-    using is_holder = detail::any_of<detail::is_holder_type<type_, T>,
+    using is_holder
+        = detail::any_of<detail::is_holder_type<type_, T>,
                         detail::all_of<detail::negation<is_base<T>>,
                                        detail::negation<is_subtype<T>>,
-                                                    detail::is_smart_holder_type_caster<type_>>>;
+                                        detail::type_uses_smart_holder_type_caster<type_>>>;
    // clang-format off
    // struct instead of using here to help MSVC:
    template <typename T> struct is_valid_class_option :
@@ -1314,7 +1315,7 @@ public:
        static constexpr bool holder_is_smart_holder
            = detail::is_smart_holder_type<holder_type>::value;
        static constexpr bool type_caster_type_is_smart_holder_type_caster
-            = detail::is_smart_holder_type_caster<type>::value;
+            = detail::type_uses_smart_holder_type_caster<type>::value;
        static constexpr bool type_caster_type_is_type_caster_base_subtype
            = std::is_base_of<detail::type_caster_base<type>, detail::type_caster<type>>::value;
        // Necessary conditions, but not strict.
@@ -1574,13 +1575,13 @@ public:
 private:
    // clang-format on
    template <typename T = type,
-              detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+              detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
    void generic_type_initialize(const detail::type_record &record) {
        generic_type::initialize(record, &detail::type_caster_generic::local_load);
    }
    template <typename T = type,
-              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+              detail::enable_if_t<detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
    void generic_type_initialize(const detail::type_record &record) {
        generic_type::initialize(record, detail::type_caster<T>::get_local_load_function_ptr());
    }
@@ -1632,7 +1633,7 @@ private:
    /// `.owned`, a new holder will be constructed to manage the value pointer.
    template <
        typename T = type,
-        detail::enable_if_t<!detail::is_smart_holder_type_caster<T>::value, int> = 0>
+        detail::enable_if_t<!detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
    static void init_instance(detail::instance *inst, const void *holder_ptr) {
        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
        if (!v_h.instance_registered()) {
@@ -1644,7 +1645,7 @@ private:
    // clang-format on
    template <typename T = type,
-              detail::enable_if_t<detail::is_smart_holder_type_caster<T>::value, int> = 0>
+              detail::enable_if_t<detail::type_uses_smart_holder_type_caster<T>::value, int> = 0>
    static void init_instance(detail::instance *inst, const void *holder_ptr) {
        detail::type_caster<T>::template init_instance_for_type<type>(inst, holder_ptr);
    }