Boost.Python

Contents

Introduction

Functions

make_function

make_constructor

Example

Introduction

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.

Functions

template <class F>
objects::function* make_function(F f)

template <class F, class Policies>
objects::function* make_function(F f, Policies const& policies)

Requires: F is a function pointer or member function pointer type

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. If policies are supplied, it must be a model of CallPolicies, and will be applied to the function as described here.

Returns: A pointer convertible to PyObject* which refers to the new Python callable object.

template <class T, class ArgList, class Generator>
objects::function* make_constructor();

template <class ArgList, class Generator, class Policies>
objects::function* 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: 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"; }

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

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