# Boost.Python - <boost/python/make_function.hpp>

###

# 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 `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();

Requires: `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.
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. The result is installed in the extension class 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);
    }

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.