ceph/src/boost/libs/proto/include/boost/proto/detail/deprecated.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 /// \file deprecated.hpp
   3 /// Definition of the deprecated BOOST_PROTO_DEFINE_FUCTION_TEMPLATE and
   4 /// BOOST_PROTO_DEFINE_VARARG_FUCTION_TEMPLATE macros
   5 //
   6 //  Copyright 2008 Eric Niebler. Distributed under the Boost
   7 //  Software License, Version 1.0. (See accompanying file
   8 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #ifndef BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
  11 #define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
  12
  13 #include <boost/preprocessor/cat.hpp>
  14 #include <boost/preprocessor/facilities/intercept.hpp>
  15 #include <boost/preprocessor/arithmetic/inc.hpp>
  16 #include <boost/preprocessor/arithmetic/dec.hpp>
  17 #include <boost/preprocessor/arithmetic/sub.hpp>
  18 #include <boost/preprocessor/punctuation/comma_if.hpp>
  19 #include <boost/preprocessor/control/if.hpp>
  20 #include <boost/preprocessor/control/expr_if.hpp>
  21 #include <boost/preprocessor/comparison/greater.hpp>
  22 #include <boost/preprocessor/tuple/elem.hpp>
  23 #include <boost/preprocessor/tuple/to_list.hpp>
  24 #include <boost/preprocessor/logical/and.hpp>
  25 #include <boost/preprocessor/seq/size.hpp>
  26 #include <boost/preprocessor/seq/enum.hpp>
  27 #include <boost/preprocessor/seq/seq.hpp>
  28 #include <boost/preprocessor/seq/to_tuple.hpp>
  29 #include <boost/preprocessor/seq/for_each_i.hpp>
  30 #include <boost/preprocessor/seq/pop_back.hpp>
  31 #include <boost/preprocessor/seq/push_back.hpp>
  32 #include <boost/preprocessor/seq/push_front.hpp>
  33 #include <boost/preprocessor/list/for_each_i.hpp>
  34 #include <boost/preprocessor/repetition/repeat.hpp>
  35 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
  36 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  37 #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
  38 #include <boost/proto/proto_fwd.hpp>
  39
  40 /// INTERNAL ONLY
  41 ///
  42 #define BOOST_PROTO_VARARG_TEMPLATE_AUX_(R, DATA, I, ELEM)                                      \
  43     (ELEM BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I)))                              \
  44     /**/
  45
  46 /// INTERNAL ONLY
  47 ///
  48 #define BOOST_PROTO_VARARG_TEMPLATE_YES_(R, DATA, I, ELEM)                                      \
  49     BOOST_PP_LIST_FOR_EACH_I_R(                                                                 \
  50         R                                                                                       \
  51       , BOOST_PROTO_VARARG_TEMPLATE_AUX_                                                        \
  52       , I                                                                                       \
  53       , BOOST_PP_TUPLE_TO_LIST(                                                                 \
  54             BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                               \
  55           , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM))                                      \
  56         )                                                                                       \
  57     )                                                                                           \
  58     /**/
  59
  60 /// INTERNAL ONLY
  61 ///
  62 #define BOOST_PROTO_VARARG_TEMPLATE_NO_(R, DATA, I, ELEM)                                       \
  63     /**/
  64
  65 /// INTERNAL ONLY
  66 ///
  67 #define BOOST_PROTO_VARARG_TEMPLATE_(R, DATA, I, ELEM)                                          \
  68     BOOST_PP_IF(                                                                                \
  69         BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                                   \
  70       , BOOST_PROTO_VARARG_TEMPLATE_YES_                                                        \
  71       , BOOST_PROTO_VARARG_TEMPLATE_NO_                                                         \
  72     )(R, DATA, I, ELEM)                                                                         \
  73     /**/
  74
  75 /// INTERNAL ONLY
  76 ///
  77 #define BOOST_PROTO_VARARG_TYPE_AUX_(R, DATA, I, ELEM)                                          \
  78     (BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I)))                                   \
  79     /**/
  80
  81 /// INTERNAL ONLY
  82 ///
  83 #define BOOST_PROTO_TEMPLATE_PARAMS_YES_(R, DATA, I, ELEM)                                      \
  84     <                                                                                           \
  85         BOOST_PP_SEQ_ENUM(                                                                      \
  86             BOOST_PP_LIST_FOR_EACH_I_R(                                                         \
  87                 R                                                                               \
  88               , BOOST_PROTO_VARARG_TYPE_AUX_                                                    \
  89               , I                                                                               \
  90               , BOOST_PP_TUPLE_TO_LIST(                                                         \
  91                     BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                       \
  92                   , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM))                              \
  93                 )                                                                               \
  94             )                                                                                   \
  95         )                                                                                       \
  96     >                                                                                           \
  97     /**/
  98
  99 /// INTERNAL ONLY
 100 ///
 101 #define BOOST_PROTO_TEMPLATE_PARAMS_NO_(R, DATA, I, ELEM)                                       \
 102     /**/
 103
 104 /// INTERNAL ONLY
 105 ///
 106 #define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM)                                              \
 107     BOOST_PP_COMMA_IF(I)                                                                        \
 108     BOOST_PP_SEQ_HEAD(ELEM)                                                                     \
 109     BOOST_PP_IF(                                                                                \
 110         BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                                   \
 111       , BOOST_PROTO_TEMPLATE_PARAMS_YES_                                                        \
 112       , BOOST_PROTO_TEMPLATE_PARAMS_NO_                                                         \
 113     )(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const)                         \
 114     /**/
 115
 116 /// INTERNAL ONLY
 117 ///
 118 #define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM)                                           \
 119     BOOST_PP_EXPR_IF(                                                                           \
 120         BOOST_PP_GREATER(I, 1)                                                                  \
 121       , ((                                                                                      \
 122             BOOST_PP_SEQ_HEAD(ELEM)                                                             \
 123             BOOST_PP_IF(                                                                        \
 124                 BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                           \
 125               , BOOST_PROTO_TEMPLATE_PARAMS_YES_                                                \
 126               , BOOST_PROTO_TEMPLATE_PARAMS_NO_                                                 \
 127             )(R, DATA, I, ELEM)()                                                               \
 128         ))                                                                                      \
 129     )                                                                                           \
 130     /**/
 131
 132 /// INTERNAL ONLY
 133 ///
 134 #define BOOST_PROTO_VARARG_AS_CHILD_(Z, N, DATA)                                                \
 135     (BOOST_PP_CAT(DATA, N))                                                                     \
 136     /**/
 137
 138 /// INTERNAL ONLY
 139 ///
 140 #define BOOST_PROTO_SEQ_PUSH_FRONT(SEQ, ELEM)                                                   \
 141     BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ, _dummy_), ELEM))  \
 142     /**/
 143
 144 /// INTERNAL ONLY
 145 ///
 146 #define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA)                                                \
 147     (BOOST_PP_CAT(DATA, N))                                                                     \
 148     /**/
 149
 150 /// INTERNAL ONLY
 151 ///
 152 #define BOOST_PROTO_VARARG_FUN_(Z, N, DATA)                                                     \
 153     template<                                                                                   \
 154         BOOST_PP_SEQ_ENUM(                                                                      \
 155             BOOST_PP_SEQ_FOR_EACH_I(                                                            \
 156                 BOOST_PROTO_VARARG_TEMPLATE_, ~                                                 \
 157               , BOOST_PP_SEQ_PUSH_FRONT(                                                        \
 158                     BOOST_PROTO_SEQ_PUSH_FRONT(                                                 \
 159                         BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                         \
 160                       , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                       \
 161                     )                                                                           \
 162                   , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                             \
 163                 )                                                                               \
 164             )                                                                                   \
 165             BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_, typename A)                  \
 166         )                                                                                       \
 167     >                                                                                           \
 168     typename boost::proto::result_of::make_expr<                                                \
 169         BOOST_PP_SEQ_FOR_EACH_I(                                                                \
 170             BOOST_PROTO_VARARG_TYPE_, ~                                                         \
 171           , BOOST_PP_SEQ_PUSH_FRONT(                                                            \
 172                 BOOST_PROTO_SEQ_PUSH_FRONT(                                                     \
 173                     BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                             \
 174                   , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                           \
 175                 )                                                                               \
 176               , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                                 \
 177             )                                                                                   \
 178         )                                                                                       \
 179         BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT)             \
 180     >::type const                                                                               \
 181     BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a))           \
 182     {                                                                                           \
 183         return boost::proto::detail::make_expr_<                                                \
 184             BOOST_PP_SEQ_FOR_EACH_I(                                                            \
 185                 BOOST_PROTO_VARARG_TYPE_, ~                                                     \
 186               , BOOST_PP_SEQ_PUSH_FRONT(                                                        \
 187                     BOOST_PROTO_SEQ_PUSH_FRONT(                                                 \
 188                         BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                         \
 189                       , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                       \
 190                     )                                                                           \
 191                   , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                             \
 192                 )                                                                               \
 193             )                                                                                   \
 194             BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT)         \
 195         >()(                                                                                    \
 196             BOOST_PP_SEQ_ENUM(                                                                  \
 197                 BOOST_PP_SEQ_FOR_EACH_I(                                                        \
 198                     BOOST_PROTO_VARARG_AS_EXPR_, ~                                              \
 199                   , BOOST_PP_SEQ_PUSH_FRONT(                                                    \
 200                         BOOST_PROTO_SEQ_PUSH_FRONT(                                             \
 201                             BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                     \
 202                           , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                   \
 203                         )                                                                       \
 204                       , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                         \
 205                     )                                                                           \
 206                 )                                                                               \
 207                 BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_CHILD_, a)                       \
 208             )                                                                                   \
 209         );                                                                                      \
 210     }                                                                                           \
 211     /**/
 212
 213 /// \code
 214 /// BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
 215 ///     1
 216 ///   , construct
 217 ///   , boost::proto::default_domain
 218 ///   , (boost::proto::tag::function)
 219 ///   , ((op::construct)(typename)(int))
 220 /// )
 221 /// \endcode
 222 #define BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(ARGCOUNT, NAME, DOMAIN, TAG, BOUNDARGS)            \
 223     BOOST_PP_REPEAT_FROM_TO(                                                                    \
 224         ARGCOUNT                                                                                \
 225       , BOOST_PP_INC(ARGCOUNT)                                                                  \
 226       , BOOST_PROTO_VARARG_FUN_                                                                 \
 227       , (NAME, TAG, BOUNDARGS, DOMAIN)                                                          \
 228     )\
 229     /**/
 230
 231 /// \code
 232 /// BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
 233 ///     construct
 234 ///   , boost::proto::default_domain
 235 ///   , (boost::proto::tag::function)
 236 ///   , ((op::construct)(typename)(int))
 237 /// )
 238 /// \endcode
 239 #define BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(NAME, DOMAIN, TAG, BOUNDARGS)               \
 240     BOOST_PP_REPEAT(                                                                            \
 241         BOOST_PP_SUB(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), BOOST_PP_SEQ_SIZE(BOUNDARGS))         \
 242       , BOOST_PROTO_VARARG_FUN_                                                                 \
 243       , (NAME, TAG, BOUNDARGS, DOMAIN)                                                          \
 244     )                                                                                           \
 245     /**/
 246
 247 #endif