ceph/src/boost/boost/mpl/aux_/fold_impl_body.hpp

   1
   2 // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
   3
   4 #if !defined(BOOST_PP_IS_ITERATING)
   5
   6 // Copyright Aleksey Gurtovoy 2000-2004
   7 //
   8 // Distributed under the Boost Software License, Version 1.0.
   9 // (See accompanying file LICENSE_1_0.txt or copy at
  10 // http://www.boost.org/LICENSE_1_0.txt)
  11 //
  12 // See http://www.boost.org/libs/mpl for documentation.
  13
  14 // $Id$
  15 // $Date$
  16 // $Revision$
  17
  18 #   include <boost/mpl/limits/unrolling.hpp>
  19 #   include <boost/mpl/aux_/preprocessor/repeat.hpp>
  20 #   include <boost/mpl/aux_/config/workaround.hpp>
  21 #   include <boost/mpl/aux_/config/ctps.hpp>
  22 #   include <boost/mpl/aux_/nttp_decl.hpp>
  23 #   include <boost/mpl/aux_/config/eti.hpp>
  24
  25 #   include <boost/preprocessor/iterate.hpp>
  26 #   include <boost/preprocessor/dec.hpp>
  27 #   include <boost/preprocessor/cat.hpp>
  28
  29 // local macros, #undef-ined at the end of the header
  30
  31 #   define AUX778076_ITER_FOLD_STEP(unused, i, unused2) \
  32     typedef typename apply2< \
  33           ForwardOp \
  34         , BOOST_PP_CAT(state,i) \
  35         , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,i)) \
  36         >::type BOOST_PP_CAT(state,BOOST_PP_INC(i)); \
  37     typedef typename mpl::next<BOOST_PP_CAT(iter,i)>::type \
  38         BOOST_PP_CAT(iter,BOOST_PP_INC(i)); \
  39     /**/
  40
  41 #   define AUX778076_FOLD_IMPL_NAME \
  42     BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \
  43     /**/
  44
  45 #   define AUX778076_FOLD_CHUNK_NAME \
  46     BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \
  47     /**/
  48
  49 namespace boost { namespace mpl { namespace aux {
  50
  51 /// forward declaration
  52 template<
  53       BOOST_MPL_AUX_NTTP_DECL(int, N)
  54     , typename First
  55     , typename Last
  56     , typename State
  57     , typename ForwardOp
  58     >
  59 struct AUX778076_FOLD_IMPL_NAME;
  60
  61 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  62
  63 #   if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
  64
  65 #   define BOOST_PP_ITERATION_PARAMS_1 \
  66     (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
  67 #   include BOOST_PP_ITERATE()
  68
  69 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
  70 template<
  71       BOOST_MPL_AUX_NTTP_DECL(int, N)
  72     , typename First
  73     , typename Last
  74     , typename State
  75     , typename ForwardOp
  76     >
  77 struct AUX778076_FOLD_IMPL_NAME
  78 {
  79     typedef AUX778076_FOLD_IMPL_NAME<
  80           BOOST_MPL_LIMIT_UNROLLING
  81         , First
  82         , Last
  83         , State
  84         , ForwardOp
  85         > chunk_;
  86
  87     typedef AUX778076_FOLD_IMPL_NAME<
  88           ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
  89         , typename chunk_::iterator
  90         , Last
  91         , typename chunk_::state
  92         , ForwardOp
  93         > res_;
  94
  95     typedef typename res_::state state;
  96     typedef typename res_::iterator iterator;
  97 };
  98
  99 // fallback implementation for sequences of unknown size
 100 template<
 101       typename First
 102     , typename Last
 103     , typename State
 104     , typename ForwardOp
 105     >
 106 struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp>
 107     : AUX778076_FOLD_IMPL_NAME<
 108           -1
 109         , typename mpl::next<First>::type
 110         , Last
 111         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
 112         , ForwardOp
 113         >
 114 {
 115 };
 116
 117 template<
 118       typename Last
 119     , typename State
 120     , typename ForwardOp
 121     >
 122 struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp>
 123 {
 124     typedef State state;
 125     typedef Last iterator;
 126 };
 127
 128 #   else // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
 129
 130 // Borland have some serious problems with the unrolled version, so
 131 // we always use a basic implementation
 132 template<
 133       BOOST_MPL_AUX_NTTP_DECL(int, N)
 134     , typename First
 135     , typename Last
 136     , typename State
 137     , typename ForwardOp
 138     >
 139 struct AUX778076_FOLD_IMPL_NAME
 140 {
 141     typedef AUX778076_FOLD_IMPL_NAME<
 142           -1
 143         , typename mpl::next<First>::type
 144         , Last
 145         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
 146         , ForwardOp
 147         > res_;
 148
 149     typedef typename res_::state state;
 150     typedef typename res_::iterator iterator;
 151     typedef state type;
 152 };
 153
 154 template<
 155       BOOST_MPL_AUX_NTTP_DECL(int, N)
 156      , typename Last
 157     , typename State
 158     , typename ForwardOp
 159     >
 160 struct AUX778076_FOLD_IMPL_NAME<N,Last,Last,State,ForwardOp >
 161 {
 162     typedef State state;
 163     typedef Last iterator;
 164     typedef state type;
 165 };
 166
 167 #   endif // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
 168
 169 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 170
 171 template< BOOST_MPL_AUX_NTTP_DECL(int, N) >
 172 struct AUX778076_FOLD_CHUNK_NAME;
 173
 174 #   define BOOST_PP_ITERATION_PARAMS_1 \
 175     (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
 176 #   include BOOST_PP_ITERATE()
 177
 178 // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
 179 template< BOOST_MPL_AUX_NTTP_DECL(int, N) >
 180 struct AUX778076_FOLD_CHUNK_NAME
 181 {
 182     template<
 183           typename First
 184         , typename Last
 185         , typename State
 186         , typename ForwardOp
 187         >
 188     struct result_
 189     {
 190         typedef AUX778076_FOLD_IMPL_NAME<
 191               BOOST_MPL_LIMIT_UNROLLING
 192             , First
 193             , Last
 194             , State
 195             , ForwardOp
 196             > chunk_;
 197
 198         typedef AUX778076_FOLD_IMPL_NAME<
 199               ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
 200             , typename chunk_::iterator
 201             , Last
 202             , typename chunk_::state
 203             , ForwardOp
 204             > res_;
 205
 206         typedef typename res_::state state;
 207         typedef typename res_::iterator iterator;
 208     };
 209 };
 210
 211 // fallback implementation for sequences of unknown size
 212 template<
 213       typename First
 214     , typename Last
 215     , typename State
 216     , typename ForwardOp
 217     >
 218 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step);
 219
 220 template<
 221       typename Last
 222     , typename State
 223     >
 224 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)
 225 {
 226     typedef Last iterator;
 227     typedef State state;
 228 };
 229
 230 template<>
 231 struct AUX778076_FOLD_CHUNK_NAME<-1>
 232 {
 233     template<
 234           typename First
 235         , typename Last
 236         , typename State
 237         , typename ForwardOp
 238         >
 239     struct result_
 240     {
 241         typedef typename if_<
 242               typename is_same<First,Last>::type
 243             , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)<Last,State>
 244             , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)<First,Last,State,ForwardOp>
 245             >::type res_;
 246
 247         typedef typename res_::state state;
 248         typedef typename res_::iterator iterator;
 249     };
 250
 251 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
 252     /// ETI workaround
 253     template<> struct result_<int,int,int,int>
 254     {
 255         typedef int state;
 256         typedef int iterator;
 257     };
 258 #endif
 259 };
 260
 261 template<
 262       typename First
 263     , typename Last
 264     , typename State
 265     , typename ForwardOp
 266     >
 267 struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)
 268 {
 269     // can't inherit here - it breaks MSVC 7.0
 270     typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_<
 271           typename mpl::next<First>::type
 272         , Last
 273         , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
 274         , ForwardOp
 275         > chunk_;
 276
 277     typedef typename chunk_::state state;
 278     typedef typename chunk_::iterator iterator;
 279 };
 280
 281 template<
 282       BOOST_MPL_AUX_NTTP_DECL(int, N)
 283     , typename First
 284     , typename Last
 285     , typename State
 286     , typename ForwardOp
 287     >
 288 struct AUX778076_FOLD_IMPL_NAME
 289     : AUX778076_FOLD_CHUNK_NAME<N>
 290         ::template result_<First,Last,State,ForwardOp>
 291 {
 292 };
 293
 294 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 295
 296 }}}
 297
 298 #   undef AUX778076_FOLD_IMPL_NAME
 299 #   undef AUX778076_FOLD_CHUNK_NAME
 300 #   undef AUX778076_ITER_FOLD_STEP
 301
 302 #undef AUX778076_FOLD_IMPL_OP
 303 #undef AUX778076_FOLD_IMPL_NAME_PREFIX
 304
 305 ///// iteration
 306
 307 #else
 308
 309 #   define n_ BOOST_PP_FRAME_ITERATION(1)
 310
 311 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 312
 313 template<
 314       typename First
 315     , typename Last
 316     , typename State
 317     , typename ForwardOp
 318     >
 319 struct AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,ForwardOp>
 320 {
 321     typedef First iter0;
 322     typedef State state0;
 323
 324     BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
 325
 326     typedef BOOST_PP_CAT(state,n_) state;
 327     typedef BOOST_PP_CAT(iter,n_) iterator;
 328 };
 329
 330 #else
 331
 332 template<> struct AUX778076_FOLD_CHUNK_NAME<n_>
 333 {
 334     template<
 335           typename First
 336         , typename Last
 337         , typename State
 338         , typename ForwardOp
 339         >
 340     struct result_
 341     {
 342         typedef First iter0;
 343         typedef State state0;
 344
 345         BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
 346
 347         typedef BOOST_PP_CAT(state,n_) state;
 348         typedef BOOST_PP_CAT(iter,n_) iterator;
 349     };
 350
 351 #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
 352     /// ETI workaround
 353     template<> struct result_<int,int,int,int>
 354     {
 355         typedef int state;
 356         typedef int iterator;
 357     };
 358 #endif
 359 };
 360
 361 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 362
 363 #   undef n_
 364
 365 #endif // BOOST_PP_IS_ITERATING