boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-23 05:42:30 +00:00
Code Issues Projects Releases Wiki Activity

Keyword argument support

Browse Source 
[SVN r15533]
This commit is contained in:
Dave Abrahams
2002-09-28 07:35:15 +00:00
parent bc91db64d7
commit 997e84f117
21 changed files with 1261 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
include/boost/python/args.hpp
View File

@@ -3,33 +3,117 @@
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.
#ifndef ARGS_DWA2002323_HPP
# define ARGS_DWA2002323_HPP
# include <boost/config.hpp>
# include <boost/python/detail/preprocessor.hpp>
# include <boost/python/detail/type_list.hpp>
# include <boost/preprocessor/enum_params.hpp>
#ifndef KEYWORDS_DWA2002323_HPP
# define KEYWORDS_DWA2002323_HPP
# include <boost/python/args_fwd.hpp>
# include <boost/python/handle.hpp>
# include <boost/config.hpp>
# include <boost/python/detail/preprocessor.hpp>
# include <boost/python/detail/type_list.hpp>
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/remove_reference.hpp>
# include <boost/type_traits/remove_cv.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/repeat.hpp>
# include <boost/preprocessor/facilities/intercept.hpp>
# include <boost/preprocessor/iteration/local.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
# include <boost/mpl/bool_c.hpp>
# include <boost/type.hpp>
# include <cstddef>
namespace boost { namespace python {
enum no_init_t { no_init };
namespace detail
{
template <class Args>
struct args_base {};
struct keyword
{
char const* name;
handle<> default_value;
};
template <std::size_t nkeywords>
struct keywords
{
BOOST_STATIC_CONSTANT(std::size_t, size = nkeywords);
keyword_range range() const
{
return keyword_range(elements, elements + nkeywords);
}
keyword elements[nkeywords];
};
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<typename T>
struct is_keywords
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
template<std::size_t nkeywords>
struct is_keywords<keywords<nkeywords> >
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class T>
struct is_reference_to_keywords
{
BOOST_STATIC_CONSTANT(bool, is_ref = is_reference<T>::value);
typedef typename remove_reference<T>::type deref;
typedef typename remove_cv<deref>::type key_t;
BOOST_STATIC_CONSTANT(bool, is_key = is_keywords<key_t>::value);
BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));
typedef mpl::bool_c<value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
};
# else
typedef char (&yes_keywords_t)[1];
typedef char (&no_keywords_t)[2];
no_keywords_t is_keywords_test(...);
template<std::size_t nkeywords>
yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));
template<std::size_t nkeywords>
yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));
template<typename T>
class is_reference_to_keywords
{
public:
BOOST_STATIC_CONSTANT(
bool, value = (
sizeof(detail::is_keywords_test( (void (*)(T))0 ))
== sizeof(detail::yes_keywords_t)));
typedef mpl::bool_c<value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
};
# endif
}
}}
namespace boost { namespace python {
// A type list for specifying arguments
template < BOOST_PYTHON_ENUM_WITH_DEFAULT(BOOST_PYTHON_MAX_ARITY, typename A, mpl::void_) >
struct args : detail::args_base<args<BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_ARITY, A)> >
, detail::type_list< BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_ARITY, A) >::type
{};
# define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;
# define BOOST_PP_LOCAL_MACRO(n) \
inline detail::keywords<n> args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \
{ \
detail::keywords<n> result; \
BOOST_PP_REPEAT_1(n, BOOST_PYTHON_ASSIGN_NAME, _) \
return result; \
}
# define BOOST_PP_LOCAL_LIMITS (1, BOOST_PYTHON_MAX_ARITY)
# include BOOST_PP_LOCAL_ITERATE()
}} // namespace boost::python
# endif // ARGS_DWA2002323_HPP
# endif // KEYWORDS_DWA2002323_HPP

90
include/boost/python/class.hpp
View File

@@ -34,6 +34,7 @@
# include <boost/python/detail/defaults_def.hpp>
# include <boost/python/signature.hpp>
# include <boost/python/init.hpp>
# include <boost/python/args_fwd.hpp>
namespace boost { namespace python {
@@ -120,8 +121,9 @@ template <
class class_ : public objects::class_base
{
public: // types
typedef objects::class_base base;
typedef objects::class_base base;
typedef T wrapped_type;
typedef class_<T,X1,X2,X3> self;
BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
@@ -201,7 +203,7 @@ class class_ : public objects::class_base
template <class F>
self& def(char const* name, F f)
{
this->def_impl(name, f, default_call_policies(), 0, &f);
this->def_impl(name, f, detail::keywords<>(), default_call_policies(), 0, &f);
return *this;
}
@@ -236,6 +238,13 @@ class class_ : public objects::class_base
return *this;
}
template <class Arg1T, class Arg2T, class Arg3T, class Arg4T>
self& def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3, Arg4T const& arg4)
{
dispatch_def(&arg2, name, arg1, arg2, arg3, arg4);
return *this;
}
template <detail::operator_id id, class L, class R>
self& def(detail::operator_<id,L,R> const& op)
{
@@ -297,22 +306,32 @@ class class_ : public objects::class_base
private: // helper functions
template <class Fn, class Policies>
inline void def_impl(char const* name, Fn fn, Policies const& policies
, char const* doc, ...)
template <class Fn, class Policies, class Keywords>
inline void def_impl(
char const* name
, Fn fn
, Keywords const& keywords
, Policies const& policies
, char const* doc
, ...)
{
objects::add_to_namespace(
*this, name,
make_function(
// This bit of nastiness casts F to a member function of T if possible.
// This bit of nastiness casts F to a member function of T if possible.
detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
, policies)
, policies, keywords)
, doc);
}
template <class F>
inline void def_impl(char const* name, F f, default_call_policies const&
, char const* doc, object const*)
inline void def_impl(
char const* name
, F f
, detail::keywords<> const&
, default_call_policies const&
, char const* doc
, object const*)
{
objects::add_to_namespace(*this, name, f, doc);
}
@@ -332,33 +351,60 @@ class class_ : public objects::class_base
name, overloads, *this, detail::get_signature(sig));
}
template <class Fn, class CallPolicyOrDoc>
template <class Fn, class A1>
void dispatch_def(
void const*,
char const* name,
Fn fn,
CallPolicyOrDoc const& policy_or_doc)
A1 const& a1)
{
typedef detail::def_helper<CallPolicyOrDoc> helper;
detail::def_helper<A1> helper(a1);
this->def_impl(
name, fn, helper::get_policy(policy_or_doc),
helper::get_doc(policy_or_doc, 0), &fn);
name, fn
, helper.keywords()
, helper.policies()
, helper.doc()
, &fn);
}
template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
template <class Fn, class A1, class A2>
void dispatch_def(
void const*,
char const* name,
Fn fn,
CallPolicyOrDoc1 const& policy_or_doc1,
CallPolicyOrDoc2 const& policy_or_doc2)
A1 const& a1,
A2 const& a2)
{
typedef detail::def_helper<CallPolicyOrDoc1> helper;
detail::def_helper<A1,A2> helper(a1,a2);
this->def_impl(
name, fn, helper::get_policy(policy_or_doc1, policy_or_doc2),
helper::get_doc(policy_or_doc1, policy_or_doc2), &fn);
name, fn
, helper.keywords()
, helper.policies()
, helper.doc()
, &fn);
}
template <class Fn, class A1, class A2, class A3>
void dispatch_def(
void const*,
char const* name,
Fn fn,
A1 const& a1,
A2 const& a2,
A3 const& a3
)
{
detail::def_helper<A1,A2,A3> helper(a1,a2,a3);
this->def_impl(
name, fn
, helper.keywords()
, helper.policies()
, helper.doc()
, &fn);
}
};

