// Copyright Daniel Wallin 2006. Use, modification and distribution is | |
// subject to the Boost Software License, Version 1.0. (See accompanying | |
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
#ifndef BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |
# define BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |
# include <boost/parameter/parameters.hpp> | |
# include <boost/parameter/binding.hpp> | |
# include <boost/parameter/match.hpp> | |
# include <boost/parameter/aux_/parenthesized_type.hpp> | |
# include <boost/parameter/aux_/cast.hpp> | |
# include <boost/parameter/aux_/preprocessor/flatten.hpp> | |
# include <boost/preprocessor/repetition/repeat_from_to.hpp> | |
# include <boost/preprocessor/comparison/equal.hpp> | |
# include <boost/preprocessor/control/if.hpp> | |
# include <boost/preprocessor/control/iif.hpp> | |
# include <boost/preprocessor/control/expr_if.hpp> | |
# include <boost/preprocessor/repetition/enum_params.hpp> | |
# include <boost/preprocessor/repetition/enum_binary_params.hpp> | |
# include <boost/preprocessor/repetition/enum_trailing.hpp> | |
# include <boost/preprocessor/seq/first_n.hpp> | |
# include <boost/preprocessor/seq/for_each_product.hpp> | |
# include <boost/preprocessor/seq/for_each_i.hpp> | |
# include <boost/preprocessor/tuple/elem.hpp> | |
# include <boost/preprocessor/tuple/eat.hpp> | |
# include <boost/preprocessor/seq/fold_left.hpp> | |
# include <boost/preprocessor/seq/push_back.hpp> | |
# include <boost/preprocessor/seq/size.hpp> | |
# include <boost/preprocessor/seq/enum.hpp> | |
# include <boost/preprocessor/seq/push_back.hpp> | |
# include <boost/preprocessor/detail/is_nullary.hpp> | |
# include <boost/mpl/always.hpp> | |
# include <boost/mpl/apply_wrap.hpp> | |
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) | |
# include <boost/type.hpp> | |
# endif | |
namespace boost { namespace parameter { namespace aux { | |
# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
// Given Match, which is "void x" where x is an argument matching | |
// criterion, extract a corresponding MPL predicate. | |
template <class Match> | |
struct unwrap_predicate; | |
// Match anything | |
template <> | |
struct unwrap_predicate<void*> | |
{ | |
typedef mpl::always<mpl::true_> type; | |
}; | |
#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) | |
typedef void* voidstar; | |
// A matching predicate is explicitly specified | |
template <class Predicate> | |
struct unwrap_predicate<voidstar (Predicate)> | |
{ | |
typedef Predicate type; | |
}; | |
#else | |
// A matching predicate is explicitly specified | |
template <class Predicate> | |
struct unwrap_predicate<void *(Predicate)> | |
{ | |
typedef Predicate type; | |
}; | |
#endif | |
// A type to which the argument is supposed to be convertible is | |
// specified | |
template <class Target> | |
struct unwrap_predicate<void (Target)> | |
{ | |
typedef is_convertible<mpl::_, Target> type; | |
}; | |
// Recast the ParameterSpec's nested match metafunction as a free metafunction | |
template < | |
class Parameters | |
, BOOST_PP_ENUM_BINARY_PARAMS( | |
BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT | |
) | |
> | |
struct match | |
: Parameters::template match< | |
BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A) | |
> | |
{}; | |
# endif | |
# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) | |
// Function template argument deduction does many of the same things | |
// as type matching during partial specialization, so we call a | |
// function template to "store" T into the type memory addressed by | |
// void(*)(T). | |
template <class T> | |
msvc_store_type<T,void*(*)(void**(T))> | |
msvc_store_predicate_type(void*(*)(void**(T))); | |
template <class T> | |
msvc_store_type<boost::is_convertible<mpl::_,T>,void*(*)(void*(T))> | |
msvc_store_predicate_type(void*(*)(void*(T))); | |
template <class FunctionType> | |
struct unwrap_predicate | |
{ | |
static FunctionType f; | |
// We don't want the function to be evaluated, just instantiated, | |
// so protect it inside of sizeof. | |
enum { dummy = sizeof(msvc_store_predicate_type(f)) }; | |
// Now pull the type out of the instantiated base class | |
typedef typename msvc_type_memory<FunctionType>::storage::type type; | |
}; | |
template <> | |
struct unwrap_predicate<void*(*)(void**)> | |
{ | |
typedef mpl::always<mpl::true_> type; | |
}; | |
# endif | |
# undef false_ | |
template < | |
class Parameters | |
, BOOST_PP_ENUM_BINARY_PARAMS( | |
BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT | |
) | |
> | |
struct argument_pack | |
{ | |
typedef typename make_arg_list< | |
typename BOOST_PARAMETER_build_arg_list( | |
BOOST_PARAMETER_MAX_ARITY, make_items, typename Parameters::parameter_spec, A | |
)::type | |
, typename Parameters::deduced_list | |
, tag_keyword_arg | |
, mpl::false_ | |
>::type result; | |
typedef typename mpl::first<result>::type type; | |
}; | |
# if 1 //BOOST_WORKAROUND(BOOST_MSVC, < 1300) | |
// Works around VC6 problem where it won't accept rvalues. | |
template <class T> | |
T& as_lvalue(T& value, long) | |
{ | |
return value; | |
} | |
template <class T> | |
T const& as_lvalue(T const& value, int) | |
{ | |
return value; | |
} | |
# endif | |
# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \ | |
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
template <class Predicate, class T, class Args> | |
struct apply_predicate | |
{ | |
BOOST_MPL_ASSERT(( | |
mpl::and_<mpl::false_,T> | |
)); | |
typedef typename mpl::if_< | |
typename mpl::apply2<Predicate,T,Args>::type | |
, char | |
, int | |
>::type type; | |
}; | |
template <class P> | |
struct funptr_predicate | |
{ | |
static P p; | |
template <class T, class Args, class P0> | |
static typename apply_predicate<P0,T,Args>::type | |
check_predicate(type<T>, Args*, void**(*)(P0)); | |
template <class T, class Args, class P0> | |
static typename mpl::if_< | |
is_convertible<T,P0> | |
, char | |
, int | |
>::type check_predicate(type<T>, Args*, void*(*)(P0)); | |
template <class T, class Args> | |
struct apply | |
{ | |
BOOST_STATIC_CONSTANT(bool, result = | |
sizeof(check_predicate(boost::type<T>(), (Args*)0, &p)) == 1 | |
); | |
typedef mpl::bool_<apply<T,Args>::result> type; | |
}; | |
}; | |
template <> | |
struct funptr_predicate<void**> | |
: mpl::always<mpl::true_> | |
{}; | |
# endif | |
}}} // namespace boost::parameter::aux | |
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
// From Paul Mensonides | |
# define BOOST_PARAMETER_IS_NULLARY(x) \ | |
BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) \ | |
/**/ | |
# define BOOST_PARAMETER_IS_NULLARY_C() \ | |
~, 1 BOOST_PP_RPAREN() \ | |
BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \ | |
/**/ | |
# else | |
# define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x) | |
# endif | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static () | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
BOOST_PARAMETER_IS_NULLARY( \ | |
BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \ | |
) | |
# if !defined(BOOST_MSVC) | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ | |
BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name) | |
# else | |
// Workaround for MSVC preprocessor. | |
// | |
// When stripping static from "static f", msvc will produce | |
// " f". The leading whitespace doesn't go away when pasting | |
// the token with something else, so this thing is a hack to | |
// strip the whitespace. | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static ( | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ | |
BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)) | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ | |
BOOST_PP_SEQ_HEAD( \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ | |
) | |
# endif | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
BOOST_PP_EXPR_IF( \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
, static \ | |
) | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \ | |
BOOST_PP_IF( \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
, BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \ | |
, name BOOST_PP_TUPLE_EAT(1) \ | |
)(name) | |
// Calculates [begin, end) arity range. | |
# define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state | |
# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state | |
# define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state) | |
# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) BOOST_PP_INC(state) | |
# define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \ | |
BOOST_PP_CAT( \ | |
BOOST_PARAMETER_ARITY_RANGE_M_ \ | |
, BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ | |
)(state) | |
/**/ | |
# define BOOST_PARAMETER_ARITY_RANGE(args) \ | |
( \ | |
BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \ | |
, BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \ | |
) | |
/**/ | |
// Accessor macros for the argument specs tuple. | |
# define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ | |
BOOST_PP_TUPLE_ELEM(4,0,x) | |
/**/ | |
# define BOOST_PARAMETER_FN_ARG_NAME(x) \ | |
BOOST_PP_TUPLE_ELEM(4,1,x) | |
/**/ | |
# define BOOST_PARAMETER_FN_ARG_PRED(x) \ | |
BOOST_PP_TUPLE_ELEM(4,2,x) | |
/**/ | |
# define BOOST_PARAMETER_FN_ARG_DEFAULT(x) \ | |
BOOST_PP_TUPLE_ELEM(4,3,x) | |
/**/ | |
# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out(x) | |
# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out(x) | |
// Returns 1 if x is either "out(k)" or "in_out(k)". | |
# define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ | |
BOOST_PP_IS_EMPTY( \ | |
BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \ | |
) \ | |
/**/ | |
# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out(x) x | |
# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out(x) x | |
# define BOOST_PARAMETER_FUNCTION_KEYWORD_GET(x) \ | |
BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x) | |
/**/ | |
// Returns the keyword of x, where x is either a keyword qualifier | |
// or a keyword. | |
// | |
// k => k | |
// out(k) => k | |
// in_out(k) => k | |
// | |
# define BOOST_PARAMETER_FUNCTION_KEYWORD(x) \ | |
BOOST_PP_IF( \ | |
BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ | |
, BOOST_PARAMETER_FUNCTION_KEYWORD_GET \ | |
, x BOOST_PP_TUPLE_EAT(1) \ | |
)(x) | |
/**/ | |
# define BOOST_PARAMETER_FN_ARG_KEYWORD(x) \ | |
BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
BOOST_PARAMETER_FN_ARG_NAME(x) \ | |
) | |
// Builds forwarding functions. | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n) \ | |
template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)> | |
/**/ | |
# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \ | |
, typename boost::parameter::aux::match< \ | |
parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \ | |
>::type = parameters() | |
# else | |
# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) | |
# endif | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base) \ | |
BOOST_PP_CAT( \ | |
boost_param_parameters_ \ | |
, BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ | |
) | |
// Produce a name for a result type metafunction for the function | |
// named base | |
# define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base) \ | |
BOOST_PP_CAT( \ | |
boost_param_result_ \ | |
, BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ | |
) | |
// Can't do boost_param_impl_ ## basee because base might start with an underscore | |
// daniel: what? how is that relevant? the reason for using CAT() is to make sure | |
// base is expanded. i'm not sure we need to here, but it's more stable to do it. | |
# define BOOST_PARAMETER_IMPL(base) \ | |
BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00(z, n, r, data, elem) \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ | |
)(z,n) \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
inline \ | |
BOOST_PP_EXPR_IF(n, typename) \ | |
BOOST_PARAMETER_FUNCTION_RESULT_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))< \ | |
BOOST_PP_EXPR_IF(n, typename) \ | |
boost::parameter::aux::argument_pack< \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
BOOST_PP_COMMA_IF(n) \ | |
BOOST_PP_IF( \ | |
n, BOOST_PP_SEQ_ENUM, BOOST_PP_TUPLE_EAT(1) \ | |
)(elem) \ | |
>::type \ | |
>::type \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))( \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PP_SEQ_FOR_EACH_I_R \ | |
, BOOST_PP_TUPLE_EAT(4) \ | |
)( \ | |
r \ | |
, BOOST_PARAMETER_FUNCTION_ARGUMENT \ | |
, ~ \ | |
, elem \ | |
) \ | |
BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ | |
z \ | |
, BOOST_PP_TUPLE_ELEM(7,3,data) \ | |
, BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
, n \ | |
) \ | |
) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(7,4,data), const) \ | |
{ \ | |
return BOOST_PARAMETER_IMPL(BOOST_PP_TUPLE_ELEM(7,3,data))( \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))()( \ | |
BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ | |
) \ | |
); \ | |
} | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem) \ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ | |
BOOST_PP_TUPLE_ELEM(7,0,data) \ | |
, BOOST_PP_TUPLE_ELEM(7,1,data) \ | |
, r \ | |
, data \ | |
, elem \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data) \ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ | |
z, n, BOOST_PP_DEDUCE_R() \ | |
, (z, n, BOOST_PP_TUPLE_REM(5) data) \ | |
, ~ \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data) \ | |
BOOST_PP_SEQ_FOR_EACH( \ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0 \ | |
, (z, n, BOOST_PP_TUPLE_REM(5) data) \ | |
, BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ | |
BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ | |
, BOOST_PP_SEQ_FIRST_N( \ | |
n, BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
) \ | |
) \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data) \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N \ | |
, BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0 \ | |
)(z,n,data) \ | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ | |
result,name,args,const_,combinations,range \ | |
) \ | |
BOOST_PP_REPEAT_FROM_TO( \ | |
BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ | |
, BOOST_PARAMETER_FUNCTION_FWD_FUNCTION \ | |
, (result,name,const_,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result,name,args, const_, combinations) \ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ | |
result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ | |
) | |
/**/ | |
// Builds boost::parameter::parameters<> specialization | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional(tag) \ | |
optional<tag | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required(tag) \ | |
required<tag | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_optional(tag) \ | |
optional<boost::parameter::deduced<tag> | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \ | |
required<boost::parameter::deduced<tag> | |
# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) | |
# define BOOST_PARAMETER_PREDICATE_TYPE(p) void*(*) (void* p) | |
# else | |
# define BOOST_PARAMETER_PREDICATE_TYPE(p) void p | |
# endif | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
boost::parameter::BOOST_PP_CAT( \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ | |
, BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ | |
)( \ | |
tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ | |
) \ | |
) \ | |
, typename boost::parameter::aux::unwrap_predicate< \ | |
BOOST_PARAMETER_PREDICATE_TYPE(BOOST_PARAMETER_FN_ARG_PRED(elem)) \ | |
>::type \ | |
> | |
# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300) | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
boost::parameter::BOOST_PP_CAT( \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ | |
, BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ | |
)( \ | |
tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ | |
) \ | |
) \ | |
, boost::parameter::aux::funptr_predicate< \ | |
void* BOOST_PARAMETER_FN_ARG_PRED(elem) \ | |
> \ | |
> | |
# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
boost::parameter::BOOST_PP_CAT( \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ | |
, BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ | |
)( \ | |
tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ | |
) \ | |
) \ | |
, boost::mpl::always<boost::mpl::true_> \ | |
> | |
# endif | |
# define BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args) \ | |
template <class BoostParameterDummy> \ | |
struct BOOST_PP_CAT( \ | |
BOOST_PP_CAT(boost_param_params_, __LINE__) \ | |
, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ | |
) : boost::parameter::parameters< \ | |
BOOST_PP_SEQ_FOR_EACH_I( \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_M, tag_namespace, args \ | |
) \ | |
> \ | |
{}; \ | |
\ | |
typedef BOOST_PP_CAT( \ | |
BOOST_PP_CAT(boost_param_params_, __LINE__) \ | |
, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ | |
)<int> | |
// Defines result type metafunction | |
# define BOOST_PARAMETER_FUNCTION_RESULT_ARG(z, _, i, x) \ | |
BOOST_PP_COMMA_IF(i) class BOOST_PP_TUPLE_ELEM(3,1,x) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ | |
template <class Args> \ | |
struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name) \ | |
{ \ | |
typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type; \ | |
}; | |
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) | |
# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \ | |
BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ | |
template <> \ | |
struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<int> \ | |
{ typedef int type; }; | |
# else | |
# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \ | |
BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) | |
# endif | |
// Defines implementation function | |
# define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) \ | |
template <class Args> \ | |
typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)< \ | |
Args \ | |
>::type BOOST_PARAMETER_IMPL(name)(Args const& args) | |
# define BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ | |
BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) \ | |
( \ | |
BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 0, state)) \ | |
, BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 1, state), arg) \ | |
, BOOST_PP_TUPLE_ELEM(4, 2, state) \ | |
, BOOST_PP_TUPLE_ELEM(4, 3, state) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(state, arg) \ | |
BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) \ | |
( \ | |
BOOST_PP_TUPLE_ELEM(4, 0, state) \ | |
, BOOST_PP_TUPLE_ELEM(4, 1, state) \ | |
, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, state)) \ | |
, BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 3, state), arg) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(state, arg) \ | |
BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, state, arg) \ | |
BOOST_PP_CAT( \ | |
BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \ | |
, BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \ | |
)(state, arg) | |
// Returns (required_count, required, optional_count, optionals) tuple | |
# define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \ | |
BOOST_PP_SEQ_FOLD_LEFT( \ | |
BOOST_PARAMETER_FUNCTION_SPLIT_ARG \ | |
, (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \ | |
, args \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword) \ | |
BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type) | |
// Helpers used as parameters to BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg) \ | |
, class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ | |
BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ | |
BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
)& BOOST_PARAMETER_FN_ARG_KEYWORD(arg) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg) \ | |
, BOOST_PARAMETER_FN_ARG_KEYWORD(arg) | |
// Produces a name for the dispatch functions. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name) \ | |
BOOST_PP_CAT( \ | |
boost_param_default_ \ | |
, BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \ | |
) | |
// Helper macro used below to produce lists based on the keyword argument | |
// names. macro is applied to every element. n is the number of | |
// optional arguments that should be included. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args) \ | |
BOOST_PP_SEQ_FOR_EACH( \ | |
macro \ | |
, ~ \ | |
, BOOST_PP_TUPLE_ELEM(4,1,split_args) \ | |
) \ | |
BOOST_PP_SEQ_FOR_EACH( \ | |
macro \ | |
, ~ \ | |
, BOOST_PP_SEQ_FIRST_N( \ | |
BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ | |
, BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
) \ | |
) | |
// Generates a keyword | default expression. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \ | |
boost::parameter::keyword< \ | |
tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
>::instance | boost::parameter::aux::use_default_tag() | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \ | |
BOOST_PARAMETER_FUNCTION_CAST( \ | |
args[ \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \ | |
arg, tag_ns \ | |
) \ | |
] \ | |
, BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \ | |
{ \ | |
return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
(ResultType(*)())0 \ | |
, args \ | |
, 0L \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ | |
, n \ | |
, split_args \ | |
) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG( \ | |
BOOST_PP_SEQ_ELEM( \ | |
BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ | |
, BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
) \ | |
, tag_namespace \ | |
) \ | |
); \ | |
} | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg) \ | |
BOOST_PARAMETER_FUNCTION_CAST( \ | |
boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \ | |
, BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \ | |
template < \ | |
class ResultType \ | |
, class Args \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
, BOOST_PP_INC(n) \ | |
, split_args \ | |
) \ | |
> \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
ResultType(*)() \ | |
, Args const& args \ | |
, long \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
, BOOST_PP_INC(n) \ | |
, split_args \ | |
) \ | |
, boost::parameter::aux::use_default_tag \ | |
) BOOST_PP_EXPR_IF(const_, const) \ | |
{ \ | |
return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
(ResultType(*)())0 \ | |
, args \ | |
, 0L \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ | |
, BOOST_PP_INC(n) \ | |
, split_args \ | |
) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT( \ | |
BOOST_PP_SEQ_ELEM( \ | |
BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), BOOST_PP_INC(n)) \ | |
, BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
) \ | |
) \ | |
); \ | |
} | |
// Produces a forwarding layer in the default evaluation machine. | |
// | |
// data is a tuple: | |
// | |
// (name, split_args) | |
// | |
// Where name is the base name of the function, and split_args is a tuple: | |
// | |
// (required_count, required_args, optional_count, required_args) | |
// | |
// defines the actual function body for BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION below. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data) \ | |
template < \ | |
class ResultType \ | |
, class Args \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
, n \ | |
, BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
) \ | |
> \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(5,0,data)) \ | |
ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(BOOST_PP_TUPLE_ELEM(5,0,data))( \ | |
ResultType(*)() \ | |
, Args const& args \ | |
, int \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
, n \ | |
, BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
) \ | |
) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(5,2,data), const) \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY \ | |
, ; BOOST_PP_TUPLE_EAT(4) \ | |
)( \ | |
BOOST_PP_TUPLE_ELEM(5,0,data) \ | |
, n \ | |
, BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
, BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data) \ | |
BOOST_PP_IF( \ | |
BOOST_PP_AND( \ | |
BOOST_PP_NOT(n) \ | |
, BOOST_PP_TUPLE_ELEM(5,4,data) \ | |
) \ | |
, BOOST_PP_TUPLE_EAT(3) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0 \ | |
)(z, n, data) \ | |
BOOST_PP_IF( \ | |
BOOST_PP_EQUAL(n, BOOST_PP_TUPLE_ELEM(4,2,BOOST_PP_TUPLE_ELEM(5,1,data))) \ | |
, BOOST_PP_TUPLE_EAT(5) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY \ | |
)( \ | |
BOOST_PP_TUPLE_ELEM(5,0,data) \ | |
, n \ | |
, BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
, BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
, BOOST_PP_TUPLE_ELEM(5,2,data) \ | |
) | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \ | |
, BOOST_PARAMETER_FUNCTION_CAST( \ | |
args[ \ | |
boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \ | |
] \ | |
, BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
) | |
// Generates the function template that recives a ArgumentPack, and then | |
// goes on to call the layers of overloads generated by | |
// BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER. | |
# define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns) \ | |
template <class Args> \ | |
typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
BOOST_PARAMETER_IMPL(name)(Args const& args) BOOST_PP_EXPR_IF(const_, const) \ | |
{ \ | |
return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
(typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type(*)())0 \ | |
, args \ | |
, 0L \ | |
\ | |
BOOST_PP_SEQ_FOR_EACH( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG \ | |
, tag_ns \ | |
, BOOST_PP_TUPLE_ELEM(4,1,split_args) \ | |
) \ | |
\ | |
); \ | |
} | |
// Helper for BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER below. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ | |
name, split_args, skip_fwd_decl, const_, tag_namespace \ | |
) \ | |
BOOST_PP_REPEAT_FROM_TO( \ | |
0 \ | |
, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, split_args)) \ | |
, BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION \ | |
, (name, split_args, const_, tag_namespace, skip_fwd_decl) \ | |
) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_namespace) \ | |
\ | |
template < \ | |
class ResultType \ | |
, class Args \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
, 0 \ | |
, split_args \ | |
) \ | |
> \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
ResultType(*)() \ | |
, Args const& args \ | |
, int \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
, 0 \ | |
, split_args \ | |
) \ | |
) BOOST_PP_EXPR_IF(const_, const) | |
// Generates a bunch of forwarding functions that each extract | |
// one more argument. | |
# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns) \ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ | |
name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \ | |
) | |
/**/ | |
// Defines the result metafunction and the parameters specialization. | |
# define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args) \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name); \ | |
// Helper for BOOST_PARAMETER_FUNCTION below. | |
# define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); \ | |
\ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
result, name, args, 0 \ | |
, BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 0, 0, tag_namespace) | |
// Defines a Boost.Parameter enabled function with the new syntax. | |
# define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_AUX( \ | |
result, name, tag_namespace \ | |
, BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
) \ | |
/**/ | |
// Defines a Boost.Parameter enabled function. | |
# define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
result, name, args, 0 \ | |
, BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) | |
# define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_BASIC_FUNCTION_AUX( \ | |
result, name, tag_namespace \ | |
, BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
) \ | |
/**/ | |
// Defines a Boost.Parameter enabled member function. | |
# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_) \ | |
BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
result, name, args, const_ \ | |
, BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) BOOST_PP_EXPR_IF(const_, const) \ | |
/**/ | |
# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ | |
result, name, tag_namespace \ | |
, BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
, 0 \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ | |
result, name, tag_namespace \ | |
, BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
, 1 \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args) \ | |
BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
result, name, args, const_ \ | |
, BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
) \ | |
\ | |
BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 1, const_, tag_namespace) | |
// Defines a Boost.Parameter enabled function with the new syntax. | |
# define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ | |
result, name, tag_namespace, 0 \ | |
, BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
) \ | |
/**/ | |
# define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ | |
result, name, tag_namespace, 1 \ | |
, BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
) \ | |
/**/ | |
// Defines a Boost.Parameter enabled constructor. | |
# define BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem) \ | |
BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i) | |
/**/ | |
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) | |
// Older MSVC can't do what's necessary to handle commas in base names; just | |
// use a typedef instead if you have a base name that contains commas. | |
# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PP_SEQ_HEAD(x) | |
# else | |
# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PARAMETER_PARENTHESIZED_TYPE(x) | |
# endif | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ | |
)(z, n) \ | |
BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n,1), explicit) \ | |
BOOST_PP_TUPLE_ELEM(6,2,data)( \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PP_SEQ_FOR_EACH_I_R \ | |
, BOOST_PP_TUPLE_EAT(4) \ | |
)( \ | |
r \ | |
, BOOST_PARAMETER_FUNCTION_ARGUMENT \ | |
, ~ \ | |
, elem \ | |
) \ | |
BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ | |
z \ | |
, BOOST_PP_TUPLE_ELEM(6,3,data) \ | |
, BOOST_PP_CAT(constructor_parameters, __LINE__) \ | |
, n \ | |
) \ | |
) \ | |
: BOOST_PARAMETER_PARENTHESIZED_BASE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \ | |
BOOST_PP_CAT(constructor_parameters, __LINE__)()( \ | |
BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ | |
) \ | |
) \ | |
{} | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem) \ | |
BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ | |
BOOST_PP_TUPLE_ELEM(6,0,data) \ | |
, BOOST_PP_TUPLE_ELEM(6,1,data) \ | |
, r \ | |
, data \ | |
, elem \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product) \ | |
(product) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data) \ | |
BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ | |
z, n, BOOST_PP_DEDUCE_R() \ | |
, (z, n, BOOST_PP_TUPLE_REM(4) data) \ | |
, ~ \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data) \ | |
BOOST_PP_SEQ_FOR_EACH( \ | |
BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0 \ | |
, (z, n, BOOST_PP_TUPLE_REM(4) data) \ | |
, BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ | |
BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ | |
, BOOST_PP_SEQ_FIRST_N( \ | |
n, BOOST_PP_TUPLE_ELEM(4,2,data) \ | |
) \ | |
) \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data) \ | |
BOOST_PP_IF( \ | |
n \ | |
, BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N \ | |
, BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0 \ | |
)(z,n,data) \ | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_,base,args,combinations,range) \ | |
BOOST_PP_REPEAT_FROM_TO( \ | |
BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ | |
, BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR \ | |
, (class_,base,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_,base,args,combinations) \ | |
BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \ | |
class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ | |
) | |
/**/ | |
# define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \ | |
BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, ctor, args) \ | |
BOOST_PP_CAT(constructor_parameters, __LINE__); \ | |
\ | |
BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS( \ | |
class_, base, args \ | |
, BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
) \ | |
/**/ | |
# define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \ | |
BOOST_PARAMETER_CONSTRUCTOR_AUX( \ | |
class_, base, tag_namespace \ | |
, BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
) | |
/**/ | |
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ | |
(BOOST_PP_IF( \ | |
BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ | |
BOOST_PARAMETER_FN_ARG_NAME(elem) \ | |
) \ | |
, (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \ | |
, (const ParameterArgumentType ## i) \ | |
)) | |
// MSVC6.5 lets us bind rvalues to T&. | |
# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300) | |
# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ | |
(BOOST_PP_IF( \ | |
BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ | |
BOOST_PARAMETER_FN_ARG_NAME(elem) \ | |
) \ | |
, (ParameterArgumentType ## i) \ | |
, (const ParameterArgumentType ## i) \ | |
)) | |
// No partial ordering. This feature doesn't work. | |
// This is exactly the same as for VC6.5, but we might change it later. | |
# else | |
# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ | |
(BOOST_PP_IF( \ | |
BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ | |
BOOST_PARAMETER_FN_ARG_NAME(elem) \ | |
) \ | |
, (ParameterArgumentType ## i) \ | |
, (const ParameterArgumentType ## i) \ | |
)) | |
# endif | |
# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args) | |
#endif // BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |