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

Revert "Redesigned virtual call mechanism and user-facing syntax (breaking change!)"

Browse Source 
This reverts commit 86d825f330.
This commit is contained in:
Wenzel Jakob 2016-06-14 15:06:13 +02:00
parent f950215046
commit 6ebb9eafa3
7 changed files with 27 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
docs/advanced.rst
View File

@ -283,8 +283,9 @@ The binding code also needs a few minor adaptations (highlighted):
PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin");
py::class_<Animal, std::unique_ptr<Animal>, PyAnimal /* <--- trampoline*/> animal(m, "Animal");
py::class_<PyAnimal> animal(m, "Animal");
animal
.alias<Animal>()
.def(py::init<>())
.def("go", &Animal::go);
@ -296,10 +297,10 @@ The binding code also needs a few minor adaptations (highlighted):
return m.ptr();
}
Importantly, pybind11 is made aware of the trampoline trampoline helper class
by specifying it as the *third* template argument to :class:`class_`. The
second argument with the unique pointer is simply the default holder type used
by pybind11. Following this, we are able to define a constructor as usual.
Importantly, the trampoline helper class is used as the template argument to
:class:`class_`, and a call to :func:`class_::alias` informs the binding
generator that this is merely an alias for the underlying type ``Animal``.
Following this, we are able to define a constructor as usual.
The Python session below shows how to override ``Animal::go`` and invoke it via
a virtual method call.
@ -376,8 +377,9 @@ be realized as follows (important changes highlighted):
PYBIND11_PLUGIN(example) {
py::module m("example", "pybind11 example plugin");
py::class_<Animal, std::unique_ptr<Animal>, PyAnimal> animal(m, "Animal");
py::class_<PyAnimal> animal(m, "Animal");
animal
.alias<Animal>()
.def(py::init<>())
.def("go", &Animal::go);

12
example/example12.cpp
View File

@ -82,11 +82,15 @@ void runExample12Virtual(Example12 *ex) {
}
void init_ex12(py::module &m) {
/* Important: indicate the trampoline class PyExample12 using the third
argument to py::class_. The second argument with the unique pointer
is simply the default holder type used by pybind11. */
py::class_<Example12, std::unique_ptr<Example12>, PyExample12>(m, "Example12")
/* Important: use the wrapper type as a template
argument to class_<>, but use the original name
to denote the type */
py::class_<PyExample12>(m, "Example12")
/* Declare that 'PyExample12' is really an alias for the original type 'Example12' */
.alias<Example12>()
.def(py::init<int>())
/* Copy constructor (not needed in this case, but should generally be declared in this way) */
.def(py::init<const PyExample12 &>())
/* Reference original class in function definitions */
.def("run", &Example12::run)
.def("run_bool", &Example12::run_bool)

34
example/issues.cpp
View File

@ -42,7 +42,8 @@ void init_issues(py::module &m) {
}
};
py::class_<Base, std::unique_ptr<Base>, DispatchIssue>(m2, "DispatchIssue")
py::class_<DispatchIssue> base(m2, "DispatchIssue");
base.alias<Base>()
.def(py::init<>())
.def("dispatch", &Base::dispatch);
@ -107,35 +108,4 @@ void init_issues(py::module &m) {
// (no id): don't cast doubles to ints
m2.def("expect_float", [](float f) { return f; });
m2.def("expect_int", [](int i) { return i; });
// (no id): don't invoke Python dispatch code when instantiating C++
// classes that were not extended on the Python side
struct A {
virtual ~A() {}
virtual void f() { std::cout << "A.f()" << std::endl; }
};
struct PyA : A {
PyA() { std::cout << "PyA.PyA()" << std::endl; }
void f() override {
std::cout << "PyA.f()" << std::endl;
PYBIND11_OVERLOAD(void, A, f);
}
};
auto call_f = [](A *a) { a->f(); };
pybind11::class_<A, std::unique_ptr<A>, PyA>(m2, "A")
.def(py::init<>())
.def("f", &A::f);
m2.def("call_f", call_f);
try {
py::class_<Placeholder>(m2, "Placeholder");
throw std::logic_error("Expected an exception!");
} catch (std::runtime_error &) {
/* All good */
}
}

17
example/issues.py
View File

@ -9,7 +9,6 @@ from example.issues import Placeholder, return_vec_of_reference_wrapper
from example.issues import iterator_passthrough
from example.issues import ElementList, ElementA, print_element
from example.issues import expect_float, expect_int
from example.issues import A, call_f
import gc
print_cchar("const char *")
@ -56,19 +55,3 @@ except Exception as e:
print("Failed as expected: " + str(e))
print(expect_float(12))
class B(A):
def __init__(self):
super(B, self).__init__()
def f(self):
print("In python f()")
print("C++ version")
a = A()
call_f(a)
print("Python version")
b = B()
call_f(b)

6
example/issues.ref
View File

@ -12,9 +12,3 @@ Failed as expected: Incompatible function arguments. The following argument type
1. (int) -> int
Invoked with: 5.2
12.0
C++ version
A.f()
Python version
PyA.PyA()
PyA.f()
In python f()

1
include/pybind11/attr.h
View File

@ -71,7 +71,6 @@ enum op_type : int;
struct undefined_t;
template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
template <typename... Args> struct init;
template <typename... Args> struct init_alias;
inline void keep_alive_impl(int Nurse, int Patient, handle args, handle ret);
/// Internal data structure which holds metadata about a keyword argument

46
include/pybind11/pybind11.h
View File

@ -500,7 +500,7 @@ public:
NAMESPACE_BEGIN(detail)
/// Generic support for creating new Python heap types
class generic_type : public object {
template <typename type, typename holder_type, typename type_alias> friend class class_;
template <typename type, typename holder_type> friend class class_;
public:
PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
protected:
@ -725,7 +725,7 @@ protected:
};
NAMESPACE_END(detail)
template <typename type, typename holder_type = std::unique_ptr<type>, typename type_alias = type>
template <typename type, typename holder_type = std::unique_ptr<type>>
class class_ : public detail::generic_type {
public:
typedef detail::instance<type, holder_type> instance_type;
@ -747,11 +747,6 @@ public:
detail::process_attributes<Extra...>::init(extra..., &record);
detail::generic_type::initialize(&record);
if (!std::is_same<type, type_alias>::value) {
auto &instances = pybind11::detail::get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
template <typename Func, typename... Extra>
@ -789,12 +784,6 @@ public:
return *this;
}
template <typename... Args, typename... Extra>
class_ &def(const detail::init_alias<Args...> &init, const Extra&... extra) {
init.template execute<type>(*this, extra...);
return *this;
}
template <typename Func> class_& def_buffer(Func &&func) {
struct capture { Func func; };
capture *ptr = new capture { std::forward<Func>(func) };
@ -882,6 +871,11 @@ public:
return *this;
}
template <typename target> class_ alias() {
auto &instances = pybind11::detail::get_internals().registered_types_cpp;
instances[std::type_index(typeid(target))] = instances[std::type_index(typeid(type))];
return *this;
}
private:
/// Initialize holder object, variant 1: object derives from enable_shared_from_this
template <typename T>
@ -980,31 +974,9 @@ private:
NAMESPACE_BEGIN(detail)
template <typename... Args> struct init {
template <typename Base, typename Holder, typename Alias, typename... Extra,
typename std::enable_if<std::is_same<Base, Alias>::value, int>::type = 0>
void execute(pybind11::class_<Base, Holder, Alias> &class_, const Extra&... extra) const {
template <typename Base, typename Holder, typename... Extra> void execute(pybind11::class_<Base, Holder> &class_, const Extra&... extra) const {
/// Function which calls a specific C++ in-place constructor
class_.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
}
template <typename Base, typename Holder, typename Alias, typename... Extra,
typename std::enable_if<!std::is_same<Base, Alias>::value &&
std::is_constructible<Base, Args...>::value, int>::type = 0>
void execute(pybind11::class_<Base, Holder, Alias> &class_, const Extra&... extra) const {
handle cl_type = class_;
class_.def("__init__", [cl_type](handle self_, Args... args) {
if (self_.get_type() == cl_type)
new (self_.cast<Base *>()) Base(args...);
else
new (self_.cast<Alias *>()) Alias(args...);
}, extra...);
}
template <typename Base, typename Holder, typename Alias, typename... Extra,
typename std::enable_if<!std::is_same<Base, Alias>::value &&
!std::is_constructible<Base, Args...>::value, int>::type = 0>
void execute(pybind11::class_<Base, Holder, Alias> &class_, const Extra&... extra) const {
class_.def("__init__", [](Alias *self, Args... args) { new (self) Alias(args...); }, extra...);
class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, extra...);
}
};