1[section boost/python/make_function.hpp] 2[section Introduction] 3make_function() and make_constructor() are the functions used internally by def() and class_<>::def() to produce Python callable objects which wrap C++ functions and member functions. 4[endsect] 5[section Functions] 6`` 7template <class F> 8object make_function(F f) 9 10template <class F, class Policies> 11object make_function(F f, Policies const& policies) 12 13template <class F, class Policies, class KeywordsOrSignature> 14object make_function(F f, Policies const& policies, KeywordsOrSignature const& ks) 15 16template <class F, class Policies, class Keywords, class Signature> 17object make_function(F f, Policies const& policies, Keywords const& kw, Signature const& sig) 18`` 19[variablelist 20[[Requires][F is a function pointer or member function pointer type. If policies are supplied, it must be a model of CallPolicies. If kewords are supplied, it must be the result of a keyword-expression specifying no more arguments than the arity of f.]] 21[[Effects][Creates a Python callable object which, when called from Python, converts its arguments to C++ and calls 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. 22 23* If policies are supplied, it will be applied to the function as described here. 24* If keywords are supplied, the keywords will be applied in order to the final arguments of the resulting function. 25* If Signature is supplied, it should be an instance of an MPL front-extensible sequence representing the function's return type followed by its argument types. Pass a Signature when wrapping function object types whose signatures can't be deduced, or when you wish to override the types which will be passed to the wrapped function. ]] 26[[Returns][An instance of object which holds the new Python callable object.]] 27[[Caveats][An argument of pointer type may be 0 if None is passed from Python. An argument type which is a constant reference may refer to a temporary which was created from the Python object for just the duration of the call to the wrapped function, for example a std::vector conjured up by the conversion process from a Python list. Use a non-const reference argument when a persistent lvalue is required. ]] 28] 29`` 30template <class F> 31object make_constructor(F f) 32 33template <class F, class Policies> 34object make_constructor(F f, Policies const& policies) 35 36template <class F, class Policies, class KeywordsOrSignature> 37object make_constructor(F f, Policies const& policies, KeywordsOrSignature const& ks) 38 39template <class F, class Policies, class Keywords, class Signature> 40object make_constructor(F f, Policies const& policies, Keywords const& kw, Signature const& sig) 41`` 42[variablelist 43[[Requires][F is a function pointer type. If policies are supplied, it must be a model of CallPolicies. If kewords are supplied, it must be the result of a keyword-expression specifying no more arguments than the arity of f.]] 44[[Effects][Creates a Python callable object which, when called from Python, converts its arguments to C++ and calls f.]] 45[[Returns][An instance of object which holds the new Python callable object.]] 46] 47 48[endsect] 49[section Example] 50C++ function exposed below returns a callable object wrapping one of two functions. 51`` 52#include <boost/python/make_function.hpp> 53#include <boost/python/module.hpp> 54 55char const* foo() { return "foo"; } 56char const* bar() { return "bar"; } 57 58using namespace boost::python; 59object choose_function(bool selector) 60{ 61 if (selector) 62 return boost::python::make_function(foo); 63 else 64 return boost::python::make_function(bar); 65} 66 67BOOST_PYTHON_MODULE(make_function_test) 68{ 69 def("choose_function", choose_function); 70} 71`` 72It can be used this way in Python: 73`` 74>>> from make_function_test import * 75>>> f = choose_function(1) 76>>> g = choose_function(0) 77>>> f() 78'foo' 79>>> g() 80'bar' 81`` 82[endsect] 83[endsect] 84