classh.h: renaming of class_ to classh + namespace; forking test_classh_wip...

classh.h: renaming of class_ to classh + namespace; forking test_classh_wip from test_type_caster_bare_interface_demo.

include/pybind11/classh.h

+#pragma once
+
+#include "pybind11.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
 template <typename type_, typename... options>
-class class_ : public detail::generic_type {
+class classh : public detail::generic_type {
     template <typename T> using is_holder = detail::is_holder_type<type_, T>;
     template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
     template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
@@ -14,24 +20,24 @@ public:
     using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
 
     static_assert(detail::all_of<is_valid_class_option<options>...>::value,
-            "Unknown/invalid class_ template parameters provided");
+            "Unknown/invalid classh template parameters provided");
 
     static_assert(!has_alias || std::is_polymorphic<type>::value,
             "Cannot use an alias class with a non-polymorphic type");
 
-    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
+    PYBIND11_OBJECT(classh, generic_type, PyType_Check)
 
     template <typename... Extra>
-    class_(handle scope, const char *name, const Extra &... extra) {
+    classh(handle scope, const char *name, const Extra &... extra) {
         using namespace detail;
 
-        // MI can only be specified via class_ template options, not constructor parameters
+        // MI can only be specified via classh template options, not constructor parameters
         static_assert(
             none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
             (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
                 constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
                 none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
-            "Error: multiple inheritance bases must be specified via class_ template options");
+            "Error: multiple inheritance bases must be specified via classh template options");
 
         type_record record;
         record.scope = scope;
@@ -46,7 +52,7 @@ public:
 
         set_operator_new<type>(&record);
 
-        /* Register base classes specified via template arguments to class_, if any */
+        /* Register base classes specified via template arguments to classh, if any */
         PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
 
         /* Process optional arguments, if any */
@@ -71,14 +77,14 @@ public:
     static void add_base(detail::type_record &) { }
 
     template <typename Func, typename... Extra>
-    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
+    classh &def(const char *name_, Func&& f, const Extra&... extra) {
         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
                         sibling(getattr(*this, name_, none())), extra...);
         add_class_method(*this, name_, cf);
         return *this;
     }
 
-    template <typename Func, typename... Extra> class_ &
+    template <typename Func, typename... Extra> classh &
     def_static(const char *name_, Func &&f, const Extra&... extra) {
         static_assert(!std::is_member_function_pointer<Func>::value,
                 "def_static(...) called with a non-static member function pointer");
@@ -89,43 +95,43 @@ public:
     }
 
     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+    classh &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
         op.execute(*this, extra...);
         return *this;
     }
 
     template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
+    classh & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
         op.execute_cast(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
+    classh &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
         init.execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
+    classh &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
         init.execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
+    classh &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
         std::move(init).execute(*this, extra...);
         return *this;
     }
 
     template <typename... Args, typename... Extra>
-    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
+    classh &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
         std::move(pf).execute(*this, extra...);
         return *this;
     }
 
     template <typename Func>
-    class_& def_buffer(Func &&func) {
+    classh& def_buffer(Func &&func) {
         struct capture { Func func; };
         auto *ptr = new capture { std::forward<Func>(func) };
         install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
@@ -142,17 +148,17 @@ public:
     }
 
     template <typename Return, typename Class, typename... Args>
-    class_ &def_buffer(Return (Class::*func)(Args...)) {
+    classh &def_buffer(Return (Class::*func)(Args...)) {
         return def_buffer([func] (type &obj) { return (obj.*func)(); });
     }
 
     template <typename Return, typename Class, typename... Args>
-    class_ &def_buffer(Return (Class::*func)(Args...) const) {
+    classh &def_buffer(Return (Class::*func)(Args...) const) {
         return def_buffer([func] (const type &obj) { return (obj.*func)(); });
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
+    classh &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
                      fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
@@ -161,7 +167,7 @@ public:
     }
 
     template <typename C, typename D, typename... Extra>
-    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
+    classh &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
         static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
         cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
         def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
@@ -169,7 +175,7 @@ public:
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
+    classh &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
         cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
                      fset([pm](object, const D &value) { *pm = value; }, scope(*this));
         def_property_static(name, fget, fset, return_value_policy::reference, extra...);
@@ -177,7 +183,7 @@ public:
     }
 
     template <typename D, typename... Extra>
-    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
+    classh &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
         cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
         def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
         return *this;
@@ -185,55 +191,55 @@ public:
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
+    classh &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
                                      return_value_policy::reference_internal, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
+    classh &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property(name, fget, nullptr, extra...);
     }
 
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
+    classh &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
         return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
+    classh &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
         return def_property_static(name, fget, nullptr, extra...);
     }
 
     /// Uses return_value_policy::reference_internal by default
     template <typename Getter, typename Setter, typename... Extra>
-    class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
         return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
     }
     template <typename Getter, typename... Extra>