64
include/boost/python/def.hpp
View File

@@ -12,43 +12,49 @@
# include <boost/python/detail/defaults_def.hpp>
# include <boost/python/scope.hpp>
# include <boost/python/signature.hpp>
# include <boost/python/detail/scope.hpp>
namespace boost { namespace python {
namespace detail
{
void BOOST_PYTHON_DECL scope_setattr_doc(char const* name, object const& obj, char const* doc);
template <class Fn, class CallPolicyOrDoc>
template <class Fn, class A1>
void
dispatch_def(
void const*,
char const* name,
Fn fn,
CallPolicyOrDoc const& policy_or_doc)
A1 const& a1)
{
typedef detail::def_helper<CallPolicyOrDoc> helper;
def_helper<A1> helper(a1);
detail::scope_setattr_doc(
name, boost::python::make_function(fn, helper::get_policy(policy_or_doc)),
helper::get_doc(policy_or_doc, 0));
name, boost::python::make_function(
fn
, helper.policies()
, helper.keywords())
, helper.doc()
);
}
template <class Fn, class CallPolicyOrDoc1, class CallPolicyOrDoc2>
template <class Fn, class A1, class A2>
void dispatch_def(
void const*,
char const* name,
Fn fn,
CallPolicyOrDoc1 const& policy_or_doc1,
CallPolicyOrDoc2 const& policy_or_doc2)
A1 const& a1,
A2 const& a2)
{
typedef detail::def_helper<CallPolicyOrDoc1> helper;
def_helper<A1,A2> helper(a1,a2);
detail::scope_setattr_doc(
name, boost::python::make_function(
fn, helper::get_policy(policy_or_doc1, policy_or_doc2)),
helper::get_doc(policy_or_doc1, policy_or_doc2));
}
name, python::make_function(
fn
, helper.policies()
, helper.keywords())
, helper.doc()
);
}
template <class StubsT, class SigT>
void dispatch_def(
@@ -87,22 +93,22 @@ void def(char const* name, Arg1T arg1, Arg2T const& arg2)
template <class Arg1T, class Arg2T, class Arg3T>
void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3)
{
// The arguments are definitely:
// def(name, function, policy, doc_string) // TODO: exchange policy, doc_string position
detail::dispatch_def(&arg2, name, arg1, arg2, arg3);
}
//template <class Arg1T, class Arg2T, class Arg3T>
//void def(char const* name, Arg1T arg1, Arg2T const& arg2, Arg3T const& arg3, char const* doc)
//{
// // The arguments are definitely:
// // arg1: signature
// // arg2: stubs
// // arg3: policy
//
// detail::dispatch_def(&arg2, name, arg1, arg2, arg3, doc);
//}
template <class F, class A1, class A2, class A3>
void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
{
detail::def_helper<A1,A2,A3> helper(a1,a2,a3);
detail::scope_setattr_doc(
name, python::make_function(
f
, helper.policies()
, helper.keywords())
, helper.doc()
);
}
}} // namespace boost::python

192
include/boost/python/detail/def_helper.hpp
View File

