ceph/src/boost/boost/phoenix/support/detail/iterate_define.hpp

   1 /*==============================================================================
   2     Copyright (c) 2010 Thomas Heller
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7
   8 #if !BOOST_PHOENIX_IS_ITERATING
   9
  10 #define BOOST_PHOENIX_typename_A(N)                                             \
  11     BOOST_PP_ENUM_PARAMS(N, typename A)                                         \
  12 /**/
  13
  14 #define BOOST_PHOENIX_typename_A_void(N)                                        \
  15     BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(N, typename A, void)                    \
  16 /**/
  17
  18 #define BOOST_PHOENIX_A(N)                                                      \
  19     BOOST_PP_ENUM_PARAMS(N, A)                                                  \
  20 /**/
  21
  22 #define BOOST_PHOENIX_A_ref(N)                                                  \
  23     BOOST_PP_ENUM_BINARY_PARAMS(N, A, & BOOST_PP_INTERCEPT)                     \
  24 /**/
  25
  26 #define BOOST_PHOENIX_A_const_ref(N)                                            \
  27     BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& BOOST_PP_INTERCEPT)                \
  28 /**/
  29
  30 #define BOOST_PHOENIX_A_a(N)                                                    \
  31     BOOST_PP_ENUM_BINARY_PARAMS(N, A, a)                                        \
  32 /**/
  33
  34 #define BOOST_PHOENIX_A_ref_a(N)                                                \
  35     BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)                                      \
  36 /**/
  37
  38 #define BOOST_PHOENIX_A_const_ref_a(N)                                          \
  39     BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a)                                 \
  40 /**/
  41
  42 #define BOOST_PHOENIX_a(N)                                                      \
  43     BOOST_PP_ENUM_PARAMS(N, a)                                                  \
  44 /**/
  45
  46 #else
  47
  48 #include <boost/preprocessor/repetition/repeat.hpp>
  49 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  50 #include <boost/preprocessor/repetition/enum_params.hpp>
  51 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
  52 #include <boost/preprocessor/seq/elem.hpp>
  53 #include <boost/preprocessor/seq/enum.hpp>
  54 #include <boost/preprocessor/seq/for_each_i.hpp>
  55 #include <boost/preprocessor/seq/for_each_product.hpp>
  56 #include <boost/preprocessor/seq/size.hpp>
  57 #include <boost/preprocessor/tuple/elem.hpp>
  58
  59 #define BOOST_PHOENIX_ITERATION                                                 \
  60     BOOST_PP_ITERATION()                                                        \
  61 /**/
  62
  63 #define BOOST_PHOENIX_typename_A                                                \
  64     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename A)                   \
  65 /**/
  66
  67 #define BOOST_PHOENIX_typename_A_void                                           \
  68     BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PHOENIX_ITERATION, typename A, void)
  69 /**/
  70
  71 #define BOOST_PHOENIX_A                                                          \
  72     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, A)                             \
  73 /**/
  74
  75 #define BOOST_PHOENIX_A_ref                                                      \
  76     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, & BOOST_PP_INTERCEPT)\
  77 /**/
  78
  79 #define BOOST_PHOENIX_A_const_ref                                                \
  80     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, const& BOOST_PP_INTERCEPT)\
  81 /**/
  82
  83 #define BOOST_PHOENIX_A_a                                                        \
  84     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, a)                   \
  85 /**/
  86
  87 #define BOOST_PHOENIX_A_ref_a                                                    \
  88     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, & a)                 \
  89 /**/
  90
  91 #define BOOST_PHOENIX_A_const_ref_a                                              \
  92     BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PHOENIX_ITERATION, A, const& a)            \
  93 /**/
  94
  95 #define BOOST_PHOENIX_a                                                          \
  96     BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, a)                             \
  97 /**/
  98
  99     /////////////////////////////////////////////////////////////////////////////
 100     // Begin Perfect Forward argument permutation calculation
 101     /////////////////////////////////////////////////////////////////////////////
 102 #define BOOST_PHOENIX_M0_R(_, N, __)                                            \
 103     (((A ## N)(&))((A ## N)(const&)))                                           \
 104 /**/
 105
 106 #define BOOST_PHOENIX_M0                                                        \
 107     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M0_R, _)             \
 108 /**/
 109
 110 #define BOOST_PHOENIX_M1_R_R(_, N, SEQ)                                         \
 111     BOOST_PP_SEQ_ELEM(N, SEQ)                                                   \
 112 /**/
 113
 114 #define BOOST_PHOENIX_M1_R(R, __, ___, ELEM)                                    \
 115     (BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(ELEM), BOOST_PHOENIX_M1_R_R, ELEM))      \
 116 /**/
 117
 118 #define BOOST_PHOENIX_M1(R, PRODUCT)                                            \
 119     ((BOOST_PP_SEQ_ENUM                                                         \
 120         (BOOST_PP_SEQ_FOR_EACH_I_R                                              \
 121             (R, BOOST_PHOENIX_M1_R, _, PRODUCT))))                              \
 122 /**/
 123
 124 #define BOOST_PHOENIX_PERM_SEQ                                                  \
 125     BOOST_PP_SEQ_FOR_EACH_PRODUCT(BOOST_PHOENIX_M1, BOOST_PHOENIX_M0)           \
 126 /**/
 127     ////////////////////////////////////////////////////////////////////////////
 128     // End
 129     ////////////////////////////////////////////////////////////////////////////
 130
 131 #define BOOST_PHOENIX_PERM_SIZE                                                 \
 132     BOOST_PP_SEQ_SIZE(BOOST_PHOENIX_PERM_SEQ)                                   \
 133 /**/
 134
 135 #define BOOST_PHOENIX_M2(_, N, TUPLE)                                           \
 136     BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(BOOST_PHOENIX_ITERATION, N, TUPLE) \
 137 /**/
 138
 139 #define BOOST_PHOENIX_M3(_, N, TUPLE)                                           \
 140     BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(BOOST_PHOENIX_ITERATION, N, TUPLE) a ## N\
 141 /**/
 142
 143 #define BOOST_PHOENIX_PERM_ELEM(N)                                              \
 144     BOOST_PP_SEQ_ELEM(N, BOOST_PHOENIX_PERM_SEQ)                                \
 145 /**/
 146
 147 #define BOOST_PHOENIX_PERM_A(N)                                                 \
 148     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M2, BOOST_PHOENIX_PERM_ELEM(N))\
 149 /**/
 150
 151 #define BOOST_PHOENIX_PERM_A_a(N)                                               \
 152     BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_M3, BOOST_PHOENIX_PERM_ELEM(N))\
 153 /**/
 154
 155 #endif