Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 10:09:06 

0001 /*=============================================================================
0002     Phoenix V1.2.1
0003     Copyright (c) 2001-2003 Joel de Guzman
0004     Copyright (c) 2001-2003 Hartmut Kaiser
0005     Copyright (c) 2003 Vaclav Vesely
0006 
0007   Distributed under the Boost Software License, Version 1.0. (See accompanying
0008   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0009 ==============================================================================*/
0010 
0011 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_NEW_HPP
0012 #define BOOST_SPIRIT_CLASSIC_PHOENIX_NEW_HPP
0013 
0014 ///////////////////////////////////////////////////////////////////////////////
0015 #include <boost/spirit/home/classic/phoenix/actor.hpp>
0016 #include <boost/spirit/home/classic/phoenix/composite.hpp>
0017 #include <boost/static_assert.hpp>
0018 
0019 ///////////////////////////////////////////////////////////////////////////////
0020 namespace phoenix {
0021 
0022 ///////////////////////////////////////////////////////////////////////////////
0023 //
0024 //  Phoenix predefined maximum new_ limit. This limit defines the maximum
0025 //  number of parameters supported for calles to the set of new_ template
0026 //  functions (lazy object construction, see below). This number defaults to 3.
0027 //  The actual maximum is rounded up in multiples of 3. Thus, if this value
0028 //  is 4, the actual limit is 6. The ultimate maximum limit in this
0029 //  implementation is 15.
0030 //  PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT!
0031 
0032 #if !defined(PHOENIX_CONSTRUCT_LIMIT)
0033 #define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT
0034 #endif
0035 
0036 // ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT
0037 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT);
0038 
0039 // ensure PHOENIX_CONSTRUCT_LIMIT <= 15
0040 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15);
0041 
0042 ///////////////////////////////////////////////////////////////////////////////
0043 //
0044 //  new_
0045 //
0046 //      Lazy object construction
0047 //
0048 //      The set of new_<> template classes and functions provide a way
0049 //      of lazily constructing certain object from a arbitrary set of
0050 //      actors during parsing.
0051 //      The new_ templates are (syntactically) used very much like
0052 //      the well known C++ casts:
0053 //
0054 //          A *a = new_<A>(...arbitrary list of actors...);
0055 //
0056 //      where the given parameters are submitted as parameters to the
0057 //      constructor of the object of type A. (This certainly implies, that
0058 //      type A has a constructor with a fitting set of parameter types
0059 //      defined.)
0060 //
0061 //      The maximum number of needed parameters is controlled through the
0062 //      preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this
0063 //      limit should not be greater than PHOENIX_LIMIT.
0064 //
0065 ///////////////////////////////////////////////////////////////////////////////
0066 
0067 template <typename T>
0068 struct new_l_0
0069 {
0070     typedef T* result_type;
0071 
0072     T* operator()() const
0073     {
0074         return new T();
0075     }
0076 };
0077 
0078 template <typename T>
0079 struct new_l {
0080 
0081     template <
0082             typename A
0083         ,   typename B
0084         ,   typename C
0085 
0086 #if PHOENIX_CONSTRUCT_LIMIT > 3
0087         ,   typename D
0088         ,   typename E
0089         ,   typename F
0090 
0091 #if PHOENIX_CONSTRUCT_LIMIT > 6
0092         ,   typename G
0093         ,   typename H
0094         ,   typename I
0095 
0096 #if PHOENIX_CONSTRUCT_LIMIT > 9
0097         ,   typename J
0098         ,   typename K
0099         ,   typename L
0100 
0101 #if PHOENIX_CONSTRUCT_LIMIT > 12
0102         ,   typename M
0103         ,   typename N
0104         ,   typename O
0105 #endif
0106 #endif
0107 #endif
0108 #endif
0109     >
0110     struct result { typedef T* type; };
0111 
0112     T* operator()() const {
0113         return new T();
0114     }
0115 
0116     template <typename A>
0117     T* operator()(A const& a) const {
0118         return new T(a);
0119     }
0120 
0121     template <typename A, typename B>
0122     T* operator()(A const& a, B const& b) const {
0123         return new T(a, b);
0124     }
0125 
0126     template <typename A, typename B, typename C>
0127     T* operator()(A const& a, B const& b, C const& c) const {
0128         return new T(a, b, c);
0129     }
0130 
0131 #if PHOENIX_CONSTRUCT_LIMIT > 3
0132     template <
0133         typename A, typename B, typename C, typename D
0134     >
0135     T* operator()(
0136         A const& a, B const& b, C const& c, D const& d) const
0137     {
0138         return new T(a, b, c, d);
0139     }
0140 
0141     template <
0142         typename A, typename B, typename C, typename D, typename E
0143     >
0144     T* operator()(
0145         A const& a, B const& b, C const& c, D const& d, E const& e) const
0146     {
0147         return new T(a, b, c, d, e);
0148     }
0149 
0150     template <
0151         typename A, typename B, typename C, typename D, typename E,
0152         typename F
0153     >
0154     T* operator()(
0155         A const& a, B const& b, C const& c, D const& d, E const& e,
0156         F const& f) const
0157     {
0158         return new T(a, b, c, d, e, f);
0159     }
0160 
0161 #if PHOENIX_CONSTRUCT_LIMIT > 6
0162     template <
0163         typename A, typename B, typename C, typename D, typename E,
0164         typename F, typename G
0165     >
0166     T* operator()(
0167         A const& a, B const& b, C const& c, D const& d, E const& e,
0168         F const& f, G const& g) const
0169     {
0170         return new T(a, b, c, d, e, f, g);
0171     }
0172 
0173     template <
0174         typename A, typename B, typename C, typename D, typename E,
0175         typename F, typename G, typename H
0176     >
0177     T* operator()(
0178         A const& a, B const& b, C const& c, D const& d, E const& e,
0179         F const& f, G const& g, H const& h) const
0180     {
0181         return new T(a, b, c, d, e, f, g, h);
0182     }
0183 
0184     template <
0185         typename A, typename B, typename C, typename D, typename E,
0186         typename F, typename G, typename H, typename I
0187     >
0188     T* operator()(
0189         A const& a, B const& b, C const& c, D const& d, E const& e,
0190         F const& f, G const& g, H const& h, I const& i) const
0191     {
0192         return new T(a, b, c, d, e, f, g, h, i);
0193     }
0194 
0195 #if PHOENIX_CONSTRUCT_LIMIT > 9
0196     template <
0197         typename A, typename B, typename C, typename D, typename E,
0198         typename F, typename G, typename H, typename I, typename J
0199     >
0200     T* operator()(
0201         A const& a, B const& b, C const& c, D const& d, E const& e,
0202         F const& f, G const& g, H const& h, I const& i, J const& j) const
0203     {
0204         return new T(a, b, c, d, e, f, g, h, i, j);
0205     }
0206 
0207     template <
0208         typename A, typename B, typename C, typename D, typename E,
0209         typename F, typename G, typename H, typename I, typename J,
0210         typename K
0211     >
0212     T* operator()(
0213         A const& a, B const& b, C const& c, D const& d, E const& e,
0214         F const& f, G const& g, H const& h, I const& i, J const& j,
0215         K const& k) const
0216     {
0217         return new T(a, b, c, d, e, f, g, h, i, j, k);
0218     }
0219 
0220     template <
0221         typename A, typename B, typename C, typename D, typename E,
0222         typename F, typename G, typename H, typename I, typename J,
0223         typename K, typename L
0224     >
0225     T* operator()(
0226         A const& a, B const& b, C const& c, D const& d, E const& e,
0227         F const& f, G const& g, H const& h, I const& i, J const& j,
0228         K const& k, L const& l) const
0229     {
0230         return new T(a, b, c, d, e, f, g, h, i, j, k, l);
0231     }
0232 
0233 #if PHOENIX_CONSTRUCT_LIMIT > 12
0234     template <
0235         typename A, typename B, typename C, typename D, typename E,
0236         typename F, typename G, typename H, typename I, typename J,
0237         typename K, typename L, typename M
0238     >
0239     T* operator()(
0240         A const& a, B const& b, C const& c, D const& d, E const& e,
0241         F const& f, G const& g, H const& h, I const& i, J const& j,
0242         K const& k, L const& l, M const& m) const
0243     {
0244         return new T(a, b, c, d, e, f, g, h, i, j, k, l, m);
0245     }
0246 
0247     template <
0248         typename A, typename B, typename C, typename D, typename E,
0249         typename F, typename G, typename H, typename I, typename J,
0250         typename K, typename L, typename M, typename N
0251     >
0252     T* operator()(
0253         A const& a, B const& b, C const& c, D const& d, E const& e,
0254         F const& f, G const& g, H const& h, I const& i, J const& j,
0255         K const& k, L const& l, M const& m, N const& n) const
0256     {
0257         return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
0258     }
0259 
0260     template <
0261         typename A, typename B, typename C, typename D, typename E,
0262         typename F, typename G, typename H, typename I, typename J,
0263         typename K, typename L, typename M, typename N, typename O
0264     >
0265     T* operator()(
0266         A const& a, B const& b, C const& c, D const& d, E const& e,
0267         F const& f, G const& g, H const& h, I const& i, J const& j,
0268         K const& k, L const& l, M const& m, N const& n, O const& o) const
0269     {
0270         return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
0271     }
0272 
0273 #endif
0274 #endif
0275 #endif
0276 #endif
0277 };
0278 
0279 template <typename T>
0280 struct new_1 {
0281 
0282     template <
0283             typename A
0284     >
0285     struct result { typedef T* type; };
0286 
0287     template <typename A>
0288     T* operator()(A const& a) const {
0289         return new T(a);
0290     }
0291 
0292 };
0293 
0294 template <typename T>
0295 struct new_2 {
0296 
0297     template <
0298             typename A
0299         ,   typename B
0300     >
0301     struct result { typedef T* type; };
0302 
0303     template <typename A, typename B>
0304     T* operator()(A const& a, B const& b) const {
0305         return new T(a, b);
0306     }
0307 
0308 };
0309 
0310 template <typename T>
0311 struct new_3 {
0312 
0313     template <
0314             typename A
0315         ,   typename B
0316         ,   typename C
0317     >
0318     struct result { typedef T* type; };
0319 
0320     template <typename A, typename B, typename C>
0321     T* operator()(A const& a, B const& b, C const& c) const {
0322         return new T(a, b, c);
0323     }
0324 };
0325 
0326 #if PHOENIX_CONSTRUCT_LIMIT > 3
0327 template <typename T>
0328 struct new_4 {
0329 
0330     template <
0331             typename A
0332         ,   typename B
0333         ,   typename C
0334         ,   typename D
0335     >
0336     struct result { typedef T* type; };
0337 
0338 
0339     template <
0340         typename A, typename B, typename C, typename D
0341     >
0342     T* operator()(
0343         A const& a, B const& b, C const& c, D const& d) const
0344     {
0345         return new T(a, b, c, d);
0346     }
0347 };
0348 
0349 
0350 template <typename T>
0351 struct new_5 {
0352 
0353     template <
0354             typename A
0355         ,   typename B
0356         ,   typename C
0357         ,   typename D
0358         ,   typename E
0359     >
0360     struct result { typedef T* type; };
0361 
0362     template <
0363         typename A, typename B, typename C, typename D, typename E
0364     >
0365     T* operator()(
0366         A const& a, B const& b, C const& c, D const& d, E const& e) const
0367     {
0368         return new T(a, b, c, d, e);
0369     }
0370 };
0371 
0372 
0373 template <typename T>
0374 struct new_6 {
0375 
0376     template <
0377             typename A
0378         ,   typename B
0379         ,   typename C
0380         ,   typename D
0381         ,   typename E
0382         ,   typename F
0383     >
0384     struct result { typedef T* type; };
0385 
0386     template <
0387         typename A, typename B, typename C, typename D, typename E,
0388         typename F
0389     >
0390     T* operator()(
0391         A const& a, B const& b, C const& c, D const& d, E const& e,
0392         F const& f) const
0393     {
0394         return new T(a, b, c, d, e, f);
0395     }
0396 };
0397 #endif
0398 
0399 
0400 #if PHOENIX_CONSTRUCT_LIMIT > 6
0401 template <typename T>
0402 struct new_7 {
0403 
0404     template <
0405             typename A
0406         ,   typename B
0407         ,   typename C
0408         ,   typename D
0409         ,   typename E
0410         ,   typename F
0411         ,   typename G
0412     >
0413     struct result { typedef T* type; };
0414 
0415     template <
0416         typename A, typename B, typename C, typename D, typename E,
0417         typename F, typename G
0418     >
0419     T* operator()(
0420         A const& a, B const& b, C const& c, D const& d, E const& e,
0421         F const& f, G const& g) const
0422     {
0423         return new T(a, b, c, d, e, f, g);
0424     }
0425 };
0426 
0427 template <typename T>
0428 struct new_8 {
0429 
0430     template <
0431             typename A
0432         ,   typename B
0433         ,   typename C
0434         ,   typename D
0435         ,   typename E
0436         ,   typename F
0437         ,   typename G
0438         ,   typename H
0439     >
0440     struct result { typedef T* type; };
0441 
0442     template <
0443         typename A, typename B, typename C, typename D, typename E,
0444         typename F, typename G, typename H
0445     >
0446     T* operator()(
0447         A const& a, B const& b, C const& c, D const& d, E const& e,
0448         F const& f, G const& g, H const& h) const
0449     {
0450         return new T(a, b, c, d, e, f, g, h);
0451     }
0452 };
0453 
0454 template <typename T>
0455 struct new_9 {
0456 
0457     template <
0458             typename A
0459         ,   typename B
0460         ,   typename C
0461         ,   typename D
0462         ,   typename E
0463         ,   typename F
0464         ,   typename G
0465         ,   typename H
0466         ,   typename I
0467     >
0468     struct result { typedef T* type; };
0469 
0470     template <
0471         typename A, typename B, typename C, typename D, typename E,
0472         typename F, typename G, typename H, typename I
0473     >
0474     T* operator()(
0475         A const& a, B const& b, C const& c, D const& d, E const& e,
0476         F const& f, G const& g, H const& h, I const& i) const
0477     {
0478         return new T(a, b, c, d, e, f, g, h, i);
0479     }
0480 };
0481 #endif
0482 
0483 
0484 #if PHOENIX_CONSTRUCT_LIMIT > 9
0485 template <typename T>
0486 struct new_10 {
0487 
0488     template <
0489             typename A
0490         ,   typename B
0491         ,   typename C
0492         ,   typename D
0493         ,   typename E
0494         ,   typename F
0495         ,   typename G
0496         ,   typename H
0497         ,   typename I
0498         ,   typename J
0499     >
0500     struct result { typedef T* type; };
0501 
0502 
0503     template <
0504         typename A, typename B, typename C, typename D, typename E,
0505         typename F, typename G, typename H, typename I, typename J
0506     >
0507     T* operator()(
0508         A const& a, B const& b, C const& c, D const& d, E const& e,
0509         F const& f, G const& g, H const& h, I const& i, J const& j) const
0510     {
0511         return new T(a, b, c, d, e, f, g, h, i, j);
0512     }
0513 };
0514 
0515 template <typename T>
0516 struct new_11 {
0517 
0518     template <
0519             typename A
0520         ,   typename B
0521         ,   typename C
0522         ,   typename D
0523         ,   typename E
0524         ,   typename F
0525         ,   typename G
0526         ,   typename H
0527         ,   typename I
0528         ,   typename J
0529         ,   typename K
0530     >
0531     struct result { typedef T* type; };
0532 
0533 
0534     template <
0535         typename A, typename B, typename C, typename D, typename E,
0536         typename F, typename G, typename H, typename I, typename J,
0537         typename K
0538     >
0539     T* operator()(
0540         A const& a, B const& b, C const& c, D const& d, E const& e,
0541         F const& f, G const& g, H const& h, I const& i, J const& j,
0542         K const& k) const
0543     {
0544         return new T(a, b, c, d, e, f, g, h, i, j, k);
0545     }
0546 
0547 };
0548 
0549 template <typename T>
0550 struct new_12 {
0551 
0552     template <
0553             typename A
0554         ,   typename B
0555         ,   typename C
0556         ,   typename D
0557         ,   typename E
0558         ,   typename F
0559         ,   typename G
0560         ,   typename H
0561         ,   typename I
0562         ,   typename J
0563         ,   typename K
0564         ,   typename L
0565     >
0566     struct result { typedef T* type; };
0567 
0568 
0569     template <
0570         typename A, typename B, typename C, typename D, typename E,
0571         typename F, typename G, typename H, typename I, typename J,
0572         typename K, typename L
0573     >
0574     T* operator()(
0575         A const& a, B const& b, C const& c, D const& d, E const& e,
0576         F const& f, G const& g, H const& h, I const& i, J const& j,
0577         K const& k, L const& l) const
0578     {
0579         return new T(a, b, c, d, f, e, g, h, i, j, k, l);
0580     }
0581 };
0582 #endif
0583 
0584 #if PHOENIX_CONSTRUCT_LIMIT > 12
0585 template <typename T>
0586 struct new_13 {
0587 
0588     template <
0589             typename A
0590         ,   typename B
0591         ,   typename C
0592         ,   typename D
0593         ,   typename E
0594         ,   typename F
0595         ,   typename G
0596         ,   typename H
0597         ,   typename I
0598         ,   typename J
0599         ,   typename K
0600         ,   typename L
0601         ,   typename M
0602     >
0603     struct result { typedef T* type; };
0604 
0605 
0606     template <
0607         typename A, typename B, typename C, typename D, typename E,
0608         typename F, typename G, typename H, typename I, typename J,
0609         typename K, typename L, typename M
0610     >
0611     T* operator()(
0612         A const& a, B const& b, C const& c, D const& d, E const& e,
0613         F const& f, G const& g, H const& h, I const& i, J const& j,
0614         K const& k, L const& l, M const& m) const
0615     {
0616         return new T(a, b, c, d, e, f, g, h, i, j, k, l, m);
0617     }
0618 };
0619 
0620 template <typename T>
0621 struct new_14 {
0622 
0623     template <
0624             typename A
0625         ,   typename B
0626         ,   typename C
0627         ,   typename D
0628         ,   typename E
0629         ,   typename F
0630         ,   typename G
0631         ,   typename H
0632         ,   typename I
0633         ,   typename J
0634         ,   typename K
0635         ,   typename L
0636         ,   typename M
0637         ,   typename N
0638     >
0639     struct result { typedef T* type; };
0640 
0641 
0642     template <
0643         typename A, typename B, typename C, typename D, typename E,
0644         typename F, typename G, typename H, typename I, typename J,
0645         typename K, typename L, typename M, typename N
0646     >
0647     T* operator()(
0648         A const& a, B const& b, C const& c, D const& d, E const& e,
0649         F const& f, G const& g, H const& h, I const& i, J const& j,
0650         K const& k, L const& l, M const& m, N const& n) const
0651     {
0652         return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
0653     }
0654 
0655 };
0656 
0657 template <typename T>
0658 struct new_15 {
0659 
0660     template <
0661             typename A
0662         ,   typename B
0663         ,   typename C
0664         ,   typename D
0665         ,   typename E
0666         ,   typename F
0667         ,   typename G
0668         ,   typename H
0669         ,   typename I
0670         ,   typename J
0671         ,   typename K
0672         ,   typename L
0673         ,   typename M
0674         ,   typename N
0675         ,   typename O
0676     >
0677     struct result { typedef T* type; };
0678 
0679 
0680     template <
0681         typename A, typename B, typename C, typename D, typename E,
0682         typename F, typename G, typename H, typename I, typename J,
0683         typename K, typename L, typename M, typename N, typename O
0684     >
0685     T* operator()(
0686         A const& a, B const& b, C const& c, D const& d, E const& e,
0687         F const& f, G const& g, H const& h, I const& i, J const& j,
0688         K const& k, L const& l, M const& m, N const& n, O const& o) const
0689     {
0690         return new T(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o);
0691     }
0692 
0693 };
0694 #endif
0695 
0696 
0697 #if defined(BOOST_BORLANDC) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002))
0698 
0699 ///////////////////////////////////////////////////////////////////////////////
0700 //
0701 //  The following specializations are needed because Borland and CodeWarrior
0702 //  does not accept default template arguments in nested template classes in
0703 //  classes (i.e new_l::result)
0704 //
0705 ///////////////////////////////////////////////////////////////////////////////
0706 template <typename T, typename TupleT>
0707 struct composite0_result<new_l_0<T>, TupleT> {
0708 
0709     typedef T* type;
0710 };
0711 
0712 //////////////////////////////////
0713 template <typename T, typename TupleT,
0714     typename A>
0715 struct composite1_result<new_l<T>, TupleT, A> {
0716 
0717     typedef T* type;
0718 };
0719 
0720 //////////////////////////////////
0721 template <typename T, typename TupleT,
0722     typename A, typename B>
0723 struct composite2_result<new_l<T>, TupleT, A, B> {
0724 
0725     typedef T* type;
0726 };
0727 
0728 //////////////////////////////////
0729 template <typename T, typename TupleT,
0730     typename A, typename B, typename C>
0731 struct composite3_result<new_l<T>, TupleT, A, B, C> {
0732 
0733     typedef T* type;
0734 };
0735 
0736 #if PHOENIX_LIMIT > 3
0737 //////////////////////////////////
0738 template <typename T, typename TupleT,
0739     typename A, typename B, typename C, typename D>
0740 struct composite4_result<new_l<T>, TupleT,
0741     A, B, C, D> {
0742 
0743     typedef T* type;
0744 };
0745 
0746 //////////////////////////////////
0747 template <typename T, typename TupleT,
0748     typename A, typename B, typename C, typename D, typename E>
0749 struct composite5_result<new_l<T>, TupleT,
0750     A, B, C, D, E> {
0751 
0752     typedef T* type;
0753 };
0754 
0755 //////////////////////////////////
0756 template <typename T, typename TupleT,
0757     typename A, typename B, typename C, typename D, typename E,
0758     typename F>
0759 struct composite6_result<new_l<T>, TupleT,
0760     A, B, C, D, E, F> {
0761 
0762     typedef T* type;
0763 };
0764 
0765 #if PHOENIX_LIMIT > 6
0766 //////////////////////////////////
0767 template <typename T, typename TupleT,
0768     typename A, typename B, typename C, typename D, typename E,
0769     typename F, typename G>
0770 struct composite7_result<new_l<T>, TupleT,
0771     A, B, C, D, E, F, G> {
0772 
0773     typedef T* type;
0774 };
0775 
0776 //////////////////////////////////
0777 template <typename T, typename TupleT,
0778     typename A, typename B, typename C, typename D, typename E,
0779     typename F, typename G, typename H>
0780 struct composite8_result<new_l<T>, TupleT,
0781     A, B, C, D, E, F, G, H> {
0782 
0783     typedef T* type;
0784 };
0785 
0786 //////////////////////////////////
0787 template <typename T, typename TupleT,
0788     typename A, typename B, typename C, typename D, typename E,
0789     typename F, typename G, typename H, typename I>
0790 struct composite9_result<new_l<T>, TupleT,
0791     A, B, C, D, E, F, G, H, I> {
0792 
0793     typedef T* type;
0794 };
0795 
0796 #if PHOENIX_LIMIT > 9
0797 //////////////////////////////////
0798 template <typename T, typename TupleT,
0799     typename A, typename B, typename C, typename D, typename E,
0800     typename F, typename G, typename H, typename I, typename J>
0801 struct composite10_result<new_l<T>, TupleT,
0802     A, B, C, D, E, F, G, H, I, J> {
0803 
0804     typedef T* type;
0805 };
0806 
0807 //////////////////////////////////
0808 template <typename T, typename TupleT,
0809     typename A, typename B, typename C, typename D, typename E,
0810     typename F, typename G, typename H, typename I, typename J,
0811     typename K>
0812 struct composite11_result<new_l<T>, TupleT,
0813     A, B, C, D, E, F, G, H, I, J, K> {
0814 
0815     typedef T* type;
0816 };
0817 
0818 //////////////////////////////////
0819 template <typename T, typename TupleT,
0820     typename A, typename B, typename C, typename D, typename E,
0821     typename F, typename G, typename H, typename I, typename J,
0822     typename K, typename L>
0823 struct composite12_result<new_l<T>, TupleT,
0824     A, B, C, D, E, F, G, H, I, J, K, L> {
0825 
0826     typedef T* type;
0827 };
0828 
0829 #if PHOENIX_LIMIT > 12
0830 //////////////////////////////////
0831 template <typename T, typename TupleT,
0832     typename A, typename B, typename C, typename D, typename E,
0833     typename F, typename G, typename H, typename I, typename J,
0834     typename K, typename L, typename M>
0835 struct composite13_result<new_l<T>, TupleT,
0836     A, B, C, D, E, F, G, H, I, J, K, L, M> {
0837 
0838     typedef T* type;
0839 };
0840 
0841 //////////////////////////////////
0842 template <typename T, typename TupleT,
0843     typename A, typename B, typename C, typename D, typename E,
0844     typename F, typename G, typename H, typename I, typename J,
0845     typename K, typename L, typename M, typename N>
0846 struct composite14_result<new_l<T>, TupleT,
0847     A, B, C, D, E, F, G, H, I, J, K, L, M, N> {
0848 
0849     typedef T* type;
0850 };
0851 
0852 //////////////////////////////////
0853 template <typename T, typename TupleT,
0854     typename A, typename B, typename C, typename D, typename E,
0855     typename F, typename G, typename H, typename I, typename J,
0856     typename K, typename L, typename M, typename N, typename O>
0857 struct composite15_result<new_l<T>, TupleT,
0858     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {
0859 
0860     typedef T* type;
0861 };
0862 
0863 #endif
0864 #endif
0865 #endif
0866 #endif
0867 #endif
0868 
0869 //////////////////////////////////
0870 template <typename T>
0871 inline typename impl::make_composite<new_l_0<T> >::type
0872 new_()
0873 {
0874     typedef impl::make_composite<new_l_0<T> > make_composite_t;
0875     typedef typename make_composite_t::type type_t;
0876     typedef typename make_composite_t::composite_type composite_type_t;
0877 
0878     return type_t(composite_type_t(new_l_0<T>()));
0879 }
0880 
0881 //////////////////////////////////
0882 template <typename T, typename A>
0883 inline typename impl::make_composite<new_1<T>, A>::type
0884 new_(A const& a)
0885 {
0886     typedef impl::make_composite<new_1<T>, A> make_composite_t;
0887     typedef typename make_composite_t::type type_t;
0888     typedef typename make_composite_t::composite_type composite_type_t;
0889 
0890     return type_t(composite_type_t(new_1<T>(),
0891         as_actor<A>::convert(a)
0892     ));
0893 }
0894 
0895 //////////////////////////////////
0896 template <typename T, typename A, typename B>
0897 inline typename impl::make_composite<new_2<T>, A, B>::type
0898 new_(A const& a, B const& b)
0899 {
0900     typedef impl::make_composite<new_2<T>, A, B> make_composite_t;
0901     typedef typename make_composite_t::type type_t;
0902     typedef typename make_composite_t::composite_type composite_type_t;
0903 
0904     return type_t(composite_type_t(new_2<T>(),
0905         as_actor<A>::convert(a),
0906         as_actor<B>::convert(b)
0907     ));
0908 }
0909 
0910 //////////////////////////////////
0911 template <typename T, typename A, typename B, typename C>
0912 inline typename impl::make_composite<new_3<T>, A, B, C>::type
0913 new_(A const& a, B const& b, C const& c)
0914 {
0915     typedef impl::make_composite<new_3<T>, A, B, C> make_composite_t;
0916     typedef typename make_composite_t::type type_t;
0917     typedef typename make_composite_t::composite_type composite_type_t;
0918 
0919     return type_t(composite_type_t(new_3<T>(),
0920         as_actor<A>::convert(a),
0921         as_actor<B>::convert(b),
0922         as_actor<C>::convert(c)
0923     ));
0924 }
0925 
0926 #if PHOENIX_CONSTRUCT_LIMIT > 3
0927 //////////////////////////////////
0928 template <
0929     typename T, typename A, typename B, typename C, typename D
0930 >
0931 inline typename impl::make_composite<new_4<T>, A, B, C, D>::type
0932 new_(
0933     A const& a, B const& b, C const& c, D const& d)
0934 {
0935     typedef
0936         impl::make_composite<new_4<T>, A, B, C, D>
0937         make_composite_t;
0938     typedef typename make_composite_t::type type_t;
0939     typedef typename make_composite_t::composite_type composite_type_t;
0940 
0941     return type_t(composite_type_t(new_4<T>(),
0942         as_actor<A>::convert(a),
0943         as_actor<B>::convert(b),
0944         as_actor<C>::convert(c),
0945         as_actor<D>::convert(d)
0946     ));
0947 }
0948 
0949 //////////////////////////////////
0950 template <
0951     typename T, typename A, typename B, typename C, typename D, typename E
0952 >
0953 inline typename impl::make_composite<new_5<T>, A, B, C, D, E>::type
0954 new_(
0955     A const& a, B const& b, C const& c, D const& d, E const& e)
0956 {
0957     typedef
0958         impl::make_composite<new_5<T>, A, B, C, D, E>
0959         make_composite_t;
0960     typedef typename make_composite_t::type type_t;
0961     typedef typename make_composite_t::composite_type composite_type_t;
0962 
0963     return type_t(composite_type_t(new_5<T>(),
0964         as_actor<A>::convert(a),
0965         as_actor<B>::convert(b),
0966         as_actor<C>::convert(c),
0967         as_actor<D>::convert(d),
0968         as_actor<E>::convert(e)
0969     ));
0970 }
0971 
0972 //////////////////////////////////
0973 template <
0974     typename T, typename A, typename B, typename C, typename D, typename E,
0975     typename F
0976 >
0977 inline typename impl::make_composite<new_6<T>, A, B, C, D, E, F>::type
0978 new_(
0979     A const& a, B const& b, C const& c, D const& d, E const& e,
0980     F const& f)
0981 {
0982     typedef
0983         impl::make_composite<new_6<T>, A, B, C, D, E, F>
0984         make_composite_t;
0985     typedef typename make_composite_t::type type_t;
0986     typedef typename make_composite_t::composite_type composite_type_t;
0987 
0988     return type_t(composite_type_t(new_6<T>(),
0989         as_actor<A>::convert(a),
0990         as_actor<B>::convert(b),
0991         as_actor<C>::convert(c),
0992         as_actor<D>::convert(d),
0993         as_actor<E>::convert(e),
0994         as_actor<F>::convert(f)
0995     ));
0996 }
0997 
0998 #if PHOENIX_CONSTRUCT_LIMIT > 6
0999 //////////////////////////////////
1000 template <
1001     typename T, typename A, typename B, typename C, typename D, typename E,
1002     typename F, typename G
1003 >
1004 inline typename impl::make_composite<new_7<T>, A, B, C, D, E, F, G>::type
1005 new_(
1006     A const& a, B const& b, C const& c, D const& d, E const& e,
1007     F const& f, G const& g)
1008 {
1009     typedef
1010         impl::make_composite<new_7<T>, A, B, C, D, E, F, G>
1011         make_composite_t;
1012     typedef typename make_composite_t::type type_t;
1013     typedef typename make_composite_t::composite_type composite_type_t;
1014 
1015     return type_t(composite_type_t(new_7<T>(),
1016         as_actor<A>::convert(a),
1017         as_actor<B>::convert(b),
1018         as_actor<C>::convert(c),
1019         as_actor<D>::convert(d),
1020         as_actor<E>::convert(e),
1021         as_actor<F>::convert(f),
1022         as_actor<G>::convert(g)
1023     ));
1024 }
1025 
1026 //////////////////////////////////
1027 template <
1028     typename T, typename A, typename B, typename C, typename D, typename E,
1029     typename F, typename G, typename H
1030 >
1031 inline typename impl::make_composite<new_8<T>, A, B, C, D, E, F, G, H>::type
1032 new_(
1033     A const& a, B const& b, C const& c, D const& d, E const& e,
1034     F const& f, G const& g, H const& h)
1035 {
1036     typedef
1037         impl::make_composite<new_8<T>, A, B, C, D, E, F, G, H>
1038         make_composite_t;
1039     typedef typename make_composite_t::type type_t;
1040     typedef typename make_composite_t::composite_type composite_type_t;
1041 
1042     return type_t(composite_type_t(new_8<T>(),
1043         as_actor<A>::convert(a),
1044         as_actor<B>::convert(b),
1045         as_actor<C>::convert(c),
1046         as_actor<D>::convert(d),
1047         as_actor<E>::convert(e),
1048         as_actor<F>::convert(f),
1049         as_actor<G>::convert(g),
1050         as_actor<H>::convert(h)
1051     ));
1052 }
1053 
1054 //////////////////////////////////
1055 template <
1056     typename T, typename A, typename B, typename C, typename D, typename E,
1057     typename F, typename G, typename H, typename I
1058 >
1059 inline typename impl::make_composite<new_9<T>, A, B, C, D, E, F, G, H, I>::type
1060 new_(
1061     A const& a, B const& b, C const& c, D const& d, E const& e,
1062     F const& f, G const& g, H const& h, I const& i)
1063 {
1064     typedef
1065         impl::make_composite<new_9<T>, A, B, C, D, E, F, G, H, I>
1066         make_composite_t;
1067     typedef typename make_composite_t::type type_t;
1068     typedef typename make_composite_t::composite_type composite_type_t;
1069 
1070     return type_t(composite_type_t(new_9<T>(),
1071         as_actor<A>::convert(a),
1072         as_actor<B>::convert(b),
1073         as_actor<C>::convert(c),
1074         as_actor<D>::convert(d),
1075         as_actor<E>::convert(e),
1076         as_actor<F>::convert(f),
1077         as_actor<G>::convert(g),
1078         as_actor<H>::convert(h),
1079         as_actor<I>::convert(i)
1080     ));
1081 }
1082 
1083 #if PHOENIX_CONSTRUCT_LIMIT > 9
1084 //////////////////////////////////
1085 template <
1086     typename T, typename A, typename B, typename C, typename D, typename E,
1087     typename F, typename G, typename H, typename I, typename J
1088 >
1089 inline typename impl::make_composite<
1090     new_10<T>, A, B, C, D, E, F, G, H, I, J>::type
1091 new_(
1092     A const& a, B const& b, C const& c, D const& d, E const& e,
1093     F const& f, G const& g, H const& h, I const& i, J const& j)
1094 {
1095     typedef
1096         impl::make_composite<
1097             new_10<T>, A, B, C, D, E, F, G, H, I, J
1098         >
1099         make_composite_t;
1100     typedef typename make_composite_t::type type_t;
1101     typedef typename make_composite_t::composite_type composite_type_t;
1102 
1103     return type_t(composite_type_t(new_10<T>(),
1104         as_actor<A>::convert(a),
1105         as_actor<B>::convert(b),
1106         as_actor<C>::convert(c),
1107         as_actor<D>::convert(d),
1108         as_actor<E>::convert(e),
1109         as_actor<F>::convert(f),
1110         as_actor<G>::convert(g),
1111         as_actor<H>::convert(h),
1112         as_actor<I>::convert(i),
1113         as_actor<J>::convert(j)
1114     ));
1115 }
1116 
1117 //////////////////////////////////
1118 template <
1119     typename T, typename A, typename B, typename C, typename D, typename E,
1120     typename F, typename G, typename H, typename I, typename J, typename K
1121 >
1122 inline typename impl::make_composite<
1123     new_11<T>, A, B, C, D, E, F, G, H, I, J, K>::type
1124 new_(
1125     A const& a, B const& b, C const& c, D const& d, E const& e,
1126     F const& f, G const& g, H const& h, I const& i, J const& j,
1127     K const& k)
1128 {
1129     typedef
1130         impl::make_composite<
1131             new_11<T>, A, B, C, D, E, F, G, H, I, J, K
1132         >
1133         make_composite_t;
1134     typedef typename make_composite_t::type type_t;
1135     typedef typename make_composite_t::composite_type composite_type_t;
1136 
1137     return type_t(composite_type_t(new_11<T>(),
1138         as_actor<A>::convert(a),
1139         as_actor<B>::convert(b),
1140         as_actor<C>::convert(c),
1141         as_actor<D>::convert(d),
1142         as_actor<E>::convert(e),
1143         as_actor<F>::convert(f),
1144         as_actor<G>::convert(g),
1145         as_actor<H>::convert(h),
1146         as_actor<I>::convert(i),
1147         as_actor<J>::convert(j),
1148         as_actor<K>::convert(k)
1149     ));
1150 }
1151 
1152 //////////////////////////////////
1153 template <
1154     typename T, typename A, typename B, typename C, typename D, typename E,
1155     typename F, typename G, typename H, typename I, typename J, typename K,
1156     typename L
1157 >
1158 inline typename impl::make_composite<
1159     new_12<T>, A, B, C, D, E, F, G, H, I, J, K, L>::type
1160 new_(
1161     A const& a, B const& b, C const& c, D const& d, E const& e,
1162     F const& f, G const& g, H const& h, I const& i, J const& j,
1163     K const& k, L const& l)
1164 {
1165     typedef
1166         impl::make_composite<
1167             new_12<T>, A, B, C, D, E, F, G, H, I, J, K, L
1168         >
1169         make_composite_t;
1170     typedef typename make_composite_t::type type_t;
1171     typedef typename make_composite_t::composite_type composite_type_t;
1172 
1173     return type_t(composite_type_t(new_12<T>(),
1174         as_actor<A>::convert(a),
1175         as_actor<B>::convert(b),
1176         as_actor<C>::convert(c),
1177         as_actor<D>::convert(d),
1178         as_actor<E>::convert(e),
1179         as_actor<F>::convert(f),
1180         as_actor<G>::convert(g),
1181         as_actor<H>::convert(h),
1182         as_actor<I>::convert(i),
1183         as_actor<J>::convert(j),
1184         as_actor<K>::convert(k),
1185         as_actor<L>::convert(l)
1186     ));
1187 }
1188 
1189 #if PHOENIX_CONSTRUCT_LIMIT > 12
1190 //////////////////////////////////
1191 template <
1192     typename T, typename A, typename B, typename C, typename D, typename E,
1193     typename F, typename G, typename H, typename I, typename J, typename K,
1194     typename L, typename M
1195 >
1196 inline typename impl::make_composite<
1197     new_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type
1198 new_(
1199     A const& a, B const& b, C const& c, D const& d, E const& e,
1200     F const& f, G const& g, H const& h, I const& i, J const& j,
1201     K const& k, L const& l, M const& m)
1202 {
1203     typedef
1204         impl::make_composite<
1205             new_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M
1206         >
1207         make_composite_t;
1208     typedef typename make_composite_t::type type_t;
1209     typedef typename make_composite_t::composite_type composite_type_t;
1210 
1211     return type_t(composite_type_t(new_13<T>(),
1212         as_actor<A>::convert(a),
1213         as_actor<B>::convert(b),
1214         as_actor<C>::convert(c),
1215         as_actor<D>::convert(d),
1216         as_actor<E>::convert(e),
1217         as_actor<F>::convert(f),
1218         as_actor<G>::convert(g),
1219         as_actor<H>::convert(h),
1220         as_actor<I>::convert(i),
1221         as_actor<J>::convert(j),
1222         as_actor<K>::convert(k),
1223         as_actor<L>::convert(l),
1224         as_actor<M>::convert(m)
1225     ));
1226 }
1227 
1228 //////////////////////////////////
1229 template <
1230     typename T, typename A, typename B, typename C, typename D, typename E,
1231     typename F, typename G, typename H, typename I, typename J, typename K,
1232     typename L, typename M, typename N
1233 >
1234 inline typename impl::make_composite<
1235     new_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type
1236 new_(
1237     A const& a, B const& b, C const& c, D const& d, E const& e,
1238     F const& f, G const& g, H const& h, I const& i, J const& j,
1239     K const& k, L const& l, M const& m, N const& n)
1240 {
1241     typedef
1242         impl::make_composite<
1243             new_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1244         >
1245         make_composite_t;
1246     typedef typename make_composite_t::type type_t;
1247     typedef typename make_composite_t::composite_type composite_type_t;
1248 
1249     return type_t(composite_type_t(new_14<T>(),
1250         as_actor<A>::convert(a),
1251         as_actor<B>::convert(b),
1252         as_actor<C>::convert(c),
1253         as_actor<D>::convert(d),
1254         as_actor<E>::convert(e),
1255         as_actor<F>::convert(f),
1256         as_actor<G>::convert(g),
1257         as_actor<H>::convert(h),
1258         as_actor<I>::convert(i),
1259         as_actor<J>::convert(j),
1260         as_actor<K>::convert(k),
1261         as_actor<L>::convert(l),
1262         as_actor<M>::convert(m),
1263         as_actor<N>::convert(n)
1264     ));
1265 }
1266 
1267 //////////////////////////////////
1268 template <
1269     typename T, typename A, typename B, typename C, typename D, typename E,
1270     typename F, typename G, typename H, typename I, typename J, typename K,
1271     typename L, typename M, typename N, typename O
1272 >
1273 inline typename impl::make_composite<
1274     new_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type
1275 new_(
1276     A const& a, B const& b, C const& c, D const& d, E const& e,
1277     F const& f, G const& g, H const& h, I const& i, J const& j,
1278     K const& k, L const& l, M const& m, N const& n, O const& o)
1279 {
1280     typedef
1281         impl::make_composite<
1282             new_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1283         >
1284         make_composite_t;
1285     typedef typename make_composite_t::type type_t;
1286     typedef typename make_composite_t::composite_type composite_type_t;
1287 
1288     return type_t(composite_type_t(new_15<T>(),
1289         as_actor<A>::convert(a),
1290         as_actor<B>::convert(b),
1291         as_actor<C>::convert(c),
1292         as_actor<D>::convert(d),
1293         as_actor<E>::convert(e),
1294         as_actor<F>::convert(f),
1295         as_actor<G>::convert(g),
1296         as_actor<H>::convert(h),
1297         as_actor<I>::convert(i),
1298         as_actor<J>::convert(j),
1299         as_actor<K>::convert(k),
1300         as_actor<L>::convert(l),
1301         as_actor<M>::convert(m),
1302         as_actor<N>::convert(n),
1303         as_actor<O>::convert(o)
1304     ));
1305 }
1306 
1307 #endif
1308 #endif
1309 #endif
1310 #endif
1311 
1312 ///////////////////////////////////////////////////////////////////////////////
1313 }   //  namespace phoenix
1314 
1315 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!