| /*============================================================================= |
| Phoenix V1.2.1 |
| Copyright (c) 2002 Joel de Guzman |
| Copyright (c) 2002-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_TUPLEHELPERS_HPP |
| #define PHOENIX_TUPLEHELPERS_HPP |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <cassert> |
| #include <boost/spirit/home/classic/phoenix/tuples.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace phoenix |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // make_tuple template class |
| // |
| // This template class is used to calculate a tuple type required to hold |
| // the given template parameter type |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // normal (non-tuple types are wrapped into a tuple) |
| template <typename ResultT> |
| struct make_tuple { |
| |
| typedef tuple<ResultT> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // nil_t is converted to an empty tuple type |
| template <> |
| struct make_tuple<nil_t> { |
| |
| typedef tuple<> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // tuple types are left alone without any refactoring |
| template < |
| typename A, typename B, typename C |
| #if PHOENIX_LIMIT > 3 |
| , typename D, typename E, typename F |
| #if PHOENIX_LIMIT > 6 |
| , typename G, typename H, typename I |
| #if PHOENIX_LIMIT > 9 |
| , typename J, typename K, typename L |
| #if PHOENIX_LIMIT > 12 |
| , typename M, typename N, typename O |
| #endif |
| #endif |
| #endif |
| #endif |
| > |
| struct make_tuple<tuple<A, B, C |
| #if PHOENIX_LIMIT > 3 |
| , D, E, F |
| #if PHOENIX_LIMIT > 6 |
| , G, H, I |
| #if PHOENIX_LIMIT > 9 |
| , J, K, L |
| #if PHOENIX_LIMIT > 12 |
| , M, N, O |
| #endif |
| #endif |
| #endif |
| #endif |
| > > { |
| |
| // the tuple parameter itself is the required tuple type |
| typedef tuple<A, B, C |
| #if PHOENIX_LIMIT > 3 |
| , D, E, F |
| #if PHOENIX_LIMIT > 6 |
| , G, H, I |
| #if PHOENIX_LIMIT > 9 |
| , J, K, L |
| #if PHOENIX_LIMIT > 12 |
| , M, N, O |
| #endif |
| #endif |
| #endif |
| #endif |
| > type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat_tuple type computer |
| // |
| // This class returns the type of a tuple, which is constructed by |
| // concatenating a tuple with a given type |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename TupleT, typename AppendT> |
| struct concat_tuple; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <0 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename AppendT> |
| struct concat_tuple<tuple<>, AppendT> { |
| |
| typedef tuple<AppendT> type; |
| }; |
| |
| template <> |
| struct concat_tuple<tuple<>, nil_t> { |
| |
| typedef tuple<> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <1 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename A, typename AppendT> |
| struct concat_tuple<tuple<A>, AppendT> { |
| |
| typedef tuple<A, AppendT> type; |
| }; |
| |
| template <typename A> |
| struct concat_tuple<tuple<A>, nil_t> { |
| |
| typedef tuple<A> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <2 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename A, typename B, typename AppendT> |
| struct concat_tuple<tuple<A, B>, AppendT> { |
| |
| typedef tuple<A, B, AppendT> type; |
| }; |
| |
| template <typename A, typename B> |
| struct concat_tuple<tuple<A, B>, nil_t> { |
| |
| typedef tuple<A, B> type; |
| }; |
| |
| #if PHOENIX_LIMIT > 3 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <3 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C>, AppendT> { |
| |
| typedef tuple<A, B, C, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C |
| > |
| struct concat_tuple<tuple<A, B, C>, nil_t> { |
| |
| typedef tuple<A, B, C> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <4 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D>, AppendT> { |
| |
| typedef tuple<A, B, C, D, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D |
| > |
| struct concat_tuple<tuple<A, B, C, D>, nil_t> { |
| |
| typedef tuple<A, B, C, D> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <5 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E |
| > |
| struct concat_tuple<tuple<A, B, C, D, E>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E> type; |
| }; |
| |
| #if PHOENIX_LIMIT > 6 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <6 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <7 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <8 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H> type; |
| }; |
| |
| #if PHOENIX_LIMIT > 9 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <9 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <10 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I, typename J, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I, typename J |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <11 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I, typename J, typename K, |
| typename AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, AppendT> type; |
| }; |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, typename F, |
| typename G, typename H, typename I, typename J, typename K |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K> type; |
| }; |
| |
| #if PHOENIX_LIMIT > 12 |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <12 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| 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 AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, AppendT> 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 |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <13 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| 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 AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, AppendT> 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 |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat tuple <14 member> class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| 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 AppendT |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, AppendT> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, AppendT> 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 |
| > |
| struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, nil_t> { |
| |
| typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> type; |
| }; |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // concat_tuples type computer |
| // |
| // This template class returns the type of a tuple built from the |
| // concatenation of two given tuples. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename TupleT1, typename TupleT2, int N, typename AppendT> |
| struct concat_tuple_element { |
| |
| typedef |
| typename concat_tuple_element< |
| typename concat_tuple<TupleT1, AppendT>::type, TupleT2, N+1, |
| typename tuple_element<N+1, TupleT2>::type |
| >::type |
| type; |
| }; |
| |
| template <typename TupleT1, typename TupleT2, int N> |
| struct concat_tuple_element<TupleT1, TupleT2, N, nil_t> { |
| |
| typedef TupleT1 type; |
| }; |
| |
| template <typename TupleT1, typename TupleT2> |
| struct concat_tuples { |
| |
| typedef |
| typename concat_tuple_element< |
| TupleT1, TupleT2, 0, |
| typename tuple_element<0, TupleT2>::type |
| >::type |
| type; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // convert_actors template function |
| // |
| // The convert_actors template functions constructs a new tuple object |
| // composed of the elements returned by the actors contained in the |
| // input tuple. (i.e. the given tuple type 'actor_tuple' contains a set |
| // of actors to evaluate and the resulting tuple contains the results of |
| // evaluating the actors.) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template <typename ActorT, typename TupleT> |
| struct actor_result; // forward declaration |
| |
| namespace impl |
| { |
| template <unsigned N> |
| struct convert_actors_ {}; |
| } |
| |
| template <typename TupleResultT, typename ActorTupleT> |
| TupleResultT |
| convert_actors(ActorTupleT const& actor_tuple) |
| { |
| BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); |
| BOOST_STATIC_CONSTANT(int, length = TupleResultT::length); |
| return impl::convert_actors_<length> |
| ::template apply<TupleResultT, ActorTupleT>::do_(actor_tuple); |
| } |
| |
| namespace impl |
| { |
| template <int N, typename TupleResultT, typename ActorTupleT> |
| struct convert_actor |
| { |
| typedef typename tuple_element<N, TupleResultT>::type type; |
| |
| template <bool C> |
| struct is_default_t {}; |
| typedef is_default_t<true> is_default; |
| typedef is_default_t<false> is_not_default; |
| |
| static type |
| actor_element(ActorTupleT const& /*actor_tuple*/, is_default) |
| { |
| return type(); // default construct |
| } |
| |
| static type |
| actor_element(ActorTupleT const& actor_tuple, is_not_default) |
| { |
| BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); |
| return actor_tuple[tuple_index<N>()](); // apply the actor |
| } |
| |
| static type |
| do_(ActorTupleT const& actor_tuple) |
| { |
| return actor_element( |
| actor_tuple, is_default_t<(N >= ActorTupleT::length)>()); |
| } |
| }; |
| |
| /////////////////////////////////////// |
| template <> |
| struct convert_actors_<1> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| /////////////////////////////////////// |
| template <> |
| struct convert_actors_<2> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| /////////////////////////////////////// |
| template <> |
| struct convert_actors_<3> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| #if PHOENIX_LIMIT > 3 |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<4> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<5> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<6> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| #if PHOENIX_LIMIT > 6 |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<7> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<8> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<9> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| #if PHOENIX_LIMIT > 9 |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<10> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<11> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| , converter10::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<12> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; |
| typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| , converter10::do_(actor_tuple) |
| , converter11::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| #if PHOENIX_LIMIT > 12 |
| |
| ///////////////////////////////////// |
| template <> |
| struct convert_actors_<13> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; |
| typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; |
| typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| , converter10::do_(actor_tuple) |
| , converter11::do_(actor_tuple) |
| , converter12::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| /////////////////////////////////////// |
| template <> |
| struct convert_actors_<14> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; |
| typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; |
| typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; |
| typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| , converter10::do_(actor_tuple) |
| , converter11::do_(actor_tuple) |
| , converter12::do_(actor_tuple) |
| , converter13::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| /////////////////////////////////////// |
| template <> |
| struct convert_actors_<15> |
| { |
| template <typename TupleResultT, typename ActorTupleT> |
| struct apply |
| { |
| static TupleResultT |
| do_(ActorTupleT const& actor_tuple) |
| { |
| typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; |
| typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; |
| typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; |
| typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; |
| typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; |
| typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; |
| typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; |
| typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; |
| typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; |
| typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; |
| typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; |
| typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; |
| typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; |
| typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; |
| typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14; |
| |
| using namespace tuple_index_names; |
| return TupleResultT( |
| converter0::do_(actor_tuple) |
| , converter1::do_(actor_tuple) |
| , converter2::do_(actor_tuple) |
| , converter3::do_(actor_tuple) |
| , converter4::do_(actor_tuple) |
| , converter5::do_(actor_tuple) |
| , converter6::do_(actor_tuple) |
| , converter7::do_(actor_tuple) |
| , converter8::do_(actor_tuple) |
| , converter9::do_(actor_tuple) |
| , converter10::do_(actor_tuple) |
| , converter11::do_(actor_tuple) |
| , converter12::do_(actor_tuple) |
| , converter13::do_(actor_tuple) |
| , converter14::do_(actor_tuple) |
| ); |
| } |
| }; |
| }; |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| } // namespace impl |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| } // namespace phoenix |
| |
| #endif // PHOENIX_TUPLEHELPERS_HPP |