@@ -6,72 +6,146 @@
#ifndef DEF_HELPER_DWA200287_HPP
# define DEF_HELPER_DWA200287_HPP
# include <boost/python/args.hpp>
# include <boost/type_traits/ice.hpp>
# include <boost/type_traits/same_traits.hpp>
# include <boost/python/detail/string_literal.hpp>
# include <boost/python/detail/indirect_traits.hpp>
# include <boost/mpl/logical/not.hpp>
# include <boost/mpl/logical/and.hpp>
# include <boost/type_traits/add_reference.hpp>
# include <boost/mpl/lambda.hpp>
# include <boost/mpl/apply.hpp>
# include <boost/tuple/tuple.hpp>
# include <boost/python/detail/not_specified.hpp>
namespace boost { namespace python { namespace detail {
namespace boost { namespace python {
//
// def_helper<T> --
//
// A helper for def() functions which determines how to interpret
// an argument of type T which could be either CallPolicies or a
// string literal representing a docstring.
//
// Generates two static functions:
//
// get_policy(x), where x is of type T, returns a policies
// object: either a reference to x or default_call_policies()
// if x is a string literal.
//
// get_doc(x, s), where s convertible to char const*, returns x
// if x is a string literal, s otherwise.
struct default_call_policies;
template <bool is_string = false>
struct def_helper_impl
namespace detail
{
template <class P>
static P const&
get_policy(P const& x) { return x; }
template <class P1, class P2>
static P1 const&
get_policy(P1 const& x, P2 const&) { return x; } // select left
template <class P>
static char const*
get_doc(P const&, char const* doc) { return doc; } // select right
};
template <>
struct def_helper_impl<true>
{
static python::default_call_policies
get_policy(char const*)
{ return default_call_policies(); }
template <class P1, class P2>
static P2 const&
get_policy(P1 const&, P2 const& y) { return y; } // select right
template <class P>
static char const*
get_doc(char const* doc, P const&) // select left
{ return doc; }
};
template <class Tuple, class Predicate>
struct tuple_extract;
template <class T>
struct def_helper
: def_helper_impl<
type_traits::ice_or<
is_string_literal<T const>::value
, is_same<T, char const*>::value
, is_same<T, char*>::value
>::value
>
{};
template <bool matched>
struct tuple_extract_impl
{
template <class Tuple, class Predicate>
struct apply
{
typedef typename Tuple::head_type result_type;
static typename Tuple::head_type extract(Tuple const& x)
{
return x.get_head();
}
};
};
template <>
struct tuple_extract_impl<false>
{
template <class Tuple, class Predicate>
struct apply
: tuple_extract<typename Tuple::tail_type, Predicate>
{
// All of this forwarding would be unneeded if tuples were
// derived from their tails.
typedef tuple_extract<typename Tuple::tail_type, Predicate> base;
typedef typename base::result_type result_type;
static result_type extract(Tuple const& x)
{
return base::extract(x.get_tail());
}
};
};
}}} // namespace boost::python::detail
template <class Tuple, class Predicate>
struct tuple_extract_base_select
{
typedef typename Tuple::head_type head_type;
typedef typename mpl::apply1<Predicate,head_type>::type match_t;
BOOST_STATIC_CONSTANT(bool, match = match_t::value);
typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
};
template <class Tuple, class Predicate>
struct tuple_extract
: tuple_extract_base_select<
Tuple
, typename mpl::lambda<Predicate>::type
>::type
{
};
template <class Tuple>
struct doc_extract
: tuple_extract<
Tuple,
mpl::logical_not<
is_reference_to_class<
add_reference<mpl::_1>
>
> >
{
};
template <class Tuple>
struct keyword_extract
: tuple_extract<Tuple, is_reference_to_keywords<add_reference<mpl::_1> > >
{
};
template <class Tuple>
struct policy_extract
: tuple_extract<
Tuple,
mpl::logical_and<
is_reference_to_class<add_reference<mpl::_> >
, mpl::logical_not<is_reference_to_keywords<add_reference<mpl::_1> > >
>
>
{
};
# define BOOST_PYTHON_DEF_HELPER_TAIL default_call_policies, keywords<0>, char const*
template <class T1, class T2 = not_specified, class T3 = not_specified>
struct def_helper
{
typedef typename mpl::if_<
is_same<T2, not_specified>
, boost::tuples::tuple<T1 const&, BOOST_PYTHON_DEF_HELPER_TAIL>
, typename mpl::if_<
is_same<T3, not_specified>
, boost::tuples::tuple<T1 const&, T2 const&, BOOST_PYTHON_DEF_HELPER_TAIL>
, boost::tuples::tuple<T1 const&, T2 const&, T3 const&>
>::type
>::type all_t;
def_helper(T1 const& a1) : m_all(a1) {}
def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2) {}
def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3) {}
char const* doc() const
{
return doc_extract<all_t>::extract(m_all);
}
typename keyword_extract<all_t>::result_type keywords() const
{
return keyword_extract<all_t>::extract(m_all);
}
typename policy_extract<all_t>::result_type policies() const
{
return policy_extract<all_t>::extract(m_all);
}
all_t m_all;
};
# undef BOOST_PYTHON_DEF_HELPER_TAIL
}
}} // namespace boost::python::detail
#endif // DEF_HELPER_DWA200287_HPP

215
include/boost/python/detail/defaults_def.hpp
View File

