Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/casts.hpp @ 133:4acb5d8d80b6 tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Don't fail environmental check if README.md exists (but .txt and no-suffix don't)
author Chris Cannam
date Tue, 30 Jul 2019 12:25:44 +0100
parents 2665513ce2d3
children
rev   line source
Chris@16 1 /*=============================================================================
Chris@16 2 Phoenix V1.2.1
Chris@16 3 Copyright (c) 2001-2003 Joel de Guzman
Chris@16 4 Copyright (c) 2001-2003 Hartmut Kaiser
Chris@16 5
Chris@16 6 Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16 7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16 8 ==============================================================================*/
Chris@16 9
Chris@16 10 #ifndef PHOENIX_CASTS_HPP
Chris@16 11 #define PHOENIX_CASTS_HPP
Chris@16 12
Chris@16 13 ///////////////////////////////////////////////////////////////////////////////
Chris@16 14 #include <boost/spirit/home/classic/phoenix/actor.hpp>
Chris@16 15 #include <boost/spirit/home/classic/phoenix/composite.hpp>
Chris@16 16 #include <boost/static_assert.hpp>
Chris@16 17
Chris@16 18 ///////////////////////////////////////////////////////////////////////////////
Chris@16 19 namespace phoenix {
Chris@16 20
Chris@16 21 ///////////////////////////////////////////////////////////////////////////////
Chris@16 22 //
Chris@16 23 // Phoenix predefined maximum construct_ limit. This limit defines the maximum
Chris@16 24 // number of parameters supported for calles to the set of construct_ template
Chris@16 25 // functions (lazy object construction, see below). This number defaults to 3.
Chris@16 26 // The actual maximum is rounded up in multiples of 3. Thus, if this value
Chris@16 27 // is 4, the actual limit is 6. The ultimate maximum limit in this
Chris@16 28 // implementation is 15.
Chris@16 29 // PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT!
Chris@16 30
Chris@16 31 #if !defined(PHOENIX_CONSTRUCT_LIMIT)
Chris@16 32 #define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT
Chris@16 33 #endif
Chris@16 34
Chris@16 35 // ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT
Chris@16 36 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT);
Chris@16 37
Chris@16 38 // ensure PHOENIX_CONSTRUCT_LIMIT <= 15
Chris@16 39 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15);
Chris@16 40
Chris@16 41 ///////////////////////////////////////////////////////////////////////////////
Chris@16 42 //
Chris@16 43 // Lazy C++ casts
Chris@16 44 //
Chris@16 45 // The set of lazy C++ cast template classes and functions provide a way
Chris@16 46 // of lazily casting certain type to another during parsing.
Chris@16 47 // The lazy C++ templates are (syntactically) used very much like
Chris@16 48 // the well known C++ casts:
Chris@16 49 //
Chris@16 50 // A *a = static_cast_<A *>(...actor returning a convertible type...);
Chris@16 51 //
Chris@16 52 // where the given parameter should be an actor, which eval() function
Chris@16 53 // returns a convertible type.
Chris@16 54 //
Chris@16 55 ///////////////////////////////////////////////////////////////////////////////
Chris@16 56 template <typename T, typename A>
Chris@16 57 struct static_cast_l {
Chris@16 58
Chris@16 59 template <typename TupleT>
Chris@16 60 struct result { typedef T type; };
Chris@16 61
Chris@16 62 static_cast_l(A const& a_)
Chris@16 63 : a(a_) {}
Chris@16 64
Chris@16 65 template <typename TupleT>
Chris@16 66 T
Chris@16 67 eval(TupleT const& args) const
Chris@16 68 {
Chris@16 69 return static_cast<T>(a.eval(args));
Chris@16 70 }
Chris@16 71
Chris@16 72 A a;
Chris@16 73 };
Chris@16 74
Chris@16 75 //////////////////////////////////
Chris@16 76 template <typename T, typename BaseAT>
Chris@16 77 inline actor<static_cast_l<T, BaseAT> >
Chris@16 78 static_cast_(actor<BaseAT> const& a)
Chris@16 79 {
Chris@16 80 typedef static_cast_l<T, BaseAT> cast_t;
Chris@16 81 return actor<cast_t>(cast_t(a));
Chris@16 82 }
Chris@16 83
Chris@16 84 //////////////////////////////////
Chris@16 85 template <typename T, typename A>
Chris@16 86 struct dynamic_cast_l {
Chris@16 87
Chris@16 88 template <typename TupleT>
Chris@16 89 struct result { typedef T type; };
Chris@16 90
Chris@16 91 dynamic_cast_l(A const& a_)
Chris@16 92 : a(a_) {}
Chris@16 93
Chris@16 94 template <typename TupleT>
Chris@16 95 T
Chris@16 96 eval(TupleT const& args) const
Chris@16 97 {
Chris@16 98 return dynamic_cast<T>(a.eval(args));
Chris@16 99 }
Chris@16 100
Chris@16 101 A a;
Chris@16 102 };
Chris@16 103
Chris@16 104 //////////////////////////////////
Chris@16 105 template <typename T, typename BaseAT>
Chris@16 106 inline actor<dynamic_cast_l<T, BaseAT> >
Chris@16 107 dynamic_cast_(actor<BaseAT> const& a)
Chris@16 108 {
Chris@16 109 typedef dynamic_cast_l<T, BaseAT> cast_t;
Chris@16 110 return actor<cast_t>(cast_t(a));
Chris@16 111 }
Chris@16 112
Chris@16 113 //////////////////////////////////
Chris@16 114 template <typename T, typename A>
Chris@16 115 struct reinterpret_cast_l {
Chris@16 116
Chris@16 117 template <typename TupleT>
Chris@16 118 struct result { typedef T type; };
Chris@16 119
Chris@16 120 reinterpret_cast_l(A const& a_)
Chris@16 121 : a(a_) {}
Chris@16 122
Chris@16 123 template <typename TupleT>
Chris@16 124 T
Chris@16 125 eval(TupleT const& args) const
Chris@16 126 {
Chris@16 127 return reinterpret_cast<T>(a.eval(args));
Chris@16 128 }
Chris@16 129
Chris@16 130 A a;
Chris@16 131 };
Chris@16 132
Chris@16 133 //////////////////////////////////
Chris@16 134 template <typename T, typename BaseAT>
Chris@16 135 inline actor<reinterpret_cast_l<T, BaseAT> >
Chris@16 136 reinterpret_cast_(actor<BaseAT> const& a)
Chris@16 137 {
Chris@16 138 typedef reinterpret_cast_l<T, BaseAT> cast_t;
Chris@16 139 return actor<cast_t>(cast_t(a));
Chris@16 140 }
Chris@16 141
Chris@16 142 //////////////////////////////////
Chris@16 143 template <typename T, typename A>
Chris@16 144 struct const_cast_l {
Chris@16 145
Chris@16 146 template <typename TupleT>
Chris@16 147 struct result { typedef T type; };
Chris@16 148
Chris@16 149 const_cast_l(A const& a_)
Chris@16 150 : a(a_) {}
Chris@16 151
Chris@16 152 template <typename TupleT>
Chris@16 153 T
Chris@16 154 eval(TupleT const& args) const
Chris@16 155 {
Chris@16 156 return const_cast<T>(a.eval(args));
Chris@16 157 }
Chris@16 158
Chris@16 159 A a;
Chris@16 160 };
Chris@16 161
Chris@16 162 //////////////////////////////////
Chris@16 163 template <typename T, typename BaseAT>
Chris@16 164 inline actor<const_cast_l<T, BaseAT> >
Chris@16 165 const_cast_(actor<BaseAT> const& a)
Chris@16 166 {
Chris@16 167 typedef const_cast_l<T, BaseAT> cast_t;
Chris@16 168 return actor<cast_t>(cast_t(a));
Chris@16 169 }
Chris@16 170
Chris@16 171 ///////////////////////////////////////////////////////////////////////////////
Chris@16 172 //
Chris@16 173 // construct_
Chris@16 174 //
Chris@16 175 // Lazy object construction
Chris@16 176 //
Chris@16 177 // The set of construct_<> template classes and functions provide a way
Chris@16 178 // of lazily constructing certain object from a arbitrary set of
Chris@16 179 // actors during parsing.
Chris@16 180 // The construct_ templates are (syntactically) used very much like
Chris@16 181 // the well known C++ casts:
Chris@16 182 //
Chris@16 183 // A a = construct_<A>(...arbitrary list of actors...);
Chris@16 184 //
Chris@16 185 // where the given parameters are submitted as parameters to the
Chris@16 186 // contructor of the object of type A. (This certainly implies, that
Chris@16 187 // type A has a constructor with a fitting set of parameter types
Chris@16 188 // defined.)
Chris@16 189 //
Chris@16 190 // The maximum number of needed parameters is controlled through the
Chris@16 191 // preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this
Chris@16 192 // limit should not be greater than PHOENIX_LIMIT.
Chris@16 193 //
Chris@16 194 ///////////////////////////////////////////////////////////////////////////////
Chris@16 195 template <typename T>
Chris@16 196 struct construct_l_0 {
Chris@16 197 typedef T result_type;
Chris@16 198
Chris@16 199 T operator()() const {
Chris@16 200 return T();
Chris@16 201 }
Chris@16 202 };
Chris@16 203
Chris@16 204
Chris@16 205 template <typename T>
Chris@16 206 struct construct_l {
Chris@16 207
Chris@16 208 template <
Chris@16 209 typename A
Chris@16 210 , typename B
Chris@16 211 , typename C
Chris@16 212
Chris@16 213 #if PHOENIX_CONSTRUCT_LIMIT > 3
Chris@16 214 , typename D
Chris@16 215 , typename E
Chris@16 216 , typename F
Chris@16 217
Chris@16 218 #if PHOENIX_CONSTRUCT_LIMIT > 6
Chris@16 219 , typename G
Chris@16 220 , typename H
Chris@16 221 , typename I
Chris@16 222
Chris@16 223 #if PHOENIX_CONSTRUCT_LIMIT > 9
Chris@16 224 , typename J
Chris@16 225 , typename K
Chris@16 226 , typename L
Chris@16 227
Chris@16 228 #if PHOENIX_CONSTRUCT_LIMIT > 12
Chris@16 229 , typename M
Chris@16 230 , typename N
Chris@16 231 , typename O
Chris@16 232 #endif
Chris@16 233 #endif
Chris@16 234 #endif
Chris@16 235 #endif
Chris@16 236 >
Chris@16 237 struct result { typedef T type; };
Chris@16 238
Chris@16 239 T operator()() const
Chris@16 240 {
Chris@16 241 return T();
Chris@16 242 }
Chris@16 243
Chris@16 244 template <typename A>
Chris@16 245 T operator()(A const& a) const
Chris@16 246 {
Chris@16 247 T t(a);
Chris@16 248 return t;
Chris@16 249 }
Chris@16 250
Chris@16 251 template <typename A, typename B>
Chris@16 252 T operator()(A const& a, B const& b) const
Chris@16 253 {
Chris@16 254 T t(a, b);
Chris@16 255 return t;
Chris@16 256 }
Chris@16 257
Chris@16 258 template <typename A, typename B, typename C>
Chris@16 259 T operator()(A const& a, B const& b, C const& c) const
Chris@16 260 {
Chris@16 261 T t(a, b, c);
Chris@16 262 return t;
Chris@16 263 }
Chris@16 264
Chris@16 265 #if PHOENIX_CONSTRUCT_LIMIT > 3
Chris@16 266 template <
Chris@16 267 typename A, typename B, typename C, typename D
Chris@16 268 >
Chris@16 269 T operator()(
Chris@16 270 A const& a, B const& b, C const& c, D const& d) const
Chris@16 271 {
Chris@16 272 T t(a, b, c, d);
Chris@16 273 return t;
Chris@16 274 }
Chris@16 275
Chris@16 276 template <
Chris@16 277 typename A, typename B, typename C, typename D, typename E
Chris@16 278 >
Chris@16 279 T operator()(
Chris@16 280 A const& a, B const& b, C const& c, D const& d, E const& e) const
Chris@16 281 {
Chris@16 282 T t(a, b, c, d, e);
Chris@16 283 return t;
Chris@16 284 }
Chris@16 285
Chris@16 286 template <
Chris@16 287 typename A, typename B, typename C, typename D, typename E,
Chris@16 288 typename F
Chris@16 289 >
Chris@16 290 T operator()(
Chris@16 291 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 292 F const& f) const
Chris@16 293 {
Chris@16 294 T t(a, b, c, d, e, f);
Chris@16 295 return t;
Chris@16 296 }
Chris@16 297
Chris@16 298 #if PHOENIX_CONSTRUCT_LIMIT > 6
Chris@16 299 template <
Chris@16 300 typename A, typename B, typename C, typename D, typename E,
Chris@16 301 typename F, typename G
Chris@16 302 >
Chris@16 303 T operator()(
Chris@16 304 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 305 F const& f, G const& g) const
Chris@16 306 {
Chris@16 307 T t(a, b, c, d, e, f, g);
Chris@16 308 return t;
Chris@16 309 }
Chris@16 310
Chris@16 311 template <
Chris@16 312 typename A, typename B, typename C, typename D, typename E,
Chris@16 313 typename F, typename G, typename H
Chris@16 314 >
Chris@16 315 T operator()(
Chris@16 316 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 317 F const& f, G const& g, H const& h) const
Chris@16 318 {
Chris@16 319 T t(a, b, c, d, e, f, g, h);
Chris@16 320 return t;
Chris@16 321 }
Chris@16 322
Chris@16 323 template <
Chris@16 324 typename A, typename B, typename C, typename D, typename E,
Chris@16 325 typename F, typename G, typename H, typename I
Chris@16 326 >
Chris@16 327 T operator()(
Chris@16 328 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 329 F const& f, G const& g, H const& h, I const& i) const
Chris@16 330 {
Chris@16 331 T t(a, b, c, d, e, f, g, h, i);
Chris@16 332 return t;
Chris@16 333 }
Chris@16 334
Chris@16 335 #if PHOENIX_CONSTRUCT_LIMIT > 9
Chris@16 336 template <
Chris@16 337 typename A, typename B, typename C, typename D, typename E,
Chris@16 338 typename F, typename G, typename H, typename I, typename J
Chris@16 339 >
Chris@16 340 T operator()(
Chris@16 341 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 342 F const& f, G const& g, H const& h, I const& i, J const& j) const
Chris@16 343 {
Chris@16 344 T t(a, b, c, d, e, f, g, h, i, j);
Chris@16 345 return t;
Chris@16 346 }
Chris@16 347
Chris@16 348 template <
Chris@16 349 typename A, typename B, typename C, typename D, typename E,
Chris@16 350 typename F, typename G, typename H, typename I, typename J,
Chris@16 351 typename K
Chris@16 352 >
Chris@16 353 T operator()(
Chris@16 354 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 355 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 356 K const& k) const
Chris@16 357 {
Chris@16 358 T t(a, b, c, d, e, f, g, h, i, j, k);
Chris@16 359 return t;
Chris@16 360 }
Chris@16 361
Chris@16 362 template <
Chris@16 363 typename A, typename B, typename C, typename D, typename E,
Chris@16 364 typename F, typename G, typename H, typename I, typename J,
Chris@16 365 typename K, typename L
Chris@16 366 >
Chris@16 367 T operator()(
Chris@16 368 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 369 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 370 K const& k, L const& l) const
Chris@16 371 {
Chris@16 372 T t(a, b, c, d, e, f, g, h, i, j, k, l);
Chris@16 373 return t;
Chris@16 374 }
Chris@16 375
Chris@16 376 #if PHOENIX_CONSTRUCT_LIMIT > 12
Chris@16 377 template <
Chris@16 378 typename A, typename B, typename C, typename D, typename E,
Chris@16 379 typename F, typename G, typename H, typename I, typename J,
Chris@16 380 typename K, typename L, typename M
Chris@16 381 >
Chris@16 382 T operator()(
Chris@16 383 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 384 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 385 K const& k, L const& l, M const& m) const
Chris@16 386 {
Chris@16 387 T t(a, b, c, d, e, f, g, h, i, j, k, l, m);
Chris@16 388 return t;
Chris@16 389 }
Chris@16 390
Chris@16 391 template <
Chris@16 392 typename A, typename B, typename C, typename D, typename E,
Chris@16 393 typename F, typename G, typename H, typename I, typename J,
Chris@16 394 typename K, typename L, typename M, typename N
Chris@16 395 >
Chris@16 396 T operator()(
Chris@16 397 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 398 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 399 K const& k, L const& l, M const& m, N const& n) const
Chris@16 400 {
Chris@16 401 T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
Chris@16 402 return t;
Chris@16 403 }
Chris@16 404
Chris@16 405 template <
Chris@16 406 typename A, typename B, typename C, typename D, typename E,
Chris@16 407 typename F, typename G, typename H, typename I, typename J,
Chris@16 408 typename K, typename L, typename M, typename N, typename O
Chris@16 409 >
Chris@16 410 T operator()(
Chris@16 411 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 412 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 413 K const& k, L const& l, M const& m, N const& n, O const& o) const
Chris@16 414 {
Chris@16 415 T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
Chris@16 416 return t;
Chris@16 417 }
Chris@16 418
Chris@16 419 #endif
Chris@16 420 #endif
Chris@16 421 #endif
Chris@16 422 #endif
Chris@16 423 };
Chris@16 424
Chris@16 425
Chris@16 426 template <typename T>
Chris@16 427 struct construct_1 {
Chris@16 428
Chris@16 429 template <
Chris@16 430 typename A
Chris@16 431 >
Chris@16 432 struct result { typedef T type; };
Chris@16 433
Chris@16 434 template <typename A>
Chris@16 435 T operator()(A const& a) const
Chris@16 436 {
Chris@16 437 T t(a);
Chris@16 438 return t;
Chris@16 439 }
Chris@16 440
Chris@16 441 };
Chris@16 442
Chris@16 443 template <typename T>
Chris@16 444 struct construct_2 {
Chris@16 445
Chris@16 446 template <
Chris@16 447 typename A
Chris@16 448 , typename B
Chris@16 449 >
Chris@16 450 struct result { typedef T type; };
Chris@16 451
Chris@16 452 template <typename A, typename B>
Chris@16 453 T operator()(A const& a, B const& b) const
Chris@16 454 {
Chris@16 455 T t(a, b);
Chris@16 456 return t;
Chris@16 457 }
Chris@16 458
Chris@16 459 };
Chris@16 460
Chris@16 461 template <typename T>
Chris@16 462 struct construct_3 {
Chris@16 463
Chris@16 464 template <
Chris@16 465 typename A
Chris@16 466 , typename B
Chris@16 467 , typename C
Chris@16 468 >
Chris@16 469 struct result { typedef T type; };
Chris@16 470
Chris@16 471 template <typename A, typename B, typename C>
Chris@16 472 T operator()(A const& a, B const& b, C const& c) const
Chris@16 473 {
Chris@16 474 T t(a, b, c);
Chris@16 475 return t;
Chris@16 476 }
Chris@16 477 };
Chris@16 478
Chris@16 479 #if PHOENIX_CONSTRUCT_LIMIT > 3
Chris@16 480 template <typename T>
Chris@16 481 struct construct_4 {
Chris@16 482
Chris@16 483 template <
Chris@16 484 typename A
Chris@16 485 , typename B
Chris@16 486 , typename C
Chris@16 487 , typename D
Chris@16 488 >
Chris@16 489 struct result { typedef T type; };
Chris@16 490
Chris@16 491 template <
Chris@16 492 typename A, typename B, typename C, typename D
Chris@16 493 >
Chris@16 494 T operator()(
Chris@16 495 A const& a, B const& b, C const& c, D const& d) const
Chris@16 496 {
Chris@16 497 T t(a, b, c, d);
Chris@16 498 return t;
Chris@16 499 }
Chris@16 500 };
Chris@16 501
Chris@16 502
Chris@16 503 template <typename T>
Chris@16 504 struct construct_5 {
Chris@16 505
Chris@16 506 template <
Chris@16 507 typename A
Chris@16 508 , typename B
Chris@16 509 , typename C
Chris@16 510 , typename D
Chris@16 511 , typename E
Chris@16 512 >
Chris@16 513 struct result { typedef T type; };
Chris@16 514
Chris@16 515 template <
Chris@16 516 typename A, typename B, typename C, typename D, typename E
Chris@16 517 >
Chris@16 518 T operator()(
Chris@16 519 A const& a, B const& b, C const& c, D const& d, E const& e) const
Chris@16 520 {
Chris@16 521 T t(a, b, c, d, e);
Chris@16 522 return t;
Chris@16 523 }
Chris@16 524 };
Chris@16 525
Chris@16 526
Chris@16 527 template <typename T>
Chris@16 528 struct construct_6 {
Chris@16 529
Chris@16 530 template <
Chris@16 531 typename A
Chris@16 532 , typename B
Chris@16 533 , typename C
Chris@16 534 , typename D
Chris@16 535 , typename E
Chris@16 536 , typename F
Chris@16 537 >
Chris@16 538 struct result { typedef T type; };
Chris@16 539
Chris@16 540 template <
Chris@16 541 typename A, typename B, typename C, typename D, typename E,
Chris@16 542 typename F
Chris@16 543 >
Chris@16 544 T operator()(
Chris@16 545 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 546 F const& f) const
Chris@16 547 {
Chris@16 548 T t(a, b, c, d, e, f);
Chris@16 549 return t;
Chris@16 550 }
Chris@16 551 };
Chris@16 552 #endif
Chris@16 553
Chris@16 554
Chris@16 555 #if PHOENIX_CONSTRUCT_LIMIT > 6
Chris@16 556 template <typename T>
Chris@16 557 struct construct_7 {
Chris@16 558
Chris@16 559 template <
Chris@16 560 typename A
Chris@16 561 , typename B
Chris@16 562 , typename C
Chris@16 563 , typename D
Chris@16 564 , typename E
Chris@16 565 , typename F
Chris@16 566 , typename G
Chris@16 567 >
Chris@16 568 struct result { typedef T type; };
Chris@16 569
Chris@16 570 template <
Chris@16 571 typename A, typename B, typename C, typename D, typename E,
Chris@16 572 typename F, typename G
Chris@16 573 >
Chris@16 574 T operator()(
Chris@16 575 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 576 F const& f, G const& g) const
Chris@16 577 {
Chris@16 578 T t(a, b, c, d, e, f, g);
Chris@16 579 return t;
Chris@16 580 }
Chris@16 581 };
Chris@16 582
Chris@16 583 template <typename T>
Chris@16 584 struct construct_8 {
Chris@16 585
Chris@16 586 template <
Chris@16 587 typename A
Chris@16 588 , typename B
Chris@16 589 , typename C
Chris@16 590 , typename D
Chris@16 591 , typename E
Chris@16 592 , typename F
Chris@16 593 , typename G
Chris@16 594 , typename H
Chris@16 595 >
Chris@16 596 struct result { typedef T type; };
Chris@16 597
Chris@16 598 template <
Chris@16 599 typename A, typename B, typename C, typename D, typename E,
Chris@16 600 typename F, typename G, typename H
Chris@16 601 >
Chris@16 602 T operator()(
Chris@16 603 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 604 F const& f, G const& g, H const& h) const
Chris@16 605 {
Chris@16 606 T t(a, b, c, d, e, f, g, h);
Chris@16 607 return t;
Chris@16 608 }
Chris@16 609 };
Chris@16 610
Chris@16 611 template <typename T>
Chris@16 612 struct construct_9 {
Chris@16 613
Chris@16 614 template <
Chris@16 615 typename A
Chris@16 616 , typename B
Chris@16 617 , typename C
Chris@16 618 , typename D
Chris@16 619 , typename E
Chris@16 620 , typename F
Chris@16 621 , typename G
Chris@16 622 , typename H
Chris@16 623 , typename I
Chris@16 624 >
Chris@16 625 struct result { typedef T type; };
Chris@16 626
Chris@16 627 template <
Chris@16 628 typename A, typename B, typename C, typename D, typename E,
Chris@16 629 typename F, typename G, typename H, typename I
Chris@16 630 >
Chris@16 631 T operator()(
Chris@16 632 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 633 F const& f, G const& g, H const& h, I const& i) const
Chris@16 634 {
Chris@16 635 T t(a, b, c, d, e, f, g, h, i);
Chris@16 636 return t;
Chris@16 637 }
Chris@16 638 };
Chris@16 639 #endif
Chris@16 640
Chris@16 641
Chris@16 642 #if PHOENIX_CONSTRUCT_LIMIT > 9
Chris@16 643 template <typename T>
Chris@16 644 struct construct_10 {
Chris@16 645
Chris@16 646 template <
Chris@16 647 typename A
Chris@16 648 , typename B
Chris@16 649 , typename C
Chris@16 650 , typename D
Chris@16 651 , typename E
Chris@16 652 , typename F
Chris@16 653 , typename G
Chris@16 654 , typename H
Chris@16 655 , typename I
Chris@16 656 , typename J
Chris@16 657 >
Chris@16 658 struct result { typedef T type; };
Chris@16 659
Chris@16 660 template <
Chris@16 661 typename A, typename B, typename C, typename D, typename E,
Chris@16 662 typename F, typename G, typename H, typename I, typename J
Chris@16 663 >
Chris@16 664 T operator()(
Chris@16 665 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 666 F const& f, G const& g, H const& h, I const& i, J const& j) const
Chris@16 667 {
Chris@16 668 T t(a, b, c, d, e, f, g, h, i, j);
Chris@16 669 return t;
Chris@16 670 }
Chris@16 671 };
Chris@16 672
Chris@16 673 template <typename T>
Chris@16 674 struct construct_11 {
Chris@16 675
Chris@16 676 template <
Chris@16 677 typename A
Chris@16 678 , typename B
Chris@16 679 , typename C
Chris@16 680 , typename D
Chris@16 681 , typename E
Chris@16 682 , typename F
Chris@16 683 , typename G
Chris@16 684 , typename H
Chris@16 685 , typename I
Chris@16 686 , typename J
Chris@16 687 , typename K
Chris@16 688 >
Chris@16 689 struct result { typedef T type; };
Chris@16 690
Chris@16 691 template <
Chris@16 692 typename A, typename B, typename C, typename D, typename E,
Chris@16 693 typename F, typename G, typename H, typename I, typename J,
Chris@16 694 typename K
Chris@16 695 >
Chris@16 696 T operator()(
Chris@16 697 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 698 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 699 K const& k) const
Chris@16 700 {
Chris@16 701 T t(a, b, c, d, e, f, g, h, i, j, k);
Chris@16 702 return t;
Chris@16 703 }
Chris@16 704 };
Chris@16 705
Chris@16 706 template <typename T>
Chris@16 707 struct construct_12 {
Chris@16 708
Chris@16 709 template <
Chris@16 710 typename A
Chris@16 711 , typename B
Chris@16 712 , typename C
Chris@16 713 , typename D
Chris@16 714 , typename E
Chris@16 715 , typename F
Chris@16 716 , typename G
Chris@16 717 , typename H
Chris@16 718 , typename I
Chris@16 719 , typename J
Chris@16 720 , typename K
Chris@16 721 , typename L
Chris@16 722 >
Chris@16 723 struct result { typedef T type; };
Chris@16 724
Chris@16 725 template <
Chris@16 726 typename A, typename B, typename C, typename D, typename E,
Chris@16 727 typename F, typename G, typename H, typename I, typename J,
Chris@16 728 typename K, typename L
Chris@16 729 >
Chris@16 730 T operator()(
Chris@16 731 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 732 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 733 K const& k, L const& l) const
Chris@16 734 {
Chris@16 735 T t(a, b, c, d, f, e, g, h, i, j, k, l);
Chris@16 736 return t;
Chris@16 737 }
Chris@16 738 };
Chris@16 739 #endif
Chris@16 740
Chris@16 741 #if PHOENIX_CONSTRUCT_LIMIT > 12
Chris@16 742 template <typename T>
Chris@16 743 struct construct_13 {
Chris@16 744
Chris@16 745 template <
Chris@16 746 typename A
Chris@16 747 , typename B
Chris@16 748 , typename C
Chris@16 749 , typename D
Chris@16 750 , typename E
Chris@16 751 , typename F
Chris@16 752 , typename G
Chris@16 753 , typename H
Chris@16 754 , typename I
Chris@16 755 , typename J
Chris@16 756 , typename K
Chris@16 757 , typename L
Chris@16 758 , typename M
Chris@16 759 >
Chris@16 760 struct result { typedef T type; };
Chris@16 761
Chris@16 762 template <
Chris@16 763 typename A, typename B, typename C, typename D, typename E,
Chris@16 764 typename F, typename G, typename H, typename I, typename J,
Chris@16 765 typename K, typename L, typename M
Chris@16 766 >
Chris@16 767 T operator()(
Chris@16 768 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 769 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 770 K const& k, L const& l, M const& m) const
Chris@16 771 {
Chris@16 772 T t(a, b, c, d, e, f, g, h, i, j, k, l, m);
Chris@16 773 return t;
Chris@16 774 }
Chris@16 775 };
Chris@16 776
Chris@16 777 template <typename T>
Chris@16 778 struct construct_14 {
Chris@16 779
Chris@16 780 template <
Chris@16 781 typename A
Chris@16 782 , typename B
Chris@16 783 , typename C
Chris@16 784 , typename D
Chris@16 785 , typename E
Chris@16 786 , typename F
Chris@16 787 , typename G
Chris@16 788 , typename H
Chris@16 789 , typename I
Chris@16 790 , typename J
Chris@16 791 , typename K
Chris@16 792 , typename L
Chris@16 793 , typename M
Chris@16 794 , typename N
Chris@16 795 >
Chris@16 796 struct result { typedef T type; };
Chris@16 797
Chris@16 798 template <
Chris@16 799 typename A, typename B, typename C, typename D, typename E,
Chris@16 800 typename F, typename G, typename H, typename I, typename J,
Chris@16 801 typename K, typename L, typename M, typename N
Chris@16 802 >
Chris@16 803 T operator()(
Chris@16 804 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 805 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 806 K const& k, L const& l, M const& m, N const& n) const
Chris@16 807 {
Chris@16 808 T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
Chris@16 809 return t;
Chris@16 810 }
Chris@16 811 };
Chris@16 812
Chris@16 813 template <typename T>
Chris@16 814 struct construct_15 {
Chris@16 815
Chris@16 816 template <
Chris@16 817 typename A
Chris@16 818 , typename B
Chris@16 819 , typename C
Chris@16 820 , typename D
Chris@16 821 , typename E
Chris@16 822 , typename F
Chris@16 823 , typename G
Chris@16 824 , typename H
Chris@16 825 , typename I
Chris@16 826 , typename J
Chris@16 827 , typename K
Chris@16 828 , typename L
Chris@16 829 , typename M
Chris@16 830 , typename N
Chris@16 831 , typename O
Chris@16 832 >
Chris@16 833 struct result { typedef T type; };
Chris@16 834
Chris@16 835 template <
Chris@16 836 typename A, typename B, typename C, typename D, typename E,
Chris@16 837 typename F, typename G, typename H, typename I, typename J,
Chris@16 838 typename K, typename L, typename M, typename N, typename O
Chris@16 839 >
Chris@16 840 T operator()(
Chris@16 841 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 842 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 843 K const& k, L const& l, M const& m, N const& n, O const& o) const
Chris@16 844 {
Chris@16 845 T t(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o);
Chris@16 846 return t;
Chris@16 847 }
Chris@16 848 };
Chris@16 849 #endif
Chris@16 850
Chris@16 851
Chris@16 852 #if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002))
Chris@16 853
Chris@16 854 ///////////////////////////////////////////////////////////////////////////////
Chris@16 855 //
Chris@16 856 // The following specializations are needed because Borland and CodeWarrior
Chris@16 857 // does not accept default template arguments in nested template classes in
Chris@16 858 // classes (i.e construct_l::result)
Chris@16 859 //
Chris@16 860 ///////////////////////////////////////////////////////////////////////////////
Chris@16 861 template <typename T, typename TupleT>
Chris@16 862 struct composite0_result<construct_l_0<T>, TupleT> {
Chris@16 863
Chris@16 864 typedef T type;
Chris@16 865 };
Chris@16 866
Chris@16 867 //////////////////////////////////
Chris@16 868 template <typename T, typename TupleT,
Chris@16 869 typename A>
Chris@16 870 struct composite1_result<construct_l<T>, TupleT, A> {
Chris@16 871
Chris@16 872 typedef T type;
Chris@16 873 };
Chris@16 874
Chris@16 875 //////////////////////////////////
Chris@16 876 template <typename T, typename TupleT,
Chris@16 877 typename A, typename B>
Chris@16 878 struct composite2_result<construct_l<T>, TupleT, A, B> {
Chris@16 879
Chris@16 880 typedef T type;
Chris@16 881 };
Chris@16 882
Chris@16 883 //////////////////////////////////
Chris@16 884 template <typename T, typename TupleT,
Chris@16 885 typename A, typename B, typename C>
Chris@16 886 struct composite3_result<construct_l<T>, TupleT, A, B, C> {
Chris@16 887
Chris@16 888 typedef T type;
Chris@16 889 };
Chris@16 890
Chris@16 891 #if PHOENIX_LIMIT > 3
Chris@16 892 //////////////////////////////////
Chris@16 893 template <typename T, typename TupleT,
Chris@16 894 typename A, typename B, typename C, typename D>
Chris@16 895 struct composite4_result<construct_l<T>, TupleT,
Chris@16 896 A, B, C, D> {
Chris@16 897
Chris@16 898 typedef T type;
Chris@16 899 };
Chris@16 900
Chris@16 901 //////////////////////////////////
Chris@16 902 template <typename T, typename TupleT,
Chris@16 903 typename A, typename B, typename C, typename D, typename E>
Chris@16 904 struct composite5_result<construct_l<T>, TupleT,
Chris@16 905 A, B, C, D, E> {
Chris@16 906
Chris@16 907 typedef T type;
Chris@16 908 };
Chris@16 909
Chris@16 910 //////////////////////////////////
Chris@16 911 template <typename T, typename TupleT,
Chris@16 912 typename A, typename B, typename C, typename D, typename E,
Chris@16 913 typename F>
Chris@16 914 struct composite6_result<construct_l<T>, TupleT,
Chris@16 915 A, B, C, D, E, F> {
Chris@16 916
Chris@16 917 typedef T type;
Chris@16 918 };
Chris@16 919
Chris@16 920 #if PHOENIX_LIMIT > 6
Chris@16 921 //////////////////////////////////
Chris@16 922 template <typename T, typename TupleT,
Chris@16 923 typename A, typename B, typename C, typename D, typename E,
Chris@16 924 typename F, typename G>
Chris@16 925 struct composite7_result<construct_l<T>, TupleT,
Chris@16 926 A, B, C, D, E, F, G> {
Chris@16 927
Chris@16 928 typedef T type;
Chris@16 929 };
Chris@16 930
Chris@16 931 //////////////////////////////////
Chris@16 932 template <typename T, typename TupleT,
Chris@16 933 typename A, typename B, typename C, typename D, typename E,
Chris@16 934 typename F, typename G, typename H>
Chris@16 935 struct composite8_result<construct_l<T>, TupleT,
Chris@16 936 A, B, C, D, E, F, G, H> {
Chris@16 937
Chris@16 938 typedef T type;
Chris@16 939 };
Chris@16 940
Chris@16 941 //////////////////////////////////
Chris@16 942 template <typename T, typename TupleT,
Chris@16 943 typename A, typename B, typename C, typename D, typename E,
Chris@16 944 typename F, typename G, typename H, typename I>
Chris@16 945 struct composite9_result<construct_l<T>, TupleT,
Chris@16 946 A, B, C, D, E, F, G, H, I> {
Chris@16 947
Chris@16 948 typedef T type;
Chris@16 949 };
Chris@16 950
Chris@16 951 #if PHOENIX_LIMIT > 9
Chris@16 952 //////////////////////////////////
Chris@16 953 template <typename T, typename TupleT,
Chris@16 954 typename A, typename B, typename C, typename D, typename E,
Chris@16 955 typename F, typename G, typename H, typename I, typename J>
Chris@16 956 struct composite10_result<construct_l<T>, TupleT,
Chris@16 957 A, B, C, D, E, F, G, H, I, J> {
Chris@16 958
Chris@16 959 typedef T type;
Chris@16 960 };
Chris@16 961
Chris@16 962 //////////////////////////////////
Chris@16 963 template <typename T, typename TupleT,
Chris@16 964 typename A, typename B, typename C, typename D, typename E,
Chris@16 965 typename F, typename G, typename H, typename I, typename J,
Chris@16 966 typename K>
Chris@16 967 struct composite11_result<construct_l<T>, TupleT,
Chris@16 968 A, B, C, D, E, F, G, H, I, J, K> {
Chris@16 969
Chris@16 970 typedef T type;
Chris@16 971 };
Chris@16 972
Chris@16 973 //////////////////////////////////
Chris@16 974 template <typename T, typename TupleT,
Chris@16 975 typename A, typename B, typename C, typename D, typename E,
Chris@16 976 typename F, typename G, typename H, typename I, typename J,
Chris@16 977 typename K, typename L>
Chris@16 978 struct composite12_result<construct_l<T>, TupleT,
Chris@16 979 A, B, C, D, E, F, G, H, I, J, K, L> {
Chris@16 980
Chris@16 981 typedef T type;
Chris@16 982 };
Chris@16 983
Chris@16 984 #if PHOENIX_LIMIT > 12
Chris@16 985 //////////////////////////////////
Chris@16 986 template <typename T, typename TupleT,
Chris@16 987 typename A, typename B, typename C, typename D, typename E,
Chris@16 988 typename F, typename G, typename H, typename I, typename J,
Chris@16 989 typename K, typename L, typename M>
Chris@16 990 struct composite13_result<construct_l<T>, TupleT,
Chris@16 991 A, B, C, D, E, F, G, H, I, J, K, L, M> {
Chris@16 992
Chris@16 993 typedef T type;
Chris@16 994 };
Chris@16 995
Chris@16 996 //////////////////////////////////
Chris@16 997 template <typename T, typename TupleT,
Chris@16 998 typename A, typename B, typename C, typename D, typename E,
Chris@16 999 typename F, typename G, typename H, typename I, typename J,
Chris@16 1000 typename K, typename L, typename M, typename N>
Chris@16 1001 struct composite14_result<construct_l<T>, TupleT,
Chris@16 1002 A, B, C, D, E, F, G, H, I, J, K, L, M, N> {
Chris@16 1003
Chris@16 1004 typedef T type;
Chris@16 1005 };
Chris@16 1006
Chris@16 1007 //////////////////////////////////
Chris@16 1008 template <typename T, typename TupleT,
Chris@16 1009 typename A, typename B, typename C, typename D, typename E,
Chris@16 1010 typename F, typename G, typename H, typename I, typename J,
Chris@16 1011 typename K, typename L, typename M, typename N, typename O>
Chris@16 1012 struct composite15_result<construct_l<T>, TupleT,
Chris@16 1013 A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {
Chris@16 1014
Chris@16 1015 typedef T type;
Chris@16 1016 };
Chris@16 1017
Chris@16 1018 #endif
Chris@16 1019 #endif
Chris@16 1020 #endif
Chris@16 1021 #endif
Chris@16 1022 #endif
Chris@16 1023
Chris@16 1024 //////////////////////////////////
Chris@16 1025 template <typename T>
Chris@16 1026 inline typename impl::make_composite<construct_l_0<T> >::type
Chris@16 1027 construct_()
Chris@16 1028 {
Chris@16 1029 typedef impl::make_composite<construct_l_0<T> > make_composite_t;
Chris@16 1030 typedef typename make_composite_t::type type_t;
Chris@16 1031 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1032
Chris@16 1033 return type_t(composite_type_t(construct_l_0<T>()));
Chris@16 1034 }
Chris@16 1035
Chris@16 1036 //////////////////////////////////
Chris@16 1037 template <typename T, typename A>
Chris@16 1038 inline typename impl::make_composite<construct_1<T>, A>::type
Chris@16 1039 construct_(A const& a)
Chris@16 1040 {
Chris@16 1041 typedef impl::make_composite<construct_1<T>, A> make_composite_t;
Chris@16 1042 typedef typename make_composite_t::type type_t;
Chris@16 1043 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1044
Chris@16 1045 return type_t(composite_type_t(construct_1<T>(),
Chris@16 1046 as_actor<A>::convert(a)
Chris@16 1047 ));
Chris@16 1048 }
Chris@16 1049
Chris@16 1050 //////////////////////////////////
Chris@16 1051 template <typename T, typename A, typename B>
Chris@16 1052 inline typename impl::make_composite<construct_2<T>, A, B>::type
Chris@16 1053 construct_(A const& a, B const& b)
Chris@16 1054 {
Chris@16 1055 typedef impl::make_composite<construct_2<T>, A, B> make_composite_t;
Chris@16 1056 typedef typename make_composite_t::type type_t;
Chris@16 1057 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1058
Chris@16 1059 return type_t(composite_type_t(construct_2<T>(),
Chris@16 1060 as_actor<A>::convert(a),
Chris@16 1061 as_actor<B>::convert(b)
Chris@16 1062 ));
Chris@16 1063 }
Chris@16 1064
Chris@16 1065 //////////////////////////////////
Chris@16 1066 template <typename T, typename A, typename B, typename C>
Chris@16 1067 inline typename impl::make_composite<construct_3<T>, A, B, C>::type
Chris@16 1068 construct_(A const& a, B const& b, C const& c)
Chris@16 1069 {
Chris@16 1070 typedef impl::make_composite<construct_3<T>, A, B, C> make_composite_t;
Chris@16 1071 typedef typename make_composite_t::type type_t;
Chris@16 1072 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1073
Chris@16 1074 return type_t(composite_type_t(construct_3<T>(),
Chris@16 1075 as_actor<A>::convert(a),
Chris@16 1076 as_actor<B>::convert(b),
Chris@16 1077 as_actor<C>::convert(c)
Chris@16 1078 ));
Chris@16 1079 }
Chris@16 1080
Chris@16 1081 #if PHOENIX_CONSTRUCT_LIMIT > 3
Chris@16 1082 //////////////////////////////////
Chris@16 1083 template <
Chris@16 1084 typename T, typename A, typename B, typename C, typename D
Chris@16 1085 >
Chris@16 1086 inline typename impl::make_composite<construct_4<T>, A, B, C, D>::type
Chris@16 1087 construct_(
Chris@16 1088 A const& a, B const& b, C const& c, D const& d)
Chris@16 1089 {
Chris@16 1090 typedef
Chris@16 1091 impl::make_composite<construct_4<T>, A, B, C, D>
Chris@16 1092 make_composite_t;
Chris@16 1093 typedef typename make_composite_t::type type_t;
Chris@16 1094 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1095
Chris@16 1096 return type_t(composite_type_t(construct_4<T>(),
Chris@16 1097 as_actor<A>::convert(a),
Chris@16 1098 as_actor<B>::convert(b),
Chris@16 1099 as_actor<C>::convert(c),
Chris@16 1100 as_actor<D>::convert(d)
Chris@16 1101 ));
Chris@16 1102 }
Chris@16 1103
Chris@16 1104 //////////////////////////////////
Chris@16 1105 template <
Chris@16 1106 typename T, typename A, typename B, typename C, typename D, typename E
Chris@16 1107 >
Chris@16 1108 inline typename impl::make_composite<construct_5<T>, A, B, C, D, E>::type
Chris@16 1109 construct_(
Chris@16 1110 A const& a, B const& b, C const& c, D const& d, E const& e)
Chris@16 1111 {
Chris@16 1112 typedef
Chris@16 1113 impl::make_composite<construct_5<T>, A, B, C, D, E>
Chris@16 1114 make_composite_t;
Chris@16 1115 typedef typename make_composite_t::type type_t;
Chris@16 1116 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1117
Chris@16 1118 return type_t(composite_type_t(construct_5<T>(),
Chris@16 1119 as_actor<A>::convert(a),
Chris@16 1120 as_actor<B>::convert(b),
Chris@16 1121 as_actor<C>::convert(c),
Chris@16 1122 as_actor<D>::convert(d),
Chris@16 1123 as_actor<E>::convert(e)
Chris@16 1124 ));
Chris@16 1125 }
Chris@16 1126
Chris@16 1127 //////////////////////////////////
Chris@16 1128 template <
Chris@16 1129 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1130 typename F
Chris@16 1131 >
Chris@16 1132 inline typename impl::make_composite<construct_6<T>, A, B, C, D, E, F>::type
Chris@16 1133 construct_(
Chris@16 1134 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1135 F const& f)
Chris@16 1136 {
Chris@16 1137 typedef
Chris@16 1138 impl::make_composite<construct_6<T>, A, B, C, D, E, F>
Chris@16 1139 make_composite_t;
Chris@16 1140 typedef typename make_composite_t::type type_t;
Chris@16 1141 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1142
Chris@16 1143 return type_t(composite_type_t(construct_6<T>(),
Chris@16 1144 as_actor<A>::convert(a),
Chris@16 1145 as_actor<B>::convert(b),
Chris@16 1146 as_actor<C>::convert(c),
Chris@16 1147 as_actor<D>::convert(d),
Chris@16 1148 as_actor<E>::convert(e),
Chris@16 1149 as_actor<F>::convert(f)
Chris@16 1150 ));
Chris@16 1151 }
Chris@16 1152
Chris@16 1153 #if PHOENIX_CONSTRUCT_LIMIT > 6
Chris@16 1154 //////////////////////////////////
Chris@16 1155 template <
Chris@16 1156 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1157 typename F, typename G
Chris@16 1158 >
Chris@16 1159 inline typename impl::make_composite<construct_7<T>, A, B, C, D, E, F, G>::type
Chris@16 1160 construct_(
Chris@16 1161 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1162 F const& f, G const& g)
Chris@16 1163 {
Chris@16 1164 typedef
Chris@16 1165 impl::make_composite<construct_7<T>, A, B, C, D, E, F, G>
Chris@16 1166 make_composite_t;
Chris@16 1167 typedef typename make_composite_t::type type_t;
Chris@16 1168 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1169
Chris@16 1170 return type_t(composite_type_t(construct_7<T>(),
Chris@16 1171 as_actor<A>::convert(a),
Chris@16 1172 as_actor<B>::convert(b),
Chris@16 1173 as_actor<C>::convert(c),
Chris@16 1174 as_actor<D>::convert(d),
Chris@16 1175 as_actor<E>::convert(e),
Chris@16 1176 as_actor<F>::convert(f),
Chris@16 1177 as_actor<G>::convert(g)
Chris@16 1178 ));
Chris@16 1179 }
Chris@16 1180
Chris@16 1181 //////////////////////////////////
Chris@16 1182 template <
Chris@16 1183 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1184 typename F, typename G, typename H
Chris@16 1185 >
Chris@16 1186 inline typename impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H>::type
Chris@16 1187 construct_(
Chris@16 1188 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1189 F const& f, G const& g, H const& h)
Chris@16 1190 {
Chris@16 1191 typedef
Chris@16 1192 impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H>
Chris@16 1193 make_composite_t;
Chris@16 1194 typedef typename make_composite_t::type type_t;
Chris@16 1195 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1196
Chris@16 1197 return type_t(composite_type_t(construct_8<T>(),
Chris@16 1198 as_actor<A>::convert(a),
Chris@16 1199 as_actor<B>::convert(b),
Chris@16 1200 as_actor<C>::convert(c),
Chris@16 1201 as_actor<D>::convert(d),
Chris@16 1202 as_actor<E>::convert(e),
Chris@16 1203 as_actor<F>::convert(f),
Chris@16 1204 as_actor<G>::convert(g),
Chris@16 1205 as_actor<H>::convert(h)
Chris@16 1206 ));
Chris@16 1207 }
Chris@16 1208
Chris@16 1209 //////////////////////////////////
Chris@16 1210 template <
Chris@16 1211 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1212 typename F, typename G, typename H, typename I
Chris@16 1213 >
Chris@16 1214 inline typename impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I>::type
Chris@16 1215 construct_(
Chris@16 1216 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1217 F const& f, G const& g, H const& h, I const& i)
Chris@16 1218 {
Chris@16 1219 typedef
Chris@16 1220 impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I>
Chris@16 1221 make_composite_t;
Chris@16 1222 typedef typename make_composite_t::type type_t;
Chris@16 1223 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1224
Chris@16 1225 return type_t(composite_type_t(construct_9<T>(),
Chris@16 1226 as_actor<A>::convert(a),
Chris@16 1227 as_actor<B>::convert(b),
Chris@16 1228 as_actor<C>::convert(c),
Chris@16 1229 as_actor<D>::convert(d),
Chris@16 1230 as_actor<E>::convert(e),
Chris@16 1231 as_actor<F>::convert(f),
Chris@16 1232 as_actor<G>::convert(g),
Chris@16 1233 as_actor<H>::convert(h),
Chris@16 1234 as_actor<I>::convert(i)
Chris@16 1235 ));
Chris@16 1236 }
Chris@16 1237
Chris@16 1238 #if PHOENIX_CONSTRUCT_LIMIT > 9
Chris@16 1239 //////////////////////////////////
Chris@16 1240 template <
Chris@16 1241 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1242 typename F, typename G, typename H, typename I, typename J
Chris@16 1243 >
Chris@16 1244 inline typename impl::make_composite<
Chris@16 1245 construct_10<T>, A, B, C, D, E, F, G, H, I, J>::type
Chris@16 1246 construct_(
Chris@16 1247 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1248 F const& f, G const& g, H const& h, I const& i, J const& j)
Chris@16 1249 {
Chris@16 1250 typedef
Chris@16 1251 impl::make_composite<
Chris@16 1252 construct_10<T>, A, B, C, D, E, F, G, H, I, J
Chris@16 1253 >
Chris@16 1254 make_composite_t;
Chris@16 1255 typedef typename make_composite_t::type type_t;
Chris@16 1256 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1257
Chris@16 1258 return type_t(composite_type_t(construct_10<T>(),
Chris@16 1259 as_actor<A>::convert(a),
Chris@16 1260 as_actor<B>::convert(b),
Chris@16 1261 as_actor<C>::convert(c),
Chris@16 1262 as_actor<D>::convert(d),
Chris@16 1263 as_actor<E>::convert(e),
Chris@16 1264 as_actor<F>::convert(f),
Chris@16 1265 as_actor<G>::convert(g),
Chris@16 1266 as_actor<H>::convert(h),
Chris@16 1267 as_actor<I>::convert(i),
Chris@16 1268 as_actor<J>::convert(j)
Chris@16 1269 ));
Chris@16 1270 }
Chris@16 1271
Chris@16 1272 //////////////////////////////////
Chris@16 1273 template <
Chris@16 1274 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1275 typename F, typename G, typename H, typename I, typename J, typename K
Chris@16 1276 >
Chris@16 1277 inline typename impl::make_composite<
Chris@16 1278 construct_11<T>, A, B, C, D, E, F, G, H, I, J, K>::type
Chris@16 1279 construct_(
Chris@16 1280 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1281 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 1282 K const& k)
Chris@16 1283 {
Chris@16 1284 typedef
Chris@16 1285 impl::make_composite<
Chris@16 1286 construct_11<T>, A, B, C, D, E, F, G, H, I, J, K
Chris@16 1287 >
Chris@16 1288 make_composite_t;
Chris@16 1289 typedef typename make_composite_t::type type_t;
Chris@16 1290 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1291
Chris@16 1292 return type_t(composite_type_t(construct_11<T>(),
Chris@16 1293 as_actor<A>::convert(a),
Chris@16 1294 as_actor<B>::convert(b),
Chris@16 1295 as_actor<C>::convert(c),
Chris@16 1296 as_actor<D>::convert(d),
Chris@16 1297 as_actor<E>::convert(e),
Chris@16 1298 as_actor<F>::convert(f),
Chris@16 1299 as_actor<G>::convert(g),
Chris@16 1300 as_actor<H>::convert(h),
Chris@16 1301 as_actor<I>::convert(i),
Chris@16 1302 as_actor<J>::convert(j),
Chris@16 1303 as_actor<K>::convert(k)
Chris@16 1304 ));
Chris@16 1305 }
Chris@16 1306
Chris@16 1307 //////////////////////////////////
Chris@16 1308 template <
Chris@16 1309 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1310 typename F, typename G, typename H, typename I, typename J, typename K,
Chris@16 1311 typename L
Chris@16 1312 >
Chris@16 1313 inline typename impl::make_composite<
Chris@16 1314 construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L>::type
Chris@16 1315 construct_(
Chris@16 1316 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1317 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 1318 K const& k, L const& l)
Chris@16 1319 {
Chris@16 1320 typedef
Chris@16 1321 impl::make_composite<
Chris@16 1322 construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L
Chris@16 1323 >
Chris@16 1324 make_composite_t;
Chris@16 1325 typedef typename make_composite_t::type type_t;
Chris@16 1326 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1327
Chris@16 1328 return type_t(composite_type_t(construct_12<T>(),
Chris@16 1329 as_actor<A>::convert(a),
Chris@16 1330 as_actor<B>::convert(b),
Chris@16 1331 as_actor<C>::convert(c),
Chris@16 1332 as_actor<D>::convert(d),
Chris@16 1333 as_actor<E>::convert(e),
Chris@16 1334 as_actor<F>::convert(f),
Chris@16 1335 as_actor<G>::convert(g),
Chris@16 1336 as_actor<H>::convert(h),
Chris@16 1337 as_actor<I>::convert(i),
Chris@16 1338 as_actor<J>::convert(j),
Chris@16 1339 as_actor<K>::convert(k),
Chris@16 1340 as_actor<L>::convert(l)
Chris@16 1341 ));
Chris@16 1342 }
Chris@16 1343
Chris@16 1344 #if PHOENIX_CONSTRUCT_LIMIT > 12
Chris@16 1345 //////////////////////////////////
Chris@16 1346 template <
Chris@16 1347 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1348 typename F, typename G, typename H, typename I, typename J, typename K,
Chris@16 1349 typename L, typename M
Chris@16 1350 >
Chris@16 1351 inline typename impl::make_composite<
Chris@16 1352 construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type
Chris@16 1353 construct_(
Chris@16 1354 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1355 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 1356 K const& k, L const& l, M const& m)
Chris@16 1357 {
Chris@16 1358 typedef
Chris@16 1359 impl::make_composite<
Chris@16 1360 construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M
Chris@16 1361 >
Chris@16 1362 make_composite_t;
Chris@16 1363 typedef typename make_composite_t::type type_t;
Chris@16 1364 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1365
Chris@16 1366 return type_t(composite_type_t(construct_13<T>(),
Chris@16 1367 as_actor<A>::convert(a),
Chris@16 1368 as_actor<B>::convert(b),
Chris@16 1369 as_actor<C>::convert(c),
Chris@16 1370 as_actor<D>::convert(d),
Chris@16 1371 as_actor<E>::convert(e),
Chris@16 1372 as_actor<F>::convert(f),
Chris@16 1373 as_actor<G>::convert(g),
Chris@16 1374 as_actor<H>::convert(h),
Chris@16 1375 as_actor<I>::convert(i),
Chris@16 1376 as_actor<J>::convert(j),
Chris@16 1377 as_actor<K>::convert(k),
Chris@16 1378 as_actor<L>::convert(l),
Chris@16 1379 as_actor<M>::convert(m)
Chris@16 1380 ));
Chris@16 1381 }
Chris@16 1382
Chris@16 1383 //////////////////////////////////
Chris@16 1384 template <
Chris@16 1385 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1386 typename F, typename G, typename H, typename I, typename J, typename K,
Chris@16 1387 typename L, typename M, typename N
Chris@16 1388 >
Chris@16 1389 inline typename impl::make_composite<
Chris@16 1390 construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type
Chris@16 1391 construct_(
Chris@16 1392 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1393 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 1394 K const& k, L const& l, M const& m, N const& n)
Chris@16 1395 {
Chris@16 1396 typedef
Chris@16 1397 impl::make_composite<
Chris@16 1398 construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Chris@16 1399 >
Chris@16 1400 make_composite_t;
Chris@16 1401 typedef typename make_composite_t::type type_t;
Chris@16 1402 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1403
Chris@16 1404 return type_t(composite_type_t(construct_14<T>(),
Chris@16 1405 as_actor<A>::convert(a),
Chris@16 1406 as_actor<B>::convert(b),
Chris@16 1407 as_actor<C>::convert(c),
Chris@16 1408 as_actor<D>::convert(d),
Chris@16 1409 as_actor<E>::convert(e),
Chris@16 1410 as_actor<F>::convert(f),
Chris@16 1411 as_actor<G>::convert(g),
Chris@16 1412 as_actor<H>::convert(h),
Chris@16 1413 as_actor<I>::convert(i),
Chris@16 1414 as_actor<J>::convert(j),
Chris@16 1415 as_actor<K>::convert(k),
Chris@16 1416 as_actor<L>::convert(l),
Chris@16 1417 as_actor<M>::convert(m),
Chris@16 1418 as_actor<N>::convert(n)
Chris@16 1419 ));
Chris@16 1420 }
Chris@16 1421
Chris@16 1422 //////////////////////////////////
Chris@16 1423 template <
Chris@16 1424 typename T, typename A, typename B, typename C, typename D, typename E,
Chris@16 1425 typename F, typename G, typename H, typename I, typename J, typename K,
Chris@16 1426 typename L, typename M, typename N, typename O
Chris@16 1427 >
Chris@16 1428 inline typename impl::make_composite<
Chris@16 1429 construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type
Chris@16 1430 construct_(
Chris@16 1431 A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16 1432 F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16 1433 K const& k, L const& l, M const& m, N const& n, O const& o)
Chris@16 1434 {
Chris@16 1435 typedef
Chris@16 1436 impl::make_composite<
Chris@16 1437 construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
Chris@16 1438 >
Chris@16 1439 make_composite_t;
Chris@16 1440 typedef typename make_composite_t::type type_t;
Chris@16 1441 typedef typename make_composite_t::composite_type composite_type_t;
Chris@16 1442
Chris@16 1443 return type_t(composite_type_t(construct_15<T>(),
Chris@16 1444 as_actor<A>::convert(a),
Chris@16 1445 as_actor<B>::convert(b),
Chris@16 1446 as_actor<C>::convert(c),
Chris@16 1447 as_actor<D>::convert(d),
Chris@16 1448 as_actor<E>::convert(e),
Chris@16 1449 as_actor<F>::convert(f),
Chris@16 1450 as_actor<G>::convert(g),
Chris@16 1451 as_actor<H>::convert(h),
Chris@16 1452 as_actor<I>::convert(i),
Chris@16 1453 as_actor<J>::convert(j),
Chris@16 1454 as_actor<K>::convert(k),
Chris@16 1455 as_actor<L>::convert(l),
Chris@16 1456 as_actor<M>::convert(m),
Chris@16 1457 as_actor<N>::convert(n),
Chris@16 1458 as_actor<O>::convert(o)
Chris@16 1459 ));
Chris@16 1460 }
Chris@16 1461
Chris@16 1462 #endif
Chris@16 1463 #endif
Chris@16 1464 #endif
Chris@16 1465 #endif
Chris@16 1466
Chris@16 1467 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1468 } // namespace phoenix
Chris@16 1469
Chris@16 1470 #endif // PHOENIX_CASTS_HPP