AND Private Git Repository - canny.git/blob

   1 \r
   2 // Copyright Aleksey Gurtovoy 2000-2004\r
   3 //\r
   4 // Distributed under the Boost Software License, Version 1.0. \r
   5 // (See accompanying file LICENSE_1_0.txt or copy at \r
   6 // http://www.boost.org/LICENSE_1_0.txt)\r
   7 //\r
   8 \r
   9 // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header\r
  10 // -- DO NOT modify by hand!\r
  11 \r
  12 namespace boost { namespace mpl { namespace aux {\r
  13 \r
  14 /// forward declaration\r
  15 \r
  16 template<\r
  17       long N\r
  18     , typename First\r
  19     , typename Last\r
  20     , typename State\r
  21     , typename BackwardOp\r
  22     , typename ForwardOp\r
  23     >\r
  24 struct reverse_iter_fold_impl;\r
  25 \r
  26 template< long N >\r
  27 struct reverse_iter_fold_chunk;\r
  28 \r
  29 template<> struct reverse_iter_fold_chunk<0>\r
  30 {\r
  31     template<\r
  32           typename First\r
  33         , typename Last\r
  34         , typename State\r
  35         , typename BackwardOp\r
  36         , typename ForwardOp\r
  37         >\r
  38     struct result_\r
  39     {\r
  40         typedef First iter0;\r
  41         typedef State fwd_state0;\r
  42         typedef fwd_state0 bkwd_state0;\r
  43         typedef bkwd_state0 state;\r
  44         typedef iter0 iterator;\r
  45     };\r
  46 \r
  47     /// ETI workaround\r
  48     template<> struct result_< int,int,int,int,int >\r
  49     {\r
  50         typedef int state;\r
  51         typedef int iterator;\r
  52     };\r
  53 \r
  54 };\r
  55 \r
  56 template<> struct reverse_iter_fold_chunk<1>\r
  57 {\r
  58     template<\r
  59           typename First\r
  60         , typename Last\r
  61         , typename State\r
  62         , typename BackwardOp\r
  63         , typename ForwardOp\r
  64         >\r
  65     struct result_\r
  66     {\r
  67         typedef First iter0;\r
  68         typedef State fwd_state0;\r
  69         typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;\r
  70         typedef typename mpl::next<iter0>::type iter1;\r
  71         \r
  72 \r
  73         typedef fwd_state1 bkwd_state1;\r
  74         typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;\r
  75         typedef bkwd_state0 state;\r
  76         typedef iter1 iterator;\r
  77     };\r
  78 \r
  79     /// ETI workaround\r
  80     template<> struct result_< int,int,int,int,int >\r
  81     {\r
  82         typedef int state;\r
  83         typedef int iterator;\r
  84     };\r
  85 \r
  86 };\r
  87 \r
  88 template<> struct reverse_iter_fold_chunk<2>\r
  89 {\r
  90     template<\r
  91           typename First\r
  92         , typename Last\r
  93         , typename State\r
  94         , typename BackwardOp\r
  95         , typename ForwardOp\r
  96         >\r
  97     struct result_\r
  98     {\r
  99         typedef First iter0;\r
 100         typedef State fwd_state0;\r
 101         typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;\r
 102         typedef typename mpl::next<iter0>::type iter1;\r
 103         typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;\r
 104         typedef typename mpl::next<iter1>::type iter2;\r
 105         \r
 106 \r
 107         typedef fwd_state2 bkwd_state2;\r
 108         typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;\r
 109         typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;\r
 110         \r
 111 \r
 112         typedef bkwd_state0 state;\r
 113         typedef iter2 iterator;\r
 114     };\r
 115 \r
 116     /// ETI workaround\r
 117     template<> struct result_< int,int,int,int,int >\r
 118     {\r
 119         typedef int state;\r
 120         typedef int iterator;\r
 121     };\r
 122 \r
 123 };\r
 124 \r
 125 template<> struct reverse_iter_fold_chunk<3>\r
 126 {\r
 127     template<\r
 128           typename First\r
 129         , typename Last\r
 130         , typename State\r
 131         , typename BackwardOp\r
 132         , typename ForwardOp\r
 133         >\r
 134     struct result_\r
 135     {\r
 136         typedef First iter0;\r
 137         typedef State fwd_state0;\r
 138         typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;\r
 139         typedef typename mpl::next<iter0>::type iter1;\r
 140         typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;\r
 141         typedef typename mpl::next<iter1>::type iter2;\r
 142         typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;\r
 143         typedef typename mpl::next<iter2>::type iter3;\r
 144         \r
 145 \r
 146         typedef fwd_state3 bkwd_state3;\r
 147         typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;\r
 148         typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;\r
 149         typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;\r
 150         \r
 151 \r
 152         typedef bkwd_state0 state;\r
 153         typedef iter3 iterator;\r
 154     };\r
 155 \r
 156     /// ETI workaround\r
 157     template<> struct result_< int,int,int,int,int >\r
 158     {\r
 159         typedef int state;\r
 160         typedef int iterator;\r
 161     };\r
 162 \r
 163 };\r
 164 \r
 165 template<> struct reverse_iter_fold_chunk<4>\r
 166 {\r
 167     template<\r
 168           typename First\r
 169         , typename Last\r
 170         , typename State\r
 171         , typename BackwardOp\r
 172         , typename ForwardOp\r
 173         >\r
 174     struct result_\r
 175     {\r
 176         typedef First iter0;\r
 177         typedef State fwd_state0;\r
 178         typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;\r
 179         typedef typename mpl::next<iter0>::type iter1;\r
 180         typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;\r
 181         typedef typename mpl::next<iter1>::type iter2;\r
 182         typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;\r
 183         typedef typename mpl::next<iter2>::type iter3;\r
 184         typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;\r
 185         typedef typename mpl::next<iter3>::type iter4;\r
 186         \r
 187 \r
 188         typedef fwd_state4 bkwd_state4;\r
 189         typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;\r
 190         typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;\r
 191         typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;\r
 192         typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;\r
 193         \r
 194 \r
 195         typedef bkwd_state0 state;\r
 196         typedef iter4 iterator;\r
 197     };\r
 198 \r
 199     /// ETI workaround\r
 200     template<> struct result_< int,int,int,int,int >\r
 201     {\r
 202         typedef int state;\r
 203         typedef int iterator;\r
 204     };\r
 205 \r
 206 };\r
 207 \r
 208 template< long N >\r
 209 struct reverse_iter_fold_chunk\r
 210 {\r
 211     template<\r
 212           typename First\r
 213         , typename Last\r
 214         , typename State\r
 215         , typename BackwardOp\r
 216         , typename ForwardOp\r
 217         >\r
 218     struct result_\r
 219     {\r
 220         typedef First iter0;\r
 221         typedef State fwd_state0;\r
 222         typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;\r
 223         typedef typename mpl::next<iter0>::type iter1;\r
 224         typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;\r
 225         typedef typename mpl::next<iter1>::type iter2;\r
 226         typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;\r
 227         typedef typename mpl::next<iter2>::type iter3;\r
 228         typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;\r
 229         typedef typename mpl::next<iter3>::type iter4;\r
 230         \r
 231 \r
 232         typedef reverse_iter_fold_impl<\r
 233               ( (N - 4) < 0 ? 0 : N - 4 )\r
 234             , iter4\r
 235             , Last\r
 236             , fwd_state4\r
 237             , BackwardOp\r
 238             , ForwardOp\r
 239             > nested_chunk;\r
 240 \r
 241         typedef typename nested_chunk::state bkwd_state4;\r
 242         typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;\r
 243         typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;\r
 244         typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;\r
 245         typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;\r
 246         \r
 247 \r
 248         typedef bkwd_state0 state;\r
 249         typedef typename nested_chunk::iterator iterator;\r
 250     };\r
 251 };\r
 252 \r
 253 template<\r
 254       typename First\r
 255     , typename Last\r
 256     , typename State\r
 257     , typename BackwardOp\r
 258     , typename ForwardOp\r
 259     >\r
 260 struct reverse_iter_fold_step;\r
 261 \r
 262 template<\r
 263       typename Last\r
 264     , typename State\r
 265     >\r
 266 struct reverse_iter_fold_null_step\r
 267 {\r
 268     typedef Last iterator;\r
 269     typedef State state;\r
 270 };\r
 271 \r
 272 template<>\r
 273 struct reverse_iter_fold_chunk< -1 >\r
 274 {\r
 275     template<\r
 276           typename First\r
 277         , typename Last\r
 278         , typename State\r
 279         , typename BackwardOp\r
 280         , typename ForwardOp\r
 281         >\r
 282     struct result_\r
 283     {\r
 284         typedef typename if_<\r
 285               typename is_same< First,Last >::type\r
 286             , reverse_iter_fold_null_step< Last,State >\r
 287             , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp >\r
 288             >::type res_;\r
 289 \r
 290         typedef typename res_::state state;\r
 291         typedef typename res_::iterator iterator;\r
 292     };\r
 293 \r
 294     /// ETI workaround\r
 295     template<> struct result_< int,int,int,int,int >\r
 296     {\r
 297         typedef int state;\r
 298         typedef int iterator;\r
 299     };\r
 300 \r
 301 };\r
 302 \r
 303 template<\r
 304       typename First\r
 305     , typename Last\r
 306     , typename State\r
 307     , typename BackwardOp\r
 308     , typename ForwardOp\r
 309     >\r
 310 struct reverse_iter_fold_step\r
 311 {\r
 312     typedef reverse_iter_fold_chunk< -1 >::template result_<\r
 313           typename mpl::next<First>::type\r
 314         , Last\r
 315         , typename apply2< ForwardOp,State,First >::type\r
 316         , BackwardOp\r
 317         , ForwardOp\r
 318         > nested_step;\r
 319 \r
 320     typedef typename apply2<\r
 321           BackwardOp\r
 322         , typename nested_step::state\r
 323         , First\r
 324         >::type state;\r
 325 \r
 326     typedef typename nested_step::iterator iterator;\r
 327 };\r
 328 \r
 329 template<\r
 330       long N\r
 331     , typename First\r
 332     , typename Last\r
 333     , typename State\r
 334     , typename BackwardOp\r
 335     , typename ForwardOp\r
 336     >\r
 337 struct reverse_iter_fold_impl\r
 338     : reverse_iter_fold_chunk<N>\r
 339         ::template result_< First,Last,State,BackwardOp,ForwardOp >\r
 340 {\r
 341 };\r
 342 \r
 343 }}}\r