@@ -19,9 +19,11 @@
#include <boost/static_assert.hpp>
#include <boost/preprocessor/iterate.hpp>
#include <boost/python/class_fwd.hpp>
#include <boost/python/object/function.hpp>
#include <boost/python/scope.hpp>
#include <boost/preprocessor/debug/line.hpp>
#include <boost/python/detail/scope.hpp>
#include <boost/python/detail/make_keyword_range_fn.hpp>
#include <boost/python/object/add_to_namespace.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace python {
@@ -33,78 +35,92 @@ namespace objects
struct class_base;
}
namespace detail {
template <class Func, class CallPolicies, class NameSpaceT>
static void name_space_def(
NameSpaceT& name_space,
char const* name,
Func f,
CallPolicies const& policies,
char const* doc,
objects::class_base*
)
namespace detail
{
name_space.def(
name, f, policies, doc);
}
template <class T, class F> struct member_function_cast;
template <class Func, class CallPolicies, class NameSpaceT>
static void name_space_def(
NameSpaceT& name_space
, char const* name
, Func f
, keyword_range const& kw
, CallPolicies const& policies
, char const* doc
, objects::class_base*
)
{
typedef typename NameSpaceT::wrapped_type wrapped_type;
objects::add_to_namespace(
name_space, name,
make_keyword_range_function(
// This bit of nastiness casts F to a member function of T if possible.
member_function_cast<wrapped_type,Func>::stage1(f).stage2((wrapped_type*)0).stage3(f)
, policies, kw)
, doc);
}
template <class Func, class CallPolicies>
static void name_space_def(
object& name_space,
char const* name,
Func f,
CallPolicies const& policies,
char const* doc,
...
)
{
scope within(name_space);
template <class Func, class CallPolicies>
static void name_space_def(
object& name_space
, char const* name
, Func f
, keyword_range const& kw
, CallPolicies const& policies
, char const* doc
, ...
)
{
scope within(name_space);
def(name, f, policies, doc);
}
detail::scope_setattr_doc(
name
, detail::make_keyword_range_function(f, policies, kw)
, doc);
}
// For backward compatibility
template <class Func, class CallPolicies, class NameSpaceT>
static void name_space_def(
NameSpaceT& name_space,
char const* name,
Func f,
CallPolicies const& policies,
char const* doc,
module*
)
{
name_space.def(
name, f, policies, doc);
}
// For backward compatibility
template <class Func, class CallPolicies, class NameSpaceT>
static void name_space_def(
NameSpaceT& name_space
, char const* name
, Func f
, keyword_range const& kw // ignored
, CallPolicies const& policies
, char const* doc
, module*
)
{
name_space.def(name, f, policies, doc);
}
///////////////////////////////////////////////////////////////////////////////
//
// This Boost PP code generates expansions for
//
// template <typename StubsT, typename NameSpaceT>
// inline void
// define_stub_function(
// char const* name, StubsT s, NameSpaceT& name_space, mpl::int_c<N>)
// {
// name_space.def(name, &StubsT::func_N);
// }
//
// where N runs from 0 to BOOST_PYTHON_MAX_ARITY
//
// The set of overloaded functions (define_stub_function) expects:
//
// 1. char const* name: function name that will be visible to python
// 2. StubsT: a function stubs struct (see defaults_gen.hpp)
// 3. NameSpaceT& name_space: a python::class_ or python::module instance
// 4. int_t<N>: the Nth overloaded function (StubsT::func_N)
// (see defaults_gen.hpp)
// 5. char const* name: doc string
//
///////////////////////////////////////////////////////////////////////////////
template <int N>
struct define_stub_function {};
///////////////////////////////////////////////////////////////////////////////
//
// This Boost PP code generates expansions for
//
// template <typename OverloadsT, typename NameSpaceT>
// inline void
// define_stub_function(
// char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_c<N>)
// {
// name_space.def(name, &OverloadsT::func_N);
// }
//
// where N runs from 0 to BOOST_PYTHON_MAX_ARITY
//
// The set of overloaded functions (define_stub_function) expects:
//
// 1. char const* name: function name that will be visible to python
// 2. OverloadsT: a function overloads struct (see defaults_gen.hpp)
// 3. NameSpaceT& name_space: a python::class_ or python::module instance
// 4. int_t<N>: the Nth overloaded function (OverloadsT::func_N)
// (see defaults_gen.hpp)
// 5. char const* name: doc string
//
///////////////////////////////////////////////////////////////////////////////
template <int N>
struct define_stub_function {};
#define BOOST_PP_ITERATION_PARAMS_1 \
(3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>))
@@ -120,10 +136,10 @@ struct define_stub_function {};
// terminal case define_with_defaults_helper<0>. The struct and its
// specialization has a sole static member function def that expects:
//
// 1. char const* name: function name that will be visible to python
// 2. StubsT: a function stubs struct (see defaults_gen.hpp)
// 3. NameSpaceT& name_space: a python::class_ or python::module instance
// 4. char const* name: doc string
// 1. char const* name: function name that will be visible to python
// 2. OverloadsT: a function overloads struct (see defaults_gen.hpp)
// 3. NameSpaceT& name_space: a python::class_ or python::module instance
// 4. char const* name: doc string
//
// The def static member function calls a corresponding
// define_stub_function<N>. The general case recursively calls
@@ -139,14 +155,19 @@ struct define_stub_function {};
def(
char const* name,
StubsT stubs,
keyword_range kw,
CallPolicies const& policies,
NameSpaceT& name_space,
char const* doc)
{
// define the NTH stub function of stubs
define_stub_function<N>::define(name, stubs, policies, name_space, doc);
define_stub_function<N>::define(name, stubs, kw, policies, name_space, doc);
if (kw.second > kw.first)
--kw.second;
// call the next define_with_defaults_helper
define_with_defaults_helper<N-1>::def(name, stubs, policies, name_space, doc);
define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
}
};
@@ -159,12 +180,13 @@ struct define_stub_function {};
def(
char const* name,
StubsT stubs,
keyword_range const& kw,
CallPolicies const& policies,
NameSpaceT& name_space,
char const* doc)
{
// define the Oth stub function of stubs
define_stub_function<0>::define(name, stubs, policies, name_space, doc);
define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
// return
}
};
@@ -174,7 +196,7 @@ struct define_stub_function {};
// define_with_defaults
//
// 1. char const* name: function name that will be visible to python
// 2. StubsT: a function stubs struct (see defaults_gen.hpp)
// 2. OverloadsT: a function overloads struct (see defaults_gen.hpp)
// 3. CallPolicies& policies: Call policies
// 4. NameSpaceT& name_space: a python::class_ or python::module instance
// 5. SigT sig: Function signature typelist (see defaults_gen.hpp)
@@ -191,17 +213,17 @@ struct define_stub_function {};
// void C::foo(int) mpl::list<void, C, int>
//
///////////////////////////////////////////////////////////////////////////////
template <class StubsT, class NameSpaceT, class SigT>
template <class OverloadsT, class NameSpaceT, class SigT>
inline void
define_with_defaults(
char const* name,
StubsT const& stubs,
OverloadsT const& overloads,
NameSpaceT& name_space,
SigT sig)
{
typedef typename mpl::front<SigT>::type return_type;
typedef typename StubsT::void_return_type void_return_type;
typedef typename StubsT::non_void_return_type non_void_return_type;
typedef typename OverloadsT::void_return_type void_return_type;
typedef typename OverloadsT::non_void_return_type non_void_return_type;
typedef typename mpl::if_c<
boost::is_same<void, return_type>::value
@@ -213,8 +235,13 @@ struct define_stub_function {};
(stubs_type::max_args) <= mpl::size<SigT>::value);
typedef typename stubs_type::template gen<SigT> gen_type;
define_with_defaults_helper<stubs_type::n_funcs-1>::def
(name, gen_type(), stubs.call_policies(), name_space, stubs.doc_string());
define_with_defaults_helper<stubs_type::n_funcs-1>::def(
name
, gen_type()
, overloads.keywords()
, overloads.call_policies()
, name_space
, overloads.doc_string());
}
} // namespace detail
@@ -232,17 +259,21 @@ template <>
struct define_stub_function<BOOST_PP_ITERATION()> {
template <class StubsT, class CallPolicies, class NameSpaceT>
static void define(
char const* name,
StubsT,
CallPolicies const& policies,
NameSpaceT& name_space,
char const* doc)
char const* name
, StubsT const&
, keyword_range const& kw
, CallPolicies const& policies
, NameSpaceT& name_space
, char const* doc)
{
detail::name_space_def(name_space,
name,
&StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION()),
policies,
doc, &name_space);
detail::name_space_def(
name_space
, name
, &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION())
, kw
, policies
, doc
, &name_space);
}
};

298
include/boost/python/detail/defaults_gen.hpp
View File

