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

Use preprocessor lib for caller.hpp

Browse Source 
[SVN r13435]
This commit is contained in:
Dave Abrahams
2002-04-10 17:30:34 +00:00
parent 558170582a
commit eab0a73f53
4 changed files with 350 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
include/boost/python/detail/arg_tuple_size.hpp
View File

@@ -12,11 +12,10 @@
# define ARG_TUPLE_SIZE_DWA20011201_HPP
# include <boost/config.hpp>
# include <boost/python/detail/char_array.hpp>
# include <boost/python/detail/preprocessor.hpp>
# include <boost/mpl/aux_/preprocessor.hpp>
# include <boost/python/detail/char_array.hpp>
# include <boost/preprocessor/comma_if.hpp>
# include <boost/preprocessor/list/for_each.hpp>
namespace boost { namespace python { namespace detail {
@@ -26,26 +25,26 @@ namespace boost { namespace python { namespace detail {
template <class F> struct arg_tuple_size;
// Include the pre-expanded version of the code
# if BOOST_PYTHON_DEBUGGABLE_ARITY
# ifndef BOOST_PYTHON_GENERATE_CODE
# include <boost/python/preprocessed/arg_tuple_size.hpp>
# endif
# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
// Specializations for function pointers
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PF(args, ignored) \
template <class R BOOST_PP_COMMA_IF(args) BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
struct arg_tuple_size<BOOST_PYTHON_PF(args)> \
{ \
BOOST_STATIC_CONSTANT(std::size_t, value = args); \
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PF(args, ignored) \
template <class R BOOST_PP_COMMA_IF(args) BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
struct arg_tuple_size<BOOST_PYTHON_PF(args)> \
{ \
BOOST_STATIC_CONSTANT(std::size_t, value = args); \
};
// Specializations for member function pointers
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PMF1(args, cv) \
template <class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
struct arg_tuple_size<BOOST_PYTHON_PMF(args,cv)> \
{ \
BOOST_STATIC_CONSTANT(std::size_t, value = args); \
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PMF(args, cv) \
template <class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
struct arg_tuple_size<BOOST_PYTHON_PMF(args,cv)> \
{ \
BOOST_STATIC_CONSTANT(std::size_t, value = args); \
};
# else
@@ -61,11 +60,11 @@ struct arg_tuple_size<BOOST_PYTHON_PMF(args,cv)> \
// their return value is used to discriminate between various free
// and member function pointers at compile-time.
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PF(args, ignored) \
template <class R BOOST_PP_COMMA_IF(args) BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PF(args, ignored) \
template <class R BOOST_PP_COMMA_IF(args) BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
char_array<args> arg_tuple_size_helper(BOOST_PYTHON_PF(args));
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PMF1(args, cv) \
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PMF(args, cv) \
template <class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)> \
char_array<args> arg_tuple_size_helper(BOOST_PYTHON_PMF(args,cv));
@@ -73,12 +72,9 @@ char_array<args> arg_tuple_size_helper(BOOST_PYTHON_PMF(args,cv));
BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_ARG_TUPLE_SIZE_PF, nil)
# define BOOST_PYTHON_ARG_TUPLE_SIZE_PMF(index, ignored, cv) \
BOOST_PYTHON_REPEAT_MF_ARITY_2ND(BOOST_PYTHON_ARG_TUPLE_SIZE_PMF1,cv)
// Generate a series for each cv-qualification
BOOST_PP_LIST_FOR_EACH(BOOST_PYTHON_ARG_TUPLE_SIZE_PMF,nil,BOOST_PYTHON_MEMBER_FUNCTION_CV)
// Generate a series for each cv-qualification
BOOST_PYTHON_REPEAT_MF_CV_2ND(BOOST_PYTHON_ARG_TUPLE_SIZE_PMF)
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(__BORLANDC__)
template <class F>
struct arg_tuple_size

214
include/boost/python/detail/caller.hpp
View File

@@ -11,6 +11,9 @@
# include <boost/mpl/select_type.hpp>
# include <boost/type_traits/composite_traits.hpp>
# include <boost/type_traits/same_traits.hpp>
# include <boost/python/detail/preprocessor.hpp>
# include <boost/mpl/aux_/preprocessor.hpp>
# include <boost/preprocessor/comma_if.hpp>
namespace boost { namespace python
{
@@ -23,192 +26,41 @@ struct caller
{
typedef PyObject* result_type;
template <class P, class R>
PyObject* operator()(R (*f)(), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
# ifndef BOOST_PYTHON_GENERATE_CODE
# include <boost/python/preprocessed/caller.hpp>
# endif
template <class P, class R, class A0>
PyObject* operator()(R (*f)(A0), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
# define BOOST_PYTHON_CALLER_PF(args_, ignored) \
template < \
class P \
, class R \
BOOST_PP_COMMA_IF(args_) BOOST_MPL_TEMPLATE_PARAMETERS(0, args_, class A) \
> \
PyObject* operator()( \
BOOST_PYTHON_NAMED_PF(f,args_) \
, PyObject* args, PyObject* keywords \
, P const& policies \
) const \
{ \
return returning<R>::call(f, args, keywords, policies); \
}
template <class P, class R, class A0, class A1>
PyObject* operator()(R (*f)(A0, A1), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2>
PyObject* operator()(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3>
PyObject* operator()(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4>
PyObject* operator()(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
PyObject* operator()(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CALLER_PF, nil)
// Member functions
template <class P, class R, class A0>
PyObject* operator()(R (A0::*f)(), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
# define BOOST_PYTHON_CALLER_PMF(args_, cv) \
template <class P, class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args_, class A)> \
PyObject* operator()( \
BOOST_PYTHON_NAMED_PMF(f,args_,cv) \
, PyObject* args, PyObject* keywords \
, P const& policies \
) const \
{ \
return returning<R>::call(f, args, keywords, policies); \
}
template <class P, class R, class A0, class A1>
PyObject* operator()(R (A0::*f)(A1), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2>
PyObject* operator()(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3>
PyObject* operator()(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0>
PyObject* operator()(R (A0::*f)() const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1>
PyObject* operator()(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2>
PyObject* operator()(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3>
PyObject* operator()(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0>
PyObject* operator()(R (A0::*f)() volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1>
PyObject* operator()(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2>
PyObject* operator()(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3>
PyObject* operator()(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0>
PyObject* operator()(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1>
PyObject* operator()(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2>
PyObject* operator()(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3>
PyObject* operator()(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
{
return returning<R>::call(f, args, keywords, policies);
}
BOOST_PYTHON_REPEAT_MF_ALL_CV_2ND(BOOST_PYTHON_CALLER_PMF)
};
}}} // namespace boost::python::detail

51
include/boost/python/detail/preprocessor.hpp
View File

@@ -8,9 +8,11 @@
# include <boost/config.hpp>
# include <boost/preprocessor/tuple/to_list.hpp>
# include <boost/preprocessor/list/for_each.hpp>
# include <boost/preprocessor/repeat_from_to_2nd.hpp>
# include <boost/preprocessor/inc.hpp>
# include <boost/preprocessor/empty.hpp>
# include <boost/preprocessor/expr_if.hpp>
namespace boost { namespace python { namespace detail {
@@ -18,15 +20,16 @@ namespace boost { namespace python { namespace detail {
# define BOOST_PYTHON_VOLATILE() volatile
# define BOOST_PYTHON_CONST_VOLATILE() const volatile
# if !defined(__MWERKS__) || __MWERKS__ > 0x2407
# define BOOST_PYTHON_MEMBER_FUNCTION_CV \
BOOST_PP_TUPLE_TO_LIST(4, (BOOST_PP_EMPTY \
, BOOST_PYTHON_CONST \
, BOOST_PYTHON_VOLATILE \
# define BOOST_PYTHON_ALL_CV \
BOOST_PP_TUPLE_TO_LIST(4, (BOOST_PP_EMPTY \
, BOOST_PYTHON_CONST \
, BOOST_PYTHON_VOLATILE \
, BOOST_PYTHON_CONST_VOLATILE))
# if !defined(__MWERKS__) || __MWERKS__ > 0x2407
# define BOOST_PYTHON_MEMBER_FUNCTION_CV BOOST_PYTHON_ALL_CV
# else
# define BOOST_PYTHON_MEMBER_FUNCTION_CV \
BOOST_PP_TUPLE_TO_LIST(1, (BOOST_PP_EMPTY))
# define BOOST_PYTHON_MEMBER_FUNCTION_CV BOOST_PP_TUPLE_TO_LIST(1, (BOOST_PP_EMPTY))
# endif
#ifndef BOOST_PYTHON_DEBUGGABLE_ARITY
@@ -58,14 +61,36 @@ namespace boost { namespace python { namespace detail {
# define BOOST_PYTHON_MF_ARITY_FINISH BOOST_PP_INC(BOOST_PYTHON_MAX_ARITY)
#endif
# define BOOST_PYTHON_PF(Count) R(*)(BOOST_MPL_TEMPLATE_PARAMETERS(0,Count,A))
# define BOOST_PYTHON_PMF(Count, cv) R(A0::*)(BOOST_MPL_TEMPLATE_PARAMETERS(1,Count,A))cv()
# define BOOST_PYTHON_NAMED_PF(f,Count) \
R(*f)(BOOST_MPL_TEMPLATE_PARAMETERS(0,Count,A))
# define BOOST_PYTHON_REPEAT_ARITY_2ND(function,data) \
BOOST_PP_REPEAT_FROM_TO_2ND(BOOST_PYTHON_ARITY_START, BOOST_PYTHON_ARITY_FINISH, function, data)
# define BOOST_PYTHON_NAMED_PMF(f, Count, cv) \
R(A0::*f)(BOOST_MPL_TEMPLATE_PARAMETERS(1,Count,A))cv()
# define BOOST_PYTHON_REPEAT_MF_ARITY_2ND(function,data) \
BOOST_PP_REPEAT_FROM_TO_2ND(BOOST_PYTHON_MF_ARITY_START, BOOST_PYTHON_MF_ARITY_FINISH, function, data)
# define BOOST_PYTHON_PF(Count) \
R(*)(BOOST_MPL_TEMPLATE_PARAMETERS(0,Count,A))
# define BOOST_PYTHON_PMF(Count, cv) \
R(A0::*)(BOOST_MPL_TEMPLATE_PARAMETERS(1,Count,A))cv()
# define BOOST_PYTHON_REPEAT_ARITY_2ND(function,data) \
BOOST_PP_REPEAT_FROM_TO_2ND( \
BOOST_PYTHON_ARITY_START, BOOST_PYTHON_ARITY_FINISH \
, function, data)
# define BOOST_PYTHON_REPEAT_MF_ARITY_2ND(function,data) \
BOOST_PP_REPEAT_FROM_TO_2ND( \
BOOST_PYTHON_MF_ARITY_START, BOOST_PYTHON_MF_ARITY_FINISH \
, function, data)
# define BOOST_PYTHON_REPEAT_PMF_CV(index, function, cv) \
BOOST_PYTHON_REPEAT_MF_ARITY_2ND(function,cv)
# define BOOST_PYTHON_REPEAT_MF_CV_2ND(function) \
BOOST_PP_LIST_FOR_EACH(BOOST_PYTHON_REPEAT_PMF_CV,function,BOOST_PYTHON_MEMBER_FUNCTION_CV)
# define BOOST_PYTHON_REPEAT_MF_ALL_CV_2ND(function) \
BOOST_PP_LIST_FOR_EACH(BOOST_PYTHON_REPEAT_PMF_CV,function,BOOST_PYTHON_ALL_CV)
}}} // namespace boost::python::detail

261
include/boost/python/preprocessed/caller.hpp Normal file
View File

@@ -0,0 +1,261 @@
// 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 CALLER_DWA2002410_HPP
# define CALLER_DWA2002410_HPP
template<class P,class R>
PyObject*operator()(R(*f)(),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0>
PyObject*operator()(R(*f)(A0),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1>
PyObject*operator()(R(*f)(A0,A1),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2>
PyObject*operator()(R(*f)(A0,A1,A2),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3>
PyObject*operator()(R(*f)(A0,A1,A2,A3),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4>
PyObject*operator()(R(*f)(A0,A1,A2,A3,A4),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5>
PyObject*operator()(R(*f)(A0,A1,A2,A3,A4,A5),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
PyObject*operator()(R(*f)(A0,A1,A2,A3,A4,A5,A6),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
PyObject*operator()(R(*f)(A0,A1,A2,A3,A4,A5,A6,A7),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
PyObject*operator()(R(*f)(A0,A1,A2,A3,A4,A5,A6,A7,A8),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0>
PyObject*operator()(R(A0::*f)(),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1>
PyObject*operator()(R(A0::*f)(A1),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2>
PyObject*operator()(R(A0::*f)(A1,A2),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3>
PyObject*operator()(R(A0::*f)(A1,A2,A3),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8,A9),PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0>
PyObject*operator()(R(A0::*f)()const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1>
PyObject*operator()(R(A0::*f)(A1)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2>
PyObject*operator()(R(A0::*f)(A1,A2)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3>
PyObject*operator()(R(A0::*f)(A1,A2,A3)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0>
PyObject*operator()(R(A0::*f)()volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1>
PyObject*operator()(R(A0::*f)(A1)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2>
PyObject*operator()(R(A0::*f)(A1,A2)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3>
PyObject*operator()(R(A0::*f)(A1,A2,A3)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8,A9)volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0>
PyObject*operator()(R(A0::*f)()const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1>
PyObject*operator()(R(A0::*f)(A1)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2>
PyObject*operator()(R(A0::*f)(A1,A2)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3>
PyObject*operator()(R(A0::*f)(A1,A2,A3)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
template<class P,class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
PyObject*operator()(R(A0::*f)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const volatile,PyObject*args,PyObject*keywords,P const&policies)const
{
return returning<R>::call(f,args,keywords,policies);
}
#endif // CALLER_DWA2002410_HPP