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

   1     ///////////////////////////////////////////////////////////////////////////////
   2     /// \file make.hpp
   3     /// Contains definition of the make<> 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     namespace detail
   9     {
  10         template<typename R >
  11         struct is_applyable<R()>
  12           : mpl::true_
  13         {};
  14         template<typename R >
  15         struct is_applyable<R(*)()>
  16           : mpl::true_
  17         {};
  18         template<typename T, typename A>
  19         struct construct_<proto::expr<T, A, 0>, true>
  20         {
  21             typedef proto::expr<T, A, 0> result_type;
  22             template<typename A0>
  23             BOOST_FORCEINLINE
  24             result_type operator ()(A0 &a0) const
  25             {
  26                 return result_type::make(a0);
  27             }
  28         };
  29         template<typename T, typename A>
  30         struct construct_<proto::basic_expr<T, A, 0>, true>
  31         {
  32             typedef proto::basic_expr<T, A, 0> result_type;
  33             template<typename A0>
  34             BOOST_FORCEINLINE
  35             result_type operator ()(A0 &a0) const
  36             {
  37                 return result_type::make(a0);
  38             }
  39         };
  40         template<typename Type >
  41         BOOST_FORCEINLINE
  42         Type construct()
  43         {
  44             return construct_<Type>()();
  45         }
  46     }
  47
  48
  49
  50
  51     template<typename Object >
  52     struct make<Object()>
  53       : transform<make<Object()> >
  54     {
  55         template<typename Expr, typename State, typename Data>
  56         struct impl : transform_impl<Expr, State, Data>
  57         {
  58
  59             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
  60
  61
  62
  63
  64
  65
  66
  67             BOOST_FORCEINLINE
  68             result_type operator ()(
  69                 typename impl::expr_param e
  70               , typename impl::state_param s
  71               , typename impl::data_param d
  72             ) const
  73             {
  74                 proto::detail::ignore_unused(e);
  75                 proto::detail::ignore_unused(s);
  76                 proto::detail::ignore_unused(d);
  77                 return detail::construct<result_type>();
  78             }
  79         };
  80     };
  81     namespace detail
  82     {
  83         template<
  84             template<typename> class R
  85             , typename A0
  86           , typename Expr, typename State, typename Data
  87         >
  88         struct make_<
  89             R<A0>
  90           , Expr, State, Data
  91             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
  92         >
  93           : nested_type_if<
  94                 R<typename make_if_<A0, Expr, State, Data> ::type>
  95               , (make_if_<A0, Expr, State, Data> ::applied || false)
  96             >
  97         {};
  98         template<
  99             template<typename> class R
 100             , typename A0
 101           , typename Expr, typename State, typename Data
 102         >
 103         struct make_<
 104             noinvoke<R<A0> >
 105           , Expr, State, Data
 106             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 107         >
 108         {
 109             typedef R<typename make_if_<A0, Expr, State, Data> ::type> type;
 110             static bool const applied = true;
 111         };
 112         template<typename R , typename A0>
 113         struct is_applyable<R(A0)>
 114           : mpl::true_
 115         {};
 116         template<typename R , typename A0>
 117         struct is_applyable<R(*)(A0)>
 118           : mpl::true_
 119         {};
 120         template<typename T, typename A>
 121         struct construct_<proto::expr<T, A, 1>, true>
 122         {
 123             typedef proto::expr<T, A, 1> result_type;
 124             template<typename A0>
 125             BOOST_FORCEINLINE
 126             result_type operator ()(A0 &a0) const
 127             {
 128                 return result_type::make(a0);
 129             }
 130         };
 131         template<typename T, typename A>
 132         struct construct_<proto::basic_expr<T, A, 1>, true>
 133         {
 134             typedef proto::basic_expr<T, A, 1> result_type;
 135             template<typename A0>
 136             BOOST_FORCEINLINE
 137             result_type operator ()(A0 &a0) const
 138             {
 139                 return result_type::make(a0);
 140             }
 141         };
 142         template<typename Type , typename A0>
 143         BOOST_FORCEINLINE
 144         Type construct(A0 &a0)
 145         {
 146             return construct_<Type>()(a0);
 147         }
 148     }
 149
 150
 151
 152
 153     template<typename Object , typename A0>
 154     struct make<Object(A0)>
 155       : transform<make<Object(A0)> >
 156     {
 157         template<typename Expr, typename State, typename Data>
 158         struct impl : transform_impl<Expr, State, Data>
 159         {
 160
 161             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 162
 163
 164
 165
 166
 167
 168
 169             BOOST_FORCEINLINE
 170             result_type operator ()(
 171                 typename impl::expr_param e
 172               , typename impl::state_param s
 173               , typename impl::data_param d
 174             ) const
 175             {
 176                 proto::detail::ignore_unused(e);
 177                 proto::detail::ignore_unused(s);
 178                 proto::detail::ignore_unused(d);
 179                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ));
 180             }
 181         };
 182     };
 183
 184
 185
 186
 187     template<typename Object , typename A0>
 188     struct make<Object(A0...)>
 189       : transform<make<Object(A0...)> >
 190     {
 191         template<typename Expr, typename State, typename Data>
 192         struct impl
 193           : make<
 194                 typename detail::expand_pattern<
 195                     proto::arity_of<Expr>::value
 196                   , A0
 197                   , detail::expand_pattern_rest_0<
 198                         Object
 199
 200                     >
 201                 >::type
 202             >::template impl<Expr, State, Data>
 203         {};
 204     };
 205     namespace detail
 206     {
 207         template<
 208             template<typename , typename> class R
 209             , typename A0 , typename A1
 210           , typename Expr, typename State, typename Data
 211         >
 212         struct make_<
 213             R<A0 , A1>
 214           , Expr, State, Data
 215             BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
 216         >
 217           : nested_type_if<
 218                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type>
 219               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false)
 220             >
 221         {};
 222         template<
 223             template<typename , typename> class R
 224             , typename A0 , typename A1
 225           , typename Expr, typename State, typename Data
 226         >
 227         struct make_<
 228             noinvoke<R<A0 , A1> >
 229           , Expr, State, Data
 230             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 231         >
 232         {
 233             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type;
 234             static bool const applied = true;
 235         };
 236         template<typename R , typename A0 , typename A1>
 237         struct is_applyable<R(A0 , A1)>
 238           : mpl::true_
 239         {};
 240         template<typename R , typename A0 , typename A1>
 241         struct is_applyable<R(*)(A0 , A1)>
 242           : mpl::true_
 243         {};
 244         template<typename T, typename A>
 245         struct construct_<proto::expr<T, A, 2>, true>
 246         {
 247             typedef proto::expr<T, A, 2> result_type;
 248             template<typename A0 , typename A1>
 249             BOOST_FORCEINLINE
 250             result_type operator ()(A0 &a0 , A1 &a1) const
 251             {
 252                 return result_type::make(a0 , a1);
 253             }
 254         };
 255         template<typename T, typename A>
 256         struct construct_<proto::basic_expr<T, A, 2>, true>
 257         {
 258             typedef proto::basic_expr<T, A, 2> result_type;
 259             template<typename A0 , typename A1>
 260             BOOST_FORCEINLINE
 261             result_type operator ()(A0 &a0 , A1 &a1) const
 262             {
 263                 return result_type::make(a0 , a1);
 264             }
 265         };
 266         template<typename Type , typename A0 , typename A1>
 267         BOOST_FORCEINLINE
 268         Type construct(A0 &a0 , A1 &a1)
 269         {
 270             return construct_<Type>()(a0 , a1);
 271         }
 272     }
 273
 274
 275
 276
 277     template<typename Object , typename A0 , typename A1>
 278     struct make<Object(A0 , A1)>
 279       : transform<make<Object(A0 , A1)> >
 280     {
 281         template<typename Expr, typename State, typename Data>
 282         struct impl : transform_impl<Expr, State, Data>
 283         {
 284
 285             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 286
 287
 288
 289
 290
 291
 292
 293             BOOST_FORCEINLINE
 294             result_type operator ()(
 295                 typename impl::expr_param e
 296               , typename impl::state_param s
 297               , typename impl::data_param d
 298             ) const
 299             {
 300                 proto::detail::ignore_unused(e);
 301                 proto::detail::ignore_unused(s);
 302                 proto::detail::ignore_unused(d);
 303                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ));
 304             }
 305         };
 306     };
 307
 308
 309
 310
 311     template<typename Object , typename A0 , typename A1>
 312     struct make<Object(A0 , A1...)>
 313       : transform<make<Object(A0 , A1...)> >
 314     {
 315         template<typename Expr, typename State, typename Data>
 316         struct impl
 317           : make<
 318                 typename detail::expand_pattern<
 319                     proto::arity_of<Expr>::value
 320                   , A1
 321                   , detail::expand_pattern_rest_1<
 322                         Object
 323                         , A0
 324                     >
 325                 >::type
 326             >::template impl<Expr, State, Data>
 327         {};
 328     };
 329     namespace detail
 330     {
 331         template<
 332             template<typename , typename , typename> class R
 333             , typename A0 , typename A1 , typename A2
 334           , typename Expr, typename State, typename Data
 335         >
 336         struct make_<
 337             R<A0 , A1 , A2>
 338           , Expr, State, Data
 339             BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
 340         >
 341           : nested_type_if<
 342                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type>
 343               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false)
 344             >
 345         {};
 346         template<
 347             template<typename , typename , typename> class R
 348             , typename A0 , typename A1 , typename A2
 349           , typename Expr, typename State, typename Data
 350         >
 351         struct make_<
 352             noinvoke<R<A0 , A1 , A2> >
 353           , Expr, State, Data
 354             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 355         >
 356         {
 357             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type;
 358             static bool const applied = true;
 359         };
 360         template<typename R , typename A0 , typename A1 , typename A2>
 361         struct is_applyable<R(A0 , A1 , A2)>
 362           : mpl::true_
 363         {};
 364         template<typename R , typename A0 , typename A1 , typename A2>
 365         struct is_applyable<R(*)(A0 , A1 , A2)>
 366           : mpl::true_
 367         {};
 368         template<typename T, typename A>
 369         struct construct_<proto::expr<T, A, 3>, true>
 370         {
 371             typedef proto::expr<T, A, 3> result_type;
 372             template<typename A0 , typename A1 , typename A2>
 373             BOOST_FORCEINLINE
 374             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
 375             {
 376                 return result_type::make(a0 , a1 , a2);
 377             }
 378         };
 379         template<typename T, typename A>
 380         struct construct_<proto::basic_expr<T, A, 3>, true>
 381         {
 382             typedef proto::basic_expr<T, A, 3> result_type;
 383             template<typename A0 , typename A1 , typename A2>
 384             BOOST_FORCEINLINE
 385             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
 386             {
 387                 return result_type::make(a0 , a1 , a2);
 388             }
 389         };
 390         template<typename Type , typename A0 , typename A1 , typename A2>
 391         BOOST_FORCEINLINE
 392         Type construct(A0 &a0 , A1 &a1 , A2 &a2)
 393         {
 394             return construct_<Type>()(a0 , a1 , a2);
 395         }
 396     }
 397
 398
 399
 400
 401     template<typename Object , typename A0 , typename A1 , typename A2>
 402     struct make<Object(A0 , A1 , A2)>
 403       : transform<make<Object(A0 , A1 , A2)> >
 404     {
 405         template<typename Expr, typename State, typename Data>
 406         struct impl : transform_impl<Expr, State, Data>
 407         {
 408
 409             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 410
 411
 412
 413
 414
 415
 416
 417             BOOST_FORCEINLINE
 418             result_type operator ()(
 419                 typename impl::expr_param e
 420               , typename impl::state_param s
 421               , typename impl::data_param d
 422             ) const
 423             {
 424                 proto::detail::ignore_unused(e);
 425                 proto::detail::ignore_unused(s);
 426                 proto::detail::ignore_unused(d);
 427                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ));
 428             }
 429         };
 430     };
 431
 432
 433
 434
 435     template<typename Object , typename A0 , typename A1 , typename A2>
 436     struct make<Object(A0 , A1 , A2...)>
 437       : transform<make<Object(A0 , A1 , A2...)> >
 438     {
 439         template<typename Expr, typename State, typename Data>
 440         struct impl
 441           : make<
 442                 typename detail::expand_pattern<
 443                     proto::arity_of<Expr>::value
 444                   , A2
 445                   , detail::expand_pattern_rest_2<
 446                         Object
 447                         , A0 , A1
 448                     >
 449                 >::type
 450             >::template impl<Expr, State, Data>
 451         {};
 452     };
 453     namespace detail
 454     {
 455         template<
 456             template<typename , typename , typename , typename> class R
 457             , typename A0 , typename A1 , typename A2 , typename A3
 458           , typename Expr, typename State, typename Data
 459         >
 460         struct make_<
 461             R<A0 , A1 , A2 , A3>
 462           , Expr, State, Data
 463             BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
 464         >
 465           : nested_type_if<
 466                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type>
 467               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false)
 468             >
 469         {};
 470         template<
 471             template<typename , typename , typename , typename> class R
 472             , typename A0 , typename A1 , typename A2 , typename A3
 473           , typename Expr, typename State, typename Data
 474         >
 475         struct make_<
 476             noinvoke<R<A0 , A1 , A2 , A3> >
 477           , Expr, State, Data
 478             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 479         >
 480         {
 481             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type;
 482             static bool const applied = true;
 483         };
 484         template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
 485         struct is_applyable<R(A0 , A1 , A2 , A3)>
 486           : mpl::true_
 487         {};
 488         template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
 489         struct is_applyable<R(*)(A0 , A1 , A2 , A3)>
 490           : mpl::true_
 491         {};
 492         template<typename T, typename A>
 493         struct construct_<proto::expr<T, A, 4>, true>
 494         {
 495             typedef proto::expr<T, A, 4> result_type;
 496             template<typename A0 , typename A1 , typename A2 , typename A3>
 497             BOOST_FORCEINLINE
 498             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
 499             {
 500                 return result_type::make(a0 , a1 , a2 , a3);
 501             }
 502         };
 503         template<typename T, typename A>
 504         struct construct_<proto::basic_expr<T, A, 4>, true>
 505         {
 506             typedef proto::basic_expr<T, A, 4> result_type;
 507             template<typename A0 , typename A1 , typename A2 , typename A3>
 508             BOOST_FORCEINLINE
 509             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
 510             {
 511                 return result_type::make(a0 , a1 , a2 , a3);
 512             }
 513         };
 514         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3>
 515         BOOST_FORCEINLINE
 516         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3)
 517         {
 518             return construct_<Type>()(a0 , a1 , a2 , a3);
 519         }
 520     }
 521
 522
 523
 524
 525     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
 526     struct make<Object(A0 , A1 , A2 , A3)>
 527       : transform<make<Object(A0 , A1 , A2 , A3)> >
 528     {
 529         template<typename Expr, typename State, typename Data>
 530         struct impl : transform_impl<Expr, State, Data>
 531         {
 532
 533             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 534
 535
 536
 537
 538
 539
 540
 541             BOOST_FORCEINLINE
 542             result_type operator ()(
 543                 typename impl::expr_param e
 544               , typename impl::state_param s
 545               , typename impl::data_param d
 546             ) const
 547             {
 548                 proto::detail::ignore_unused(e);
 549                 proto::detail::ignore_unused(s);
 550                 proto::detail::ignore_unused(d);
 551                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ));
 552             }
 553         };
 554     };
 555
 556
 557
 558
 559     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
 560     struct make<Object(A0 , A1 , A2 , A3...)>
 561       : transform<make<Object(A0 , A1 , A2 , A3...)> >
 562     {
 563         template<typename Expr, typename State, typename Data>
 564         struct impl
 565           : make<
 566                 typename detail::expand_pattern<
 567                     proto::arity_of<Expr>::value
 568                   , A3
 569                   , detail::expand_pattern_rest_3<
 570                         Object
 571                         , A0 , A1 , A2
 572                     >
 573                 >::type
 574             >::template impl<Expr, State, Data>
 575         {};
 576     };
 577     namespace detail
 578     {
 579         template<
 580             template<typename , typename , typename , typename , typename> class R
 581             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
 582           , typename Expr, typename State, typename Data
 583         >
 584         struct make_<
 585             R<A0 , A1 , A2 , A3 , A4>
 586           , Expr, State, Data
 587             BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
 588         >
 589           : nested_type_if<
 590                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type>
 591               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false)
 592             >
 593         {};
 594         template<
 595             template<typename , typename , typename , typename , typename> class R
 596             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
 597           , typename Expr, typename State, typename Data
 598         >
 599         struct make_<
 600             noinvoke<R<A0 , A1 , A2 , A3 , A4> >
 601           , Expr, State, Data
 602             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 603         >
 604         {
 605             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type;
 606             static bool const applied = true;
 607         };
 608         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 609         struct is_applyable<R(A0 , A1 , A2 , A3 , A4)>
 610           : mpl::true_
 611         {};
 612         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 613         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)>
 614           : mpl::true_
 615         {};
 616         template<typename T, typename A>
 617         struct construct_<proto::expr<T, A, 5>, true>
 618         {
 619             typedef proto::expr<T, A, 5> result_type;
 620             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 621             BOOST_FORCEINLINE
 622             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
 623             {
 624                 return result_type::make(a0 , a1 , a2 , a3 , a4);
 625             }
 626         };
 627         template<typename T, typename A>
 628         struct construct_<proto::basic_expr<T, A, 5>, true>
 629         {
 630             typedef proto::basic_expr<T, A, 5> result_type;
 631             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 632             BOOST_FORCEINLINE
 633             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
 634             {
 635                 return result_type::make(a0 , a1 , a2 , a3 , a4);
 636             }
 637         };
 638         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 639         BOOST_FORCEINLINE
 640         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4)
 641         {
 642             return construct_<Type>()(a0 , a1 , a2 , a3 , a4);
 643         }
 644     }
 645
 646
 647
 648
 649     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 650     struct make<Object(A0 , A1 , A2 , A3 , A4)>
 651       : transform<make<Object(A0 , A1 , A2 , A3 , A4)> >
 652     {
 653         template<typename Expr, typename State, typename Data>
 654         struct impl : transform_impl<Expr, State, Data>
 655         {
 656
 657             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 658
 659
 660
 661
 662
 663
 664
 665             BOOST_FORCEINLINE
 666             result_type operator ()(
 667                 typename impl::expr_param e
 668               , typename impl::state_param s
 669               , typename impl::data_param d
 670             ) const
 671             {
 672                 proto::detail::ignore_unused(e);
 673                 proto::detail::ignore_unused(s);
 674                 proto::detail::ignore_unused(d);
 675                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ));
 676             }
 677         };
 678     };
 679
 680
 681
 682
 683     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
 684     struct make<Object(A0 , A1 , A2 , A3 , A4...)>
 685       : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> >
 686     {
 687         template<typename Expr, typename State, typename Data>
 688         struct impl
 689           : make<
 690                 typename detail::expand_pattern<
 691                     proto::arity_of<Expr>::value
 692                   , A4
 693                   , detail::expand_pattern_rest_4<
 694                         Object
 695                         , A0 , A1 , A2 , A3
 696                     >
 697                 >::type
 698             >::template impl<Expr, State, Data>
 699         {};
 700     };
 701     namespace detail
 702     {
 703         template<
 704             template<typename , typename , typename , typename , typename , typename> class R
 705             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
 706           , typename Expr, typename State, typename Data
 707         >
 708         struct make_<
 709             R<A0 , A1 , A2 , A3 , A4 , A5>
 710           , Expr, State, Data
 711             BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
 712         >
 713           : nested_type_if<
 714                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type>
 715               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false)
 716             >
 717         {};
 718         template<
 719             template<typename , typename , typename , typename , typename , typename> class R
 720             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
 721           , typename Expr, typename State, typename Data
 722         >
 723         struct make_<
 724             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> >
 725           , Expr, State, Data
 726             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 727         >
 728         {
 729             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type;
 730             static bool const applied = true;
 731         };
 732         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 733         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)>
 734           : mpl::true_
 735         {};
 736         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 737         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)>
 738           : mpl::true_
 739         {};
 740         template<typename T, typename A>
 741         struct construct_<proto::expr<T, A, 6>, true>
 742         {
 743             typedef proto::expr<T, A, 6> result_type;
 744             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 745             BOOST_FORCEINLINE
 746             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
 747             {
 748                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
 749             }
 750         };
 751         template<typename T, typename A>
 752         struct construct_<proto::basic_expr<T, A, 6>, true>
 753         {
 754             typedef proto::basic_expr<T, A, 6> result_type;
 755             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 756             BOOST_FORCEINLINE
 757             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
 758             {
 759                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
 760             }
 761         };
 762         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 763         BOOST_FORCEINLINE
 764         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5)
 765         {
 766             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5);
 767         }
 768     }
 769
 770
 771
 772
 773     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 774     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)>
 775       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
 776     {
 777         template<typename Expr, typename State, typename Data>
 778         struct impl : transform_impl<Expr, State, Data>
 779         {
 780
 781             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 782
 783
 784
 785
 786
 787
 788
 789             BOOST_FORCEINLINE
 790             result_type operator ()(
 791                 typename impl::expr_param e
 792               , typename impl::state_param s
 793               , typename impl::data_param d
 794             ) const
 795             {
 796                 proto::detail::ignore_unused(e);
 797                 proto::detail::ignore_unused(s);
 798                 proto::detail::ignore_unused(d);
 799                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ));
 800             }
 801         };
 802     };
 803
 804
 805
 806
 807     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
 808     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
 809       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
 810     {
 811         template<typename Expr, typename State, typename Data>
 812         struct impl
 813           : make<
 814                 typename detail::expand_pattern<
 815                     proto::arity_of<Expr>::value
 816                   , A5
 817                   , detail::expand_pattern_rest_5<
 818                         Object
 819                         , A0 , A1 , A2 , A3 , A4
 820                     >
 821                 >::type
 822             >::template impl<Expr, State, Data>
 823         {};
 824     };
 825     namespace detail
 826     {
 827         template<
 828             template<typename , typename , typename , typename , typename , typename , typename> class R
 829             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
 830           , typename Expr, typename State, typename Data
 831         >
 832         struct make_<
 833             R<A0 , A1 , A2 , A3 , A4 , A5 , A6>
 834           , Expr, State, Data
 835             BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
 836         >
 837           : nested_type_if<
 838                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type>
 839               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false)
 840             >
 841         {};
 842         template<
 843             template<typename , typename , typename , typename , typename , typename , typename> class R
 844             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
 845           , typename Expr, typename State, typename Data
 846         >
 847         struct make_<
 848             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> >
 849           , Expr, State, Data
 850             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 851         >
 852         {
 853             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type;
 854             static bool const applied = true;
 855         };
 856         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 857         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
 858           : mpl::true_
 859         {};
 860         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 861         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
 862           : mpl::true_
 863         {};
 864         template<typename T, typename A>
 865         struct construct_<proto::expr<T, A, 7>, true>
 866         {
 867             typedef proto::expr<T, A, 7> result_type;
 868             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 869             BOOST_FORCEINLINE
 870             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
 871             {
 872                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
 873             }
 874         };
 875         template<typename T, typename A>
 876         struct construct_<proto::basic_expr<T, A, 7>, true>
 877         {
 878             typedef proto::basic_expr<T, A, 7> result_type;
 879             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 880             BOOST_FORCEINLINE
 881             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
 882             {
 883                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
 884             }
 885         };
 886         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 887         BOOST_FORCEINLINE
 888         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6)
 889         {
 890             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
 891         }
 892     }
 893
 894
 895
 896
 897     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 898     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
 899       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
 900     {
 901         template<typename Expr, typename State, typename Data>
 902         struct impl : transform_impl<Expr, State, Data>
 903         {
 904
 905             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
 906
 907
 908
 909
 910
 911
 912
 913             BOOST_FORCEINLINE
 914             result_type operator ()(
 915                 typename impl::expr_param e
 916               , typename impl::state_param s
 917               , typename impl::data_param d
 918             ) const
 919             {
 920                 proto::detail::ignore_unused(e);
 921                 proto::detail::ignore_unused(s);
 922                 proto::detail::ignore_unused(d);
 923                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ));
 924             }
 925         };
 926     };
 927
 928
 929
 930
 931     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
 932     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
 933       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
 934     {
 935         template<typename Expr, typename State, typename Data>
 936         struct impl
 937           : make<
 938                 typename detail::expand_pattern<
 939                     proto::arity_of<Expr>::value
 940                   , A6
 941                   , detail::expand_pattern_rest_6<
 942                         Object
 943                         , A0 , A1 , A2 , A3 , A4 , A5
 944                     >
 945                 >::type
 946             >::template impl<Expr, State, Data>
 947         {};
 948     };
 949     namespace detail
 950     {
 951         template<
 952             template<typename , typename , typename , typename , typename , typename , typename , typename> class R
 953             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
 954           , typename Expr, typename State, typename Data
 955         >
 956         struct make_<
 957             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
 958           , Expr, State, Data
 959             BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
 960         >
 961           : nested_type_if<
 962                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type>
 963               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false)
 964             >
 965         {};
 966         template<
 967             template<typename , typename , typename , typename , typename , typename , typename , typename> class R
 968             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
 969           , typename Expr, typename State, typename Data
 970         >
 971         struct make_<
 972             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
 973           , Expr, State, Data
 974             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
 975         >
 976         {
 977             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type;
 978             static bool const applied = true;
 979         };
 980         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 981         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
 982           : mpl::true_
 983         {};
 984         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 985         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
 986           : mpl::true_
 987         {};
 988         template<typename T, typename A>
 989         struct construct_<proto::expr<T, A, 8>, true>
 990         {
 991             typedef proto::expr<T, A, 8> result_type;
 992             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
 993             BOOST_FORCEINLINE
 994             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
 995             {
 996                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
 997             }
 998         };
 999         template<typename T, typename A>
