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> operator ()detail::construct_23 result_type operator ()(A0 &a0) const 24 { 25 return result_type::make(a0); 26 } 27 }; 28 template<typename T, typename A> 29 struct construct_<proto::basic_expr<T, A, 0>, true> 30 { 31 typedef proto::basic_expr<T, A, 0> result_type; 32 template<typename A0> operator ()detail::construct_33 result_type operator ()(A0 &a0) const 34 { 35 return result_type::make(a0); 36 } 37 }; 38 template<typename Type > construct()39 Type construct() 40 { 41 return construct_<Type>()(); 42 } 43 } 44 45 46 47 48 template<typename Object > 49 struct make<Object()> 50 : transform<make<Object()> > 51 { 52 template<typename Expr, typename State, typename Data> 53 struct impl : transform_impl<Expr, State, Data> 54 { 55 56 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 57 58 59 60 61 62 63 operator ()make::impl64 result_type operator ()( 65 typename impl::expr_param e 66 , typename impl::state_param s 67 , typename impl::data_param d 68 ) const 69 { 70 proto::detail::ignore_unused(e); 71 proto::detail::ignore_unused(s); 72 proto::detail::ignore_unused(d); 73 return detail::construct<result_type>(); 74 } 75 }; 76 }; 77 namespace detail 78 { 79 template< 80 template<typename> class R 81 , typename A0 82 , typename Expr, typename State, typename Data 83 > 84 struct make_< 85 R<A0> 86 , Expr, State, Data 87 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 88 > 89 : nested_type_if< 90 R<typename make_if_<A0, Expr, State, Data> ::type> 91 , (make_if_<A0, Expr, State, Data> ::applied || false) 92 > 93 {}; 94 template< 95 template<typename> class R 96 , typename A0 97 , typename Expr, typename State, typename Data 98 > 99 struct make_< 100 noinvoke<R<A0> > 101 , Expr, State, Data 102 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 103 > 104 { 105 typedef R<typename make_if_<A0, Expr, State, Data> ::type> type; 106 static bool const applied = true; 107 }; 108 template<typename R , typename A0> 109 struct is_applyable<R(A0)> 110 : mpl::true_ 111 {}; 112 template<typename R , typename A0> 113 struct is_applyable<R(*)(A0)> 114 : mpl::true_ 115 {}; 116 template<typename T, typename A> 117 struct construct_<proto::expr<T, A, 1>, true> 118 { 119 typedef proto::expr<T, A, 1> result_type; 120 template<typename A0> operator ()detail::construct_121 result_type operator ()(A0 &a0) const 122 { 123 return result_type::make(a0); 124 } 125 }; 126 template<typename T, typename A> 127 struct construct_<proto::basic_expr<T, A, 1>, true> 128 { 129 typedef proto::basic_expr<T, A, 1> result_type; 130 template<typename A0> operator ()detail::construct_131 result_type operator ()(A0 &a0) const 132 { 133 return result_type::make(a0); 134 } 135 }; 136 template<typename Type , typename A0> 137 Type construct(A0 &a0) 138 { 139 return construct_<Type>()(a0); 140 } 141 } 142 143 144 145 146 template<typename Object , typename A0> 147 struct make<Object(A0)> 148 : transform<make<Object(A0)> > 149 { 150 template<typename Expr, typename State, typename Data> 151 struct impl : transform_impl<Expr, State, Data> 152 { 153 154 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 155 156 157 158 159 160 161 operator ()make::impl162 result_type operator ()( 163 typename impl::expr_param e 164 , typename impl::state_param s 165 , typename impl::data_param d 166 ) const 167 { 168 proto::detail::ignore_unused(e); 169 proto::detail::ignore_unused(s); 170 proto::detail::ignore_unused(d); 171 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )); 172 } 173 }; 174 }; 175 namespace detail 176 { 177 template< 178 template<typename , typename> class R 179 , typename A0 , typename A1 180 , typename Expr, typename State, typename Data 181 > 182 struct make_< 183 R<A0 , A1> 184 , Expr, State, Data 185 BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) 186 > 187 : nested_type_if< 188 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> 189 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false) 190 > 191 {}; 192 template< 193 template<typename , typename> class R 194 , typename A0 , typename A1 195 , typename Expr, typename State, typename Data 196 > 197 struct make_< 198 noinvoke<R<A0 , A1> > 199 , Expr, State, Data 200 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 201 > 202 { 203 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type; 204 static bool const applied = true; 205 }; 206 template<typename R , typename A0 , typename A1> 207 struct is_applyable<R(A0 , A1)> 208 : mpl::true_ 209 {}; 210 template<typename R , typename A0 , typename A1> 211 struct is_applyable<R(*)(A0 , A1)> 212 : mpl::true_ 213 {}; 214 template<typename T, typename A> 215 struct construct_<proto::expr<T, A, 2>, true> 216 { 217 typedef proto::expr<T, A, 2> result_type; 218 template<typename A0 , typename A1> operator ()detail::construct_219 result_type operator ()(A0 &a0 , A1 &a1) const 220 { 221 return result_type::make(a0 , a1); 222 } 223 }; 224 template<typename T, typename A> 225 struct construct_<proto::basic_expr<T, A, 2>, true> 226 { 227 typedef proto::basic_expr<T, A, 2> result_type; 228 template<typename A0 , typename A1> operator ()detail::construct_229 result_type operator ()(A0 &a0 , A1 &a1) const 230 { 231 return result_type::make(a0 , a1); 232 } 233 }; 234 template<typename Type , typename A0 , typename A1> 235 Type construct(A0 &a0 , A1 &a1) 236 { 237 return construct_<Type>()(a0 , a1); 238 } 239 } 240 241 242 243 244 template<typename Object , typename A0 , typename A1> 245 struct make<Object(A0 , A1)> 246 : transform<make<Object(A0 , A1)> > 247 { 248 template<typename Expr, typename State, typename Data> 249 struct impl : transform_impl<Expr, State, Data> 250 { 251 252 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 253 254 255 256 257 258 259 operator ()make::impl260 result_type operator ()( 261 typename impl::expr_param e 262 , typename impl::state_param s 263 , typename impl::data_param d 264 ) const 265 { 266 proto::detail::ignore_unused(e); 267 proto::detail::ignore_unused(s); 268 proto::detail::ignore_unused(d); 269 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) )); 270 } 271 }; 272 }; 273 namespace detail 274 { 275 template< 276 template<typename , typename , typename> class R 277 , typename A0 , typename A1 , typename A2 278 , typename Expr, typename State, typename Data 279 > 280 struct make_< 281 R<A0 , A1 , A2> 282 , Expr, State, Data 283 BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) 284 > 285 : nested_type_if< 286 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> 287 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false) 288 > 289 {}; 290 template< 291 template<typename , typename , typename> class R 292 , typename A0 , typename A1 , typename A2 293 , typename Expr, typename State, typename Data 294 > 295 struct make_< 296 noinvoke<R<A0 , A1 , A2> > 297 , Expr, State, Data 298 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 299 > 300 { 301 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; 302 static bool const applied = true; 303 }; 304 template<typename R , typename A0 , typename A1 , typename A2> 305 struct is_applyable<R(A0 , A1 , A2)> 306 : mpl::true_ 307 {}; 308 template<typename R , typename A0 , typename A1 , typename A2> 309 struct is_applyable<R(*)(A0 , A1 , A2)> 310 : mpl::true_ 311 {}; 312 template<typename T, typename A> 313 struct construct_<proto::expr<T, A, 3>, true> 314 { 315 typedef proto::expr<T, A, 3> result_type; 316 template<typename A0 , typename A1 , typename A2> operator ()detail::construct_317 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const 318 { 319 return result_type::make(a0 , a1 , a2); 320 } 321 }; 322 template<typename T, typename A> 323 struct construct_<proto::basic_expr<T, A, 3>, true> 324 { 325 typedef proto::basic_expr<T, A, 3> result_type; 326 template<typename A0 , typename A1 , typename A2> operator ()detail::construct_327 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const 328 { 329 return result_type::make(a0 , a1 , a2); 330 } 331 }; 332 template<typename Type , typename A0 , typename A1 , typename A2> 333 Type construct(A0 &a0 , A1 &a1 , A2 &a2) 334 { 335 return construct_<Type>()(a0 , a1 , a2); 336 } 337 } 338 339 340 341 342 template<typename Object , typename A0 , typename A1 , typename A2> 343 struct make<Object(A0 , A1 , A2)> 344 : transform<make<Object(A0 , A1 , A2)> > 345 { 346 template<typename Expr, typename State, typename Data> 347 struct impl : transform_impl<Expr, State, Data> 348 { 349 350 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 351 352 353 354 355 356 357 operator ()make::impl358 result_type operator ()( 359 typename impl::expr_param e 360 , typename impl::state_param s 361 , typename impl::data_param d 362 ) const 363 { 364 proto::detail::ignore_unused(e); 365 proto::detail::ignore_unused(s); 366 proto::detail::ignore_unused(d); 367 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) )); 368 } 369 }; 370 }; 371 namespace detail 372 { 373 template< 374 template<typename , typename , typename , typename> class R 375 , typename A0 , typename A1 , typename A2 , typename A3 376 , typename Expr, typename State, typename Data 377 > 378 struct make_< 379 R<A0 , A1 , A2 , A3> 380 , Expr, State, Data 381 BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) 382 > 383 : nested_type_if< 384 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> 385 , (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) 386 > 387 {}; 388 template< 389 template<typename , typename , typename , typename> class R 390 , typename A0 , typename A1 , typename A2 , typename A3 391 , typename Expr, typename State, typename Data 392 > 393 struct make_< 394 noinvoke<R<A0 , A1 , A2 , A3> > 395 , Expr, State, Data 396 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 397 > 398 { 399 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; 400 static bool const applied = true; 401 }; 402 template<typename R , typename A0 , typename A1 , typename A2 , typename A3> 403 struct is_applyable<R(A0 , A1 , A2 , A3)> 404 : mpl::true_ 405 {}; 406 template<typename R , typename A0 , typename A1 , typename A2 , typename A3> 407 struct is_applyable<R(*)(A0 , A1 , A2 , A3)> 408 : mpl::true_ 409 {}; 410 template<typename T, typename A> 411 struct construct_<proto::expr<T, A, 4>, true> 412 { 413 typedef proto::expr<T, A, 4> result_type; 414 template<typename A0 , typename A1 , typename A2 , typename A3> operator ()detail::construct_415 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const 416 { 417 return result_type::make(a0 , a1 , a2 , a3); 418 } 419 }; 420 template<typename T, typename A> 421 struct construct_<proto::basic_expr<T, A, 4>, true> 422 { 423 typedef proto::basic_expr<T, A, 4> result_type; 424 template<typename A0 , typename A1 , typename A2 , typename A3> operator ()detail::construct_425 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const 426 { 427 return result_type::make(a0 , a1 , a2 , a3); 428 } 429 }; 430 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3> 431 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) 432 { 433 return construct_<Type>()(a0 , a1 , a2 , a3); 434 } 435 } 436 437 438 439 440 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> 441 struct make<Object(A0 , A1 , A2 , A3)> 442 : transform<make<Object(A0 , A1 , A2 , A3)> > 443 { 444 template<typename Expr, typename State, typename Data> 445 struct impl : transform_impl<Expr, State, Data> 446 { 447 448 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 449 450 451 452 453 454 455 operator ()make::impl456 result_type operator ()( 457 typename impl::expr_param e 458 , typename impl::state_param s 459 , typename impl::data_param d 460 ) const 461 { 462 proto::detail::ignore_unused(e); 463 proto::detail::ignore_unused(s); 464 proto::detail::ignore_unused(d); 465 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) )); 466 } 467 }; 468 }; 469 namespace detail 470 { 471 template< 472 template<typename , typename , typename , typename , typename> class R 473 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 474 , typename Expr, typename State, typename Data 475 > 476 struct make_< 477 R<A0 , A1 , A2 , A3 , A4> 478 , Expr, State, Data 479 BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) 480 > 481 : nested_type_if< 482 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> 483 , (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) 484 > 485 {}; 486 template< 487 template<typename , typename , typename , typename , typename> class R 488 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 489 , typename Expr, typename State, typename Data 490 > 491 struct make_< 492 noinvoke<R<A0 , A1 , A2 , A3 , A4> > 493 , Expr, State, Data 494 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 495 > 496 { 497 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; 498 static bool const applied = true; 499 }; 500 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 501 struct is_applyable<R(A0 , A1 , A2 , A3 , A4)> 502 : mpl::true_ 503 {}; 504 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 505 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)> 506 : mpl::true_ 507 {}; 508 template<typename T, typename A> 509 struct construct_<proto::expr<T, A, 5>, true> 510 { 511 typedef proto::expr<T, A, 5> result_type; 512 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> operator ()detail::construct_513 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const 514 { 515 return result_type::make(a0 , a1 , a2 , a3 , a4); 516 } 517 }; 518 template<typename T, typename A> 519 struct construct_<proto::basic_expr<T, A, 5>, true> 520 { 521 typedef proto::basic_expr<T, A, 5> result_type; 522 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> operator ()detail::construct_523 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const 524 { 525 return result_type::make(a0 , a1 , a2 , a3 , a4); 526 } 527 }; 528 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 529 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) 530 { 531 return construct_<Type>()(a0 , a1 , a2 , a3 , a4); 532 } 533 } 534 535 536 537 538 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 539 struct make<Object(A0 , A1 , A2 , A3 , A4)> 540 : transform<make<Object(A0 , A1 , A2 , A3 , A4)> > 541 { 542 template<typename Expr, typename State, typename Data> 543 struct impl : transform_impl<Expr, State, Data> 544 { 545 546 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 547 548 549 550 551 552 553 operator ()make::impl554 result_type operator ()( 555 typename impl::expr_param e 556 , typename impl::state_param s 557 , typename impl::data_param d 558 ) const 559 { 560 proto::detail::ignore_unused(e); 561 proto::detail::ignore_unused(s); 562 proto::detail::ignore_unused(d); 563 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) )); 564 } 565 }; 566 }; 567 namespace detail 568 { 569 template< 570 template<typename , typename , typename , typename , typename , typename> class R 571 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 572 , typename Expr, typename State, typename Data 573 > 574 struct make_< 575 R<A0 , A1 , A2 , A3 , A4 , A5> 576 , Expr, State, Data 577 BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) 578 > 579 : nested_type_if< 580 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> 581 , (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) 582 > 583 {}; 584 template< 585 template<typename , typename , typename , typename , typename , typename> class R 586 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 587 , typename Expr, typename State, typename Data 588 > 589 struct make_< 590 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> > 591 , Expr, State, Data 592 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 593 > 594 { 595 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; 596 static bool const applied = true; 597 }; 598 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 599 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)> 600 : mpl::true_ 601 {}; 602 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 603 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)> 604 : mpl::true_ 605 {}; 606 template<typename T, typename A> 607 struct construct_<proto::expr<T, A, 6>, true> 608 { 609 typedef proto::expr<T, A, 6> result_type; 610 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> operator ()detail::construct_611 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const 612 { 613 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); 614 } 615 }; 616 template<typename T, typename A> 617 struct construct_<proto::basic_expr<T, A, 6>, true> 618 { 619 typedef proto::basic_expr<T, A, 6> result_type; 620 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> operator ()detail::construct_621 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const 622 { 623 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); 624 } 625 }; 626 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 627 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) 628 { 629 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5); 630 } 631 } 632 633 634 635 636 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 637 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)> 638 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> > 639 { 640 template<typename Expr, typename State, typename Data> 641 struct impl : transform_impl<Expr, State, Data> 642 { 643 644 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 645 646 647 648 649 650 651 operator ()make::impl652 result_type operator ()( 653 typename impl::expr_param e 654 , typename impl::state_param s 655 , typename impl::data_param d 656 ) const 657 { 658 proto::detail::ignore_unused(e); 659 proto::detail::ignore_unused(s); 660 proto::detail::ignore_unused(d); 661 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) )); 662 } 663 }; 664 }; 665 namespace detail 666 { 667 template< 668 template<typename , typename , typename , typename , typename , typename , typename> class R 669 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 670 , typename Expr, typename State, typename Data 671 > 672 struct make_< 673 R<A0 , A1 , A2 , A3 , A4 , A5 , A6> 674 , Expr, State, Data 675 BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) 676 > 677 : nested_type_if< 678 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> 679 , (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) 680 > 681 {}; 682 template< 683 template<typename , typename , typename , typename , typename , typename , typename> class R 684 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 685 , typename Expr, typename State, typename Data 686 > 687 struct make_< 688 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> > 689 , Expr, State, Data 690 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 691 > 692 { 693 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; 694 static bool const applied = true; 695 }; 696 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 697 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 698 : mpl::true_ 699 {}; 700 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 701 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 702 : mpl::true_ 703 {}; 704 template<typename T, typename A> 705 struct construct_<proto::expr<T, A, 7>, true> 706 { 707 typedef proto::expr<T, A, 7> result_type; 708 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> operator ()detail::construct_709 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const 710 { 711 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); 712 } 713 }; 714 template<typename T, typename A> 715 struct construct_<proto::basic_expr<T, A, 7>, true> 716 { 717 typedef proto::basic_expr<T, A, 7> result_type; 718 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> operator ()detail::construct_719 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const 720 { 721 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); 722 } 723 }; 724 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 725 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) 726 { 727 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6); 728 } 729 } 730 731 732 733 734 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 735 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 736 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > 737 { 738 template<typename Expr, typename State, typename Data> 739 struct impl : transform_impl<Expr, State, Data> 740 { 741 742 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 743 744 745 746 747 748 749 operator ()make::impl750 result_type operator ()( 751 typename impl::expr_param e 752 , typename impl::state_param s 753 , typename impl::data_param d 754 ) const 755 { 756 proto::detail::ignore_unused(e); 757 proto::detail::ignore_unused(s); 758 proto::detail::ignore_unused(d); 759 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) )); 760 } 761 }; 762 }; 763 namespace detail 764 { 765 template< 766 template<typename , typename , typename , typename , typename , typename , typename , typename> class R 767 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 768 , typename Expr, typename State, typename Data 769 > 770 struct make_< 771 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> 772 , Expr, State, Data 773 BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) 774 > 775 : nested_type_if< 776 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> 777 , (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) 778 > 779 {}; 780 template< 781 template<typename , typename , typename , typename , typename , typename , typename , typename> class R 782 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 783 , typename Expr, typename State, typename Data 784 > 785 struct make_< 786 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> > 787 , Expr, State, Data 788 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 789 > 790 { 791 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; 792 static bool const applied = true; 793 }; 794 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 795 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 796 : mpl::true_ 797 {}; 798 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 799 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 800 : mpl::true_ 801 {}; 802 template<typename T, typename A> 803 struct construct_<proto::expr<T, A, 8>, true> 804 { 805 typedef proto::expr<T, A, 8> result_type; 806 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> operator ()detail::construct_807 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const 808 { 809 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); 810 } 811 }; 812 template<typename T, typename A> 813 struct construct_<proto::basic_expr<T, A, 8>, true> 814 { 815 typedef proto::basic_expr<T, A, 8> result_type; 816 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> operator ()detail::construct_817 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const 818 { 819 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); 820 } 821 }; 822 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 823 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) 824 { 825 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); 826 } 827 } 828 829 830 831 832 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 833 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 834 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > 835 { 836 template<typename Expr, typename State, typename Data> 837 struct impl : transform_impl<Expr, State, Data> 838 { 839 840 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 841 842 843 844 845 846 847 operator ()make::impl848 result_type operator ()( 849 typename impl::expr_param e 850 , typename impl::state_param s 851 , typename impl::data_param d 852 ) const 853 { 854 proto::detail::ignore_unused(e); 855 proto::detail::ignore_unused(s); 856 proto::detail::ignore_unused(d); 857 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) )); 858 } 859 }; 860 }; 861 namespace detail 862 { 863 template< 864 template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R 865 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 866 , typename Expr, typename State, typename Data 867 > 868 struct make_< 869 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> 870 , Expr, State, Data 871 BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) 872 > 873 : nested_type_if< 874 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> 875 , (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) 876 > 877 {}; 878 template< 879 template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R 880 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 881 , typename Expr, typename State, typename Data 882 > 883 struct make_< 884 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> > 885 , Expr, State, Data 886 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 887 > 888 { 889 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; 890 static bool const applied = true; 891 }; 892 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 893 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 894 : mpl::true_ 895 {}; 896 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 897 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 898 : mpl::true_ 899 {}; 900 template<typename T, typename A> 901 struct construct_<proto::expr<T, A, 9>, true> 902 { 903 typedef proto::expr<T, A, 9> result_type; 904 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> operator ()detail::construct_905 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const 906 { 907 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); 908 } 909 }; 910 template<typename T, typename A> 911 struct construct_<proto::basic_expr<T, A, 9>, true> 912 { 913 typedef proto::basic_expr<T, A, 9> result_type; 914 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> operator ()detail::construct_915 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const 916 { 917 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); 918 } 919 }; 920 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 921 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) 922 { 923 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); 924 } 925 } 926 927 928 929 930 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 931 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 932 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > 933 { 934 template<typename Expr, typename State, typename Data> 935 struct impl : transform_impl<Expr, State, Data> 936 { 937 938 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 939 940 941 942 943 944 945 operator ()make::impl946 result_type operator ()( 947 typename impl::expr_param e 948 , typename impl::state_param s 949 , typename impl::data_param d 950 ) const 951 { 952 proto::detail::ignore_unused(e); 953 proto::detail::ignore_unused(s); 954 proto::detail::ignore_unused(d); 955 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) )); 956 } 957 }; 958 }; 959 namespace detail 960 { 961 template< 962 template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R 963 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 964 , typename Expr, typename State, typename Data 965 > 966 struct make_< 967 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> 968 , Expr, State, Data 969 BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) 970 > 971 : nested_type_if< 972 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> 973 , (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) 974 > 975 {}; 976 template< 977 template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R 978 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 979 , typename Expr, typename State, typename Data 980 > 981 struct make_< 982 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> > 983 , Expr, State, Data 984 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) 985 > 986 { 987 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; 988 static bool const applied = true; 989 }; 990 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 991 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 992 : mpl::true_ 993 {}; 994 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 995 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 996 : mpl::true_ 997 {}; 998 template<typename T, typename A> 999 struct construct_<proto::expr<T, A, 10>, true> 1000 { 1001 typedef proto::expr<T, A, 10> result_type; 1002 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> operator ()detail::construct_1003 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const 1004 { 1005 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); 1006 } 1007 }; 1008 template<typename T, typename A> 1009 struct construct_<proto::basic_expr<T, A, 10>, true> 1010 { 1011 typedef proto::basic_expr<T, A, 10> result_type; 1012 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> operator ()detail::construct_1013 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const 1014 { 1015 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); 1016 } 1017 }; 1018 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 1019 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) 1020 { 1021 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); 1022 } 1023 } 1024 1025 1026 1027 1028 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 1029 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 1030 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > 1031 { 1032 template<typename Expr, typename State, typename Data> 1033 struct impl : transform_impl<Expr, State, Data> 1034 { 1035 1036 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; 1037 1038 1039 1040 1041 1042 1043 operator ()make::impl1044 result_type operator ()( 1045 typename impl::expr_param e 1046 , typename impl::state_param s 1047 , typename impl::data_param d 1048 ) const 1049 { 1050 proto::detail::ignore_unused(e); 1051 proto::detail::ignore_unused(s); 1052 proto::detail::ignore_unused(d); 1053 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) )); 1054 } 1055 }; 1056 }; 1057