ceph/src/boost/libs/proto/include/boost/proto/transform/detail/preprocessed/lazy.hpp

   1     ///////////////////////////////////////////////////////////////////////////////
   2     /// \file lazy.hpp
   3     /// Contains definition of the lazy<> transform.
   4     //
   5     //  Copyright 2008 Eric Niebler. Distributed under the Boost
   6     //  Software License, Version 1.0. (See accompanying file
   7     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9
  10
  11
  12
  13
  14
  15
  16     template<typename Object >
  17     struct lazy<Object()>
  18       : transform<lazy<Object()> >
  19     {
  20         template<typename Expr, typename State, typename Data>
  21         struct impl
  22           : call<
  23                 typename make<Object>::template impl<Expr, State, Data>::result_type
  24                 ()
  25             >::template impl<Expr, State, Data>
  26         {};
  27     };
  28
  29
  30
  31
  32
  33
  34
  35
  36     template<typename Object , typename A0>
  37     struct lazy<Object(A0)>
  38       : transform<lazy<Object(A0)> >
  39     {
  40         template<typename Expr, typename State, typename Data>
  41         struct impl
  42           : call<
  43                 typename make<Object>::template impl<Expr, State, Data>::result_type
  44                 (A0)
  45             >::template impl<Expr, State, Data>
  46         {};
  47     };
  48     template<typename Object , typename A0>
  49     struct lazy<Object(A0...)>
  50       : transform<lazy<Object(A0...)> >
  51     {
  52         template<typename Expr, typename State, typename Data>
  53         struct impl
  54           : lazy<
  55                 typename detail::expand_pattern<
  56                     proto::arity_of<Expr>::value
  57                   , A0
  58                   , detail::expand_pattern_rest_0<
  59                         Object
  60
  61                     >
  62                 >::type
  63             >::template impl<Expr, State, Data>
  64         {};
  65     };
  66
  67
  68
  69
  70
  71
  72
  73
  74     template<typename Object , typename A0 , typename A1>
  75     struct lazy<Object(A0 , A1)>
  76       : transform<lazy<Object(A0 , A1)> >
  77     {
  78         template<typename Expr, typename State, typename Data>
  79         struct impl
  80           : call<
  81                 typename make<Object>::template impl<Expr, State, Data>::result_type
  82                 (A0 , A1)
  83             >::template impl<Expr, State, Data>
  84         {};
  85     };
  86     template<typename Object , typename A0 , typename A1>
  87     struct lazy<Object(A0 , A1...)>
  88       : transform<lazy<Object(A0 , A1...)> >
  89     {
  90         template<typename Expr, typename State, typename Data>
  91         struct impl
  92           : lazy<
  93                 typename detail::expand_pattern<
  94                     proto::arity_of<Expr>::value
  95                   , A1
  96                   , detail::expand_pattern_rest_1<
  97                         Object
  98                         , A0
  99                     >
 100                 >::type
 101             >::template impl<Expr, State, Data>
 102         {};
 103     };
 104
 105
 106
 107
 108
 109
 110
 111
 112     template<typename Object , typename A0 , typename A1 , typename A2>
 113     struct lazy<Object(A0 , A1 , A2)>
 114       : transform<lazy<Object(A0 , A1 , A2)> >
 115     {
 116         template<typename Expr, typename State, typename Data>
 117         struct impl
 118           : call<
 119                 typename make<Object>::template impl<Expr, State, Data>::result_type
 120                 (A0 , A1 , A2)
 121             >::template impl<Expr, State, Data>
 122         {};
 123     };
 124     template<typename Object , typename A0 , typename A1 , typename A2>
 125     struct lazy<Object(A0 , A1 , A2...)>
 126       : transform<lazy<Object(A0 , A1 , A2...)> >
 127     {
 128         template<typename Expr, typename State, typename Data>
 129         struct impl
 130           : lazy<
 131                 typename detail::expand_pattern<
 132                     proto::arity_of<Expr>::value
 133                   , A2
 134                   , detail::expand_pattern_rest_2<
 135                         Object
 136                         , A0 , A1
 137                     >
 138                 >::type
 139             >::template impl<Expr, State, Data>
 140         {};
 141     };
 142
 143
 144
 145
 146
 147
 148
 149
 150     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
 151     struct lazy<Object(A0 , A1 , A2 , A3)>
 152       : transform<lazy<Object(A0 , A1 , A2 , A3)> >
 153     {
 154         template<typename Expr, typename State, typename Data>
 155         struct impl
 156           : call<
 157                 typename make<Object>::template impl<Expr, State, Data>::result_type
 158                 (A0 , A1 , A2 , A3)
 159             >::template impl<Expr, State, Data>
 160         {};
 161     };
 162     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
 163     struct lazy<Object(A0 , A1 , A2 , A3...)>
 164       : transform<lazy<Object(A0 , A1 , A2 , A3...)> >
 165     {
 166         template<typename Expr, typename State, typename Data>
 167         struct impl
 168           : lazy<
 169                 typename detail::expand_pattern<
 170                     proto::arity_of<Expr>::value
 171                   , A3
 172                   , detail::expand_pattern_rest_3<
 173                         Object
 174                         , A0 , A1 , A2
 175                     >
 176                 >::type
 177             >::template impl<Expr, State, Data>
 178         {};
 179     };
 180
 181
 182
 183
 184
 185
 186
 187
 188     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 189     struct lazy<Object(A0 , A1 , A2 , A3 , A4)>
 190       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> >
 191     {
 192         template<typename Expr, typename State, typename Data>
 193         struct impl
 194           : call<
 195                 typename make<Object>::template impl<Expr, State, Data>::result_type
 196                 (A0 , A1 , A2 , A3 , A4)
 197             >::template impl<Expr, State, Data>
 198         {};
 199     };
 200     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 201     struct lazy<Object(A0 , A1 , A2 , A3 , A4...)>
 202       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> >
 203     {
 204         template<typename Expr, typename State, typename Data>
 205         struct impl
 206           : lazy<
 207                 typename detail::expand_pattern<
 208                     proto::arity_of<Expr>::value
 209                   , A4
 210                   , detail::expand_pattern_rest_4<
 211                         Object
 212                         , A0 , A1 , A2 , A3
 213                     >
 214                 >::type
 215             >::template impl<Expr, State, Data>
 216         {};
 217     };
 218
 219
 220
 221
 222
 223
 224
 225
 226     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 227     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)>
 228       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
 229     {
 230         template<typename Expr, typename State, typename Data>
 231         struct impl
 232           : call<
 233                 typename make<Object>::template impl<Expr, State, Data>::result_type
 234                 (A0 , A1 , A2 , A3 , A4 , A5)
 235             >::template impl<Expr, State, Data>
 236         {};
 237     };
 238     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 239     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
 240       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
 241     {
 242         template<typename Expr, typename State, typename Data>
 243         struct impl
 244           : lazy<
 245                 typename detail::expand_pattern<
 246                     proto::arity_of<Expr>::value
 247                   , A5
 248                   , detail::expand_pattern_rest_5<
 249                         Object
 250                         , A0 , A1 , A2 , A3 , A4
 251                     >
 252                 >::type
 253             >::template impl<Expr, State, Data>
 254         {};
 255     };
 256
 257
 258
 259
 260
 261
 262
 263
 264     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 265     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
 266       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
 267     {
 268         template<typename Expr, typename State, typename Data>
 269         struct impl
 270           : call<
 271                 typename make<Object>::template impl<Expr, State, Data>::result_type
 272                 (A0 , A1 , A2 , A3 , A4 , A5 , A6)
 273             >::template impl<Expr, State, Data>
 274         {};
 275     };
 276     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 277     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
 278       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
 279     {
 280         template<typename Expr, typename State, typename Data>
 281         struct impl
 282           : lazy<
 283                 typename detail::expand_pattern<
 284                     proto::arity_of<Expr>::value
 285                   , A6
 286                   , detail::expand_pattern_rest_6<
 287                         Object
 288                         , A0 , A1 , A2 , A3 , A4 , A5
 289                     >
 290                 >::type
 291             >::template impl<Expr, State, Data>
 292         {};
 293     };
 294
 295
 296
 297
 298
 299
 300
 301
 302     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 303     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
 304       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
 305     {
 306         template<typename Expr, typename State, typename Data>
 307         struct impl
 308           : call<
 309                 typename make<Object>::template impl<Expr, State, Data>::result_type
 310                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)
 311             >::template impl<Expr, State, Data>
 312         {};
 313     };
 314     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 315     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
 316       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
 317     {
 318         template<typename Expr, typename State, typename Data>
 319         struct impl
 320           : lazy<
 321                 typename detail::expand_pattern<
 322                     proto::arity_of<Expr>::value
 323                   , A7
 324                   , detail::expand_pattern_rest_7<
 325                         Object
 326                         , A0 , A1 , A2 , A3 , A4 , A5 , A6
 327                     >
 328                 >::type
 329             >::template impl<Expr, State, Data>
 330         {};
 331     };
 332
 333
 334
 335
 336
 337
 338
 339
 340     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 341     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
 342       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
 343     {
 344         template<typename Expr, typename State, typename Data>
 345         struct impl
 346           : call<
 347                 typename make<Object>::template impl<Expr, State, Data>::result_type
 348                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)
 349             >::template impl<Expr, State, Data>
 350         {};
 351     };
 352     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
 353     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
 354       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
 355     {
 356         template<typename Expr, typename State, typename Data>
 357         struct impl
 358           : lazy<
 359                 typename detail::expand_pattern<
 360                     proto::arity_of<Expr>::value
 361                   , A8
 362                   , detail::expand_pattern_rest_8<
 363                         Object
 364                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
 365                     >
 366                 >::type
 367             >::template impl<Expr, State, Data>
 368         {};
 369     };
 370
 371
 372
 373
 374
 375
 376
 377
 378     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
 379     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
 380       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
 381     {
 382         template<typename Expr, typename State, typename Data>
 383         struct impl
 384           : call<
 385                 typename make<Object>::template impl<Expr, State, Data>::result_type
 386                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)
 387             >::template impl<Expr, State, Data>
 388         {};
 389     };
 390     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
 391     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
 392       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
 393     {
 394         template<typename Expr, typename State, typename Data>
 395         struct impl
 396           : lazy<
 397                 typename detail::expand_pattern<
 398                     proto::arity_of<Expr>::value
 399                   , A9
 400                   , detail::expand_pattern_rest_9<
 401                         Object
 402                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
 403                     >
 404                 >::type
 405             >::template impl<Expr, State, Data>
 406         {};
 407     };