55 lines
3.3 KiB
Plaintext
55 lines
3.3 KiB
Plaintext
[section boost/python/def.hpp]
|
|
[section Introduction]
|
|
`def()` is the function which can be used to expose C++ functions and callable objects as Python functions in the [link high_level_components.boost_python_scope_hpp.introduction current scope].
|
|
[endsect]
|
|
[section 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&);
|
|
``
|
|
[variablelist
|
|
[[Requires][name is an [link ntbs] which conforms to Python's [@http://www.python.org/doc/current/ref/identifiers.html identifier naming rules].
|
|
|
|
* If `Fn` is [derived from] [link object_wrappers.boost_python_object_hpp.class_object object], it will be added to the [link high_level_components.boost_python_scope_hpp.introduction current scope] as a single overload. To be useful, `fn` should be [@http://www.python.org/doc/current/lib/built-in-funcs.html#l2h-6 callable].
|
|
* If `a1` is the result of an [link function_invocation_and_creation.boost_python_overloads_hpp.introduction.overload_dispatch_expressions overload-dispatch-expression], only the second form is allowed and `fn` must be a pointer to function or pointer to member function whose [link arity] is the same as A1's [link function_invocation_and_creation.boost_python_overloads_hpp.introduction.overload_dispatch_expressions maximum arity].
|
|
|
|
[*Effects:] For each prefix `P` of `Fn`\ 's sequence of argument types, beginning with the one whose length is `A1`\ 's [link function_invocation_and_creation.boost_python_overloads_hpp.introduction.overload_dispatch_expressions minimum arity], adds a `name(...)` function overload to the [link high_level_components.boost_python_scope_hpp.introduction 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.
|
|
|
|
[table
|
|
[[Mnemonic Name][Requirements/Type properties][Effects]]
|
|
[[docstring][Any [link ntbs]][Value will be bound to the `__doc__` attribute of the resulting method overload.]]
|
|
[[policies][A model of [link concepts.callpolicies CallPolicies]][A copy will be used as the call policies of the resulting method overload.]]
|
|
[[keywords][The result of a [link function_invocation_and_creation.boost_python_args_hpp.introduction.keyword_expressions keyword-expression] specifying no more arguments than the [link arity] of `fn`.][A copy will be used as the call policies of the resulting method overload.]]
|
|
]
|
|
]]
|
|
]
|
|
[endsect]
|
|
[section 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");
|
|
}
|
|
``
|
|
[endsect]
|
|
[endsect]
|