preprocessor.hpp File Reference

#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/detail/is_nullary.hpp>
#include <boost/mpl/always.hpp>
#include <boost/mpl/apply_wrap.hpp>

Include dependency graph for preprocessor.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::parameter::aux::unwrap_predicate< Match >
struct	boost::parameter::aux::unwrap_predicate< void * >
struct	boost::parameter::aux::unwrap_predicate< void *(Predicate)>
struct	boost::parameter::aux::unwrap_predicate< void(Target)>
struct	boost::parameter::aux::match< Parameters, >
struct	boost::parameter::aux::argument_pack< Parameters, >

Namespaces
	boost
	Duration formatting facet for input.
	boost::parameter
	boost::parameter::aux

Macros
#define	BOOST_PARAMETER_IS_NULLARY(x)   BOOST_PP_IS_NULLARY(x)
#define	BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static   ()
#define	BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name)
#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)
#define	BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name)
#define	BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)
#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)
#define	BOOST_PARAMETER_ARITY_RANGE(args)
#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)
#define	BOOST_PARAMETER_FUNCTION_IS_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)
#define	BOOST_PARAMETER_FUNCTION_KEYWORD(x)
#define	BOOST_PARAMETER_FN_ARG_KEYWORD(x)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n)   template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)>
#define	BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n)
#define	BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base)
#define	BOOST_PARAMETER_FUNCTION_RESULT_NAME(base)
#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)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0(result, name, args, const_, combinations, range)
#define	BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result, name, args, const_, combinations)
#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>
#define	BOOST_PARAMETER_PREDICATE_TYPE(p)   void p
#define	BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r, tag_namespace, i, elem)
#define	BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args)
#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)
#define	BOOST_PARAMETER_FUNCTION_RESULT(result, name, args)   BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)
#define	BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name)
#define	BOOST_PARAMETER_FUNCTION_IMPL_FWD(name)   BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name);
#define	BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg)
#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)
#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)
#define	BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword)   BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg)   , BOOST_PARAMETER_FN_ARG_KEYWORD(arg)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg)
#define	BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX(name, split_args, skip_fwd_decl, const_, tag_namespace)
#define	BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns)
#define	BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_)
#define	BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args)
#define	BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args)
#define	BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem)   BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)
#define	BOOST_PARAMETER_PARENTHESIZED_BASE(x)   BOOST_PARAMETER_PARENTHESIZED_TYPE(x)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem)
#define	BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product)   (product)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_, base, args, combinations, range)
#define	BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_, base, args, combinations)
#define	BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args)
#define	BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args)
#define	BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem)
#define	BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args)   BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args)

Functions
template<class T >
T &	boost::parameter::aux::as_lvalue (T &value, long)
template<class T >
T const &	boost::parameter::aux::as_lvalue (T const &value, int)

Macro Definition Documentation

#define BOOST_PARAMETER_ARITY_RANGE

(

args

)

Value:

( \
        BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \
      , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \
    )

#define BOOST_PARAMETER_ARITY_RANGE_M	(		s,
			state,
			x
	)

Value:

BOOST_PP_CAT( \
        BOOST_PARAMETER_ARITY_RANGE_M_ \
      , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \
    )(state)

#define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional

(

state

)

state

#define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required

(

state

)

BOOST_PP_INC(state)

#define BOOST_PARAMETER_ARITY_RANGE_M_optional

(

state

)

state

#define BOOST_PARAMETER_ARITY_RANGE_M_required

(

state

)

BOOST_PP_INC(state)

#define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
        result, name, tag_namespace \
      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
      , 1 \
    )

#define BOOST_PARAMETER_BASIC_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_BASIC_FUNCTION_AUX(                                     \
        result, name, tag_namespace                                     \
      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args)                          \
    )                                                                   \

#define BOOST_PARAMETER_BASIC_FUNCTION_AUX	(		result,
			name,
			tag_namespace,
			args
	)

Value:

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_MEMBER_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
        result, name, tag_namespace \
      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
      , 0 \
    )

#define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX	(		result,
			name,
			tag_namespace,
			args,
			const_
	)

Value:

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_CONST_MEMBER_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                       \
        result, name, tag_namespace, 1                                     \
      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
    )                                                                    \

#define BOOST_PARAMETER_CONSTRUCTOR	(		class_,
			base,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_CONSTRUCTOR_AUX( \
        class_, base, tag_namespace \
      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
    )