@@ -29,74 +29,96 @@
namespace boost { namespace python {
// overloads_base is used as a base class for all function
// stubs. This class holds the doc_string of the stubs.
namespace detail
{
// overloads_base is used as a base class for all function
// stubs. This class holds the doc_string of the stubs.
struct overloads_base
{
overloads_base(char const* doc_)
: doc(doc_) {}
: m_doc(doc_) {}
overloads_base(char const* doc_, detail::keyword_range const& kw)
: m_doc(doc_), m_keywords(kw) {}
char const* doc_string() const
{ return doc; }
{
return m_doc;
}
char const* doc;
detail::keyword_range const& keywords() const
{
return m_keywords;
}
private:
char const* m_doc;
detail::keyword_range m_keywords;
};
}
// overloads_proxy is generated by the overloads_common operator[] (see
// below). This class holds a user defined call policies of the stubs.
// overloads_proxy is generated by the overloads_common operator[] (see
// below). This class holds a user defined call policies of the stubs.
template <class CallPoliciesT, class OverloadsT>
struct overloads_proxy
: public overloads_base
{
typedef typename OverloadsT::non_void_return_type non_void_return_type;
typedef typename OverloadsT::void_return_type void_return_type;
template <class CallPoliciesT, class OverloadsT>
struct overloads_proxy
: public detail::overloads_base
{
typedef typename OverloadsT::non_void_return_type non_void_return_type;
typedef typename OverloadsT::void_return_type void_return_type;
overloads_proxy(
CallPoliciesT const& policies_
, char const* doc
, keyword_range const& kw
)
: overloads_base(doc, kw)
, policies(policies_)
{}
overloads_proxy(CallPoliciesT const& policies_, char const* doc)
: detail::overloads_base(doc), policies(policies_) {}
CallPoliciesT
call_policies() const
{
return policies;
}
CallPoliciesT
call_policies() const
{ return policies; }
CallPoliciesT policies;
};
CallPoliciesT policies;
};
// overloads_common is our default function stubs base class. This
// class returns the default_call_policies in its call_policies()
// member function. It can generate a overloads_proxy however through
// its operator[]
template <class DerivedT>
struct overloads_common
: public overloads_base
{
overloads_common(char const* doc)
: overloads_base(doc) {}
// overloads_common is our default function stubs base class. This class
// returns the default_call_policies in its call_policies() member function.
// It can generate a overloads_proxy however through its operator[]
overloads_common(char const* doc, keyword_range const& kw)
: overloads_base(doc, kw) {}
template <class DerivedT>
struct overloads_common
: public detail::overloads_base {
default_call_policies
call_policies() const
{
return default_call_policies();
}
overloads_common(char const* doc)
: detail::overloads_base(doc) {}
template <class CallPoliciesT>
overloads_proxy<CallPoliciesT, DerivedT>
operator[](CallPoliciesT const& policies) const
{
return overloads_proxy<CallPoliciesT, DerivedT>(
policies, this->doc_string(), this->keywords());
}
};
default_call_policies
call_policies() const
{ return default_call_policies(); }
}}} // namespace boost::python::detail
template <class CallPoliciesT>
::boost::python::overloads_proxy<CallPoliciesT, DerivedT>
operator[](CallPoliciesT const& policies) const
{
return overloads_proxy<CallPoliciesT, DerivedT>
(policies, doc);
}
};
}} // namespace boost::python
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_TYPEDEF_GEN(z, index, data) \
typedef typename BOOST_PP_CAT(iter, index)::next \
BOOST_PP_CAT(iter, BOOST_PP_INC(index)); \
typedef typename BOOST_PP_CAT(iter, index)::type BOOST_PP_CAT(T, index); \
typedef typename BOOST_PP_CAT(iter, index)::type BOOST_PP_CAT(T, index);
#define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data) \
static RT BOOST_PP_CAT(func_, \
@@ -112,14 +134,14 @@ struct overloads_common
}
#define BOOST_PYTHON_GEN_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \
struct fstubs_name { \
\
struct fstubs_name \
{ \
BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts)); \
BOOST_STATIC_CONSTANT(int, max_args = n_funcs); \
\
template <typename SigT> \
struct gen { \
\
struct gen \
{ \
typedef typename ::boost::mpl::begin<SigT>::type rt_iter; \
typedef typename rt_iter::type RT; \
typedef typename rt_iter::next iter0; \
@@ -151,14 +173,14 @@ struct overloads_common
}
#define BOOST_PYTHON_GEN_MEM_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \
struct fstubs_name { \
\
struct fstubs_name \
{ \
BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts)); \
BOOST_STATIC_CONSTANT(int, max_args = n_funcs + 1); \
\
template <typename SigT> \
struct gen { \
\
struct gen \
{ \
typedef typename ::boost::mpl::begin<SigT>::type rt_iter; \
typedef typename rt_iter::type RT; \
\
@@ -179,75 +201,82 @@ struct overloads_common
}; \
};
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_NO_VOID_RETURNS)
#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;) \
struct fstubs_name \
: public boost::python::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, _NV) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, _V) void_return_type; \
\
fstubs_name(char const* doc = 0) \
: boost::python:: \
overloads_common<fstubs_name>(doc) {} \
}; \
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_MEM_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _V), n_args, n_dflts, ;) \
struct fstubs_name \
: public boost::python::overloads_common<fstubs_name> \
#define BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
fstubs_name(char const* doc = 0) \
: ::boost::python::detail::overloads_common<fstubs_name>(doc) {} \
template <class Keywords> \
fstubs_name(char const* doc, Keywords const& keywords) \
: ::boost::python::detail::overloads_common<fstubs_name>( \
doc, keywords.range()) \
{ \
typedef BOOST_PP_CAT(fstubs_name, _NV) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, _V) void_return_type; \
\
fstubs_name(char const* doc = 0) \
: boost::python:: \
overloads_common<fstubs_name>(doc) {} \
}; \
#else
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return) \
struct fstubs_name \
: public boost::python::overloads_common<fstubs_name> \
typedef typename ::boost::python::detail:: \
error::more_keywords_than_function_arguments< \
Keywords::size,(n_args+n_dflts)>::too_many_keywords assertion; \
} \
template <class Keywords> \
fstubs_name(Keywords const& keywords, char const* doc = 0) \
: ::boost::python::detail::overloads_common<fstubs_name>( \
doc, keywords.range()) \
{ \
typedef BOOST_PP_CAT(fstubs_name, _NV) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, _NV) void_return_type; \
\
fstubs_name(char const* doc = 0) \
: boost::python:: \
overloads_common<fstubs_name>(doc) {} \
}; \
typedef typename ::boost::python::detail:: \
error::more_keywords_than_function_arguments< \
Keywords::size,(n_args+n_dflts)>::too_many_keywords assertion; \
}
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION \
(fname, BOOST_PP_CAT(fstubs_name, _NV), n_args, n_dflts, return) \
# if defined(BOOST_NO_VOID_RETURNS)
# define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, Void), n_args, n_dflts, ;) \
struct fstubs_name \
: public boost::python::overloads_common<fstubs_name> \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, _NV) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, _NV) void_return_type; \
\
fstubs_name(char const* doc = 0) \
: boost::python:: \
overloads_common<fstubs_name>(doc) {} \
}; \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, Void) void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
#endif // defined(BOOST_MSVC)
# define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, Void), n_args, n_dflts, ;) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, Void) void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# else // !defined(BOOST_NO_VOID_RETURNS)
# define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \
BOOST_PYTHON_GEN_MEM_FUNCTION( \
fname, BOOST_PP_CAT(fstubs_name, NonVoid), n_args, n_dflts, return) \
struct fstubs_name \
: public ::boost::python::detail::overloads_common<fstubs_name> \
{ \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) non_void_return_type; \
typedef BOOST_PP_CAT(fstubs_name, NonVoid) void_return_type; \
BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \
};
# endif // !defined(BOOST_NO_VOID_RETURNS)
///////////////////////////////////////////////////////////////////////////////
//
@@ -278,14 +307,14 @@ struct overloads_common
//
// Generates this code:
//
// struct foo_stubs_NV {
//
// struct foo_stubsNonVoid
// {
// static const int n_funcs = 4;
// static const int max_args = n_funcs;
//
// template <typename SigT>
// struct gen {
//
// struct gen
// {
// typedef typename ::boost::mpl::begin<SigT>::type rt_iter;
// typedef typename rt_iter::type RT;
// typedef typename rt_iter::next iter0;
@@ -312,28 +341,27 @@ struct overloads_common
// };
// };
//
// struct foo_stubs
// : public boost::python::overloads_common<foo_stubs>
// struct foo_overloads
// : public boost::python::detail::overloads_common<foo_overloads>
// {
// typedef foo_overloadsNonVoid non_void_return_type;
// typedef foo_overloadsNonVoid void_return_type;
//
// typedef foo_stubs_NV non_void_return_type;
// typedef foo_stubs_NV void_return_type;
//
// fstubs_name(char const* doc = 0)
// : boost::python::
// overloads_common<foo_stubs>(doc) {}
// foo_overloads(char const* doc = 0)
// : boost::python::detail::overloads_common<foo_overloads>(doc) {}
// };
//
// The typedefs non_void_return_type and void_return_type are
// used to handle compilers that do not support void returns. The
// example above typedefs non_void_return_type and
// void_return_type to foo_stubs_NV. On compilers that do not
// support void returns, there are two versions: foo_stubs_NV and
// foo_stubs_V. The "V" version is almost identical to the "NV"
// version except for the return type (void) and the lack of the
// return keyword.
// void_return_type to foo_overloadsNonVoid. On compilers that do
// not support void returns, there are two versions:
// foo_overloadsNonVoid and foo_overloadsVoid. The "Void"
// version is almost identical to the "NonVoid" version except
// for the return type (void) and the lack of the return keyword.
//
// See the overloads_common above for a description of the foo_stubs'
// base class.
// See the overloads_common above for a description of the
// foo_overloads' base class.
//
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args) \