1000         struct construct_<proto::basic_expr<T, A, 8>, true>
1001         {
1002             typedef proto::basic_expr<T, A, 8> result_type;
1003             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1004             BOOST_FORCEINLINE
1005             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
1006             {
1007                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1008             }
1009         };
1010         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1011         BOOST_FORCEINLINE
1012         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7)
1013         {
1014             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1015         }
1016     }
1017
1018
1019
1020
1021     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1022     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
1023       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
1024     {
1025         template<typename Expr, typename State, typename Data>
1026         struct impl : transform_impl<Expr, State, Data>
1027         {
1028
1029             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1030
1031
1032
1033
1034
1035
1036
1037             BOOST_FORCEINLINE
1038             result_type operator ()(
1039                 typename impl::expr_param e
1040               , typename impl::state_param s
1041               , typename impl::data_param d
1042             ) const
1043             {
1044                 proto::detail::ignore_unused(e);
1045                 proto::detail::ignore_unused(s);
1046                 proto::detail::ignore_unused(d);
1047                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ));
1048             }
1049         };
1050     };
1051
1052
1053
1054
1055     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1056     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
1057       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
1058     {
1059         template<typename Expr, typename State, typename Data>
1060         struct impl
1061           : make<
1062                 typename detail::expand_pattern<
1063                     proto::arity_of<Expr>::value
1064                   , A7
1065                   , detail::expand_pattern_rest_7<
1066                         Object
1067                         , A0 , A1 , A2 , A3 , A4 , A5 , A6
1068                     >
1069                 >::type
1070             >::template impl<Expr, State, Data>
1071         {};
1072     };
1073     namespace detail
1074     {
1075         template<
1076             template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1077             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
1078           , typename Expr, typename State, typename Data
1079         >
1080         struct make_<
1081             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
1082           , Expr, State, Data
1083             BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
1084         >
1085           : nested_type_if<
1086                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type>
1087               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false)
1088             >
1089         {};
1090         template<
1091             template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1092             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
1093           , typename Expr, typename State, typename Data
1094         >
1095         struct make_<
1096             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
1097           , Expr, State, Data
1098             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
1099         >
1100         {
1101             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type;
1102             static bool const applied = true;
1103         };
1104         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1105         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1106           : mpl::true_
1107         {};
1108         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1109         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1110           : mpl::true_
1111         {};
1112         template<typename T, typename A>
1113         struct construct_<proto::expr<T, A, 9>, true>
1114         {
1115             typedef proto::expr<T, A, 9> result_type;
1116             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1117             BOOST_FORCEINLINE
1118             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
1119             {
1120                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1121             }
1122         };
1123         template<typename T, typename A>
1124         struct construct_<proto::basic_expr<T, A, 9>, true>
1125         {
1126             typedef proto::basic_expr<T, A, 9> result_type;
1127             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1128             BOOST_FORCEINLINE
1129             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
1130             {
1131                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1132             }
1133         };
1134         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1135         BOOST_FORCEINLINE
1136         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8)
1137         {
1138             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1139         }
1140     }
1141
1142
1143
1144
1145     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1146     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1147       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
1148     {
1149         template<typename Expr, typename State, typename Data>
1150         struct impl : transform_impl<Expr, State, Data>
1151         {
1152
1153             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1154
1155
1156
1157
1158
1159
1160
1161             BOOST_FORCEINLINE
1162             result_type operator ()(
1163                 typename impl::expr_param e
1164               , typename impl::state_param s
1165               , typename impl::data_param d
1166             ) const
1167             {
1168                 proto::detail::ignore_unused(e);
1169                 proto::detail::ignore_unused(s);
1170                 proto::detail::ignore_unused(d);
1171                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ));
1172             }
1173         };
1174     };
1175
1176
1177
1178
1179     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1180     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
1181       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
1182     {
1183         template<typename Expr, typename State, typename Data>
1184         struct impl
1185           : make<
1186                 typename detail::expand_pattern<
1187                     proto::arity_of<Expr>::value
1188                   , A8
1189                   , detail::expand_pattern_rest_8<
1190                         Object
1191                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1192                     >
1193                 >::type
1194             >::template impl<Expr, State, Data>
1195         {};
1196     };
1197     namespace detail
1198     {
1199         template<
1200             template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1201             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
1202           , typename Expr, typename State, typename Data
1203         >
1204         struct make_<
1205             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
1206           , Expr, State, Data
1207             BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
1208         >
1209           : nested_type_if<
1210                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type>
1211               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false)
1212             >
1213         {};
1214         template<
1215             template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1216             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
1217           , typename Expr, typename State, typename Data
1218         >
1219         struct make_<
1220             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
1221           , Expr, State, Data
1222             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
1223         >
1224         {
1225             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type;
1226             static bool const applied = true;
1227         };
1228         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1229         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1230           : mpl::true_
1231         {};
1232         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1233         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1234           : mpl::true_
1235         {};
1236         template<typename T, typename A>
1237         struct construct_<proto::expr<T, A, 10>, true>
1238         {
1239             typedef proto::expr<T, A, 10> result_type;
1240             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1241             BOOST_FORCEINLINE
1242             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1243             {
1244                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1245             }
1246         };
1247         template<typename T, typename A>
1248         struct construct_<proto::basic_expr<T, A, 10>, true>
1249         {
1250             typedef proto::basic_expr<T, A, 10> result_type;
1251             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1252             BOOST_FORCEINLINE
1253             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1254             {
1255                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1256             }
1257         };
1258         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1259         BOOST_FORCEINLINE
1260         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9)
1261         {
1262             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1263         }
1264     }
1265
1266
1267
1268
1269     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1270     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1271       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
1272     {
1273         template<typename Expr, typename State, typename Data>
1274         struct impl : transform_impl<Expr, State, Data>
1275         {
1276
1277             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1278
1279
1280
1281
1282
1283
1284
1285             BOOST_FORCEINLINE
1286             result_type operator ()(
1287                 typename impl::expr_param e
1288               , typename impl::state_param s
1289               , typename impl::data_param d
1290             ) const
1291             {
1292                 proto::detail::ignore_unused(e);
1293                 proto::detail::ignore_unused(s);
1294                 proto::detail::ignore_unused(d);
1295                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ));
1296             }
1297         };
1298     };
1299
1300
1301
1302
1303     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1304     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
1305       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
1306     {
1307         template<typename Expr, typename State, typename Data>
1308         struct impl
1309           : make<
1310                 typename detail::expand_pattern<
1311                     proto::arity_of<Expr>::value
1312                   , A9
1313                   , detail::expand_pattern_rest_9<
1314                         Object
1315                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1316                     >
1317                 >::type
1318             >::template impl<Expr, State, Data>
1319         {};
1320     };