#define BOOST_PARAMETER_CONSTRUCTOR_AUX	(		class_,
			base,
			tag_namespace,
			args
	)

Value:

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_FN_ARG_DEFAULT

(

x

)

BOOST_PP_TUPLE_ELEM(4,3,x)

#define BOOST_PARAMETER_FN_ARG_KEYWORD

(

x

)

Value:

BOOST_PARAMETER_FUNCTION_KEYWORD( \
        BOOST_PARAMETER_FN_ARG_NAME(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_QUALIFIER

(

x

)

BOOST_PP_TUPLE_ELEM(4,0,x)

#define BOOST_PARAMETER_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_FUNCTION_AUX(                                       \
        result, name, tag_namespace                                      \
      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
    )                                                                    \

#define BOOST_PARAMETER_FUNCTION_ARGUMENT	(		r,
			_,
			i,
			elem
	)		BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)

#define BOOST_PARAMETER_FUNCTION_AUX	(		result,
			name,
			tag_namespace,
			args
	)

Value:

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)

#define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS	(		macro,
			n,
			split_args
	)

Value:

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) \
        ) \
    )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT

(

arg

)

Value:

BOOST_PARAMETER_FUNCTION_CAST( \
        boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \
      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
      , Args \
    )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT	(		arg,
			tag_namespace
	)

Value:

boost::parameter::keyword< \
        tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
    >::instance | boost::parameter::aux::use_default_tag()

#define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY	(		name,
			n,
			split_args,
			tag_ns,
			const_
	)

#define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION	(		z,
			n,
			data
	)

Value:

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_FUNCTION0	(		z,
			n,
			data
	)

Value:

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_ARG	(		r,
			_,
			arg
	)

Value:

, 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_ARG_NAME

(

keyword

)

BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type)

#define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY	(		name,
			n,
			split_args,
			tag_namespace
	)

Value:

{ \
        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_FUNCTION_GET_ARG	(		arg,
			tag_ns
	)

Value:

BOOST_PARAMETER_FUNCTION_CAST( \
        args[ \
            BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \
                arg, tag_ns \
            ) \
        ] \
      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
      , Args \
    )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER	(		r,
			_,
			arg
	)		, BOOST_PARAMETER_FN_ARG_KEYWORD(arg)

#define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG	(		r,
			_,
			arg
	)

Value:

, class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \
              BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
      )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG	(		r,
			tag_ns,
			arg
	)

Value:

, BOOST_PARAMETER_FUNCTION_CAST( \
          args[ \
              boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
          ] \
        , BOOST_PARAMETER_FN_ARG_PRED(arg) \
        , Args \
      )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER	(		name,
			args,
			skip_fwd_decl,
			const_,
			tag_ns
	)

Value:

BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \
        name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \
    )

#define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX	(		name,
			split_args,
			skip_fwd_decl,
			const_,
			tag_namespace
	)

Value:

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)

#define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME

(

name

)

Value:

BOOST_PP_CAT( \
        boost_param_default_ \
      , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \
    )

#define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION	(		r,
			_,
			i,
			elem
	)

Value:

(BOOST_PP_IF( \
        BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
            BOOST_PARAMETER_FN_ARG_NAME(elem) \
        ) \
      , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \
      , (const ParameterArgumentType ## i) \
    ))

#define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS

(

args

)

BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args)

#define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR	(		z,
			n,
			data
	)

Value:

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_CONSTRUCTOR0	(		r,
			data,
			elem
	)

Value:

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_CONSTRUCTOR00	(		z,
			n,
			r,
			data,
			elem
	)

Value:

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_CONSTRUCTOR_ARITY_0	(		z,
			n,
			data
	)

Value:

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
	)

Value:

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_CONSTRUCTORS	(		class_,
			base,
			args,
			combinations
	)

Value:

BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \
        class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
    )

#define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0	(		class_,
			base,
			args,
			combinations,
			range
	)

Value:

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_FUNCTION	(		z,
			n,
			data
	)

Value:

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_FUNCTION0	(		r,
			data,
			elem
	)

Value:

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_FUNCTION00	(		z,
			n,
			r,
			data,
			elem
	)

#define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0	(		z,
			n,
			data
	)

Value:

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
	)

Value:

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_TEMPLATE_Z	(		z,
			n
	)		template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)>

#define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS	(		result,
			name,
			args,
			const_,
			combinations
	)

