Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/new.hpp @ 118:770eb830ec19 emscripten

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