Back to home page

EIC code displayed by LXR
 
 

    

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

0001 /*=============================================================================
0002     Phoenix V1.2.1
0003     Copyright (c) 2002 Joel de Guzman
0004     Copyright (c) 2002-2003 Hartmut Kaiser
0005 
0006   Distributed under the Boost Software License, Version 1.0. (See accompanying
0007   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008 ==============================================================================*/
0009 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP
0010 #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP
0011 
0012 ///////////////////////////////////////////////////////////////////////////////
0013 #include <cassert>
0014 #include <boost/spirit/home/classic/phoenix/tuples.hpp>
0015 
0016 ///////////////////////////////////////////////////////////////////////////////
0017 namespace phoenix
0018 {
0019 
0020 ///////////////////////////////////////////////////////////////////////////////
0021 //
0022 //  make_tuple template class
0023 //
0024 //      This template class is used to calculate a tuple type required to hold
0025 //      the given template parameter type
0026 //
0027 ///////////////////////////////////////////////////////////////////////////////
0028 
0029 ///////////////////////////////////////////////////////////////////////////////
0030 //  normal (non-tuple types are wrapped into a tuple)
0031 template <typename ResultT>
0032 struct make_tuple {
0033 
0034     typedef tuple<ResultT> type;
0035 };
0036 
0037 ///////////////////////////////////////////////////////////////////////////////
0038 //  nil_t is converted to an empty tuple type
0039 template <>
0040 struct make_tuple<nil_t> {
0041 
0042     typedef tuple<> type;
0043 };
0044 
0045 ///////////////////////////////////////////////////////////////////////////////
0046 //  tuple types are left alone without any refactoring
0047 template <
0048       typename A, typename B, typename C
0049 #if PHOENIX_LIMIT > 3
0050     , typename D, typename E, typename F
0051 #if PHOENIX_LIMIT > 6
0052     , typename G, typename H, typename I
0053 #if PHOENIX_LIMIT > 9
0054     , typename J, typename K, typename L
0055 #if PHOENIX_LIMIT > 12
0056     , typename M, typename N, typename O
0057 #endif
0058 #endif
0059 #endif
0060 #endif
0061 >
0062 struct make_tuple<tuple<A, B, C
0063 #if PHOENIX_LIMIT > 3
0064     , D, E, F
0065 #if PHOENIX_LIMIT > 6
0066     , G, H, I
0067 #if PHOENIX_LIMIT > 9
0068     , J, K, L
0069 #if PHOENIX_LIMIT > 12
0070     , M, N, O
0071 #endif
0072 #endif
0073 #endif
0074 #endif
0075     > > {
0076 
0077 // the tuple parameter itself is the required tuple type
0078     typedef tuple<A, B, C
0079 #if PHOENIX_LIMIT > 3
0080         , D, E, F
0081 #if PHOENIX_LIMIT > 6
0082         , G, H, I
0083 #if PHOENIX_LIMIT > 9
0084         , J, K, L
0085 #if PHOENIX_LIMIT > 12
0086         , M, N, O
0087 #endif
0088 #endif
0089 #endif
0090 #endif
0091         > type;
0092 };
0093 
0094 ///////////////////////////////////////////////////////////////////////////////
0095 //
0096 //  concat_tuple type computer
0097 //
0098 //      This class returns the type of a tuple, which is constructed by
0099 //      concatenating a tuple with a given type
0100 //
0101 ///////////////////////////////////////////////////////////////////////////////
0102 template <typename TupleT, typename AppendT>
0103 struct concat_tuple;
0104 
0105 ///////////////////////////////////////////////////////////////////////////////
0106 //
0107 //  concat tuple <0 member> class
0108 //
0109 ///////////////////////////////////////////////////////////////////////////////
0110 template <typename AppendT>
0111 struct concat_tuple<tuple<>, AppendT> {
0112 
0113     typedef tuple<AppendT> type;
0114 };
0115 
0116 template <>
0117 struct concat_tuple<tuple<>, nil_t> {
0118 
0119     typedef tuple<> type;
0120 };
0121 
0122 ///////////////////////////////////////////////////////////////////////////////
0123 //
0124 //  concat tuple <1 member> class
0125 //
0126 ///////////////////////////////////////////////////////////////////////////////
0127 template <typename A, typename AppendT>
0128 struct concat_tuple<tuple<A>, AppendT> {
0129 
0130     typedef tuple<A, AppendT> type;
0131 };
0132 
0133 template <typename A>
0134 struct concat_tuple<tuple<A>, nil_t> {
0135 
0136     typedef tuple<A> type;
0137 };
0138 
0139 ///////////////////////////////////////////////////////////////////////////////
0140 //
0141 //  concat tuple <2 member> class
0142 //
0143 ///////////////////////////////////////////////////////////////////////////////
0144 template <typename A, typename B, typename AppendT>
0145 struct concat_tuple<tuple<A, B>, AppendT> {
0146 
0147     typedef tuple<A, B, AppendT> type;
0148 };
0149 
0150 template <typename A, typename B>
0151 struct concat_tuple<tuple<A, B>, nil_t> {
0152 
0153     typedef tuple<A, B> type;
0154 };
0155 
0156 #if PHOENIX_LIMIT > 3
0157 ///////////////////////////////////////////////////////////////////////////////
0158 //
0159 //  concat tuple <3 member> class
0160 //
0161 ///////////////////////////////////////////////////////////////////////////////
0162 template <
0163     typename A, typename B, typename C,
0164     typename AppendT
0165 >
0166 struct concat_tuple<tuple<A, B, C>, AppendT> {
0167 
0168     typedef tuple<A, B, C, AppendT> type;
0169 };
0170 
0171 template <
0172     typename A, typename B, typename C
0173 >
0174 struct concat_tuple<tuple<A, B, C>, nil_t> {
0175 
0176     typedef tuple<A, B, C> type;
0177 };
0178 
0179 ///////////////////////////////////////////////////////////////////////////////
0180 //
0181 //  concat tuple <4 member> class
0182 //
0183 ///////////////////////////////////////////////////////////////////////////////
0184 template <
0185     typename A, typename B, typename C, typename D,
0186     typename AppendT
0187 >
0188 struct concat_tuple<tuple<A, B, C, D>, AppendT> {
0189 
0190     typedef tuple<A, B, C, D, AppendT> type;
0191 };
0192 
0193 template <
0194     typename A, typename B, typename C, typename D
0195 >
0196 struct concat_tuple<tuple<A, B, C, D>, nil_t> {
0197 
0198     typedef tuple<A, B, C, D> type;
0199 };
0200 
0201 ///////////////////////////////////////////////////////////////////////////////
0202 //
0203 //  concat tuple <5 member> class
0204 //
0205 ///////////////////////////////////////////////////////////////////////////////
0206 template <
0207     typename A, typename B, typename C, typename D, typename E,
0208     typename AppendT
0209 >
0210 struct concat_tuple<tuple<A, B, C, D, E>, AppendT> {
0211 
0212     typedef tuple<A, B, C, D, E, AppendT> type;
0213 };
0214 
0215 template <
0216     typename A, typename B, typename C, typename D, typename E
0217 >
0218 struct concat_tuple<tuple<A, B, C, D, E>, nil_t> {
0219 
0220     typedef tuple<A, B, C, D, E> type;
0221 };
0222 
0223 #if PHOENIX_LIMIT > 6
0224 ///////////////////////////////////////////////////////////////////////////////
0225 //
0226 //  concat tuple <6 member> class
0227 //
0228 ///////////////////////////////////////////////////////////////////////////////
0229 template <
0230     typename A, typename B, typename C, typename D, typename E, typename F,
0231     typename AppendT
0232 >
0233 struct concat_tuple<tuple<A, B, C, D, E, F>, AppendT> {
0234 
0235     typedef tuple<A, B, C, D, E, F, AppendT> type;
0236 };
0237 
0238 template <
0239     typename A, typename B, typename C, typename D, typename E, typename F
0240 >
0241 struct concat_tuple<tuple<A, B, C, D, E, F>, nil_t> {
0242 
0243     typedef tuple<A, B, C, D, E, F> type;
0244 };
0245 
0246 ///////////////////////////////////////////////////////////////////////////////
0247 //
0248 //  concat tuple <7 member> class
0249 //
0250 ///////////////////////////////////////////////////////////////////////////////
0251 template <
0252     typename A, typename B, typename C, typename D, typename E, typename F,
0253     typename G,
0254     typename AppendT
0255 >
0256 struct concat_tuple<tuple<A, B, C, D, E, F, G>, AppendT> {
0257 
0258     typedef tuple<A, B, C, D, E, F, G, AppendT> type;
0259 };
0260 
0261 template <
0262     typename A, typename B, typename C, typename D, typename E, typename F,
0263     typename G
0264 >
0265 struct concat_tuple<tuple<A, B, C, D, E, F, G>, nil_t> {
0266 
0267     typedef tuple<A, B, C, D, E, F, G> type;
0268 };
0269 
0270 ///////////////////////////////////////////////////////////////////////////////
0271 //
0272 //  concat tuple <8 member> class
0273 //
0274 ///////////////////////////////////////////////////////////////////////////////
0275 template <
0276     typename A, typename B, typename C, typename D, typename E, typename F,
0277     typename G, typename H,
0278     typename AppendT
0279 >
0280 struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, AppendT> {
0281 
0282     typedef tuple<A, B, C, D, E, F, G, H, AppendT> type;
0283 };
0284 
0285 template <
0286     typename A, typename B, typename C, typename D, typename E, typename F,
0287     typename G, typename H
0288 >
0289 struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, nil_t> {
0290 
0291     typedef tuple<A, B, C, D, E, F, G, H> type;
0292 };
0293 
0294 #if PHOENIX_LIMIT > 9
0295 ///////////////////////////////////////////////////////////////////////////////
0296 //
0297 //  concat tuple <9 member> class
0298 //
0299 ///////////////////////////////////////////////////////////////////////////////
0300 template <
0301     typename A, typename B, typename C, typename D, typename E, typename F,
0302     typename G, typename H, typename I,
0303     typename AppendT
0304 >
0305 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, AppendT> {
0306 
0307     typedef tuple<A, B, C, D, E, F, G, H, I, AppendT> type;
0308 };
0309 
0310 template <
0311     typename A, typename B, typename C, typename D, typename E, typename F,
0312     typename G, typename H, typename I
0313 >
0314 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, nil_t> {
0315 
0316     typedef tuple<A, B, C, D, E, F, G, H, I> type;
0317 };
0318 
0319 ///////////////////////////////////////////////////////////////////////////////
0320 //
0321 //  concat tuple <10 member> class
0322 //
0323 ///////////////////////////////////////////////////////////////////////////////
0324 template <
0325     typename A, typename B, typename C, typename D, typename E, typename F,
0326     typename G, typename H, typename I, typename J,
0327     typename AppendT
0328 >
0329 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, AppendT> {
0330 
0331     typedef tuple<A, B, C, D, E, F, G, H, I, J, AppendT> type;
0332 };
0333 
0334 template <
0335     typename A, typename B, typename C, typename D, typename E, typename F,
0336     typename G, typename H, typename I, typename J
0337 >
0338 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, nil_t> {
0339 
0340     typedef tuple<A, B, C, D, E, F, G, H, I, J> type;
0341 };
0342 
0343 ///////////////////////////////////////////////////////////////////////////////
0344 //
0345 //  concat tuple <11 member> class
0346 //
0347 ///////////////////////////////////////////////////////////////////////////////
0348 template <
0349     typename A, typename B, typename C, typename D, typename E, typename F,
0350     typename G, typename H, typename I, typename J, typename K,
0351     typename AppendT
0352 >
0353 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, AppendT> {
0354 
0355     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, AppendT> type;
0356 };
0357 
0358 template <
0359     typename A, typename B, typename C, typename D, typename E, typename F,
0360     typename G, typename H, typename I, typename J, typename K
0361 >
0362 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, nil_t> {
0363 
0364     typedef tuple<A, B, C, D, E, F, G, H, I, J, K> type;
0365 };
0366 
0367 #if PHOENIX_LIMIT > 12
0368 ///////////////////////////////////////////////////////////////////////////////
0369 //
0370 //  concat tuple <12 member> class
0371 //
0372 ///////////////////////////////////////////////////////////////////////////////
0373 template <
0374     typename A, typename B, typename C, typename D, typename E, typename F,
0375     typename G, typename H, typename I, typename J, typename K, typename L,
0376     typename AppendT
0377 >
0378 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, AppendT> {
0379 
0380     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, AppendT> type;
0381 };
0382 
0383 template <
0384     typename A, typename B, typename C, typename D, typename E, typename F,
0385     typename G, typename H, typename I, typename J, typename K, typename L
0386 >
0387 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, nil_t> {
0388 
0389     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L> type;
0390 };
0391 
0392 ///////////////////////////////////////////////////////////////////////////////
0393 //
0394 //  concat tuple <13 member> class
0395 //
0396 ///////////////////////////////////////////////////////////////////////////////
0397 template <
0398     typename A, typename B, typename C, typename D, typename E, typename F,
0399     typename G, typename H, typename I, typename J, typename K, typename L,
0400     typename M,
0401     typename AppendT
0402 >
0403 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, AppendT> {
0404 
0405     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, AppendT> type;
0406 };
0407 
0408 template <
0409     typename A, typename B, typename C, typename D, typename E, typename F,
0410     typename G, typename H, typename I, typename J, typename K, typename L,
0411     typename M
0412 >
0413 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, nil_t> {
0414 
0415     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> type;
0416 };
0417 
0418 ///////////////////////////////////////////////////////////////////////////////
0419 //
0420 //  concat tuple <14 member> class
0421 //
0422 ///////////////////////////////////////////////////////////////////////////////
0423 template <
0424     typename A, typename B, typename C, typename D, typename E, typename F,
0425     typename G, typename H, typename I, typename J, typename K, typename L,
0426     typename M, typename N,
0427     typename AppendT
0428 >
0429 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, AppendT> {
0430 
0431     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, AppendT> type;
0432 };
0433 
0434 template <
0435     typename A, typename B, typename C, typename D, typename E, typename F,
0436     typename G, typename H, typename I, typename J, typename K, typename L,
0437     typename M, typename N
0438 >
0439 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, nil_t> {
0440 
0441     typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> type;
0442 };
0443 
0444 #endif
0445 #endif
0446 #endif
0447 #endif
0448 
0449 ///////////////////////////////////////////////////////////////////////////////
0450 //
0451 //  concat_tuples type computer
0452 //
0453 //      This template class returns the type of a tuple built from the
0454 //      concatenation of two given tuples.
0455 //
0456 ///////////////////////////////////////////////////////////////////////////////
0457 template <typename TupleT1, typename TupleT2, int N, typename AppendT>
0458 struct concat_tuple_element {
0459 
0460     typedef
0461         typename concat_tuple_element<
0462                 typename concat_tuple<TupleT1, AppendT>::type, TupleT2, N+1,
0463                 typename tuple_element<N+1, TupleT2>::type
0464             >::type
0465         type;
0466 };
0467 
0468 template <typename TupleT1, typename TupleT2, int N>
0469 struct concat_tuple_element<TupleT1, TupleT2, N, nil_t> {
0470 
0471     typedef TupleT1 type;
0472 };
0473 
0474 template <typename TupleT1, typename TupleT2>
0475 struct concat_tuples {
0476 
0477     typedef
0478         typename concat_tuple_element<
0479                 TupleT1, TupleT2, 0,
0480                 typename tuple_element<0, TupleT2>::type
0481             >::type
0482         type;
0483 };
0484 
0485 ///////////////////////////////////////////////////////////////////////////////
0486 //
0487 //  convert_actors template function
0488 //
0489 //      The convert_actors template functions constructs a new tuple object
0490 //      composed of the elements returned by the actors contained in the
0491 //      input tuple. (i.e. the given tuple type 'actor_tuple' contains a set
0492 //      of actors to evaluate and the resulting tuple contains the results of
0493 //      evaluating the actors.)
0494 //
0495 ///////////////////////////////////////////////////////////////////////////////
0496 template <typename ActorT, typename TupleT>
0497 struct actor_result; // forward declaration
0498 
0499 namespace impl
0500 {
0501     template <unsigned N>
0502     struct convert_actors_ {};
0503 }
0504 
0505 template <typename TupleResultT, typename ActorTupleT>
0506 TupleResultT
0507 convert_actors(ActorTupleT const& actor_tuple)
0508 {
0509     BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length);
0510     BOOST_STATIC_CONSTANT(int, length = TupleResultT::length);
0511     return impl::convert_actors_<length>
0512         ::template apply<TupleResultT, ActorTupleT>::do_(actor_tuple);
0513 }
0514 
0515 namespace impl
0516 {
0517     template <int N, typename TupleResultT, typename ActorTupleT>
0518     struct convert_actor
0519     {
0520         typedef typename tuple_element<N, TupleResultT>::type type;
0521 
0522         template <bool C>
0523         struct is_default_t {};
0524         typedef is_default_t<true>  is_default;
0525         typedef is_default_t<false> is_not_default;
0526 
0527         static type
0528         actor_element(ActorTupleT const& /*actor_tuple*/, is_default)
0529         {
0530             return type(); // default construct
0531         }
0532 
0533         static type
0534         actor_element(ActorTupleT const& actor_tuple, is_not_default)
0535         {
0536             BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length);
0537             tuple_index<N> const idx;
0538             return actor_tuple[idx](); // apply the actor
0539         }
0540 
0541         static type
0542         do_(ActorTupleT const& actor_tuple)
0543         {
0544             return actor_element(
0545                 actor_tuple, is_default_t<(N >= ActorTupleT::length)>());
0546         }
0547     };
0548 
0549     ///////////////////////////////////////
0550     template <>
0551     struct convert_actors_<1>
0552     {
0553         template <typename TupleResultT, typename ActorTupleT>
0554         struct apply
0555         {
0556             static TupleResultT
0557             do_(ActorTupleT const& actor_tuple)
0558             {
0559                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0560 
0561                 return TupleResultT(
0562                     converter0::do_(actor_tuple)
0563                 );
0564             }
0565         };
0566     };
0567 
0568     ///////////////////////////////////////
0569     template <>
0570     struct convert_actors_<2>
0571     {
0572         template <typename TupleResultT, typename ActorTupleT>
0573         struct apply
0574         {
0575             static TupleResultT
0576             do_(ActorTupleT const& actor_tuple)
0577             {
0578                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0579                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0580 
0581                 using namespace tuple_index_names;
0582                 return TupleResultT(
0583                         converter0::do_(actor_tuple)
0584                     ,   converter1::do_(actor_tuple)
0585                 );
0586             }
0587         };
0588     };
0589 
0590     ///////////////////////////////////////
0591     template <>
0592     struct convert_actors_<3>
0593     {
0594         template <typename TupleResultT, typename ActorTupleT>
0595         struct apply
0596         {
0597             static TupleResultT
0598             do_(ActorTupleT const& actor_tuple)
0599             {
0600                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0601                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0602                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0603 
0604                 using namespace tuple_index_names;
0605                 return TupleResultT(
0606                         converter0::do_(actor_tuple)
0607                     ,   converter1::do_(actor_tuple)
0608                     ,   converter2::do_(actor_tuple)
0609                 );
0610             }
0611         };
0612     };
0613 
0614     #if PHOENIX_LIMIT > 3
0615 
0616     /////////////////////////////////////
0617     template <>
0618     struct convert_actors_<4>
0619     {
0620         template <typename TupleResultT, typename ActorTupleT>
0621         struct apply
0622         {
0623             static TupleResultT
0624             do_(ActorTupleT const& actor_tuple)
0625             {
0626                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0627                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0628                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0629                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0630 
0631                 using namespace tuple_index_names;
0632                 return TupleResultT(
0633                         converter0::do_(actor_tuple)
0634                     ,   converter1::do_(actor_tuple)
0635                     ,   converter2::do_(actor_tuple)
0636                     ,   converter3::do_(actor_tuple)
0637                 );
0638             }
0639         };
0640     };
0641 
0642     /////////////////////////////////////
0643     template <>
0644     struct convert_actors_<5>
0645     {
0646         template <typename TupleResultT, typename ActorTupleT>
0647         struct apply
0648         {
0649             static TupleResultT
0650             do_(ActorTupleT const& actor_tuple)
0651             {
0652                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0653                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0654                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0655                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0656                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0657 
0658                 using namespace tuple_index_names;
0659                 return TupleResultT(
0660                         converter0::do_(actor_tuple)
0661                     ,   converter1::do_(actor_tuple)
0662                     ,   converter2::do_(actor_tuple)
0663                     ,   converter3::do_(actor_tuple)
0664                     ,   converter4::do_(actor_tuple)
0665                 );
0666             }
0667         };
0668     };
0669 
0670     /////////////////////////////////////
0671     template <>
0672     struct convert_actors_<6>
0673     {
0674         template <typename TupleResultT, typename ActorTupleT>
0675         struct apply
0676         {
0677             static TupleResultT
0678             do_(ActorTupleT const& actor_tuple)
0679             {
0680                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0681                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0682                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0683                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0684                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0685                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0686 
0687                 using namespace tuple_index_names;
0688                 return TupleResultT(
0689                         converter0::do_(actor_tuple)
0690                     ,   converter1::do_(actor_tuple)
0691                     ,   converter2::do_(actor_tuple)
0692                     ,   converter3::do_(actor_tuple)
0693                     ,   converter4::do_(actor_tuple)
0694                     ,   converter5::do_(actor_tuple)
0695                 );
0696             }
0697         };
0698     };
0699 
0700     #if PHOENIX_LIMIT > 6
0701 
0702     /////////////////////////////////////
0703     template <>
0704     struct convert_actors_<7>
0705     {
0706         template <typename TupleResultT, typename ActorTupleT>
0707         struct apply
0708         {
0709             static TupleResultT
0710             do_(ActorTupleT const& actor_tuple)
0711             {
0712                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0713                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0714                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0715                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0716                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0717                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0718                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0719 
0720                 using namespace tuple_index_names;
0721                 return TupleResultT(
0722                         converter0::do_(actor_tuple)
0723                     ,   converter1::do_(actor_tuple)
0724                     ,   converter2::do_(actor_tuple)
0725                     ,   converter3::do_(actor_tuple)
0726                     ,   converter4::do_(actor_tuple)
0727                     ,   converter5::do_(actor_tuple)
0728                     ,   converter6::do_(actor_tuple)
0729                 );
0730             }
0731         };
0732     };
0733 
0734     /////////////////////////////////////
0735     template <>
0736     struct convert_actors_<8>
0737     {
0738         template <typename TupleResultT, typename ActorTupleT>
0739         struct apply
0740         {
0741             static TupleResultT
0742             do_(ActorTupleT const& actor_tuple)
0743             {
0744                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0745                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0746                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0747                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0748                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0749                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0750                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0751                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0752 
0753                 using namespace tuple_index_names;
0754                 return TupleResultT(
0755                         converter0::do_(actor_tuple)
0756                     ,   converter1::do_(actor_tuple)
0757                     ,   converter2::do_(actor_tuple)
0758                     ,   converter3::do_(actor_tuple)
0759                     ,   converter4::do_(actor_tuple)
0760                     ,   converter5::do_(actor_tuple)
0761                     ,   converter6::do_(actor_tuple)
0762                     ,   converter7::do_(actor_tuple)
0763                 );
0764             }
0765         };
0766     };
0767 
0768     /////////////////////////////////////
0769     template <>
0770     struct convert_actors_<9>
0771     {
0772         template <typename TupleResultT, typename ActorTupleT>
0773         struct apply
0774         {
0775             static TupleResultT
0776             do_(ActorTupleT const& actor_tuple)
0777             {
0778                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0779                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0780                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0781                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0782                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0783                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0784                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0785                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0786                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0787 
0788                 using namespace tuple_index_names;
0789                 return TupleResultT(
0790                         converter0::do_(actor_tuple)
0791                     ,   converter1::do_(actor_tuple)
0792                     ,   converter2::do_(actor_tuple)
0793                     ,   converter3::do_(actor_tuple)
0794                     ,   converter4::do_(actor_tuple)
0795                     ,   converter5::do_(actor_tuple)
0796                     ,   converter6::do_(actor_tuple)
0797                     ,   converter7::do_(actor_tuple)
0798                     ,   converter8::do_(actor_tuple)
0799                 );
0800             }
0801         };
0802     };
0803 
0804     #if PHOENIX_LIMIT > 9
0805 
0806     /////////////////////////////////////
0807     template <>
0808     struct convert_actors_<10>
0809     {
0810         template <typename TupleResultT, typename ActorTupleT>
0811         struct apply
0812         {
0813             static TupleResultT
0814             do_(ActorTupleT const& actor_tuple)
0815             {
0816                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0817                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0818                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0819                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0820                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0821                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0822                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0823                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0824                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0825                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
0826 
0827                 using namespace tuple_index_names;
0828                 return TupleResultT(
0829                         converter0::do_(actor_tuple)
0830                     ,   converter1::do_(actor_tuple)
0831                     ,   converter2::do_(actor_tuple)
0832                     ,   converter3::do_(actor_tuple)
0833                     ,   converter4::do_(actor_tuple)
0834                     ,   converter5::do_(actor_tuple)
0835                     ,   converter6::do_(actor_tuple)
0836                     ,   converter7::do_(actor_tuple)
0837                     ,   converter8::do_(actor_tuple)
0838                     ,   converter9::do_(actor_tuple)
0839                 );
0840             }
0841         };
0842     };
0843 
0844     /////////////////////////////////////
0845     template <>
0846     struct convert_actors_<11>
0847     {
0848         template <typename TupleResultT, typename ActorTupleT>
0849         struct apply
0850         {
0851             static TupleResultT
0852             do_(ActorTupleT const& actor_tuple)
0853             {
0854                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0855                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0856                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0857                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0858                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0859                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0860                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0861                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0862                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0863                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
0864                 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10;
0865 
0866                 using namespace tuple_index_names;
0867                 return TupleResultT(
0868                         converter0::do_(actor_tuple)
0869                     ,   converter1::do_(actor_tuple)
0870                     ,   converter2::do_(actor_tuple)
0871                     ,   converter3::do_(actor_tuple)
0872                     ,   converter4::do_(actor_tuple)
0873                     ,   converter5::do_(actor_tuple)
0874                     ,   converter6::do_(actor_tuple)
0875                     ,   converter7::do_(actor_tuple)
0876                     ,   converter8::do_(actor_tuple)
0877                     ,   converter9::do_(actor_tuple)
0878                     ,   converter10::do_(actor_tuple)
0879                 );
0880             }
0881         };
0882     };
0883 
0884     /////////////////////////////////////
0885     template <>
0886     struct convert_actors_<12>
0887     {
0888         template <typename TupleResultT, typename ActorTupleT>
0889         struct apply
0890         {
0891             static TupleResultT
0892             do_(ActorTupleT const& actor_tuple)
0893             {
0894                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0895                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0896                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0897                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0898                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0899                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0900                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0901                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0902                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0903                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
0904                 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10;
0905                 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11;
0906 
0907                 using namespace tuple_index_names;
0908                 return TupleResultT(
0909                         converter0::do_(actor_tuple)
0910                     ,   converter1::do_(actor_tuple)
0911                     ,   converter2::do_(actor_tuple)
0912                     ,   converter3::do_(actor_tuple)
0913                     ,   converter4::do_(actor_tuple)
0914                     ,   converter5::do_(actor_tuple)
0915                     ,   converter6::do_(actor_tuple)
0916                     ,   converter7::do_(actor_tuple)
0917                     ,   converter8::do_(actor_tuple)
0918                     ,   converter9::do_(actor_tuple)
0919                     ,   converter10::do_(actor_tuple)
0920                     ,   converter11::do_(actor_tuple)
0921                 );
0922             }
0923         };
0924     };
0925 
0926     #if PHOENIX_LIMIT > 12
0927 
0928     /////////////////////////////////////
0929     template <>
0930     struct convert_actors_<13>
0931     {
0932         template <typename TupleResultT, typename ActorTupleT>
0933         struct apply
0934         {
0935             static TupleResultT
0936             do_(ActorTupleT const& actor_tuple)
0937             {
0938                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0939                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0940                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0941                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0942                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0943                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0944                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0945                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0946                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0947                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
0948                 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10;
0949                 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11;
0950                 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12;
0951 
0952                 using namespace tuple_index_names;
0953                 return TupleResultT(
0954                         converter0::do_(actor_tuple)
0955                     ,   converter1::do_(actor_tuple)
0956                     ,   converter2::do_(actor_tuple)
0957                     ,   converter3::do_(actor_tuple)
0958                     ,   converter4::do_(actor_tuple)
0959                     ,   converter5::do_(actor_tuple)
0960                     ,   converter6::do_(actor_tuple)
0961                     ,   converter7::do_(actor_tuple)
0962                     ,   converter8::do_(actor_tuple)
0963                     ,   converter9::do_(actor_tuple)
0964                     ,   converter10::do_(actor_tuple)
0965                     ,   converter11::do_(actor_tuple)
0966                     ,   converter12::do_(actor_tuple)
0967                 );
0968             }
0969         };
0970     };
0971 
0972     ///////////////////////////////////////
0973     template <>
0974     struct convert_actors_<14>
0975     {
0976         template <typename TupleResultT, typename ActorTupleT>
0977         struct apply
0978         {
0979             static TupleResultT
0980             do_(ActorTupleT const& actor_tuple)
0981             {
0982                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
0983                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
0984                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
0985                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
0986                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
0987                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
0988                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
0989                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
0990                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
0991                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
0992                 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10;
0993                 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11;
0994                 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12;
0995                 typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13;
0996 
0997                 using namespace tuple_index_names;
0998                 return TupleResultT(
0999                         converter0::do_(actor_tuple)
1000                     ,   converter1::do_(actor_tuple)
1001                     ,   converter2::do_(actor_tuple)
1002                     ,   converter3::do_(actor_tuple)
1003                     ,   converter4::do_(actor_tuple)
1004                     ,   converter5::do_(actor_tuple)
1005                     ,   converter6::do_(actor_tuple)
1006                     ,   converter7::do_(actor_tuple)
1007                     ,   converter8::do_(actor_tuple)
1008                     ,   converter9::do_(actor_tuple)
1009                     ,   converter10::do_(actor_tuple)
1010                     ,   converter11::do_(actor_tuple)
1011                     ,   converter12::do_(actor_tuple)
1012                     ,   converter13::do_(actor_tuple)
1013                 );
1014             }
1015         };
1016     };
1017 
1018     ///////////////////////////////////////
1019     template <>
1020     struct convert_actors_<15>
1021     {
1022         template <typename TupleResultT, typename ActorTupleT>
1023         struct apply
1024         {
1025             static TupleResultT
1026             do_(ActorTupleT const& actor_tuple)
1027             {
1028                 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0;
1029                 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1;
1030                 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2;
1031                 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3;
1032                 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4;
1033                 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5;
1034                 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6;
1035                 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7;
1036                 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8;
1037                 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9;
1038                 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10;
1039                 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11;
1040                 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12;
1041                 typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13;
1042                 typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14;
1043 
1044                 using namespace tuple_index_names;
1045                 return TupleResultT(
1046                         converter0::do_(actor_tuple)
1047                     ,   converter1::do_(actor_tuple)
1048                     ,   converter2::do_(actor_tuple)
1049                     ,   converter3::do_(actor_tuple)
1050                     ,   converter4::do_(actor_tuple)
1051                     ,   converter5::do_(actor_tuple)
1052                     ,   converter6::do_(actor_tuple)
1053                     ,   converter7::do_(actor_tuple)
1054                     ,   converter8::do_(actor_tuple)
1055                     ,   converter9::do_(actor_tuple)
1056                     ,   converter10::do_(actor_tuple)
1057                     ,   converter11::do_(actor_tuple)
1058                     ,   converter12::do_(actor_tuple)
1059                     ,   converter13::do_(actor_tuple)
1060                     ,   converter14::do_(actor_tuple)
1061                 );
1062             }
1063         };
1064     };
1065 
1066     #endif
1067     #endif
1068     #endif
1069     #endif
1070 }   //  namespace impl
1071 
1072 
1073 ///////////////////////////////////////////////////////////////////////////////
1074 }   //  namespace phoenix
1075 
1076 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!