123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117 |
- [section boost/python/wrapper.hpp]
- [section Introduction]
- To wrap a class T such that its virtual functions can be "overridden in Python"—so that the corresponding method of a Python derived class will be called when the virtual function is invoked from C++—you must create a C++ wrapper class derived from `T` that overrides those virtual functions so that they call into Python. This header contains classes that can be used to make that job easier.
- [endsect]
- [section Class `override`]
- Encapsulates a Python override of a C++ virtual function. An override object either holds a callable Python object or `None`.
- ``
- namespace boost
- {
- class override : object
- {
- public:
- unspecified operator() const;
- template <class A0>
- unspecified operator(A0) const;
- template <class A0, class A1>
- unspecified operator(A0, A1) const;
- ...
- template <class A0, class A1, ...class An>
- unspecified operator(A0, A1, ...An) const;
- };
- };
- ``
- [endsect]
- [section Class `override` observer functions]
- ``
- unspecified operator() const;
- template <class A0>
- unspecified operator(A0) const;
- template <class A0, class A1>
- unspecified operator(A0, A1) const;
- ...
- template <class A0, class A1, ...class An>
- unspecified operator(A0, A1, ...An) const;
- ``
- [variablelist
- [[Effects][If *this holds a callable Python object, it is invoked with the specified arguments in the manner specified here. Otherwise, throws [link high_level_components.boost_python_errors_hpp.class_error_already_set error_already_set].]]
- [[Returns][An object of unspecified type that holds the Python result of the invocation and, when converted to a C++ type R, attempts to convert that result object to R. If that conversion fails, throws [link high_level_components.boost_python_errors_hpp.class_error_already_set error_already_set].]]
- ]
- [endsect]
- [section Class template `wrapper`]
- Deriving your wrapper class from both `T` and `wrapper<T>` makes writing that derived class easier.
- ``
- namespace boost
- {
- class wrapper
- {
- protected:
- override get_override(char const* name) const;
- };
- };
- ``
- [endsect]
- [section Class template `wrapper` observer functions]
- ``override get_override(char const* name) const;``
- [variablelist
- [[Requires][name is a [link ntbs].]]
- [[Returns][If `*this` is the C++ base class subobject of a Python derived class instance that overrides the named function, returns an override object that delegates to the Python override. Otherwise, returns an override object that holds `None`.]]
- ]
- [endsect]
- [section Example]
- ``
- #include <boost/python/module.hpp>
- #include <boost/python/class.hpp>
- #include <boost/python/wrapper.hpp>
- #include <boost/python/call.hpp>
- using namespace boost::python;
- // Class with one pure virtual function
- struct P
- {
- virtual ~P(){}
- virtual char const* f() = 0;
- char const* g() { return "P::g()"; }
- };
- struct PCallback : P, wrapper<P>
- {
- char const* f()
- {
- return this->get_override("f")();
- }
- };
- // Class with one non-pure virtual function
- struct A
- {
- virtual ~A(){}
- virtual char const* f() { return "A::f()"; }
- };
- struct ACallback : A, wrapper<A>
- {
- char const* f()
- {
- if (override f = this->get_override("f"))
- return f();
- return A::f();
- }
- char const* default_f() { return this->A::f(); }
- };
- BOOST_PYTHON_MODULE_INIT(polymorphism)
- {
- class_<PCallback,boost::noncopyable>("P")
- .def("f", pure_virtual(&P::f))
- ;
- class_<ACallback,boost::noncopyable>("A")
- .def("f", &A::f, &ACallback::default_f)
- ;
- }
- ``
- [endsect]
- [endsect]
|