support/detail/iterate_define.hpp

0001 /*==============================================================================
0002     Copyright (c) 2010 Thomas Heller
0003
0004     Distributed under the Boost Software License, Version 1.0. (See accompanying
0005     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0006 ==============================================================================*/
0007
0008 #if !BOOST_PHOENIX_IS_ITERATING
0009
0010 #define BOOST_PHOENIX_typename_A(N)                                             \
0011     BOOST_PP_ENUM_PARAMS(N, typename A)                                         \
0012 /**/
0013
0014 #define BOOST_PHOENIX_typename_A_void(N)                                        \
0015     BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(N, typename A, void)                    \
0016 /**/
0017
0018 #define BOOST_PHOENIX_A(N)                                                      \
0019     BOOST_PP_ENUM_PARAMS(N, A)                                                  \
0020 /**/
0021
0022 #define BOOST_PHOENIX_A_ref(N)                                                  \
0023     BOOST_PP_ENUM_BINARY_PARAMS(N, A, & BOOST_PP_INTERCEPT)                     \
0024 /**/
0025
0026 #define BOOST_PHOENIX_A_const_ref(N)                                            \
0027     BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& BOOST_PP_INTERCEPT)                \
0028 /**/
0029
0030 #define BOOST_PHOENIX_A_a(N)                                                    \
0031     BOOST_PP_ENUM_BINARY_PARAMS(N, A, a)                                        \
0032 /**/
0033
0034 #define BOOST_PHOENIX_A_ref_a(N)                                                \
0035     BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)                                      \
0036 /**/
0037
0038 #define BOOST_PHOENIX_A_const_ref_a(N)                                          \
0039     BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a)                                 \
0040 /**/
0041
0042 #define BOOST_PHOENIX_a(N)                                                      \
0043     BOOST_PP_ENUM_PARAMS(N, a)                                                  \
0044 /**/
0045
0046 #else
0047
0048 #include <boost/preprocessor/repetition/repeat.hpp>
0049 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
0050 #include <boost/preprocessor/repetition/enum_params.hpp>
0051 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
0052 #include <boost/preprocessor/seq/elem.hpp>
0053 #include <boost/preprocessor/seq/enum.hpp>
0054 #include <boost/preprocessor/seq/for_each_i.hpp>
0055 #include <boost/preprocessor/seq/for_each_product.hpp>
0056 #include <boost/preprocessor/seq/size.hpp>
0057 #include <boost/preprocessor/tuple/elem.hpp>
0058
0059 #define BOOST_PHOENIX_ITERATION                                                 \
0060     BOOST_PP_ITERATION()                                                        \
0061 /**/
0062
0063 #define BOOST_PHOENIX_typename_A                                                \
0064     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename A)                   \
0065 /**/
0066
0067 #define BOOST_PHOENIX_typename_A_void                                           \
0068     BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PHOENIX_ITERATION, typename A, void)
0069 /**/
0070
0071 #define BOOST_PHOENIX_A                                                          \
0072     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, A)                             \
0073 /**/
0074
0075 #define BOOST_PHOENIX_A_ref                                                      \
0076     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, & BOOST_PP_INTERCEPT)\
0077 /**/
0078
0079 #define BOOST_PHOENIX_A_const_ref                                                \
0080     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, const& BOOST_PP_INTERCEPT)\
0081 /**/
0082
0083 #define BOOST_PHOENIX_A_a                                                        \
0084     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, a)                   \
0085 /**/
0086
0087 #define BOOST_PHOENIX_A_ref_a                                                    \
0088     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, & a)                 \
0089 /**/
0090
0091 #define BOOST_PHOENIX_A_const_ref_a                                              \
0092     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, const& a)            \
0093 /**/
0094
0095 #define BOOST_PHOENIX_a                                                          \
0096     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, a)                             \
0097 /**/
0098
0099     /////////////////////////////////////////////////////////////////////////////
0100     // Begin Perfect Forward argument permutation calculation
0101     /////////////////////////////////////////////////////////////////////////////
0102 #define BOOST_PHOENIX_M0_R(_, N, __)                                            \
0103     (((A ## N)(&))((A ## N)(const&)))                                           \
0104 /**/
0105
0106 #define BOOST_PHOENIX_M0                                                        \
0107     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M0_R, _)             \
0108 /**/
0109
0110 #define BOOST_PHOENIX_M1_R_R(_, N, SEQ)                                         \
0111     BOOST_PP_SEQ_ELEM(N, SEQ)                                                   \
0112 /**/
0113
0114 #define BOOST_PHOENIX_M1_R(R, __, ___, ELEM)                                    \
0115     (BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(ELEM), BOOST_PHOENIX_M1_R_R, ELEM))      \
0116 /**/
0117
0118 #define BOOST_PHOENIX_M1(R, PRODUCT)                                            \
0119     ((BOOST_PP_SEQ_ENUM                                                         \
0120         (BOOST_PP_SEQ_FOR_EACH_I_R                                              \
0121             (R, BOOST_PHOENIX_M1_R, _, PRODUCT))))                              \
0122 /**/
0123
0124 #define BOOST_PHOENIX_PERM_SEQ                                                  \
0125     BOOST_PP_SEQ_FOR_EACH_PRODUCT(BOOST_PHOENIX_M1, BOOST_PHOENIX_M0)           \
0126 /**/
0127     ////////////////////////////////////////////////////////////////////////////
0128     // End
0129     ////////////////////////////////////////////////////////////////////////////
0130
0131 #define BOOST_PHOENIX_PERM_SIZE                                                 \
0132     BOOST_PP_SEQ_SIZE(BOOST_PHOENIX_PERM_SEQ)                                   \
0133 /**/
0134
0135 #define BOOST_PHOENIX_M2(_, N, TUPLE)                                           \
0136     BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(BOOST_PHOENIX_ITERATION, N, TUPLE) \
0137 /**/
0138
0139 #define BOOST_PHOENIX_M3(_, N, TUPLE)                                           \
0140     BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(BOOST_PHOENIX_ITERATION, N, TUPLE) a ## N\
0141 /**/
0142
0143 #define BOOST_PHOENIX_PERM_ELEM(N)                                              \
0144     BOOST_PP_SEQ_ELEM(N, BOOST_PHOENIX_PERM_SEQ)                                \
0145 /**/
0146
0147 #define BOOST_PHOENIX_PERM_A(N)                                                 \
0148     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M2, BOOST_PHOENIX_PERM_ELEM(N))\
0149 /**/
0150
0151 #define BOOST_PHOENIX_PERM_A_a(N)                                               \
0152     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M3, BOOST_PHOENIX_PERM_ELEM(N))\
0153 /**/
0154
0155 #endif