9
include/boost/python/detail/indirect_traits.hpp
View File

@@ -16,6 +16,8 @@
# include <boost/type_traits/remove_reference.hpp>
# include <boost/type_traits/remove_pointer.hpp>
# include <boost/mpl/if.hpp>
# include <boost/mpl/bool_c.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
namespace boost { namespace python { namespace detail {
@@ -163,6 +165,8 @@ struct is_reference_to_class
>::value
>::value)
);
typedef mpl::bool_c<value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
};
template <class T>
@@ -343,7 +347,6 @@ struct is_reference_to_volatile
{
};
template <typename V>
typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
outer_no_type reference_to_pointer_helper(...);
@@ -370,8 +373,10 @@ struct is_reference_to_class
BOOST_STATIC_CONSTANT(
bool, value
= (is_reference<T>::value
&& sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))
& (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
);
typedef mpl::bool_c<value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
};
template <typename V>

45
include/boost/python/detail/make_keyword_range_fn.hpp Normal file
View File

@@ -0,0 +1,45 @@
// Copyright David Abrahams 2002. Permission to copy, use,
// modify, sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.
#ifndef MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
# define MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
# include <boost/python/args_fwd.hpp>
# include <boost/python/detail/caller.hpp>
# include <boost/python/object/function_object.hpp>
# include <boost/python/object/make_holder.hpp>
namespace boost { namespace python { namespace detail {
template <class F, class Policies>
object make_keyword_range_function(F f, Policies const& policies, keyword_range const& kw)
{
enum { n_arguments = detail::arg_tuple_size<F>::value };
return objects::function_object(
::boost::bind<PyObject*>(detail::caller(), f, _1, _2, policies)
, n_arguments
, kw);
}
template <class ArgList, class HolderGenerator, class Policies>
object make_keyword_range_constructor(
Policies const& policies
, detail::keyword_range const& kw
, HolderGenerator* = 0
, ArgList* = 0)
{
enum { nargs = mpl::size<ArgList>::value };
return objects::function_object(
::boost::bind<PyObject*>(detail::caller(),
objects::make_holder<nargs>
::template apply<HolderGenerator,ArgList>::execute
, _1, _2, policies)
, nargs + 1, kw);
}
}}} // namespace boost::python::detail
#endif // MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP

15
include/boost/python/detail/scope.hpp Normal file
View File

@@ -0,0 +1,15 @@
// Copyright David Abrahams 2002. Permission to copy, use,
// modify, sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.
#ifndef SCOPE_DWA2002927_HPP
# define SCOPE_DWA2002927_HPP
namespace boost { namespace python { namespace detail {
void BOOST_PYTHON_DECL scope_setattr_doc(char const* name, object const& obj, char const* doc);
}}} // namespace boost::python::detail
#endif // SCOPE_DWA2002927_HPP

198
include/boost/python/init.hpp
View File

@@ -11,6 +11,7 @@
#define INIT_JDG20020820_HPP
#include <boost/python/detail/type_list.hpp>
#include <boost/python/args_fwd.hpp>
#include <boost/mpl/fold_backward.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/apply_if.hpp>
@@ -25,6 +26,7 @@
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/bool_c.hpp>
#include <boost/type_traits/is_same.hpp>
@@ -34,6 +36,8 @@
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <utility>
///////////////////////////////////////////////////////////////////////////////
#define BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT \
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \
@@ -55,13 +59,22 @@
namespace boost { namespace python {
template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT>
struct init; // forward declaration
class init; // forward declaration
///////////////////////////////////////
template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT>
struct optional; // forward declaration
namespace detail {
namespace detail
{
namespace error
{
template <int keywords, int init_args>
struct more_keywords_than_init_arguments
{
typedef char too_many_keywords[init_args - keywords >= 0 ? 1 : -1];
};
}
///////////////////////////////////////////////////////////////////////////
//
@@ -89,7 +102,7 @@ namespace detail {
sizeof(f(t())) == sizeof(::boost::type_traits::yes_type));
typedef mpl::bool_c<value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_optional,(T)) // needed for MSVC & Borland
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_optional,(T))
};
///////////////////////////////////////
@@ -111,61 +124,114 @@ namespace detail {
struct is_optional : is_optional_impl<T>
{
typedef mpl::bool_c<is_optional_impl<T>::value> type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_optional,(T)) // needed for MSVC & Borland
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_optional,(T))
};
#endif // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
} // namespace detail
template <class DerivedT>
struct init_base {
struct init_base
{
init_base(char const* doc_, detail::keyword_range const& keywords_)
: m_doc(doc_), m_keywords(keywords_)
{}
init_base(char const* doc_)
: m_doc(doc_)
{}
DerivedT const& derived() const
{ return *static_cast<DerivedT const*>(this); }
{
return *static_cast<DerivedT const*>(this);
}
char const* doc_string() const
{
return m_doc;
}
detail::keyword_range const& keywords() const
{
return m_keywords;
}
static default_call_policies call_policies()
{
return default_call_policies();
}
private: // data members
char const* m_doc;
detail::keyword_range m_keywords;
};
template <class CallPoliciesT, class InitT>
struct init_with_call_policies
: public init_base<init_with_call_policies<CallPoliciesT, InitT> >
class init_with_call_policies
: public init_base<init_with_call_policies<CallPoliciesT, InitT> >
{
typedef init_base<init_with_call_policies<CallPoliciesT, InitT> > base;
public:
BOOST_STATIC_CONSTANT(int, n_arguments = InitT::n_arguments);
BOOST_STATIC_CONSTANT(int, n_defaults = InitT::n_defaults);
typedef typename InitT::reversed_args reversed_args;
init_with_call_policies(CallPoliciesT const& policies_, char const* doc_)
: policies(policies_), doc(doc_) {}
init_with_call_policies(
CallPoliciesT const& policies_
, char const* doc_
, detail::keyword_range const& keywords
)
: base(doc_, keywords)
, m_policies(policies_)
{}
char const* doc_string() const
{ return doc; }
CallPoliciesT
call_policies() const
{ return policies; }
CallPoliciesT policies;
char const* doc;
CallPoliciesT const& call_policies() const
{
return this->m_policies;
}
private: // data members
CallPoliciesT m_policies;
};
template <BOOST_PYTHON_OVERLOAD_TYPES>
struct init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> >
class init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> >
{
typedef init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> > base;
public:
typedef init<BOOST_PYTHON_OVERLOAD_ARGS> self_t;
init(char const* doc_ = 0)
: doc(doc_) {}
: base(doc_)
{
}
template <class Keywords>
init(char const* doc_, Keywords const& kw)
: base(doc_, std::make_pair(kw.base(), kw.base() + Keywords::size))
{
typedef typename detail::error::more_keywords_than_init_arguments<
Keywords::size, n_arguments
>::too_many_keywords assertion;
}
char const* doc_string() const
{ return doc; }
default_call_policies
call_policies() const
{ return default_call_policies(); }
template <class Keywords>
init(Keywords const& kw)
: base(0, kw.range())
{
typedef typename detail::error::more_keywords_than_init_arguments<
Keywords::size, n_arguments
>::too_many_keywords assertion;
}
template <class CallPoliciesT>
init_with_call_policies<CallPoliciesT, self_t>
operator[](CallPoliciesT const& policies) const
{ return init_with_call_policies<CallPoliciesT, self_t>(policies, doc); }
{
return init_with_call_policies<CallPoliciesT, self_t>(
policies, this->doc_string(), this->keywords());
}
typedef detail::type_list<BOOST_PYTHON_OVERLOAD_ARGS> signature_;
typedef typename mpl::end<signature_>::type finish;
@@ -213,37 +279,47 @@ struct init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> >
// Count the maximum number of arguments
BOOST_STATIC_CONSTANT(int, n_arguments = mpl::size<reversed_args>::value);
char const* doc;
};
# if 1
template <> // specialization for zero args
struct init<> : public init_base<init<> >
class init<> : public init_base<init<> >
{
typedef init_base<init<> > base;
public:
typedef init<> self_t;
init(char const* doc_ = 0)
: doc(doc_) {}
: base(doc_)
{
}
template <class Keywords>
init(char const* doc_, Keywords const& kw)
: base(doc_, std::make_pair(kw.base(), kw.base() + Keywords::size))
{
}
char const* doc_string() const
{ return doc; }
default_call_policies
call_policies() const
{ return default_call_policies(); }
template <class Keywords>
init(Keywords const& kw)
: base(0, std::make_pair(kw.base(), kw.base() + Keywords::size))
{
}
template <class CallPoliciesT>
init_with_call_policies<CallPoliciesT, self_t>
operator[](CallPoliciesT const& policies) const
{ return init_with_call_policies<CallPoliciesT, self_t>(policies, doc); }
{
return init_with_call_policies<CallPoliciesT, self_t>(
policies, this->doc_string(), this->keywords());
}
BOOST_STATIC_CONSTANT(int, n_defaults = 0);
BOOST_STATIC_CONSTANT(int, n_arguments = 0);
typedef detail::type_list<> reversed_args;
char const* doc;
};
# endif
///////////////////////////////////////////////////////////////////////////////
//
@@ -261,7 +337,13 @@ struct optional
namespace detail
{
template <class ClassT, class CallPoliciesT, class ReversedArgs>
void def_init_reversed(ClassT& cl, ReversedArgs const&, CallPoliciesT const& policies, char const* doc)
void def_init_reversed(
ClassT& cl
, ReversedArgs const&
, CallPoliciesT const& policies
, char const* doc
, detail::keyword_range const& keywords_
)
{
typedef typename mpl::fold<
ReversedArgs
@@ -274,8 +356,9 @@ namespace detail
cl.def(
"__init__",
python::make_constructor<args>(
detail::make_keyword_range_constructor<args>(
policies
, keywords_
// Using runtime type selection works around a CWPro7 bug.
, holder_selector_t::execute((held_type_t*)0).get()
)
@@ -299,12 +382,20 @@ namespace detail
struct define_class_init_helper {
template <class ClassT, class CallPoliciesT, class ReversedArgs>
static void apply(ClassT& cl, CallPoliciesT const& policies, ReversedArgs const& args, char const* doc)
static void apply(
ClassT& cl
, CallPoliciesT const& policies
, ReversedArgs const& args
, char const* doc
, detail::keyword_range keywords)
{
def_init_reversed(cl, args, policies, doc);
def_init_reversed(cl, args, policies, doc, keywords);
if (keywords.second > keywords.first)
--keywords.second;
typename mpl::pop_front<ReversedArgs>::type next;
define_class_init_helper<N-1>::apply(cl, policies, next, doc);
define_class_init_helper<N-1>::apply(cl, policies, next, doc, keywords);
}
};
@@ -322,9 +413,14 @@ namespace detail
struct define_class_init_helper<0> {
template <class ClassT, class CallPoliciesT, class ReversedArgs>
static void apply(ClassT& cl, CallPoliciesT const& policies, ReversedArgs const& args, char const* doc)
static void apply(
ClassT& cl
, CallPoliciesT const& policies
, ReversedArgs const& args
, char const* doc
, detail::keyword_range const& keywords)
{
def_init_reversed(cl, args, policies, doc);
def_init_reversed(cl, args, policies, doc, keywords);
}
};
}
@@ -356,7 +452,7 @@ define_init(ClassT& cl, InitT const& i)
{
typedef typename InitT::reversed_args reversed_args;
detail::define_class_init_helper<InitT::n_defaults>::apply(
cl, i.call_policies(), reversed_args(), i.doc_string());
cl, i.call_policies(), reversed_args(), i.doc_string(), i.keywords());
}
}} // namespace boost::python

15
include/boost/python/make_function.hpp
View File

@@ -7,6 +7,7 @@
# define MAKE_FUNCTION_DWA20011221_HPP
# include <boost/python/object/function_object.hpp>
# include <boost/python/args_fwd.hpp>
# include <boost/python/object/make_holder.hpp>
# include <boost/python/detail/caller.hpp>
# include <boost/python/detail/arg_tuple_size.hpp>
@@ -32,6 +33,20 @@ object make_function(F f, Policies const& policies)
, detail::arg_tuple_size<F>::value);
}
template <class F, class Policies, class Keywords>
object make_function(F f, Policies const& policies, Keywords const& keywords)
{
enum { n_arguments = detail::arg_tuple_size<F>::value };
typedef typename detail::error::more_keywords_than_function_arguments<
Keywords::size, n_arguments
>::too_many_keywords assertion;
return objects::function_object(
::boost::bind<PyObject*>(detail::caller(), f, _1, _2, policies)
, n_arguments
, keywords.range());
}
template <class ArgList, class HolderGenerator>
object make_constructor(HolderGenerator* = 0, ArgList* = 0)
{

7
include/boost/python/module.hpp
View File

@@ -71,11 +71,12 @@ class module : public detail::module_base
char const* doc,
void const*)
{
typedef detail::def_helper<CallPolicyOrDoc> helper;
detail::def_helper<CallPolicyOrDoc,char const*> helper(policy_or_doc, doc);
this->setattr_doc(
name, boost::python::make_function(fn, helper::get_policy(policy_or_doc)),
helper::get_doc(policy_or_doc, doc));
name
, boost::python::make_function(fn, helper.policies())
, helper.doc());
}
template <typename StubsT, typename SigT>

