aux_/preprocessor/no_perfect_forwarding_begin.hpp

0001 // Copyright David Abrahams, Daniel Wallin 2003.
0002 // Copyright Cromwell D. Enage 2017.
0003 // Distributed under the Boost Software License, Version 1.0.
0004 // (See accompanying file LICENSE_1_0.txt or copy at
0005 // http://www.boost.org/LICENSE_1_0.txt)
0006
0007 // No include guard.  This file is intended for multiple inclusion.
0008
0009 #define BOOST_PARAMETER_right_angle(z, n, _) >
0010 /**/
0011
0012 #define BOOST_PARAMETER_satisfies_end(z, n, false_t) ,false_t>
0013 /**/
0014
0015 #include <boost/preprocessor/seq/elem.hpp>
0016 #include <boost/preprocessor/cat.hpp>
0017
0018 // Generates:
0019 //
0020 //   make<
0021 //       parameter_spec##0, argument_type##0
0022 //     , make<
0023 //           parameter_spec##1, argument_type##1
0024 //         , ... boost::mpl::identity<boost::parameter::aux::empty_arg_list>
0025 //    ...>
0026 //   >
0027 #define BOOST_PARAMETER_make_arg_list(z, n, names)                           \
0028     BOOST_PP_SEQ_ELEM(0, names)<                                             \
0029         BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n),                        \
0030         BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2, names), n),
0031 /**/
0032
0033 #include <boost/parameter/aux_/void.hpp>
0034 #include <boost/mpl/identity.hpp>
0035 #include <boost/preprocessor/repetition/repeat.hpp>
0036
0037 #define BOOST_PARAMETER_build_arg_list(n, make, param_spec, arg_type)        \
0038     BOOST_PP_REPEAT(                                                         \
0039         n, BOOST_PARAMETER_make_arg_list, (make)(param_spec)(arg_type)       \
0040     )                                                                        \
0041     ::boost::mpl::identity< ::boost::parameter::void_>                       \
0042     BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
0043 /**/
0044
0045 #define BOOST_PARAMETER_make_deduced_list(z, n, names)                       \
0046     BOOST_PP_SEQ_ELEM(0, names)<BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n),
0047 /**/
0048
0049 #define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec)          \
0050     BOOST_PP_REPEAT(                                                         \
0051         n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec)         \
0052     )                                                                        \
0053     ::boost::mpl::identity< ::boost::parameter::void_>                       \
0054     BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
0055 /**/
0056
0057 #define BOOST_PARAMETER_forward_typedef(z, n, names)                         \
0058     typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, names), n)                     \
0059     BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n);
0060 /**/
0061
0062 #define BOOST_PARAMETER_template_args(z, n, prefix)                          \
0063     typename BOOST_PP_CAT(prefix, n) = ::boost::parameter::void_
0064 /**/
0065
0066 #include <boost/mpl/pair.hpp>
0067
0068 #if (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY)
0069
0070 #include <boost/parameter/aux_/pack/item.hpp>
0071 #include <boost/preprocessor/control/iif.hpp>
0072
0073 #define BOOST_PARAMETER_make_arg_items_R(r, prefix, i, elem)                 \
0074     ::boost::parameter::aux::item<BOOST_PP_CAT(prefix, i),                   \
0075     BOOST_PP_CAT(A, i) BOOST_PP_IIF(elem, &, const&),
0076 /**/
0077
0078 #include <boost/parameter/aux_/pack/make_arg_list.hpp>
0079 #include <boost/parameter/aux_/pack/tag_keyword_arg.hpp>
0080 #include <boost/preprocessor/seq/for_each_i.hpp>
0081 #include <boost/preprocessor/seq/size.hpp>
0082
0083 #define BOOST_PARAMETER_function_call_arg_list_R(r, seq)                     \
0084     ::boost::parameter::aux::make_arg_list<                                  \
0085         BOOST_PP_SEQ_FOR_EACH_I_R(                                           \
0086             r, BOOST_PARAMETER_make_arg_items_R, PS, seq                     \
0087         )                                                                    \
0088         ::boost::parameter::void_                                            \
0089         BOOST_PP_REPEAT(                                                     \
0090             BOOST_PP_SEQ_SIZE(seq), BOOST_PARAMETER_right_angle, _           \
0091         )                                                                    \
0092       , deduced_list                                                         \
0093       , ::boost::parameter::aux::tag_keyword_arg                             \
0094     >
0095 /**/
0096
0097 #include <boost/preprocessor/arithmetic/sub.hpp>
0098
0099 #define BOOST_PARAMETER_function_call_arg_pack_init(z, n, limit)             \
0100     BOOST_PP_CAT(a, BOOST_PP_SUB(limit, n))
0101 /**/
0102
0103 #include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp>
0104 #include <boost/preprocessor/arithmetic/dec.hpp>
0105 #include <boost/preprocessor/facilities/intercept.hpp>
0106 #include <boost/preprocessor/repetition/enum.hpp>
0107 #include <boost/preprocessor/repetition/enum_params.hpp>
0108 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
0109 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
0110 #include <boost/preprocessor/seq/seq.hpp>
0111
0112 #define BOOST_PARAMETER_function_call_op_overload_R(r, seq)                  \
0113     template <                                                               \
0114         BOOST_PP_ENUM_PARAMS(                                                \
0115             BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))                             \
0116           , typename A                                                       \
0117         )                                                                    \
0118     >                                                                        \
0119     inline typename ::boost::mpl::first<                                     \
0120         typename BOOST_PARAMETER_function_call_arg_list_R(                   \
0121             r, BOOST_PP_SEQ_TAIL(seq)                                        \
0122         )::type                                                              \
0123     >::type                                                                  \
0124         operator()(                                                          \
0125             BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS(                       \
0126                 BOOST_PP_SEQ_TAIL(seq), (A)(a)                               \
0127             )                                                                \
0128         ) const                                                              \
0129     {                                                                        \
0130         typedef typename BOOST_PARAMETER_function_call_arg_list_R(           \
0131             r, BOOST_PP_SEQ_TAIL(seq)                                        \
0132         )::type result;                                                      \
0133         typedef typename ::boost::mpl::first<result>::type result_type;      \
0134         typedef typename ::boost::mpl::second<result>::type error;           \
0135         error();                                                             \
0136         return result_type(                                                  \
0137             BOOST_PP_ENUM(                                                   \
0138                 BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))                         \
0139               , BOOST_PARAMETER_function_call_arg_pack_init                  \
0140               , BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)))           \
0141             )                                                                \
0142             BOOST_PP_ENUM_TRAILING_PARAMS(                                   \
0143                 BOOST_PP_SUB(                                                \
0144                     BOOST_PARAMETER_COMPOSE_MAX_ARITY                        \
0145                   , BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))                     \
0146                 )                                                            \
0147               , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT \
0148             )                                                                \
0149         );                                                                   \
0150     }
0151 /**/
0152
0153 #endif  // exponential overloads
0154
0155 #include <boost/parameter/aux_/pack/satisfies.hpp>
0156 #include <boost/mpl/eval_if.hpp>
0157
0158 #define BOOST_PARAMETER_satisfies_begin(z, n, prefix)                        \
0159     ::boost::mpl::eval_if<                                                   \
0160         ::boost::parameter::aux::satisfies_requirements_of<                  \
0161             typename ::boost::mpl::first<ArgumentPackAndError>::type         \
0162           , BOOST_PP_CAT(prefix, n)                                          \
0163         >,
0164 /**/
0165