x
Yes
No
Do you want to visit DriveHQ English website?
Inicio
Características
Precios
Prueba gratuita
Software cliente
Acerca de nosotros
Servidor de archivos
|
Solución de copias de seguridad
|
Servidor FTP
|
Servidor de correo electrónico
|
Alojamiento web
|
Software cliente
Servidor de archivos
Solución de copia de seguridad
Servidor FTP
Servidor de correo electrónico
Alojamiento web
Software cliente
tuple_helpers.hpp - Hosted on DriveHQ Cloud IT Platform
Arriba
Subir
Descargar
Compartir
Publicar
Nueva carpeta
Nuevo archivo
Copiar
Cortar
Eliminar
Pegar
Clasificación
Actualizar
Ruta de la carpeta: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\spirit\phoenix\tuple_helpers.hpp
Girar
Efecto
Propiedad
Historial
/*============================================================================= Phoenix V1.2.1 Copyright (c) 2002 Joel de Guzman Copyright (c) 2002-2003 Hartmut Kaiser Use, modification and distribution is subject to 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
#include
/////////////////////////////////////////////////////////////////////////////// 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
struct make_tuple { typedef tuple
type; }; /////////////////////////////////////////////////////////////////////////////// // nil_t is converted to an empty tuple type template <> struct make_tuple
{ 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
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
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
struct concat_tuple; /////////////////////////////////////////////////////////////////////////////// // // concat tuple <0 member> class // /////////////////////////////////////////////////////////////////////////////// template
struct concat_tuple
, AppendT> { typedef tuple
type; }; template <> struct concat_tuple
, nil_t> { typedef tuple<> type; }; /////////////////////////////////////////////////////////////////////////////// // // concat tuple <1 member> class // /////////////////////////////////////////////////////////////////////////////// template
struct concat_tuple
, AppendT> { typedef tuple
type; }; template
struct concat_tuple
, nil_t> { typedef tuple
type; }; /////////////////////////////////////////////////////////////////////////////// // // concat tuple <2 member> class // /////////////////////////////////////////////////////////////////////////////// template
struct concat_tuple
, AppendT> { typedef tuple
type; }; template
struct concat_tuple
, nil_t> { typedef tuple
type; }; #if PHOENIX_LIMIT > 3 /////////////////////////////////////////////////////////////////////////////// // // concat tuple <3 member> class // /////////////////////////////////////////////////////////////////////////////// template < typename A, typename B, typename C, typename AppendT > struct concat_tuple
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C > struct concat_tuple
, nil_t> { typedef tuple
type; }; /////////////////////////////////////////////////////////////////////////////// // // concat tuple <4 member> class // /////////////////////////////////////////////////////////////////////////////// template < typename A, typename B, typename C, typename D, typename AppendT > struct concat_tuple
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D > struct concat_tuple
, nil_t> { typedef tuple
type; }; /////////////////////////////////////////////////////////////////////////////// // // concat tuple <5 member> class // /////////////////////////////////////////////////////////////////////////////// template < typename A, typename B, typename C, typename D, typename E, typename AppendT > struct concat_tuple
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D, typename E > struct concat_tuple
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D, typename E, typename F > struct concat_tuple
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D, typename E, typename F, typename G > struct concat_tuple
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H > struct concat_tuple
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
type; }; template < typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I > struct concat_tuple
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
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
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
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
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
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
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
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
, nil_t> { typedef tuple
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
, AppendT> { typedef tuple
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
, nil_t> { typedef tuple
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
struct concat_tuple_element { typedef typename concat_tuple_element< typename concat_tuple
::type, TupleT2, N+1, typename tuple_element
::type >::type type; }; template
struct concat_tuple_element
{ typedef TupleT1 type; }; template
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
struct actor_result; // forward declaration namespace impl { template
struct convert_actors_ {}; } template
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_
::template apply
::do_(actor_tuple); } namespace impl { template
struct convert_actor { typedef typename tuple_element
::type type; template
struct is_default_t {}; typedef is_default_t
is_default; typedef is_default_t
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
()](); // 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
tuple_helpers.hpp
Dirección de la página
Dirección del archivo
Anterior
12/13
Siguiente
Descargar
( 39 KB )
Comments
Total ratings:
0
Average rating:
No clasificado
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.