detail/preprocessed/lazy.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file lazy.hpp
0003     /// Contains definition of the lazy<> transform.
0004     //
0005     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006     //  Software License, Version 1.0. (See accompanying file
0007     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008
0009
0010
0011
0012
0013
0014
0015
0016     template<typename Object >
0017     struct lazy<Object()>
0018       : transform<lazy<Object()> >
0019     {
0020         template<typename Expr, typename State, typename Data>
0021         struct impl
0022           : call<
0023                 typename make<Object>::template impl<Expr, State, Data>::result_type
0024                 ()
0025             >::template impl<Expr, State, Data>
0026         {};
0027     };
0028
0029
0030
0031
0032
0033
0034
0035
0036     template<typename Object , typename A0>
0037     struct lazy<Object(A0)>
0038       : transform<lazy<Object(A0)> >
0039     {
0040         template<typename Expr, typename State, typename Data>
0041         struct impl
0042           : call<
0043                 typename make<Object>::template impl<Expr, State, Data>::result_type
0044                 (A0)
0045             >::template impl<Expr, State, Data>
0046         {};
0047     };
0048     template<typename Object , typename A0>
0049     struct lazy<Object(A0...)>
0050       : transform<lazy<Object(A0...)> >
0051     {
0052         template<typename Expr, typename State, typename Data>
0053         struct impl
0054           : lazy<
0055                 typename detail::expand_pattern<
0056                     proto::arity_of<Expr>::value
0057                   , A0
0058                   , detail::expand_pattern_rest_0<
0059                         Object
0060
0061                     >
0062                 >::type
0063             >::template impl<Expr, State, Data>
0064         {};
0065     };
0066
0067
0068
0069
0070
0071
0072
0073
0074     template<typename Object , typename A0 , typename A1>
0075     struct lazy<Object(A0 , A1)>
0076       : transform<lazy<Object(A0 , A1)> >
0077     {
0078         template<typename Expr, typename State, typename Data>
0079         struct impl
0080           : call<
0081                 typename make<Object>::template impl<Expr, State, Data>::result_type
0082                 (A0 , A1)
0083             >::template impl<Expr, State, Data>
0084         {};
0085     };
0086     template<typename Object , typename A0 , typename A1>
0087     struct lazy<Object(A0 , A1...)>
0088       : transform<lazy<Object(A0 , A1...)> >
0089     {
0090         template<typename Expr, typename State, typename Data>
0091         struct impl
0092           : lazy<
0093                 typename detail::expand_pattern<
0094                     proto::arity_of<Expr>::value
0095                   , A1
0096                   , detail::expand_pattern_rest_1<
0097                         Object
0098                         , A0
0099                     >
0100                 >::type
0101             >::template impl<Expr, State, Data>
0102         {};
0103     };
0104
0105
0106
0107
0108
0109
0110
0111
0112     template<typename Object , typename A0 , typename A1 , typename A2>
0113     struct lazy<Object(A0 , A1 , A2)>
0114       : transform<lazy<Object(A0 , A1 , A2)> >
0115     {
0116         template<typename Expr, typename State, typename Data>
0117         struct impl
0118           : call<
0119                 typename make<Object>::template impl<Expr, State, Data>::result_type
0120                 (A0 , A1 , A2)
0121             >::template impl<Expr, State, Data>
0122         {};
0123     };
0124     template<typename Object , typename A0 , typename A1 , typename A2>
0125     struct lazy<Object(A0 , A1 , A2...)>
0126       : transform<lazy<Object(A0 , A1 , A2...)> >
0127     {
0128         template<typename Expr, typename State, typename Data>
0129         struct impl
0130           : lazy<
0131                 typename detail::expand_pattern<
0132                     proto::arity_of<Expr>::value
0133                   , A2
0134                   , detail::expand_pattern_rest_2<
0135                         Object
0136                         , A0 , A1
0137                     >
0138                 >::type
0139             >::template impl<Expr, State, Data>
0140         {};
0141     };
0142
0143
0144
0145
0146
0147
0148
0149
0150     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
0151     struct lazy<Object(A0 , A1 , A2 , A3)>
0152       : transform<lazy<Object(A0 , A1 , A2 , A3)> >
0153     {
0154         template<typename Expr, typename State, typename Data>
0155         struct impl
0156           : call<
0157                 typename make<Object>::template impl<Expr, State, Data>::result_type
0158                 (A0 , A1 , A2 , A3)
0159             >::template impl<Expr, State, Data>
0160         {};
0161     };
0162     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
0163     struct lazy<Object(A0 , A1 , A2 , A3...)>
0164       : transform<lazy<Object(A0 , A1 , A2 , A3...)> >
0165     {
0166         template<typename Expr, typename State, typename Data>
0167         struct impl
0168           : lazy<
0169                 typename detail::expand_pattern<
0170                     proto::arity_of<Expr>::value
0171                   , A3
0172                   , detail::expand_pattern_rest_3<
0173                         Object
0174                         , A0 , A1 , A2
0175                     >
0176                 >::type
0177             >::template impl<Expr, State, Data>
0178         {};
0179     };
0180
0181
0182
0183
0184
0185
0186
0187
0188     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0189     struct lazy<Object(A0 , A1 , A2 , A3 , A4)>
0190       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> >
0191     {
0192         template<typename Expr, typename State, typename Data>
0193         struct impl
0194           : call<
0195                 typename make<Object>::template impl<Expr, State, Data>::result_type
0196                 (A0 , A1 , A2 , A3 , A4)
0197             >::template impl<Expr, State, Data>
0198         {};
0199     };
0200     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0201     struct lazy<Object(A0 , A1 , A2 , A3 , A4...)>
0202       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> >
0203     {
0204         template<typename Expr, typename State, typename Data>
0205         struct impl
0206           : lazy<
0207                 typename detail::expand_pattern<
0208                     proto::arity_of<Expr>::value
0209                   , A4
0210                   , detail::expand_pattern_rest_4<
0211                         Object
0212                         , A0 , A1 , A2 , A3
0213                     >
0214                 >::type
0215             >::template impl<Expr, State, Data>
0216         {};
0217     };
0218
0219
0220
0221
0222
0223
0224
0225
0226     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0227     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)>
0228       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
0229     {
0230         template<typename Expr, typename State, typename Data>
0231         struct impl
0232           : call<
0233                 typename make<Object>::template impl<Expr, State, Data>::result_type
0234                 (A0 , A1 , A2 , A3 , A4 , A5)
0235             >::template impl<Expr, State, Data>
0236         {};
0237     };
0238     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0239     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
0240       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
0241     {
0242         template<typename Expr, typename State, typename Data>
0243         struct impl
0244           : lazy<
0245                 typename detail::expand_pattern<
0246                     proto::arity_of<Expr>::value
0247                   , A5
0248                   , detail::expand_pattern_rest_5<
0249                         Object
0250                         , A0 , A1 , A2 , A3 , A4
0251                     >
0252                 >::type
0253             >::template impl<Expr, State, Data>
0254         {};
0255     };
0256
0257
0258
0259
0260
0261
0262
0263
0264     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0265     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
0266       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
0267     {
0268         template<typename Expr, typename State, typename Data>
0269         struct impl
0270           : call<
0271                 typename make<Object>::template impl<Expr, State, Data>::result_type
0272                 (A0 , A1 , A2 , A3 , A4 , A5 , A6)
0273             >::template impl<Expr, State, Data>
0274         {};
0275     };
0276     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0277     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
0278       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
0279     {
0280         template<typename Expr, typename State, typename Data>
0281         struct impl
0282           : lazy<
0283                 typename detail::expand_pattern<
0284                     proto::arity_of<Expr>::value
0285                   , A6
0286                   , detail::expand_pattern_rest_6<
0287                         Object
0288                         , A0 , A1 , A2 , A3 , A4 , A5
0289                     >
0290                 >::type
0291             >::template impl<Expr, State, Data>
0292         {};
0293     };
0294
0295
0296
0297
0298
0299
0300
0301
0302     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0303     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
0304       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
0305     {
0306         template<typename Expr, typename State, typename Data>
0307         struct impl
0308           : call<
0309                 typename make<Object>::template impl<Expr, State, Data>::result_type
0310                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)
0311             >::template impl<Expr, State, Data>
0312         {};
0313     };
0314     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0315     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
0316       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
0317     {
0318         template<typename Expr, typename State, typename Data>
0319         struct impl
0320           : lazy<
0321                 typename detail::expand_pattern<
0322                     proto::arity_of<Expr>::value
0323                   , A7
0324                   , detail::expand_pattern_rest_7<
0325                         Object
0326                         , A0 , A1 , A2 , A3 , A4 , A5 , A6
0327                     >
0328                 >::type
0329             >::template impl<Expr, State, Data>
0330         {};
0331     };
0332
0333
0334
0335
0336
0337
0338
0339
0340     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0341     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
0342       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
0343     {
0344         template<typename Expr, typename State, typename Data>
0345         struct impl
0346           : call<
0347                 typename make<Object>::template impl<Expr, State, Data>::result_type
0348                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)
0349             >::template impl<Expr, State, Data>
0350         {};
0351     };
0352     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0353     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
0354       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
0355     {
0356         template<typename Expr, typename State, typename Data>
0357         struct impl
0358           : lazy<
0359                 typename detail::expand_pattern<
0360                     proto::arity_of<Expr>::value
0361                   , A8
0362                   , detail::expand_pattern_rest_8<
0363                         Object
0364                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
0365                     >
0366                 >::type
0367             >::template impl<Expr, State, Data>
0368         {};
0369     };
0370
0371
0372
0373
0374
0375
0376
0377
0378     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0379     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
0380       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
0381     {
0382         template<typename Expr, typename State, typename Data>
0383         struct impl
0384           : call<
0385                 typename make<Object>::template impl<Expr, State, Data>::result_type
0386                 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)
0387             >::template impl<Expr, State, Data>
0388         {};
0389     };
0390     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
0391     struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
0392       : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
0393     {
0394         template<typename Expr, typename State, typename Data>
0395         struct impl
0396           : lazy<
0397                 typename detail::expand_pattern<
0398                     proto::arity_of<Expr>::value
0399                   , A9
0400                   , detail::expand_pattern_rest_9<
0401                         Object
0402                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
0403                     >
0404                 >::type
0405             >::template impl<Expr, State, Data>
0406         {};
0407     };