16
include/boost/python/object/function.hpp
View File

@@ -7,6 +7,7 @@
# define FUNCTION_DWA20011214_HPP
# include <boost/python/detail/wrap_python.hpp>
# include <boost/python/args_fwd.hpp>
# include <boost/python/detail/config.hpp>
# include <boost/python/handle.hpp>
# include <boost/function/function2.hpp>
@@ -17,7 +18,13 @@ namespace boost { namespace python { namespace objects {
struct BOOST_PYTHON_DECL function : PyObject
{
function(py_function const&, unsigned min_args, unsigned max_args = 0);
function(
py_function const&
, unsigned min_arity
, unsigned max_arity
, python::detail::keyword const* names_and_defaults
, unsigned num_keywords);
~function();
PyObject* call(PyObject*, PyObject*) const;
@@ -42,11 +49,12 @@ struct BOOST_PYTHON_DECL function : PyObject
private: // data members
py_function m_fn;
unsigned m_min_args;
unsigned m_max_args;
unsigned m_min_arity;
unsigned m_max_arity;
handle<function> m_overloads;
object m_name;
object m_doc;
object m_arg_names;
};
//
@@ -66,7 +74,7 @@ inline object const& function::name() const
{
return this->m_name;
}
}}} // namespace boost::python::objects
#endif // FUNCTION_DWA20011214_HPP

33
include/boost/python/object/function_object.hpp
View File

@@ -8,17 +8,36 @@
# include <boost/python/detail/wrap_python.hpp>
# include <boost/function/function2.hpp>
# include <boost/python/object_core.hpp>
# include <boost/python/args_fwd.hpp>
# include <boost/python/object/py_function.hpp>
namespace boost { namespace python { namespace objects {
namespace boost { namespace python {
BOOST_PYTHON_DECL api::object function_object_impl(boost::function2<PyObject*, PyObject*, PyObject*> const& f, unsigned min_args, unsigned max_args = 0);
namespace objects
{
BOOST_PYTHON_DECL api::object function_object(
py_function const& f
, unsigned min_arity, unsigned max_arity
, python::detail::keyword_range const&);
template <class F>
inline object function_object(F const& f, unsigned min_args, unsigned max_args = 0)
{
return objects::function_object_impl(boost::function2<PyObject*, PyObject*, PyObject*>(f), min_args, max_args);
BOOST_PYTHON_DECL api::object function_object(
py_function const& f
, unsigned arity
, python::detail::keyword_range const&);
BOOST_PYTHON_DECL api::object function_object(py_function const& f, unsigned arity);
// Add an attribute to the name_space with the given name. If it is
// a Boost.Python function object
// (boost/python/object/function.hpp), and an existing function is
// already there, add it as an overload.
BOOST_PYTHON_DECL void add_to_namespace(
object const& name_space, char const* name, object const& attribute);
BOOST_PYTHON_DECL void add_to_namespace(
object const& name_space, char const* name, object const& attribute, char const* doc);
}
}}} // namespace boost::python::objects
}} // namespace boost::python::objects
#endif // FUNCTION_OBJECT_DWA2002725_HPP