|
Boost.PythonHeader <boost/python/make_function.hpp> |
make_function()
and
make_constructor()
are
the functions used internally by class_<>::def
, class_<>::def
, and
class_<>::def_init
to produce Python
callable objects which wrap C++ functions and member functions.
template <class F> objects::function* make_function(F f) template <class F, class Policies> objects::function* make_function(F f, Policies const& policies)
F
is a function pointer or member
function pointer type
f
. If
F
is a pointer-to-member-function type, the target object of
the function call (*this
) will be taken from the first
Python argument, and subsequent Python arguments will be used as the
arguments to f
. If policies
are supplied, it
must be a model of CallPolicies, and will
be applied to the function as described here.
PyObject*
which
refers to the new Python callable object.
template <class T, class ArgList, class Generator> objects::function* make_constructor();
T
is a class type. ArgList
is an MPL sequence of C++
argument types (A1, A2,... AN) such that if
a1, a2
... aN
are objects of type
A1, A2,... AN respectively, the expression new
Generator::apply<T>::type(a1, a2
... aN
) is
valid. Generator is a model of HolderGenerator.
Generator::apply<T>::type
object. The result is
installed in the extension class object.
C++ function exposed below returns a callable object wrapping one of two functions.
#include <boost/python/make_function.hpp> #include <boost/python/module.hpp> char const* foo() { return "foo"; } char const* bar() { return "bar"; } PyObject* choose_function(bool selector) { if (selector) return boost::python::make_function(foo); else return boost::python::make_function(bar); } BOOST_PYTHON_MODULE_INIT(make_function_test) { module("make_function_test") .def("choose_function", choose_function); }It can be used this way in Python:
>>> from make_function_test import * >>> f = choose_function(1) >>> g = choose_function(0) >>> f() 'foo' >>> g() 'bar'
14 February 2002
© Copyright Dave Abrahams 2002. All Rights Reserved.