boost/python/def.hpp

Introduction

def() is the function which can be used to expose C++ functions and callable objects as Python functions in the current scope.

Functions

template <class F>
void def(char const* name, F f);

template <class Fn, class A1>
void def(char const* name, Fn fn, A1 const&);

template <class Fn, class A1, class A2>
void def(char const* name, Fn fn, A1 const&, A2 const&);

template <class Fn, class A1, class A2, class A3>
void def(char const* name, Fn fn, A1 const&, A2 const&, A3 const&);

Requires

name is an ntbs which conforms to Python's identifier naming rules.

* If Fn is [derived from] object, it will be added to the current scope as a single overload. To be useful, fn should be callable. * If a1 is the result of an overload-dispatch-expression, only the second form is allowed and fn must be a pointer to function or pointer to member function whose arity is the same as A1's maximum arity.

Effects: For each prefix P of Fn's sequence of argument types, beginning with the one whose length is A1's minimum arity, adds a name(...) function overload to the current scope. Each overload generated invokes a1's call-expression with P, using a copy of a1's call policies. If the longest valid prefix of A1 contains N types and a1 holds M keywords, an initial sequence of the keywords are used for all but the first N - M arguments of each overload.

* Otherwise, fn must be a non-null function or member function pointer, and a single function overload built around fn is added to the current scope. If any of a1-a3 are supplied, they may be selected in any order from the table below.

Mnemonic Name	Requirements/Type properties	Effects
docstring	Any ntbs	Value will be bound to the `__doc__` attribute of the resulting method overload.
policies	A model of CallPolicies	A copy will be used as the call policies of the resulting method overload.
keywords	The result of a keyword-expression specifying no more arguments than the arity of `fn`.	A copy will be used as the call policies of the resulting method overload.

Example

#include <boost/python/def.hpp>
#include <boost/python/module.hpp>
#include <boost/python/args.hpp>

using namespace boost::python;

char const* foo(int x, int y) { return "foo"; }

BOOST_PYTHON_MODULE(def_test)
{
    def("foo", foo, args("x", "y"), "foo's docstring");
}