Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/casts.hpp@260cb5ec6c19

     1 /*=============================================================================

     2     Phoenix V1.2.1

     3     Copyright (c) 2001-2003 Joel de Guzman

     4     Copyright (c) 2001-2003 Hartmut Kaiser

     6     Use, modification and distribution is subject to the Boost Software

     7     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

     8     http://www.boost.org/LICENSE_1_0.txt)

     9 ==============================================================================*/

    11 #ifndef PHOENIX_CASTS_HPP

    12 #define PHOENIX_CASTS_HPP

    14 ///////////////////////////////////////////////////////////////////////////////

    15 #include <boost/spirit/phoenix/actor.hpp>

    16 #include <boost/spirit/phoenix/composite.hpp>

    17 #include <boost/static_assert.hpp>

    19 ///////////////////////////////////////////////////////////////////////////////

    20 namespace phoenix {

    22 ///////////////////////////////////////////////////////////////////////////////

    23 //

    24 //  Phoenix predefined maximum construct_ limit. This limit defines the maximum

    25 //  number of parameters supported for calles to the set of construct_ template

    26 //  functions (lazy object construction, see below). This number defaults to 3.

    27 //  The actual maximum is rounded up in multiples of 3. Thus, if this value

    28 //  is 4, the actual limit is 6. The ultimate maximum limit in this

    29 //  implementation is 15.

    30 //  PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT!

    32 #if !defined(PHOENIX_CONSTRUCT_LIMIT)

    33 #define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT

    34 #endif

    36 // ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT

    37 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT);

    39 // ensure PHOENIX_CONSTRUCT_LIMIT <= 15

    40 BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15);

    42 ///////////////////////////////////////////////////////////////////////////////

    43 //

    44 //  Lazy C++ casts

    45 //

    46 //      The set of lazy C++ cast template classes and functions provide a way

    47 //      of lazily casting certain type to another during parsing.

    48 //      The lazy C++ templates are (syntactically) used very much like

    49 //      the well known C++ casts:

    50 //

    51 //          A *a = static_cast_<A *>(...actor returning a convertible type...);

    52 //

    53 //      where the given parameter should be an actor, which eval() function

    54 //      returns a convertible type.

    55 //

    56 ///////////////////////////////////////////////////////////////////////////////

    57 template <typename T, typename A>

    58 struct static_cast_l {

    60     template <typename TupleT>

    61     struct result { typedef T type; };

    63     static_cast_l(A const& a_)

    64     :   a(a_) {}

    66     template <typename TupleT>

    67     T

    68     eval(TupleT const& args) const

    69     {

    70         return static_cast<T>(a.eval(args));

    71     }

    73     A a;

    74 };

    76 //////////////////////////////////

    77 template <typename T, typename BaseAT>

    78 inline actor<static_cast_l<T, BaseAT> >

    79 static_cast_(actor<BaseAT> const& a)

    80 {

    81     typedef static_cast_l<T, BaseAT> cast_t;

    82     return actor<cast_t>(cast_t(a));

    83 }

    85 //////////////////////////////////

    86 template <typename T, typename A>

    87 struct dynamic_cast_l {

    89     template <typename TupleT>

    90     struct result { typedef T type; };

    92     dynamic_cast_l(A const& a_)

    93     :   a(a_) {}

    95     template <typename TupleT>

    96     T

    97     eval(TupleT const& args) const

    98     {

    99         return dynamic_cast<T>(a.eval(args));

   100     }

   102     A a;

   103 };

   105 //////////////////////////////////

   106 template <typename T, typename BaseAT>

   107 inline actor<dynamic_cast_l<T, BaseAT> >

   108 dynamic_cast_(actor<BaseAT> const& a)

   109 {

   110     typedef dynamic_cast_l<T, BaseAT> cast_t;

   111     return actor<cast_t>(cast_t(a));

   112 }

   114 //////////////////////////////////

   115 template <typename T, typename A>

   116 struct reinterpret_cast_l {

   118     template <typename TupleT>

   119     struct result { typedef T type; };

   121     reinterpret_cast_l(A const& a_)

   122     :   a(a_) {}

   124     template <typename TupleT>

   125     T

   126     eval(TupleT const& args) const

   127     {

   128         return reinterpret_cast<T>(a.eval(args));

   129     }

   131     A a;

   132 };

   134 //////////////////////////////////

   135 template <typename T, typename BaseAT>

   136 inline actor<reinterpret_cast_l<T, BaseAT> >

   137 reinterpret_cast_(actor<BaseAT> const& a)

   138 {

   139     typedef reinterpret_cast_l<T, BaseAT> cast_t;

   140     return actor<cast_t>(cast_t(a));

   141 }

   143 //////////////////////////////////

   144 template <typename T, typename A>

   145 struct const_cast_l {

   147     template <typename TupleT>

   148     struct result { typedef T type; };

   150     const_cast_l(A const& a_)

   151     :   a(a_) {}

   153     template <typename TupleT>

   154     T

   155     eval(TupleT const& args) const

   156     {

   157         return const_cast<T>(a.eval(args));

   158     }

   160     A a;

   161 };

   163 //////////////////////////////////

   164 template <typename T, typename BaseAT>

   165 inline actor<const_cast_l<T, BaseAT> >

   166 const_cast_(actor<BaseAT> const& a)

   167 {

   168     typedef const_cast_l<T, BaseAT> cast_t;

   169     return actor<cast_t>(cast_t(a));

   170 }

   172 ///////////////////////////////////////////////////////////////////////////////

   173 //

   174 //  construct_

   175 //

   176 //      Lazy object construction

   177 //

   178 //      The set of construct_<> template classes and functions provide a way

   179 //      of lazily constructing certain object from a arbitrary set of

   180 //      actors during parsing.

   181 //      The construct_ templates are (syntactically) used very much like

   182 //      the well known C++ casts:

   183 //

   184 //          A a = construct_<A>(...arbitrary list of actors...);

   185 //

   186 //      where the given parameters are submitted as parameters to the

   187 //      contructor of the object of type A. (This certainly implies, that

   188 //      type A has a constructor with a fitting set of parameter types

   189 //      defined.)

   190 //

   191 //      The maximum number of needed parameters is controlled through the

   192 //      preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this

   193 //      limit should not be greater than PHOENIX_LIMIT.

   194 //

   195 ///////////////////////////////////////////////////////////////////////////////

   196 template <typename T>

   197 struct construct_l_0 {

   198     typedef T result_type;

   200     T operator()() const {

   201         return T();

   202     }

   203 };

   206 template <typename T>

   207 struct construct_l {

   209     template <

   210             typename A

   211         ,   typename B

   212         ,   typename C

   214 #if PHOENIX_CONSTRUCT_LIMIT > 3

   215         ,   typename D

   216         ,   typename E

   217         ,   typename F

   219 #if PHOENIX_CONSTRUCT_LIMIT > 6

   220         ,   typename G

   221         ,   typename H

   222         ,   typename I

   224 #if PHOENIX_CONSTRUCT_LIMIT > 9

   225         ,   typename J

   226         ,   typename K

   227         ,   typename L

   229 #if PHOENIX_CONSTRUCT_LIMIT > 12

   230         ,   typename M

   231         ,   typename N

   232         ,   typename O

   233 #endif

   234 #endif

   235 #endif

   236 #endif

   237     >

   238     struct result { typedef T type; };

   240     T operator()() const

   241     {

   242         return T();

   243     }

   245     template <typename A>

   246     T operator()(A const& a) const

   247     {

   248         T t(a);

   249         return t;

   250     }

   252     template <typename A, typename B>

   253     T operator()(A const& a, B const& b) const

   254     {

   255         T t(a, b);

   256         return t;

   257     }

   259     template <typename A, typename B, typename C>

   260     T operator()(A const& a, B const& b, C const& c) const

   261     {

   262         T t(a, b, c);

   263         return t;

   264     }

   266 #if PHOENIX_CONSTRUCT_LIMIT > 3

   267     template <

   268         typename A, typename B, typename C, typename D

   269     >

   270     T operator()(

   271         A const& a, B const& b, C const& c, D const& d) const

   272     {

   273         T t(a, b, c, d);

   274         return t;

   275     }

   277     template <

   278         typename A, typename B, typename C, typename D, typename E

   279     >

   280     T operator()(

   281         A const& a, B const& b, C const& c, D const& d, E const& e) const

   282     {

   283         T t(a, b, c, d, e);

   284         return t;

   285     }

   287     template <

   288         typename A, typename B, typename C, typename D, typename E,

   289         typename F

   290     >

   291     T operator()(

   292         A const& a, B const& b, C const& c, D const& d, E const& e,

   293         F const& f) const

   294     {

   295         T t(a, b, c, d, e, f);

   296         return t;

   297     }

   299 #if PHOENIX_CONSTRUCT_LIMIT > 6

   300     template <

   301         typename A, typename B, typename C, typename D, typename E,

   302         typename F, typename G

   303     >

   304     T operator()(

   305         A const& a, B const& b, C const& c, D const& d, E const& e,

   306         F const& f, G const& g) const

   307     {

   308         T t(a, b, c, d, e, f, g);

   309         return t;

   310     }

   312     template <

   313         typename A, typename B, typename C, typename D, typename E,

   314         typename F, typename G, typename H

   315     >

   316     T operator()(

   317         A const& a, B const& b, C const& c, D const& d, E const& e,

   318         F const& f, G const& g, H const& h) const

   319     {

   320         T t(a, b, c, d, e, f, g, h);

   321         return t;

   322     }

   324     template <

   325         typename A, typename B, typename C, typename D, typename E,

   326         typename F, typename G, typename H, typename I

   327     >

   328     T operator()(

   329         A const& a, B const& b, C const& c, D const& d, E const& e,

   330         F const& f, G const& g, H const& h, I const& i) const

   331     {

   332         T t(a, b, c, d, e, f, g, h, i);

   333         return t;

   334     }

   336 #if PHOENIX_CONSTRUCT_LIMIT > 9

   337     template <

   338         typename A, typename B, typename C, typename D, typename E,

   339         typename F, typename G, typename H, typename I, typename J

   340     >

   341     T operator()(

   342         A const& a, B const& b, C const& c, D const& d, E const& e,

   343         F const& f, G const& g, H const& h, I const& i, J const& j) const

   344     {

   345         T t(a, b, c, d, e, f, g, h, i, j);

   346         return t;

   347     }

   349     template <

   350         typename A, typename B, typename C, typename D, typename E,

   351         typename F, typename G, typename H, typename I, typename J,

   352         typename K

   353     >

   354     T operator()(

   355         A const& a, B const& b, C const& c, D const& d, E const& e,

   356         F const& f, G const& g, H const& h, I const& i, J const& j,

   357         K const& k) const

   358     {

   359         T t(a, b, c, d, e, f, g, h, i, j, k);

   360         return t;

   361     }

   363     template <

   364         typename A, typename B, typename C, typename D, typename E,

   365         typename F, typename G, typename H, typename I, typename J,

   366         typename K, typename L

   367     >

   368     T operator()(

   369         A const& a, B const& b, C const& c, D const& d, E const& e,

   370         F const& f, G const& g, H const& h, I const& i, J const& j,

   371         K const& k, L const& l) const

   372     {

   373         T t(a, b, c, d, e, f, g, h, i, j, k, l);

   374         return t;

   375     }

   377 #if PHOENIX_CONSTRUCT_LIMIT > 12

   378     template <

   379         typename A, typename B, typename C, typename D, typename E,

   380         typename F, typename G, typename H, typename I, typename J,

   381         typename K, typename L, typename M

   382     >

   383     T operator()(

   384         A const& a, B const& b, C const& c, D const& d, E const& e,

   385         F const& f, G const& g, H const& h, I const& i, J const& j,

   386         K const& k, L const& l, M const& m) const

   387     {

   388         T t(a, b, c, d, e, f, g, h, i, j, k, l, m);

   389         return t;

   390     }

   392     template <

   393         typename A, typename B, typename C, typename D, typename E,

   394         typename F, typename G, typename H, typename I, typename J,

   395         typename K, typename L, typename M, typename N

   396     >

   397     T operator()(

   398         A const& a, B const& b, C const& c, D const& d, E const& e,

   399         F const& f, G const& g, H const& h, I const& i, J const& j,

   400         K const& k, L const& l, M const& m, N const& n) const

   401     {

   402         T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n);

   403         return t;

   404     }

   406     template <

   407         typename A, typename B, typename C, typename D, typename E,

   408         typename F, typename G, typename H, typename I, typename J,

   409         typename K, typename L, typename M, typename N, typename O

   410     >

   411     T operator()(

   412         A const& a, B const& b, C const& c, D const& d, E const& e,

   413         F const& f, G const& g, H const& h, I const& i, J const& j,

   414         K const& k, L const& l, M const& m, N const& n, O const& o) const

   415     {

   416         T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);

   417         return t;

   418     }

   420 #endif

   421 #endif

   422 #endif

   423 #endif

   424 };

   427 template <typename T>

   428 struct construct_1 {

   430     template <

   431             typename A

   432     >

   433     struct result { typedef T type; };

   435     template <typename A>

   436     T operator()(A const& a) const

   437     {

   438         T t(a);

   439         return t;

   440     }

   442 };

   444 template <typename T>

   445 struct construct_2 {

   447     template <

   448             typename A

   449         ,   typename B

   450     >

   451     struct result { typedef T type; };

   453     template <typename A, typename B>

   454     T operator()(A const& a, B const& b) const

   455     {

   456         T t(a, b);

   457         return t;

   458     }

   460 };

   462 template <typename T>

   463 struct construct_3 {

   465     template <

   466             typename A

   467         ,   typename B

   468         ,   typename C

   469     >

   470     struct result { typedef T type; };

   472     template <typename A, typename B, typename C>

   473     T operator()(A const& a, B const& b, C const& c) const

   474     {

   475         T t(a, b, c);

   476         return t;

   477     }

   478 };

   480 #if PHOENIX_CONSTRUCT_LIMIT > 3

   481 template <typename T>

   482 struct construct_4 {

   484     template <

   485             typename A

   486         ,   typename B

   487         ,   typename C

   488         ,   typename D

   489     >

   490     struct result { typedef T type; };

   492     template <

   493         typename A, typename B, typename C, typename D

   494     >

   495     T operator()(

   496         A const& a, B const& b, C const& c, D const& d) const

   497     {

   498         T t(a, b, c, d);

   499         return t;

   500     }

   501 };

   504 template <typename T>

   505 struct construct_5 {

   507     template <

   508             typename A

   509         ,   typename B

   510         ,   typename C

   511         ,   typename D

   512         ,   typename E

   513     >

   514     struct result { typedef T type; };

   516     template <

   517         typename A, typename B, typename C, typename D, typename E

   518     >

   519     T operator()(

   520         A const& a, B const& b, C const& c, D const& d, E const& e) const

   521     {

   522         T t(a, b, c, d, e);

   523         return t;

   524     }

   525 };

   528 template <typename T>

   529 struct construct_6 {

   531     template <

   532             typename A

   533         ,   typename B

   534         ,   typename C

   535         ,   typename D

   536         ,   typename E

   537         ,   typename F

   538     >

   539     struct result { typedef T type; };

   541     template <

   542         typename A, typename B, typename C, typename D, typename E,

   543         typename F

   544     >

   545     T operator()(

   546         A const& a, B const& b, C const& c, D const& d, E const& e,

   547         F const& f) const

   548     {

   549         T t(a, b, c, d, e, f);

   550         return t;

   551     }

   552 };

   553 #endif

   556 #if PHOENIX_CONSTRUCT_LIMIT > 6

   557 template <typename T>

   558 struct construct_7 {

   560     template <

   561             typename A

   562         ,   typename B

   563         ,   typename C

   564         ,   typename D

   565         ,   typename E

   566         ,   typename F

   567         ,   typename G

   568     >

   569     struct result { typedef T type; };

   571     template <

   572         typename A, typename B, typename C, typename D, typename E,

   573         typename F, typename G

   574     >

   575     T operator()(

   576         A const& a, B const& b, C const& c, D const& d, E const& e,

   577         F const& f, G const& g) const

   578     {

   579         T t(a, b, c, d, e, f, g);

   580         return t;

   581     }

   582 };

   584 template <typename T>

   585 struct construct_8 {

   587     template <

   588             typename A

   589         ,   typename B

   590         ,   typename C

   591         ,   typename D

   592         ,   typename E

   593         ,   typename F

   594         ,   typename G

   595         ,   typename H

   596     >

   597     struct result { typedef T type; };

   599     template <

   600         typename A, typename B, typename C, typename D, typename E,

   601         typename F, typename G, typename H

   602     >

   603     T operator()(

   604         A const& a, B const& b, C const& c, D const& d, E const& e,

   605         F const& f, G const& g, H const& h) const

   606     {

   607         T t(a, b, c, d, e, f, g, h);

   608         return t;

   609     }

   610 };

   612 template <typename T>

   613 struct construct_9 {

   615     template <

   616             typename A

   617         ,   typename B

   618         ,   typename C

   619         ,   typename D

   620         ,   typename E

   621         ,   typename F

   622         ,   typename G

   623         ,   typename H

   624         ,   typename I

   625     >

   626     struct result { typedef T type; };

   628     template <

   629         typename A, typename B, typename C, typename D, typename E,

   630         typename F, typename G, typename H, typename I

   631     >

   632     T operator()(

   633         A const& a, B const& b, C const& c, D const& d, E const& e,

   634         F const& f, G const& g, H const& h, I const& i) const

   635     {

   636         T t(a, b, c, d, e, f, g, h, i);

   637         return t;

   638     }

   639 };

   640 #endif

   643 #if PHOENIX_CONSTRUCT_LIMIT > 9

   644 template <typename T>

   645 struct construct_10 {

   647     template <

   648             typename A

   649         ,   typename B

   650         ,   typename C

   651         ,   typename D

   652         ,   typename E

   653         ,   typename F

   654         ,   typename G

   655         ,   typename H

   656         ,   typename I

   657         ,   typename J

   658     >

   659     struct result { typedef T type; };

   661     template <

   662         typename A, typename B, typename C, typename D, typename E,

   663         typename F, typename G, typename H, typename I, typename J

   664     >

   665     T operator()(

   666         A const& a, B const& b, C const& c, D const& d, E const& e,

   667         F const& f, G const& g, H const& h, I const& i, J const& j) const

   668     {

   669         T t(a, b, c, d, e, f, g, h, i, j);

   670         return t;

   671     }

   672 };

   674 template <typename T>

   675 struct construct_11 {

   677     template <

   678             typename A

   679         ,   typename B

   680         ,   typename C

   681         ,   typename D

   682         ,   typename E

   683         ,   typename F

   684         ,   typename G

   685         ,   typename H

   686         ,   typename I

   687         ,   typename J

   688         ,   typename K

   689     >

   690     struct result { typedef T type; };

   692     template <

   693         typename A, typename B, typename C, typename D, typename E,

   694         typename F, typename G, typename H, typename I, typename J,

   695         typename K

   696     >

   697     T operator()(

   698         A const& a, B const& b, C const& c, D const& d, E const& e,

   699         F const& f, G const& g, H const& h, I const& i, J const& j,

   700         K const& k) const

   701     {

   702         T t(a, b, c, d, e, f, g, h, i, j, k);

   703         return t;

   704     }

   705 };

   707 template <typename T>

   708 struct construct_12 {

   710     template <

   711             typename A

   712         ,   typename B

   713         ,   typename C

   714         ,   typename D

   715         ,   typename E

   716         ,   typename F

   717         ,   typename G

   718         ,   typename H

   719         ,   typename I

   720         ,   typename J

   721         ,   typename K

   722         ,   typename L

   723     >

   724     struct result { typedef T type; };

   726     template <

   727         typename A, typename B, typename C, typename D, typename E,

   728         typename F, typename G, typename H, typename I, typename J,

   729         typename K, typename L

   730     >

   731     T operator()(

   732         A const& a, B const& b, C const& c, D const& d, E const& e,

   733         F const& f, G const& g, H const& h, I const& i, J const& j,

   734         K const& k, L const& l) const

   735     {

   736         T t(a, b, c, d, f, e, g, h, i, j, k, l);

   737         return t;

   738     }

   739 };

   740 #endif

   742 #if PHOENIX_CONSTRUCT_LIMIT > 12

   743 template <typename T>

   744 struct construct_13 {

   746     template <

   747             typename A

   748         ,   typename B

   749         ,   typename C

   750         ,   typename D

   751         ,   typename E

   752         ,   typename F

   753         ,   typename G

   754         ,   typename H

   755         ,   typename I

   756         ,   typename J

   757         ,   typename K

   758         ,   typename L

   759         ,   typename M

   760     >

   761     struct result { typedef T type; };

   763     template <

   764         typename A, typename B, typename C, typename D, typename E,

   765         typename F, typename G, typename H, typename I, typename J,

   766         typename K, typename L, typename M

   767     >

   768     T operator()(

   769         A const& a, B const& b, C const& c, D const& d, E const& e,

   770         F const& f, G const& g, H const& h, I const& i, J const& j,

   771         K const& k, L const& l, M const& m) const

   772     {

   773         T t(a, b, c, d, e, f, g, h, i, j, k, l, m);

   774         return t;

   775     }

   776 };

   778 template <typename T>

   779 struct construct_14 {

   781     template <

   782             typename A

   783         ,   typename B

   784         ,   typename C

   785         ,   typename D

   786         ,   typename E

   787         ,   typename F

   788         ,   typename G

   789         ,   typename H

   790         ,   typename I

   791         ,   typename J

   792         ,   typename K

   793         ,   typename L

   794         ,   typename M

   795         ,   typename N

   796     >

   797     struct result { typedef T type; };

   799     template <

   800         typename A, typename B, typename C, typename D, typename E,

   801         typename F, typename G, typename H, typename I, typename J,

   802         typename K, typename L, typename M, typename N

   803     >

   804     T operator()(

   805         A const& a, B const& b, C const& c, D const& d, E const& e,

   806         F const& f, G const& g, H const& h, I const& i, J const& j,

   807         K const& k, L const& l, M const& m, N const& n) const

   808     {

   809         T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n);

   810         return t;

   811     }

   812 };

   814 template <typename T>

   815 struct construct_15 {

   817     template <

   818             typename A

   819         ,   typename B

   820         ,   typename C

   821         ,   typename D

   822         ,   typename E

   823         ,   typename F

   824         ,   typename G

   825         ,   typename H

   826         ,   typename I

   827         ,   typename J

   828         ,   typename K

   829         ,   typename L

   830         ,   typename M

   831         ,   typename N

   832         ,   typename O

   833     >

   834     struct result { typedef T type; };

   836     template <

   837         typename A, typename B, typename C, typename D, typename E,

   838         typename F, typename G, typename H, typename I, typename J,

   839         typename K, typename L, typename M, typename N, typename O

   840     >

   841     T operator()(

   842         A const& a, B const& b, C const& c, D const& d, E const& e,

   843         F const& f, G const& g, H const& h, I const& i, J const& j,

   844         K const& k, L const& l, M const& m, N const& n, O const& o) const

   845     {

   846         T t(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o);

   847         return t;

   848     }

   849 };

   850 #endif

   853 #if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002))

   855 ///////////////////////////////////////////////////////////////////////////////

   856 //

   857 //  The following specializations are needed because Borland and CodeWarrior

   858 //  does not accept default template arguments in nested template classes in

   859 //  classes (i.e construct_l::result)

   860 //

   861 ///////////////////////////////////////////////////////////////////////////////

   862 template <typename T, typename TupleT>

   863 struct composite0_result<construct_l_0<T>, TupleT> {

   865     typedef T type;

   866 };

   868 //////////////////////////////////

   869 template <typename T, typename TupleT,

   870     typename A>

   871 struct composite1_result<construct_l<T>, TupleT, A> {

   873     typedef T type;

   874 };

   876 //////////////////////////////////

   877 template <typename T, typename TupleT,

   878     typename A, typename B>

   879 struct composite2_result<construct_l<T>, TupleT, A, B> {

   881     typedef T type;

   882 };

   884 //////////////////////////////////

   885 template <typename T, typename TupleT,

   886     typename A, typename B, typename C>

   887 struct composite3_result<construct_l<T>, TupleT, A, B, C> {

   889     typedef T type;

   890 };

   892 #if PHOENIX_LIMIT > 3

   893 //////////////////////////////////

   894 template <typename T, typename TupleT,

   895     typename A, typename B, typename C, typename D>

   896 struct composite4_result<construct_l<T>, TupleT,

   897     A, B, C, D> {

   899     typedef T type;

   900 };

   902 //////////////////////////////////

   903 template <typename T, typename TupleT,

   904     typename A, typename B, typename C, typename D, typename E>

   905 struct composite5_result<construct_l<T>, TupleT,

   906     A, B, C, D, E> {

   908     typedef T type;

   909 };

   911 //////////////////////////////////

   912 template <typename T, typename TupleT,

   913     typename A, typename B, typename C, typename D, typename E,

   914     typename F>

   915 struct composite6_result<construct_l<T>, TupleT,

   916     A, B, C, D, E, F> {

   918     typedef T type;

   919 };

   921 #if PHOENIX_LIMIT > 6

   922 //////////////////////////////////

   923 template <typename T, typename TupleT,

   924     typename A, typename B, typename C, typename D, typename E,

   925     typename F, typename G>

   926 struct composite7_result<construct_l<T>, TupleT,

   927     A, B, C, D, E, F, G> {

   929     typedef T type;

   930 };

   932 //////////////////////////////////

   933 template <typename T, typename TupleT,

   934     typename A, typename B, typename C, typename D, typename E,

   935     typename F, typename G, typename H>

   936 struct composite8_result<construct_l<T>, TupleT,

   937     A, B, C, D, E, F, G, H> {

   939     typedef T type;

   940 };

   942 //////////////////////////////////

   943 template <typename T, typename TupleT,

   944     typename A, typename B, typename C, typename D, typename E,

   945     typename F, typename G, typename H, typename I>

   946 struct composite9_result<construct_l<T>, TupleT,

   947     A, B, C, D, E, F, G, H, I> {

   949     typedef T type;

   950 };

   952 #if PHOENIX_LIMIT > 9

   953 //////////////////////////////////

   954 template <typename T, typename TupleT,

   955     typename A, typename B, typename C, typename D, typename E,

   956     typename F, typename G, typename H, typename I, typename J>

   957 struct composite10_result<construct_l<T>, TupleT,

   958     A, B, C, D, E, F, G, H, I, J> {

   960     typedef T type;

   961 };

   963 //////////////////////////////////

   964 template <typename T, typename TupleT,

   965     typename A, typename B, typename C, typename D, typename E,

   966     typename F, typename G, typename H, typename I, typename J,

   967     typename K>

   968 struct composite11_result<construct_l<T>, TupleT,

   969     A, B, C, D, E, F, G, H, I, J, K> {

   971     typedef T type;

   972 };

   974 //////////////////////////////////

   975 template <typename T, typename TupleT,

   976     typename A, typename B, typename C, typename D, typename E,

   977     typename F, typename G, typename H, typename I, typename J,

   978     typename K, typename L>

   979 struct composite12_result<construct_l<T>, TupleT,

   980     A, B, C, D, E, F, G, H, I, J, K, L> {

   982     typedef T type;

   983 };

   985 #if PHOENIX_LIMIT > 12

   986 //////////////////////////////////

   987 template <typename T, typename TupleT,

   988     typename A, typename B, typename C, typename D, typename E,

   989     typename F, typename G, typename H, typename I, typename J,

   990     typename K, typename L, typename M>

   991 struct composite13_result<construct_l<T>, TupleT,

   992     A, B, C, D, E, F, G, H, I, J, K, L, M> {

   994     typedef T type;

   995 };

   997 //////////////////////////////////

   998 template <typename T, typename TupleT,

   999     typename A, typename B, typename C, typename D, typename E,

  1000     typename F, typename G, typename H, typename I, typename J,

  1001     typename K, typename L, typename M, typename N>

  1002 struct composite14_result<construct_l<T>, TupleT,

  1003     A, B, C, D, E, F, G, H, I, J, K, L, M, N> {

  1005     typedef T type;

  1006 };

  1008 //////////////////////////////////

  1009 template <typename T, typename TupleT,

  1010     typename A, typename B, typename C, typename D, typename E,

  1011     typename F, typename G, typename H, typename I, typename J,

  1012     typename K, typename L, typename M, typename N, typename O>

  1013 struct composite15_result<construct_l<T>, TupleT,

  1014     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {

  1016     typedef T type;

  1017 };

  1019 #endif

  1020 #endif

  1021 #endif

  1022 #endif

  1023 #endif

  1025 //////////////////////////////////

  1026 template <typename T>

  1027 inline typename impl::make_composite<construct_l_0<T> >::type

  1028 construct_()

  1029 {

  1030     typedef impl::make_composite<construct_l_0<T> > make_composite_t;

  1031     typedef typename make_composite_t::type type_t;

  1032     typedef typename make_composite_t::composite_type composite_type_t;

  1034     return type_t(composite_type_t(construct_l_0<T>()));

  1035 }

  1037 //////////////////////////////////

  1038 template <typename T, typename A>

  1039 inline typename impl::make_composite<construct_1<T>, A>::type

  1040 construct_(A const& a)

  1041 {

  1042     typedef impl::make_composite<construct_1<T>, A> make_composite_t;

  1043     typedef typename make_composite_t::type type_t;

  1044     typedef typename make_composite_t::composite_type composite_type_t;

  1046     return type_t(composite_type_t(construct_1<T>(),

  1047         as_actor<A>::convert(a)

  1048     ));

  1049 }

  1051 //////////////////////////////////

  1052 template <typename T, typename A, typename B>

  1053 inline typename impl::make_composite<construct_2<T>, A, B>::type

  1054 construct_(A const& a, B const& b)

  1055 {

  1056     typedef impl::make_composite<construct_2<T>, A, B> make_composite_t;

  1057     typedef typename make_composite_t::type type_t;

  1058     typedef typename make_composite_t::composite_type composite_type_t;

  1060     return type_t(composite_type_t(construct_2<T>(),

  1061         as_actor<A>::convert(a),

  1062         as_actor<B>::convert(b)

  1063     ));

  1064 }

  1066 //////////////////////////////////

  1067 template <typename T, typename A, typename B, typename C>

  1068 inline typename impl::make_composite<construct_3<T>, A, B, C>::type

  1069 construct_(A const& a, B const& b, C const& c)

  1070 {

  1071     typedef impl::make_composite<construct_3<T>, A, B, C> make_composite_t;

  1072     typedef typename make_composite_t::type type_t;

  1073     typedef typename make_composite_t::composite_type composite_type_t;

  1075     return type_t(composite_type_t(construct_3<T>(),

  1076         as_actor<A>::convert(a),

  1077         as_actor<B>::convert(b),

  1078         as_actor<C>::convert(c)

  1079     ));

  1080 }

  1082 #if PHOENIX_CONSTRUCT_LIMIT > 3

  1083 //////////////////////////////////

  1084 template <

  1085     typename T, typename A, typename B, typename C, typename D

  1086 >

  1087 inline typename impl::make_composite<construct_4<T>, A, B, C, D>::type

  1088 construct_(

  1089     A const& a, B const& b, C const& c, D const& d)

  1090 {

  1091     typedef

  1092         impl::make_composite<construct_4<T>, A, B, C, D>

  1093         make_composite_t;

  1094     typedef typename make_composite_t::type type_t;

  1095     typedef typename make_composite_t::composite_type composite_type_t;

  1097     return type_t(composite_type_t(construct_4<T>(),

  1098         as_actor<A>::convert(a),

  1099         as_actor<B>::convert(b),

  1100         as_actor<C>::convert(c),

  1101         as_actor<D>::convert(d)

  1102     ));

  1103 }

  1105 //////////////////////////////////

  1106 template <

  1107     typename T, typename A, typename B, typename C, typename D, typename E

  1108 >

  1109 inline typename impl::make_composite<construct_5<T>, A, B, C, D, E>::type

  1110 construct_(

  1111     A const& a, B const& b, C const& c, D const& d, E const& e)

  1112 {

  1113     typedef

  1114         impl::make_composite<construct_5<T>, A, B, C, D, E>

  1115         make_composite_t;

  1116     typedef typename make_composite_t::type type_t;

  1117     typedef typename make_composite_t::composite_type composite_type_t;

  1119     return type_t(composite_type_t(construct_5<T>(),

  1120         as_actor<A>::convert(a),

  1121         as_actor<B>::convert(b),

  1122         as_actor<C>::convert(c),

  1123         as_actor<D>::convert(d),

  1124         as_actor<E>::convert(e)

  1125     ));

  1126 }

  1128 //////////////////////////////////

  1129 template <

  1130     typename T, typename A, typename B, typename C, typename D, typename E,

  1131     typename F

  1132 >

  1133 inline typename impl::make_composite<construct_6<T>, A, B, C, D, E, F>::type

  1134 construct_(

  1135     A const& a, B const& b, C const& c, D const& d, E const& e,

  1136     F const& f)

  1137 {

  1138     typedef

  1139         impl::make_composite<construct_6<T>, A, B, C, D, E, F>

  1140         make_composite_t;

  1141     typedef typename make_composite_t::type type_t;

  1142     typedef typename make_composite_t::composite_type composite_type_t;

  1144     return type_t(composite_type_t(construct_6<T>(),

  1145         as_actor<A>::convert(a),

  1146         as_actor<B>::convert(b),

  1147         as_actor<C>::convert(c),

  1148         as_actor<D>::convert(d),

  1149         as_actor<E>::convert(e),

  1150         as_actor<F>::convert(f)

  1151     ));

  1152 }

  1154 #if PHOENIX_CONSTRUCT_LIMIT > 6

  1155 //////////////////////////////////

  1156 template <

  1157     typename T, typename A, typename B, typename C, typename D, typename E,

  1158     typename F, typename G

  1159 >

  1160 inline typename impl::make_composite<construct_7<T>, A, B, C, D, E, F, G>::type

  1161 construct_(

  1162     A const& a, B const& b, C const& c, D const& d, E const& e,

  1163     F const& f, G const& g)

  1164 {

  1165     typedef

  1166         impl::make_composite<construct_7<T>, A, B, C, D, E, F, G>

  1167         make_composite_t;

  1168     typedef typename make_composite_t::type type_t;

  1169     typedef typename make_composite_t::composite_type composite_type_t;

  1171     return type_t(composite_type_t(construct_7<T>(),

  1172         as_actor<A>::convert(a),

  1173         as_actor<B>::convert(b),

  1174         as_actor<C>::convert(c),

  1175         as_actor<D>::convert(d),

  1176         as_actor<E>::convert(e),

  1177         as_actor<F>::convert(f),

  1178         as_actor<G>::convert(g)

  1179     ));

  1180 }

  1182 //////////////////////////////////

  1183 template <

  1184     typename T, typename A, typename B, typename C, typename D, typename E,

  1185     typename F, typename G, typename H

  1186 >

  1187 inline typename impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H>::type

  1188 construct_(

  1189     A const& a, B const& b, C const& c, D const& d, E const& e,

  1190     F const& f, G const& g, H const& h)

  1191 {

  1192     typedef

  1193         impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H>

  1194         make_composite_t;

  1195     typedef typename make_composite_t::type type_t;

  1196     typedef typename make_composite_t::composite_type composite_type_t;

  1198     return type_t(composite_type_t(construct_8<T>(),

  1199         as_actor<A>::convert(a),

  1200         as_actor<B>::convert(b),

  1201         as_actor<C>::convert(c),

  1202         as_actor<D>::convert(d),

  1203         as_actor<E>::convert(e),

  1204         as_actor<F>::convert(f),

  1205         as_actor<G>::convert(g),

  1206         as_actor<H>::convert(h)

  1207     ));

  1208 }

  1210 //////////////////////////////////

  1211 template <

  1212     typename T, typename A, typename B, typename C, typename D, typename E,

  1213     typename F, typename G, typename H, typename I

  1214 >

  1215 inline typename impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I>::type

  1216 construct_(

  1217     A const& a, B const& b, C const& c, D const& d, E const& e,

  1218     F const& f, G const& g, H const& h, I const& i)

  1219 {

  1220     typedef

  1221         impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I>

  1222         make_composite_t;

  1223     typedef typename make_composite_t::type type_t;

  1224     typedef typename make_composite_t::composite_type composite_type_t;

  1226     return type_t(composite_type_t(construct_9<T>(),

  1227         as_actor<A>::convert(a),

  1228         as_actor<B>::convert(b),

  1229         as_actor<C>::convert(c),

  1230         as_actor<D>::convert(d),

  1231         as_actor<E>::convert(e),

  1232         as_actor<F>::convert(f),

  1233         as_actor<G>::convert(g),

  1234         as_actor<H>::convert(h),

  1235         as_actor<I>::convert(i)

  1236     ));

  1237 }

  1239 #if PHOENIX_CONSTRUCT_LIMIT > 9

  1240 //////////////////////////////////

  1241 template <

  1242     typename T, typename A, typename B, typename C, typename D, typename E,

  1243     typename F, typename G, typename H, typename I, typename J

  1244 >

  1245 inline typename impl::make_composite<

  1246     construct_10<T>, A, B, C, D, E, F, G, H, I, J>::type

  1247 construct_(

  1248     A const& a, B const& b, C const& c, D const& d, E const& e,

  1249     F const& f, G const& g, H const& h, I const& i, J const& j)

  1250 {

  1251     typedef

  1252         impl::make_composite<

  1253             construct_10<T>, A, B, C, D, E, F, G, H, I, J

  1254         >

  1255         make_composite_t;

  1256     typedef typename make_composite_t::type type_t;

  1257     typedef typename make_composite_t::composite_type composite_type_t;

  1259     return type_t(composite_type_t(construct_10<T>(),

  1260         as_actor<A>::convert(a),

  1261         as_actor<B>::convert(b),

  1262         as_actor<C>::convert(c),

  1263         as_actor<D>::convert(d),

  1264         as_actor<E>::convert(e),

  1265         as_actor<F>::convert(f),

  1266         as_actor<G>::convert(g),

  1267         as_actor<H>::convert(h),

  1268         as_actor<I>::convert(i),

  1269         as_actor<J>::convert(j)

  1270     ));

  1271 }

  1273 //////////////////////////////////

  1274 template <

  1275     typename T, typename A, typename B, typename C, typename D, typename E,

  1276     typename F, typename G, typename H, typename I, typename J, typename K

  1277 >

  1278 inline typename impl::make_composite<

  1279     construct_11<T>, A, B, C, D, E, F, G, H, I, J, K>::type

  1280 construct_(

  1281     A const& a, B const& b, C const& c, D const& d, E const& e,

  1282     F const& f, G const& g, H const& h, I const& i, J const& j,

  1283     K const& k)

  1284 {

  1285     typedef

  1286         impl::make_composite<

  1287             construct_11<T>, A, B, C, D, E, F, G, H, I, J, K

  1288         >

  1289         make_composite_t;

  1290     typedef typename make_composite_t::type type_t;

  1291     typedef typename make_composite_t::composite_type composite_type_t;

  1293     return type_t(composite_type_t(construct_11<T>(),

  1294         as_actor<A>::convert(a),

  1295         as_actor<B>::convert(b),

  1296         as_actor<C>::convert(c),

  1297         as_actor<D>::convert(d),

  1298         as_actor<E>::convert(e),

  1299         as_actor<F>::convert(f),

  1300         as_actor<G>::convert(g),

  1301         as_actor<H>::convert(h),

  1302         as_actor<I>::convert(i),

  1303         as_actor<J>::convert(j),

  1304         as_actor<K>::convert(k)

  1305     ));

  1306 }

  1308 //////////////////////////////////

  1309 template <

  1310     typename T, typename A, typename B, typename C, typename D, typename E,

  1311     typename F, typename G, typename H, typename I, typename J, typename K,

  1312     typename L

  1313 >

  1314 inline typename impl::make_composite<

  1315     construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L>::type

  1316 construct_(

  1317     A const& a, B const& b, C const& c, D const& d, E const& e,

  1318     F const& f, G const& g, H const& h, I const& i, J const& j,

  1319     K const& k, L const& l)

  1320 {

  1321     typedef

  1322         impl::make_composite<

  1323             construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L

  1324         >

  1325         make_composite_t;

  1326     typedef typename make_composite_t::type type_t;

  1327     typedef typename make_composite_t::composite_type composite_type_t;

  1329     return type_t(composite_type_t(construct_12<T>(),

  1330         as_actor<A>::convert(a),

  1331         as_actor<B>::convert(b),

  1332         as_actor<C>::convert(c),

  1333         as_actor<D>::convert(d),

  1334         as_actor<E>::convert(e),

  1335         as_actor<F>::convert(f),

  1336         as_actor<G>::convert(g),

  1337         as_actor<H>::convert(h),

  1338         as_actor<I>::convert(i),

  1339         as_actor<J>::convert(j),

  1340         as_actor<K>::convert(k),

  1341         as_actor<L>::convert(l)

  1342     ));

  1343 }

  1345 #if PHOENIX_CONSTRUCT_LIMIT > 12

  1346 //////////////////////////////////

  1347 template <

  1348     typename T, typename A, typename B, typename C, typename D, typename E,

  1349     typename F, typename G, typename H, typename I, typename J, typename K,

  1350     typename L, typename M

  1351 >

  1352 inline typename impl::make_composite<

  1353     construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type

  1354 construct_(

  1355     A const& a, B const& b, C const& c, D const& d, E const& e,

  1356     F const& f, G const& g, H const& h, I const& i, J const& j,

  1357     K const& k, L const& l, M const& m)

  1358 {

  1359     typedef

  1360         impl::make_composite<

  1361             construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M

  1362         >

  1363         make_composite_t;

  1364     typedef typename make_composite_t::type type_t;

  1365     typedef typename make_composite_t::composite_type composite_type_t;

  1367     return type_t(composite_type_t(construct_13<T>(),

  1368         as_actor<A>::convert(a),

  1369         as_actor<B>::convert(b),

  1370         as_actor<C>::convert(c),

  1371         as_actor<D>::convert(d),

  1372         as_actor<E>::convert(e),

  1373         as_actor<F>::convert(f),

  1374         as_actor<G>::convert(g),

  1375         as_actor<H>::convert(h),

  1376         as_actor<I>::convert(i),

  1377         as_actor<J>::convert(j),

  1378         as_actor<K>::convert(k),

  1379         as_actor<L>::convert(l),

  1380         as_actor<M>::convert(m)

  1381     ));

  1382 }

  1384 //////////////////////////////////

  1385 template <

  1386     typename T, typename A, typename B, typename C, typename D, typename E,

  1387     typename F, typename G, typename H, typename I, typename J, typename K,

  1388     typename L, typename M, typename N

  1389 >

  1390 inline typename impl::make_composite<

  1391     construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type

  1392 construct_(

  1393     A const& a, B const& b, C const& c, D const& d, E const& e,

  1394     F const& f, G const& g, H const& h, I const& i, J const& j,

  1395     K const& k, L const& l, M const& m, N const& n)

  1396 {

  1397     typedef

  1398         impl::make_composite<

  1399             construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N

  1400         >

  1401         make_composite_t;

  1402     typedef typename make_composite_t::type type_t;

  1403     typedef typename make_composite_t::composite_type composite_type_t;

  1405     return type_t(composite_type_t(construct_14<T>(),

  1406         as_actor<A>::convert(a),

  1407         as_actor<B>::convert(b),

  1408         as_actor<C>::convert(c),

  1409         as_actor<D>::convert(d),

  1410         as_actor<E>::convert(e),

  1411         as_actor<F>::convert(f),

  1412         as_actor<G>::convert(g),

  1413         as_actor<H>::convert(h),

  1414         as_actor<I>::convert(i),

  1415         as_actor<J>::convert(j),

  1416         as_actor<K>::convert(k),

  1417         as_actor<L>::convert(l),

  1418         as_actor<M>::convert(m),

  1419         as_actor<N>::convert(n)

  1420     ));

  1421 }

  1423 //////////////////////////////////

  1424 template <

  1425     typename T, typename A, typename B, typename C, typename D, typename E,

  1426     typename F, typename G, typename H, typename I, typename J, typename K,

  1427     typename L, typename M, typename N, typename O

  1428 >

  1429 inline typename impl::make_composite<

  1430     construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type

  1431 construct_(

  1432     A const& a, B const& b, C const& c, D const& d, E const& e,

  1433     F const& f, G const& g, H const& h, I const& i, J const& j,

  1434     K const& k, L const& l, M const& m, N const& n, O const& o)

  1435 {

  1436     typedef

  1437         impl::make_composite<

  1438             construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O

  1439         >

  1440         make_composite_t;

  1441     typedef typename make_composite_t::type type_t;

  1442     typedef typename make_composite_t::composite_type composite_type_t;

  1444     return type_t(composite_type_t(construct_15<T>(),

  1445         as_actor<A>::convert(a),

  1446         as_actor<B>::convert(b),

  1447         as_actor<C>::convert(c),

  1448         as_actor<D>::convert(d),

  1449         as_actor<E>::convert(e),

  1450         as_actor<F>::convert(f),

  1451         as_actor<G>::convert(g),

  1452         as_actor<H>::convert(h),

  1453         as_actor<I>::convert(i),

  1454         as_actor<J>::convert(j),

  1455         as_actor<K>::convert(k),

  1456         as_actor<L>::convert(l),

  1457         as_actor<M>::convert(m),

  1458         as_actor<N>::convert(n),

  1459         as_actor<O>::convert(o)

  1460     ));

  1461 }

  1463 #endif

  1464 #endif

  1465 #endif

  1466 #endif

  1468 ///////////////////////////////////////////////////////////////////////////////

  1469 }   //  namespace phoenix

  1471 #endif // PHOENIX_CASTS_HPP

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--