Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.

C++ Boost

Boost.Python

Header <boost/python/make_function.hpp>


Contents

Introduction
Functions
make_function
make_constructor
Example

Introduction

make_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.

Functions

template <class F>
object make_function(F f)

template <class F, class Policies>
object make_function(F f, Policies const& policies)

template <class F, class Policies, class KeywordsOrSignature>
object make_function(F f, Policies const& policies, KeywordsOrSignature const& ks)

template <class F, class Policies, class Keywords, class Signature>
object make_function(F f, Policies const& policies, Keywords const& kw, Signature const& sig)
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.
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.
Returns: An instance of object which holds the new Python callable object.
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.
template <class T, class ArgList, class Generator>
object make_constructor();
 
template <class ArgList, class Generator, class Policies>
object make_constructor(Policies const& policies)
Requires: T is a class type. Policies is a model of CallPolicies. 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.
Effects: Creates a Python callable object which, when called from Python, expects its first argument to be a Boost.Python extension class object. It converts its remaining its arguments to C++ and passes them to the constructor of a dynamically-allocated Generator::apply<T>::type object, which is then installed in the extension class object. In the second form, the policies are applied to the arguments and result (None) of the Python callable object
Returns: An instance of object which holds the new Python callable object.

Example

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"; }

using namespace boost::python;
object choose_function(bool selector)
{
    if (selector)
        return boost::python::make_function(foo);
    else
        return boost::python::make_function(bar);
}

BOOST_PYTHON_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'

13 November, 2002

© Copyright Dave Abrahams 2002. All Rights Reserved.