Value:

BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \
        result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
    )

#define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0	(		result,
			name,
			args,
			const_,
			combinations,
			range
	)

Value:

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_MATCH_Z	(		z,
			name,
			parameters,
			n
	)

Value:

, typename boost::parameter::aux::match< \
          parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \
      >::type = parameters()

#define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT	(		r,
			product
	)		(product)

#define BOOST_PARAMETER_FUNCTION_HEAD	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_FUNCTION_RESULT(result, name, args)                   \
                                                                            \
          BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args)    \
          BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name);                   \

#define BOOST_PARAMETER_FUNCTION_IMPL_FWD

(

name

)

BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name);

#define BOOST_PARAMETER_FUNCTION_IMPL_HEAD

(

name

)

Value:

template <class Args>                                   \
    typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<    \
       Args                                                 \
    >::type BOOST_PARAMETER_IMPL(name)(Args const& args)

#define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION	(		name,
			split_args,
			const_,
			tag_ns
	)

Value:

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) \
            ) \
 \
        ); \
    }

#define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER

(

x

)

Value:

BOOST_PP_IS_EMPTY( \
        BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \
    ) \

#define BOOST_PARAMETER_FUNCTION_KEYWORD

(

x

)

Value:

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_FUNCTION_KEYWORD_GET

(

x

)

BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x)

#define BOOST_PARAMETER_FUNCTION_PARAMETERS	(		tag_namespace,
			base,
			args
	)

Value:

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>

#define BOOST_PARAMETER_FUNCTION_PARAMETERS_M	(		r,
			tag_namespace,
			i,
			elem
	)

Value:

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 \
    >

#define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME

(

base

)

Value:

BOOST_PP_CAT( \
        boost_param_parameters_ \
      , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
    )

#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>

#define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional

(

tag

)

optional<tag

#define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required

(

tag

)

required<tag

#define BOOST_PARAMETER_FUNCTION_RESULT	(		result,
			name,
			args
	)		BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)

#define BOOST_PARAMETER_FUNCTION_RESULT_	(		result,
			name,
			args
	)

Value:

template <class Args>                                                                       \
    struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)                                           \
    {                                                                                           \
        typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type;                       \
    };

#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_NAME

(

base

)

Value:

BOOST_PP_CAT( \
        boost_param_result_ \
      , BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
    )

#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG	(		s,
			state,
			arg
	)

Value:

BOOST_PP_CAT( \
        BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \
      , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \
    )(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_deduced_required	(		state,
			arg
	)		BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg)

#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional	(		state,
			arg
	)

Value:

( \
        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_required	(		state,
			arg
	)

Value:

( \
        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_ARGS

(

args

)

Value:

BOOST_PP_SEQ_FOLD_LEFT( \
        BOOST_PARAMETER_FUNCTION_SPLIT_ARG \
      , (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \
      , args \
    )

#define BOOST_PARAMETER_IMPL

(

base

)

BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base))

#define BOOST_PARAMETER_IS_NULLARY

(

x

)

BOOST_PP_IS_NULLARY(x)

#define BOOST_PARAMETER_MEMBER_FUNCTION	(		result,
			name,
			tag_namespace,
			args
	)

Value:

BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                       \
        result, name, tag_namespace, 0                                     \
      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
    )                                                                    \

#define BOOST_PARAMETER_MEMBER_FUNCTION_AUX	(		result,
			name,
			tag_namespace,
			const_,
			args
	)

Value:

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)

#define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static   ()

#define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC

(

name

)

Value:

BOOST_PARAMETER_IS_NULLARY( \
        BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \
    )

#define BOOST_PARAMETER_MEMBER_FUNCTION_NAME

(

name

)

Value:

BOOST_PP_IF( \
        BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
      , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \
      , name BOOST_PP_TUPLE_EAT(1) \
    )(name)

#define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC

(

name

)

Value:

BOOST_PP_EXPR_IF( \
        BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
      , static \
    )

#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC

(

name

)

BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)

#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static

#define BOOST_PARAMETER_PARENTHESIZED_BASE

(

x

)

BOOST_PARAMETER_PARENTHESIZED_TYPE(x)

#define BOOST_PARAMETER_PREDICATE_TYPE

(

p

)

void p

#define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out

(

x

)

#define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out

(

x

)

#define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out

(

x

)

x

#define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out

(

x

)

x