| /*============================================================================= |
| Phoenix V1.2.1 |
| Copyright (c) 2001-2003 Joel de Guzman |
| Copyright (c) 2001-2003 Hartmut Kaiser |
| |
| Distributed under the Boost Software License, Version 1.0. (See accompanying |
| file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| ==============================================================================*/ |
| |
| #ifndef PHOENIX_CASTS_HPP |
| #define PHOENIX_CASTS_HPP |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <boost/spirit/home/classic/phoenix/actor.hpp> |
| #include <boost/spirit/home/classic/phoenix/composite.hpp> |
| #include <boost/static_assert.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace phoenix { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Phoenix predefined maximum construct_ limit. This limit defines the maximum |
| // number of parameters supported for calles to the set of construct_ template |
| // functions (lazy object construction, see below). This number defaults to 3. |
| // The actual maximum is rounded up in multiples of 3. Thus, if this value |
| // is 4, the actual limit is 6. The ultimate maximum limit in this |
| // implementation is 15. |
| // PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT! |
| |
| #if !defined(PHOENIX_CONSTRUCT_LIMIT) |
| #define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT |
| #endif |
| |
| // ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT |
| BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT); |
| |
| // ensure PHOENIX_CONSTRUCT_LIMIT <= 15 |
| BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15); |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Lazy C++ casts |
| // |
| // The set of lazy C++ cast template classes and functions provide a way |
| // of lazily casting certain type to another during parsing. |
| // The lazy C++ templates are (syntactically) used very much like |
| // the well known C++ casts: |
| // |
| // A *a = static_cast_<A *>(...actor returning a convertible type...); |
| // |
| // where the given parameter should be an actor, which eval() function |
| // returns a convertible type. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename T, typename A> |
| struct static_cast_l { |
| |
| template <typename TupleT> |
| struct result { typedef T type; }; |
| |
| static_cast_l(A const& a_) |
| : a(a_) {} |
| |
| template <typename TupleT> |
| T |
| eval(TupleT const& args) const |
| { |
| return static_cast<T>(a.eval(args)); |
| } |
| |
| A a; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename BaseAT> |
| inline actor<static_cast_l<T, BaseAT> > |
| static_cast_(actor<BaseAT> const& a) |
| { |
| typedef static_cast_l<T, BaseAT> cast_t; |
| return actor<cast_t>(cast_t(a)); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A> |
| struct dynamic_cast_l { |
| |
| template <typename TupleT> |
| struct result { typedef T type; }; |
| |
| dynamic_cast_l(A const& a_) |
| : a(a_) {} |
| |
| template <typename TupleT> |
| T |
| eval(TupleT const& args) const |
| { |
| return dynamic_cast<T>(a.eval(args)); |
| } |
| |
| A a; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename BaseAT> |
| inline actor<dynamic_cast_l<T, BaseAT> > |
| dynamic_cast_(actor<BaseAT> const& a) |
| { |
| typedef dynamic_cast_l<T, BaseAT> cast_t; |
| return actor<cast_t>(cast_t(a)); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A> |
| struct reinterpret_cast_l { |
| |
| template <typename TupleT> |
| struct result { typedef T type; }; |
| |
| reinterpret_cast_l(A const& a_) |
| : a(a_) {} |
| |
| template <typename TupleT> |
| T |
| eval(TupleT const& args) const |
| { |
| return reinterpret_cast<T>(a.eval(args)); |
| } |
| |
| A a; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename BaseAT> |
| inline actor<reinterpret_cast_l<T, BaseAT> > |
| reinterpret_cast_(actor<BaseAT> const& a) |
| { |
| typedef reinterpret_cast_l<T, BaseAT> cast_t; |
| return actor<cast_t>(cast_t(a)); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A> |
| struct const_cast_l { |
| |
| template <typename TupleT> |
| struct result { typedef T type; }; |
| |
| const_cast_l(A const& a_) |
| : a(a_) {} |
| |
| template <typename TupleT> |
| T |
| eval(TupleT const& args) const |
| { |
| return const_cast<T>(a.eval(args)); |
| } |
| |
| A a; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename BaseAT> |
| inline actor<const_cast_l<T, BaseAT> > |
| const_cast_(actor<BaseAT> const& a) |
| { |
| typedef const_cast_l<T, BaseAT> cast_t; |
| return actor<cast_t>(cast_t(a)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // construct_ |
| // |
| // Lazy object construction |
| // |
| // The set of construct_<> template classes and functions provide a way |
| // of lazily constructing certain object from a arbitrary set of |
| // actors during parsing. |
| // The construct_ templates are (syntactically) used very much like |
| // the well known C++ casts: |
| // |
| // A a = construct_<A>(...arbitrary list of actors...); |
| // |
| // where the given parameters are submitted as parameters to the |
| // contructor of the object of type A. (This certainly implies, that |
| // type A has a constructor with a fitting set of parameter types |
| // defined.) |
| // |
| // The maximum number of needed parameters is controlled through the |
| // preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this |
| // limit should not be greater than PHOENIX_LIMIT. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename T> |
| struct construct_l_0 { |
| typedef T result_type; |
| |
| T operator()() const { |
| return T(); |
| } |
| }; |
| |
| |
| template <typename T> |
| struct construct_l { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 3 |
| , typename D |
| , typename E |
| , typename F |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 6 |
| , typename G |
| , typename H |
| , typename I |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 9 |
| , typename J |
| , typename K |
| , typename L |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 12 |
| , typename M |
| , typename N |
| , typename O |
| #endif |
| #endif |
| #endif |
| #endif |
| > |
| struct result { typedef T type; }; |
| |
| T operator()() const |
| { |
| return T(); |
| } |
| |
| template <typename A> |
| T operator()(A const& a) const |
| { |
| T t(a); |
| return t; |
| } |
| |
| template <typename A, typename B> |
| T operator()(A const& a, B const& b) const |
| { |
| T t(a, b); |
| return t; |
| } |
| |
| template <typename A, typename B, typename C> |
| T operator()(A const& a, B const& b, C const& c) const |
| { |
| T t(a, b, c); |
| return t; |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 3 |
| template < |
| typename A, typename B, typename C, typename D |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d) const |
| { |
| T t(a, b, c, d); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e) const |
| { |
| T t(a, b, c, d, e); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f) const |
| { |
| T t(a, b, c, d, e, f); |
| return t; |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 6 |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g) const |
| { |
| T t(a, b, c, d, e, f, g); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h) const |
| { |
| T t(a, b, c, d, e, f, g, h); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i) const |
| { |
| T t(a, b, c, d, e, f, g, h, i); |
| return t; |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 9 |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l); |
| return t; |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 12 |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l, m); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n); |
| return t; |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N, typename O |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n, O const& o) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); |
| return t; |
| } |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| }; |
| |
| |
| template <typename T> |
| struct construct_1 { |
| |
| template < |
| typename A |
| > |
| struct result { typedef T type; }; |
| |
| template <typename A> |
| T operator()(A const& a) const |
| { |
| T t(a); |
| return t; |
| } |
| |
| }; |
| |
| template <typename T> |
| struct construct_2 { |
| |
| template < |
| typename A |
| , typename B |
| > |
| struct result { typedef T type; }; |
| |
| template <typename A, typename B> |
| T operator()(A const& a, B const& b) const |
| { |
| T t(a, b); |
| return t; |
| } |
| |
| }; |
| |
| template <typename T> |
| struct construct_3 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| > |
| struct result { typedef T type; }; |
| |
| template <typename A, typename B, typename C> |
| T operator()(A const& a, B const& b, C const& c) const |
| { |
| T t(a, b, c); |
| return t; |
| } |
| }; |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 3 |
| template <typename T> |
| struct construct_4 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d) const |
| { |
| T t(a, b, c, d); |
| return t; |
| } |
| }; |
| |
| |
| template <typename T> |
| struct construct_5 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e) const |
| { |
| T t(a, b, c, d, e); |
| return t; |
| } |
| }; |
| |
| |
| template <typename T> |
| struct construct_6 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f) const |
| { |
| T t(a, b, c, d, e, f); |
| return t; |
| } |
| }; |
| #endif |
| |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 6 |
| template <typename T> |
| struct construct_7 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g) const |
| { |
| T t(a, b, c, d, e, f, g); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_8 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h) const |
| { |
| T t(a, b, c, d, e, f, g, h); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_9 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i) const |
| { |
| T t(a, b, c, d, e, f, g, h, i); |
| return t; |
| } |
| }; |
| #endif |
| |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 9 |
| template <typename T> |
| struct construct_10 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_11 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| , typename K |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_12 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| , typename K |
| , typename L |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l) const |
| { |
| T t(a, b, c, d, f, e, g, h, i, j, k, l); |
| return t; |
| } |
| }; |
| #endif |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 12 |
| template <typename T> |
| struct construct_13 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| , typename K |
| , typename L |
| , typename M |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l, m); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_14 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| , typename K |
| , typename L |
| , typename M |
| , typename N |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n) const |
| { |
| T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n); |
| return t; |
| } |
| }; |
| |
| template <typename T> |
| struct construct_15 { |
| |
| template < |
| typename A |
| , typename B |
| , typename C |
| , typename D |
| , typename E |
| , typename F |
| , typename G |
| , typename H |
| , typename I |
| , typename J |
| , typename K |
| , typename L |
| , typename M |
| , typename N |
| , typename O |
| > |
| struct result { typedef T type; }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N, typename O |
| > |
| T operator()( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n, O const& o) const |
| { |
| T t(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o); |
| return t; |
| } |
| }; |
| #endif |
| |
| |
| #if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002)) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The following specializations are needed because Borland and CodeWarrior |
| // does not accept default template arguments in nested template classes in |
| // classes (i.e construct_l::result) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename T, typename TupleT> |
| struct composite0_result<construct_l_0<T>, TupleT> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A> |
| struct composite1_result<construct_l<T>, TupleT, A> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B> |
| struct composite2_result<construct_l<T>, TupleT, A, B> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C> |
| struct composite3_result<construct_l<T>, TupleT, A, B, C> { |
| |
| typedef T type; |
| }; |
| |
| #if PHOENIX_LIMIT > 3 |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D> |
| struct composite4_result<construct_l<T>, TupleT, |
| A, B, C, D> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E> |
| struct composite5_result<construct_l<T>, TupleT, |
| A, B, C, D, E> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F> |
| struct composite6_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F> { |
| |
| typedef T type; |
| }; |
| |
| #if PHOENIX_LIMIT > 6 |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G> |
| struct composite7_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H> |
| struct composite8_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I> |
| struct composite9_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I> { |
| |
| typedef T type; |
| }; |
| |
| #if PHOENIX_LIMIT > 9 |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J> |
| struct composite10_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K> |
| struct composite11_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J, K> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L> |
| struct composite12_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J, K, L> { |
| |
| typedef T type; |
| }; |
| |
| #if PHOENIX_LIMIT > 12 |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M> |
| struct composite13_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J, K, L, M> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N> |
| struct composite14_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J, K, L, M, N> { |
| |
| typedef T type; |
| }; |
| |
| ////////////////////////////////// |
| template <typename T, typename TupleT, |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N, typename O> |
| struct composite15_result<construct_l<T>, TupleT, |
| A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> { |
| |
| typedef T type; |
| }; |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| #endif |
| |
| ////////////////////////////////// |
| template <typename T> |
| inline typename impl::make_composite<construct_l_0<T> >::type |
| construct_() |
| { |
| typedef impl::make_composite<construct_l_0<T> > make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_l_0<T>())); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A> |
| inline typename impl::make_composite<construct_1<T>, A>::type |
| construct_(A const& a) |
| { |
| typedef impl::make_composite<construct_1<T>, A> make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_1<T>(), |
| as_actor<A>::convert(a) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A, typename B> |
| inline typename impl::make_composite<construct_2<T>, A, B>::type |
| construct_(A const& a, B const& b) |
| { |
| typedef impl::make_composite<construct_2<T>, A, B> make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_2<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template <typename T, typename A, typename B, typename C> |
| inline typename impl::make_composite<construct_3<T>, A, B, C>::type |
| construct_(A const& a, B const& b, C const& c) |
| { |
| typedef impl::make_composite<construct_3<T>, A, B, C> make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_3<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c) |
| )); |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 3 |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D |
| > |
| inline typename impl::make_composite<construct_4<T>, A, B, C, D>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d) |
| { |
| typedef |
| impl::make_composite<construct_4<T>, A, B, C, D> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_4<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E |
| > |
| inline typename impl::make_composite<construct_5<T>, A, B, C, D, E>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e) |
| { |
| typedef |
| impl::make_composite<construct_5<T>, A, B, C, D, E> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_5<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F |
| > |
| inline typename impl::make_composite<construct_6<T>, A, B, C, D, E, F>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f) |
| { |
| typedef |
| impl::make_composite<construct_6<T>, A, B, C, D, E, F> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_6<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f) |
| )); |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 6 |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G |
| > |
| inline typename impl::make_composite<construct_7<T>, A, B, C, D, E, F, G>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g) |
| { |
| typedef |
| impl::make_composite<construct_7<T>, A, B, C, D, E, F, G> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_7<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H |
| > |
| inline typename impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h) |
| { |
| typedef |
| impl::make_composite<construct_8<T>, A, B, C, D, E, F, G, H> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_8<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I |
| > |
| inline typename impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i) |
| { |
| typedef |
| impl::make_composite<construct_9<T>, A, B, C, D, E, F, G, H, I> |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_9<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i) |
| )); |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 9 |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J |
| > |
| inline typename impl::make_composite< |
| construct_10<T>, A, B, C, D, E, F, G, H, I, J>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j) |
| { |
| typedef |
| impl::make_composite< |
| construct_10<T>, A, B, C, D, E, F, G, H, I, J |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_10<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, typename K |
| > |
| inline typename impl::make_composite< |
| construct_11<T>, A, B, C, D, E, F, G, H, I, J, K>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k) |
| { |
| typedef |
| impl::make_composite< |
| construct_11<T>, A, B, C, D, E, F, G, H, I, J, K |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_11<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j), |
| as_actor<K>::convert(k) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, typename K, |
| typename L |
| > |
| inline typename impl::make_composite< |
| construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l) |
| { |
| typedef |
| impl::make_composite< |
| construct_12<T>, A, B, C, D, E, F, G, H, I, J, K, L |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_12<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j), |
| as_actor<K>::convert(k), |
| as_actor<L>::convert(l) |
| )); |
| } |
| |
| #if PHOENIX_CONSTRUCT_LIMIT > 12 |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, typename K, |
| typename L, typename M |
| > |
| inline typename impl::make_composite< |
| construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m) |
| { |
| typedef |
| impl::make_composite< |
| construct_13<T>, A, B, C, D, E, F, G, H, I, J, K, L, M |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_13<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j), |
| as_actor<K>::convert(k), |
| as_actor<L>::convert(l), |
| as_actor<M>::convert(m) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, typename K, |
| typename L, typename M, typename N |
| > |
| inline typename impl::make_composite< |
| construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n) |
| { |
| typedef |
| impl::make_composite< |
| construct_14<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_14<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j), |
| as_actor<K>::convert(k), |
| as_actor<L>::convert(l), |
| as_actor<M>::convert(m), |
| as_actor<N>::convert(n) |
| )); |
| } |
| |
| ////////////////////////////////// |
| template < |
| typename T, typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, typename K, |
| typename L, typename M, typename N, typename O |
| > |
| inline typename impl::make_composite< |
| construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type |
| construct_( |
| A const& a, B const& b, C const& c, D const& d, E const& e, |
| F const& f, G const& g, H const& h, I const& i, J const& j, |
| K const& k, L const& l, M const& m, N const& n, O const& o) |
| { |
| typedef |
| impl::make_composite< |
| construct_15<T>, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O |
| > |
| make_composite_t; |
| typedef typename make_composite_t::type type_t; |
| typedef typename make_composite_t::composite_type composite_type_t; |
| |
| return type_t(composite_type_t(construct_15<T>(), |
| as_actor<A>::convert(a), |
| as_actor<B>::convert(b), |
| as_actor<C>::convert(c), |
| as_actor<D>::convert(d), |
| as_actor<E>::convert(e), |
| as_actor<F>::convert(f), |
| as_actor<G>::convert(g), |
| as_actor<H>::convert(h), |
| as_actor<I>::convert(i), |
| as_actor<J>::convert(j), |
| as_actor<K>::convert(k), |
| as_actor<L>::convert(l), |
| as_actor<M>::convert(m), |
| as_actor<N>::convert(n), |
| as_actor<O>::convert(o) |
| )); |
| } |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| } // namespace phoenix |
| |
| #endif // PHOENIX_CASTS_HPP |