-    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
                             return_value_policy::reference_internal, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property_static(name, fget, fset, is_method(*this), extra...);
     }
 
     /// Uses return_value_policy::reference by default
     template <typename Getter, typename... Extra>
-    class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
         return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
     }
 
     /// Uses cpp_function's return_value_policy by default
     template <typename... Extra>
-    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
+    classh &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
         static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
                       "Argument annotations are not allowed for properties");
         auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
@@ -342,3 +348,5 @@ private:
                  : nullptr;
     }
 };
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

tests/test_classh_wip.cpp

+#include "pybind11_tests.h"
+
+#include <pybind11/classh.h>
+
+#include <memory>
+
+namespace pybind11_tests {
+namespace classh_wip {
+
+struct mpty {};
+
+mpty        rtrn_mpty_valu() { mpty obj; return obj; }
+mpty&&      rtrn_mpty_rref() { mpty obj; return std::move(obj); }
+mpty const& rtrn_mpty_cref() { static mpty obj; return obj; }
+mpty&       rtrn_mpty_mref() { static mpty obj; return obj; }
+mpty const* rtrn_mpty_cptr() { static mpty obj; return &obj; }
+mpty*       rtrn_mpty_mptr() { static mpty obj; return &obj; }
+
+const char* pass_mpty_valu(mpty)        { return "load_valu"; }
+const char* pass_mpty_rref(mpty&&)      { return "load_rref"; }
+const char* pass_mpty_cref(mpty const&) { return "load_cref"; }
+const char* pass_mpty_mref(mpty&)       { return "load_mref"; }
+const char* pass_mpty_cptr(mpty const*) { return "load_cptr"; }
+const char* pass_mpty_mptr(mpty*)       { return "load_mptr"; }
+
+std::shared_ptr<mpty>       rtrn_mpty_shmp() { return std::shared_ptr<mpty>(new mpty); }
+std::shared_ptr<mpty const> rtrn_mpty_shcp() { return std::shared_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_shmp(std::shared_ptr<mpty>)       { return "load_shmp"; }
+const char* pass_mpty_shcp(std::shared_ptr<mpty const>) { return "load_shcp"; }
+
+std::unique_ptr<mpty>       rtrn_mpty_uqmp() { return std::unique_ptr<mpty>(new mpty); }
+std::unique_ptr<mpty const> rtrn_mpty_uqcp() { return std::unique_ptr<mpty const>(new mpty); }
+
+const char* pass_mpty_uqmp(std::unique_ptr<mpty>)       { return "load_uqmp"; }
+const char* pass_mpty_uqcp(std::unique_ptr<mpty const>) { return "load_uqcp"; }
+
+}  // namespace classh_wip
+}  // namespace pybind11_tests
+
+namespace pybind11 {
+namespace detail {
+
+using namespace pybind11_tests::classh_wip;
+
+template <>
+struct type_caster<mpty> {
+    static constexpr auto name = _<mpty>();
+
+    // static handle cast(mpty, ...)
+    // is redundant (leads to ambiguous overloads).
+
+    static handle cast(mpty&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_rref").release();
+    }
+
+    static handle cast(mpty const& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cref").release();
+    }
+
+    static handle cast(mpty& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mref").release();
+    }
+
+    static handle cast(mpty const* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_cptr").release();
+    }
+
+    static handle cast(mpty* /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_mptr").release();
+    }
+
+    template <typename T_>
+    using cast_op_type = conditional_t<
+        std::is_same<remove_reference_t<T_>, mpty const*>::value, mpty const*,
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, mpty*>::value, mpty*,
+            conditional_t<
+                std::is_same<T_, mpty const&>::value, mpty const&,
+                conditional_t<
+                    std::is_same<T_, mpty&>::value, mpty&,
+                    conditional_t<
+                        std::is_same<T_, mpty&&>::value, mpty&&,
+                        mpty>>>>>;
+
+    operator mpty()        { return rtrn_mpty_valu(); }
+    operator mpty&&() &&   { return rtrn_mpty_rref(); }
+    operator mpty const&() { return rtrn_mpty_cref(); }
+    operator mpty&()       { return rtrn_mpty_mref(); }
+    operator mpty const*() { return rtrn_mpty_cptr(); }
+    operator mpty*()       { return rtrn_mpty_mptr(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty>> {
+    static constexpr auto name = _<std::shared_ptr<mpty>>();
+
+    static handle cast(const std::shared_ptr<mpty>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shmp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty>;
+
+    operator std::shared_ptr<mpty>() { return rtrn_mpty_shmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::shared_ptr<mpty const>> {
+    static constexpr auto name = _<std::shared_ptr<mpty const>>();
+
+    static handle cast(const std::shared_ptr<mpty const>& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_shcp").release();
+    }
+
+    template <typename> using cast_op_type = std::shared_ptr<mpty const>;
+
+    operator std::shared_ptr<mpty const>() { return rtrn_mpty_shcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty>> {
+    static constexpr auto name = _<std::unique_ptr<mpty>>();
+
+    static handle cast(std::unique_ptr<mpty>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqmp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty>;
+
+    operator std::unique_ptr<mpty>() { return rtrn_mpty_uqmp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+template <>
+struct type_caster<std::unique_ptr<mpty const>> {
+    static constexpr auto name = _<std::unique_ptr<mpty const>>();
+
+    static handle cast(std::unique_ptr<mpty const>&& /*src*/,
+                       return_value_policy /*policy*/,
+                       handle /*parent*/) {
+        return str("cast_uqcp").release();
+    }
+
+    template <typename> using cast_op_type = std::unique_ptr<mpty const>;
+
+    operator std::unique_ptr<mpty const>() { return rtrn_mpty_uqcp(); }
+
+    bool load(handle /*src*/, bool /*convert*/) {
+        return true;
+    }
+};
+
+}  // namespace detail
+}  // namespace pybind11
+
+namespace pybind11_tests {
+namespace classh_wip {
+
+TEST_SUBMODULE(classh_wip, m) {
+    namespace py = pybind11;
+
+    py::classh<mpty>(m, "mpty")
+        .def(py::init<>())
+    ;
+
+    m.def("rtrn_mpty_valu", rtrn_mpty_valu);
+    m.def("rtrn_mpty_rref", rtrn_mpty_rref);
+    m.def("rtrn_mpty_cref", rtrn_mpty_cref);
+    m.def("rtrn_mpty_mref", rtrn_mpty_mref);
+    m.def("rtrn_mpty_cptr", rtrn_mpty_cptr);
+    m.def("rtrn_mpty_mptr", rtrn_mpty_mptr);
+
+    m.def("pass_mpty_valu", pass_mpty_valu);
+    m.def("pass_mpty_rref", pass_mpty_rref);
+    m.def("pass_mpty_cref", pass_mpty_cref);
+    m.def("pass_mpty_mref", pass_mpty_mref);
+    m.def("pass_mpty_cptr", pass_mpty_cptr);
+    m.def("pass_mpty_mptr", pass_mpty_mptr);
+
+    m.def("rtrn_mpty_shmp", rtrn_mpty_shmp);
+    m.def("rtrn_mpty_shcp", rtrn_mpty_shcp);
+
+    m.def("pass_mpty_shmp", pass_mpty_shmp);
+    m.def("pass_mpty_shcp", pass_mpty_shcp);
+
+    m.def("rtrn_mpty_uqmp", rtrn_mpty_uqmp);
+    m.def("rtrn_mpty_uqcp", rtrn_mpty_uqcp);
+
+    m.def("pass_mpty_uqmp", pass_mpty_uqmp);
+    m.def("pass_mpty_uqcp", pass_mpty_uqcp);
+}
+
+}  // namespace classh_wip
+}  // namespace pybind11_tests

tests/test_classh_wip.py

+# -*- coding: utf-8 -*-
+import pytest
+
+from pybind11_tests import classh_wip as m
+
+
+def test_mpty():
+    e = m.mpty()
+    assert e.__class__.__name__ == "mpty"
+
+
+def test_cast():
+    assert m.rtrn_mpty_valu() == "cast_rref"
+    assert m.rtrn_mpty_rref() == "cast_rref"
+    assert m.rtrn_mpty_cref() == "cast_cref"
+    assert m.rtrn_mpty_mref() == "cast_mref"
+    assert m.rtrn_mpty_cptr() == "cast_cptr"
+    assert m.rtrn_mpty_mptr() == "cast_mptr"
+
+
+def test_load():
+    assert m.pass_mpty_valu(None) == "load_valu"
+    assert m.pass_mpty_rref(None) == "load_rref"
+    assert m.pass_mpty_cref(None) == "load_cref"
+    assert m.pass_mpty_mref(None) == "load_mref"
+    assert m.pass_mpty_cptr(None) == "load_cptr"
+    assert m.pass_mpty_mptr(None) == "load_mptr"
+
+
+def test_cast_shared_ptr():
+    assert m.rtrn_mpty_shmp() == "cast_shmp"
+    assert m.rtrn_mpty_shcp() == "cast_shcp"
+
+
+def test_load_shared_ptr():
+    assert m.pass_mpty_shmp(None) == "load_shmp"
+    assert m.pass_mpty_shcp(None) == "load_shcp"
+
+
+def test_cast_unique_ptr():
+    assert m.rtrn_mpty_uqmp() == "cast_uqmp"
+    assert m.rtrn_mpty_uqcp() == "cast_uqcp"
+
+
+def test_load_unique_ptr():
+    assert m.pass_mpty_uqmp(None) == "load_uqmp"
+    assert m.pass_mpty_uqcp(None) == "load_uqcp"