Skip to content

GitLab

Commit 03f304e4 authored by Ralf W. Grosse-Kunstleve's avatar Ralf W. Grosse-Kunstleve
Browse files

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.
parent a5818bdf
Hide whitespace changes
Inline Side-by-side
Showing with 311 additions and 31 deletions
include/pybind11/classh.h
View file @ 03f304e4
#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 0 → 100644
View file @ 03f304e4
#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 0 → 100644
View file @ 03f304e4
# -*- 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"
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment