Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/actor.hpp @ 118:770eb830ec19 emscripten

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Typo fix
author Chris Cannam
date Wed, 18 May 2016 16:14:08 +0100
parents 2665513ce2d3
children
rev   line source
Chris@16 1 /*=============================================================================
Chris@16 2 Phoenix v1.2
Chris@16 3 Copyright (c) 2001-2002 Joel de Guzman
Chris@16 4
Chris@16 5 Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16 6 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16 7 ==============================================================================*/
Chris@16 8 #ifndef PHOENIX_ACTOR_HPP
Chris@16 9 #define PHOENIX_ACTOR_HPP
Chris@16 10
Chris@16 11 ///////////////////////////////////////////////////////////////////////////////
Chris@16 12 #include <boost/spirit/home/classic/phoenix/tuples.hpp>
Chris@16 13
Chris@16 14 ///////////////////////////////////////////////////////////////////////////////
Chris@16 15 namespace phoenix {
Chris@16 16
Chris@16 17 // These are forward declared here because we cannot include impl.hpp
Chris@16 18 // or operators.hpp yet but the actor's assignment operator and index
Chris@16 19 // operator are required to be members.
Chris@16 20
Chris@16 21 //////////////////////////////////
Chris@16 22 struct assign_op;
Chris@16 23 struct index_op;
Chris@16 24
Chris@16 25 //////////////////////////////////
Chris@16 26 namespace impl {
Chris@16 27
Chris@16 28 template <typename OperationT, typename BaseT, typename B>
Chris@16 29 struct make_binary1;
Chris@16 30 }
Chris@16 31
Chris@16 32 ///////////////////////////////////////////////////////////////////////////////
Chris@16 33 //
Chris@16 34 // unpack_tuple class
Chris@16 35 //
Chris@16 36 // This class is used to unpack a supplied tuple such, that the members of
Chris@16 37 // this tuple will be handled as if they would be supplied separately.
Chris@16 38 //
Chris@16 39 ///////////////////////////////////////////////////////////////////////////////
Chris@16 40 template <typename TupleT>
Chris@16 41 struct unpack_tuple : public TupleT {
Chris@16 42
Chris@16 43 typedef TupleT tuple_t;
Chris@16 44
Chris@16 45 unpack_tuple() {}
Chris@16 46 unpack_tuple(tuple_t const &tuple_) : TupleT(tuple_) {}
Chris@16 47 };
Chris@16 48
Chris@16 49 ///////////////////////////////////////////////////////////////////////////////
Chris@16 50 //
Chris@16 51 // actor class
Chris@16 52 //
Chris@16 53 // This class is a protocol class for all actors. This class is
Chris@16 54 // essentially an interface contract. The actor class does not
Chris@16 55 // really know how how to act on anything but instead relies on the
Chris@16 56 // template parameter BaseT (from which the actor will derive from)
Chris@16 57 // to do the actual action.
Chris@16 58 //
Chris@16 59 // An actor is a functor that is capable of accepting arguments up
Chris@16 60 // to a predefined maximum. It is up to the base class to do the
Chris@16 61 // actual processing or possibly to limit the arity (no. of
Chris@16 62 // arguments) passed in. Upon invocation of the functor through a
Chris@16 63 // supplied operator(), the actor funnels the arguments passed in
Chris@16 64 // by the client into a tuple and calls the base eval member
Chris@16 65 // function.
Chris@16 66 //
Chris@16 67 // Schematically:
Chris@16 68 //
Chris@16 69 // arg0 ---------|
Chris@16 70 // arg1 ---------|
Chris@16 71 // arg2 ---------|---> tupled_args ---> base.eval
Chris@16 72 // ... |
Chris@16 73 // argN ---------|
Chris@16 74 //
Chris@16 75 // actor::operator()(arg0, arg1... argN)
Chris@16 76 // ---> BaseT::eval(tupled_args);
Chris@16 77 //
Chris@16 78 // Actor base classes from which this class inherits from are
Chris@16 79 // expected to have a corresponding member function eval compatible
Chris@16 80 // with the conceptual Interface:
Chris@16 81 //
Chris@16 82 // template <typename TupleT>
Chris@16 83 // actor_return_type
Chris@16 84 // eval(TupleT const& args) const;
Chris@16 85 //
Chris@16 86 // where args are the actual arguments passed in by the client
Chris@16 87 // funneled into a tuple (see tuple.hpp for details).
Chris@16 88 //
Chris@16 89 // The actor_return_type can be anything. Base classes are free to
Chris@16 90 // return any type, even argument dependent types (types that are
Chris@16 91 // deduced from the types of the arguments). After evaluating the
Chris@16 92 // parameters and doing some computations or actions, the eval
Chris@16 93 // member function concludes by returning something back to the
Chris@16 94 // client. To do this, the forwarding function (the actor's
Chris@16 95 // operator()) needs to know the return type of the eval member
Chris@16 96 // function that it is calling. For this purpose, actor base
Chris@16 97 // classes are required to provide a nested template class:
Chris@16 98 //
Chris@16 99 // template <typename TupleT>
Chris@16 100 // struct result;
Chris@16 101 //
Chris@16 102 // This auxiliary class provides the result type information
Chris@16 103 // returned by the eval member function of a base actor class. The
Chris@16 104 // nested template class result should have a typedef 'type' that
Chris@16 105 // reflects the return type of its member function eval. It is
Chris@16 106 // basically a type computer that answers the question "given
Chris@16 107 // arguments packed into a TupleT type, what will be the result
Chris@16 108 // type of the eval member function of ActorT?". The template class
Chris@16 109 // actor_result queries this to extract the return type of an
Chris@16 110 // actor. Example:
Chris@16 111 //
Chris@16 112 // typedef typename actor_result<ActorT, TupleT>::type
Chris@16 113 // actor_return_type;
Chris@16 114 //
Chris@16 115 // where actor_return_type is the actual type returned by ActorT's
Chris@16 116 // eval member function given some arguments in a TupleT.
Chris@16 117 //
Chris@16 118 ///////////////////////////////////////////////////////////////////////////////
Chris@16 119 template <typename ActorT, typename TupleT>
Chris@16 120 struct actor_result {
Chris@16 121
Chris@16 122 typedef typename ActorT::template result<TupleT>::type type;
Chris@16 123 typedef typename remove_reference<type>::type plain_type;
Chris@16 124 };
Chris@16 125
Chris@16 126 //////////////////////////////////
Chris@16 127 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
Chris@16 128 #pragma warning(push)
Chris@16 129 #pragma warning(disable:4512) //assignment operator could not be generated
Chris@16 130 #endif
Chris@16 131
Chris@16 132 template <typename BaseT>
Chris@16 133 struct actor : public BaseT {
Chris@16 134
Chris@16 135 actor();
Chris@16 136 actor(BaseT const& base);
Chris@16 137
Chris@16 138 typename actor_result<BaseT, tuple<> >::type
Chris@16 139 operator()() const;
Chris@16 140
Chris@16 141 template <typename A>
Chris@16 142 typename actor_result<BaseT, tuple<A&> >::type
Chris@16 143 operator()(A& a) const;
Chris@16 144
Chris@16 145 template <typename A, typename B>
Chris@16 146 typename actor_result<BaseT, tuple<A&, B&> >::type
Chris@16 147 operator()(A& a, B& b) const;
Chris@16 148
Chris@16 149 template <typename A, typename B, typename C>
Chris@16 150 typename actor_result<BaseT, tuple<A&, B&, C&> >::type
Chris@16 151 operator()(A& a, B& b, C& c) const;
Chris@16 152
Chris@16 153 #if PHOENIX_LIMIT > 3
Chris@16 154 template <typename A, typename B, typename C, typename D>
Chris@16 155 typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
Chris@16 156 operator()(A& a, B& b, C& c, D& d) const;
Chris@16 157
Chris@16 158 template <typename A, typename B, typename C, typename D, typename E>
Chris@16 159 typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
Chris@16 160 operator()(A& a, B& b, C& c, D& d, E& e) const;
Chris@16 161
Chris@16 162 template <
Chris@16 163 typename A, typename B, typename C, typename D, typename E,
Chris@16 164 typename F>
Chris@16 165 typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&> >::type
Chris@16 166 operator()(A& a, B& b, C& c, D& d, E& e, F& f) const;
Chris@16 167
Chris@16 168 #if PHOENIX_LIMIT > 6
Chris@16 169
Chris@16 170 template <
Chris@16 171 typename A, typename B, typename C, typename D, typename E,
Chris@16 172 typename F, typename G>
Chris@16 173 typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&, G&> >::type
Chris@16 174 operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g) const;
Chris@16 175
Chris@16 176 template <
Chris@16 177 typename A, typename B, typename C, typename D, typename E,
Chris@16 178 typename F, typename G, typename H>
Chris@16 179 typename actor_result<BaseT,
Chris@16 180 tuple<A&, B&, C&, D&, E&, F&, G&, H&>
Chris@16 181 >::type
Chris@16 182 operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) const;
Chris@16 183
Chris@16 184 template <
Chris@16 185 typename A, typename B, typename C, typename D, typename E,
Chris@16 186 typename F, typename G, typename H, typename I>
Chris@16 187 typename actor_result<BaseT,
Chris@16 188 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
Chris@16 189 >::type
Chris@16 190 operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) const;
Chris@16 191
Chris@16 192 #if PHOENIX_LIMIT > 9
Chris@16 193
Chris@16 194 template <
Chris@16 195 typename A, typename B, typename C, typename D, typename E,
Chris@16 196 typename F, typename G, typename H, typename I, typename J>
Chris@16 197 typename actor_result<BaseT,
Chris@16 198 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
Chris@16 199 >::type
Chris@16 200 operator()(
Chris@16 201 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) const;
Chris@16 202
Chris@16 203 template <
Chris@16 204 typename A, typename B, typename C, typename D, typename E,
Chris@16 205 typename F, typename G, typename H, typename I, typename J,
Chris@16 206 typename K>
Chris@16 207 typename actor_result<BaseT,
Chris@16 208 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
Chris@16 209 >::type
Chris@16 210 operator()(
Chris@16 211 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
Chris@16 212 K& k) const;
Chris@16 213
Chris@16 214 template <
Chris@16 215 typename A, typename B, typename C, typename D, typename E,
Chris@16 216 typename F, typename G, typename H, typename I, typename J,
Chris@16 217 typename K, typename L>
Chris@16 218 typename actor_result<BaseT,
Chris@16 219 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
Chris@16 220 >::type
Chris@16 221 operator()(
Chris@16 222 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
Chris@16 223 K& k, L& l) const;
Chris@16 224
Chris@16 225 #if PHOENIX_LIMIT > 12
Chris@16 226
Chris@16 227 template <
Chris@16 228 typename A, typename B, typename C, typename D, typename E,
Chris@16 229 typename F, typename G, typename H, typename I, typename J,
Chris@16 230 typename K, typename L, typename M>
Chris@16 231 typename actor_result<BaseT,
Chris@16 232 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
Chris@16 233 >::type
Chris@16 234 operator()(
Chris@16 235 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
Chris@16 236 K& k, L& l, M& m) const;
Chris@16 237
Chris@16 238 template <
Chris@16 239 typename A, typename B, typename C, typename D, typename E,
Chris@16 240 typename F, typename G, typename H, typename I, typename J,
Chris@16 241 typename K, typename L, typename M, typename N>
Chris@16 242 typename actor_result<BaseT,
Chris@16 243 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
Chris@16 244 >::type
Chris@16 245 operator()(
Chris@16 246 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
Chris@16 247 K& k, L& l, M& m, N& n) const;
Chris@16 248
Chris@16 249 template <
Chris@16 250 typename A, typename B, typename C, typename D, typename E,
Chris@16 251 typename F, typename G, typename H, typename I, typename J,
Chris@16 252 typename K, typename L, typename M, typename N, typename O>
Chris@16 253 typename actor_result<BaseT,
Chris@16 254 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
Chris@16 255 >::type
Chris@16 256 operator()(
Chris@16 257 A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
Chris@16 258 K& k, L& l, M& m, N& n, O& o) const;
Chris@16 259
Chris@16 260 #endif
Chris@16 261 #endif
Chris@16 262 #endif
Chris@16 263 #endif
Chris@16 264
Chris@16 265 template <typename TupleT>
Chris@16 266 typename actor_result<BaseT, unpack_tuple<TupleT> >::type
Chris@16 267 operator()(unpack_tuple<TupleT> const &t) const;
Chris@16 268
Chris@16 269 template <typename B>
Chris@16 270 typename impl::make_binary1<assign_op, BaseT, B>::type
Chris@16 271 operator=(B const& b) const;
Chris@16 272
Chris@16 273 template <typename B>
Chris@16 274 typename impl::make_binary1<index_op, BaseT, B>::type
Chris@16 275 operator[](B const& b) const;
Chris@16 276 };
Chris@16 277
Chris@16 278 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
Chris@16 279 #pragma warning(pop)
Chris@16 280 #endif
Chris@16 281
Chris@16 282 ///////////////////////////////////////////////////////////////////////////
Chris@16 283 //
Chris@16 284 // as_actor
Chris@16 285 //
Chris@16 286 // as_actor is a meta-program that converts an arbitrary type into
Chris@16 287 // an actor. All participants in the framework must be first-class
Chris@16 288 // actors. This meta-program is used all throughout the framework
Chris@16 289 // whenever an unknown type needs to be converted to an actor.
Chris@16 290 // as_actor specializations are expected to have a typedef 'type'.
Chris@16 291 // This is the destination actor type. A static member function
Chris@16 292 // 'convert' converts an object to this target type.
Chris@16 293 //
Chris@16 294 // The meta-program does no conversion if the object to be
Chris@16 295 // converted is already an actor.
Chris@16 296 //
Chris@16 297 ///////////////////////////////////////////////////////////////////////////
Chris@16 298 template <typename T>
Chris@16 299 struct as_actor;
Chris@16 300
Chris@16 301 //////////////////////////////////
Chris@16 302 template <typename BaseT>
Chris@16 303 struct as_actor<actor<BaseT> > {
Chris@16 304
Chris@16 305 typedef actor<BaseT> type;
Chris@16 306 static type convert(actor<BaseT> const& x) { return x; }
Chris@16 307 };
Chris@16 308
Chris@16 309 //////////////////////////////////
Chris@16 310 template <>
Chris@16 311 struct as_actor<nil_t> {
Chris@16 312
Chris@16 313 typedef nil_t type;
Chris@16 314 static nil_t convert(nil_t /*x*/)
Chris@16 315 { return nil_t(); }
Chris@16 316 };
Chris@16 317
Chris@16 318 //////////////////////////////////
Chris@16 319 template <>
Chris@16 320 struct as_actor<void> {
Chris@16 321
Chris@16 322 typedef void type;
Chris@16 323 // ERROR!!!
Chris@16 324 };
Chris@16 325
Chris@16 326 ///////////////////////////////////////////////////////////////////////////////
Chris@16 327 //
Chris@16 328 // actor class implementation
Chris@16 329 //
Chris@16 330 ///////////////////////////////////////////////////////////////////////////////
Chris@16 331 template <typename BaseT>
Chris@16 332 actor<BaseT>::actor()
Chris@16 333 : BaseT() {}
Chris@16 334
Chris@16 335 //////////////////////////////////
Chris@16 336 template <typename BaseT>
Chris@16 337 actor<BaseT>::actor(BaseT const& base)
Chris@16 338 : BaseT(base) {}
Chris@16 339
Chris@16 340 //////////////////////////////////
Chris@16 341 template <typename BaseT>
Chris@16 342 inline typename actor_result<BaseT, tuple<> >::type
Chris@16 343 actor<BaseT>::operator()() const
Chris@16 344 {
Chris@16 345 return BaseT::eval(tuple<>());
Chris@16 346 }
Chris@16 347
Chris@16 348 //////////////////////////////////
Chris@16 349 template <typename BaseT>
Chris@16 350 template <typename A>
Chris@16 351 inline typename actor_result<BaseT, tuple<A&> >::type
Chris@16 352 actor<BaseT>::operator()(A& a_) const
Chris@16 353 {
Chris@16 354 return BaseT::eval(tuple<A&>(a_));
Chris@16 355 }
Chris@16 356
Chris@16 357 //////////////////////////////////
Chris@16 358 template <typename BaseT>
Chris@16 359 template <typename A, typename B>
Chris@16 360 inline typename actor_result<BaseT, tuple<A&, B&> >::type
Chris@16 361 actor<BaseT>::operator()(A& a_, B& b_) const
Chris@16 362 {
Chris@16 363 return BaseT::eval(tuple<A&, B&>(a_, b_));
Chris@16 364 }
Chris@16 365
Chris@16 366 //////////////////////////////////
Chris@16 367 template <typename BaseT>
Chris@16 368 template <typename A, typename B, typename C>
Chris@16 369 inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
Chris@16 370 actor<BaseT>::operator()(A& a_, B& b_, C& c_) const
Chris@16 371 {
Chris@16 372 return BaseT::eval(tuple<A&, B&, C&>(a_, b_, c_));
Chris@16 373 }
Chris@16 374
Chris@16 375 #if PHOENIX_LIMIT > 3
Chris@16 376 //////////////////////////////////
Chris@16 377 template <typename BaseT>
Chris@16 378 template <typename A, typename B, typename C, typename D>
Chris@16 379 inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
Chris@16 380 actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_) const
Chris@16 381 {
Chris@16 382 return BaseT::eval(tuple<A&, B&, C&, D&>(a_, b_, c_, d_));
Chris@16 383 }
Chris@16 384
Chris@16 385 //////////////////////////////////
Chris@16 386 template <typename BaseT>
Chris@16 387 template <typename A, typename B, typename C, typename D, typename E>
Chris@16 388 inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
Chris@16 389 actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_, E& e_) const
Chris@16 390 {
Chris@16 391 return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a_, b_, c_, d_, e_));
Chris@16 392 }
Chris@16 393
Chris@16 394 //////////////////////////////////
Chris@16 395 template <typename BaseT>
Chris@16 396 template <
Chris@16 397 typename A, typename B, typename C, typename D, typename E,
Chris@16 398 typename F>
Chris@16 399 inline typename actor_result<BaseT,
Chris@16 400 tuple<A&, B&, C&, D&, E&, F&>
Chris@16 401 >::type
Chris@16 402 actor<BaseT>::operator()(
Chris@16 403 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_
Chris@16 404 ) const
Chris@16 405 {
Chris@16 406 return BaseT::eval(
Chris@16 407 tuple<A&, B&, C&, D&, E&, F&>
Chris@16 408 (a_, b_, c_, d_, e_, f_)
Chris@16 409 );
Chris@16 410 }
Chris@16 411
Chris@16 412 #if PHOENIX_LIMIT > 6
Chris@16 413 //////////////////////////////////
Chris@16 414 template <typename BaseT>
Chris@16 415 template <
Chris@16 416 typename A, typename B, typename C, typename D, typename E,
Chris@16 417 typename F, typename G>
Chris@16 418 inline typename actor_result<BaseT,
Chris@16 419 tuple<A&, B&, C&, D&, E&, F&, G&>
Chris@16 420 >::type
Chris@16 421 actor<BaseT>::operator()(
Chris@16 422 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_
Chris@16 423 ) const
Chris@16 424 {
Chris@16 425 return BaseT::eval(
Chris@16 426 tuple<A&, B&, C&, D&, E&, F&, G&>
Chris@16 427 (a_, b_, c_, d_, e_, f_, g_)
Chris@16 428 );
Chris@16 429 }
Chris@16 430
Chris@16 431 //////////////////////////////////
Chris@16 432 template <typename BaseT>
Chris@16 433 template <
Chris@16 434 typename A, typename B, typename C, typename D, typename E,
Chris@16 435 typename F, typename G, typename H>
Chris@16 436 inline typename actor_result<BaseT,
Chris@16 437 tuple<A&, B&, C&, D&, E&, F&, G&, H&>
Chris@16 438 >::type
Chris@16 439 actor<BaseT>::operator()(
Chris@16 440 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_
Chris@16 441 ) const
Chris@16 442 {
Chris@16 443 return BaseT::eval(
Chris@16 444 tuple<A&, B&, C&, D&, E&, F&, G&, H&>
Chris@16 445 (a_, b_, c_, d_, e_, f_, g_, h_)
Chris@16 446 );
Chris@16 447 }
Chris@16 448
Chris@16 449 //////////////////////////////////
Chris@16 450 template <typename BaseT>
Chris@16 451 template <
Chris@16 452 typename A, typename B, typename C, typename D, typename E,
Chris@16 453 typename F, typename G, typename H, typename I>
Chris@16 454 inline typename actor_result<BaseT,
Chris@16 455 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
Chris@16 456 >::type
Chris@16 457 actor<BaseT>::operator()(
Chris@16 458 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_
Chris@16 459 ) const
Chris@16 460 {
Chris@16 461 return BaseT::eval(
Chris@16 462 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
Chris@16 463 (a_, b_, c_, d_, e_, f_, g_, h_, i_)
Chris@16 464 );
Chris@16 465 }
Chris@16 466
Chris@16 467 #if PHOENIX_LIMIT > 9
Chris@16 468 //////////////////////////////////
Chris@16 469 template <typename BaseT>
Chris@16 470 template <
Chris@16 471 typename A, typename B, typename C, typename D, typename E,
Chris@16 472 typename F, typename G, typename H, typename I, typename J>
Chris@16 473 inline typename actor_result<BaseT,
Chris@16 474 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
Chris@16 475 >::type
Chris@16 476 actor<BaseT>::operator()(
Chris@16 477 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_
Chris@16 478 ) const
Chris@16 479 {
Chris@16 480 return BaseT::eval(
Chris@16 481 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
Chris@16 482 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_)
Chris@16 483 );
Chris@16 484 }
Chris@16 485
Chris@16 486 //////////////////////////////////
Chris@16 487 template <typename BaseT>
Chris@16 488 template <
Chris@16 489 typename A, typename B, typename C, typename D, typename E,
Chris@16 490 typename F, typename G, typename H, typename I, typename J,
Chris@16 491 typename K>
Chris@16 492 inline typename actor_result<BaseT,
Chris@16 493 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
Chris@16 494 >::type
Chris@16 495 actor<BaseT>::operator()(
Chris@16 496 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
Chris@16 497 K& k_
Chris@16 498 ) const
Chris@16 499 {
Chris@16 500 return BaseT::eval(
Chris@16 501 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
Chris@16 502 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_)
Chris@16 503 );
Chris@16 504 }
Chris@16 505
Chris@16 506 //////////////////////////////////
Chris@16 507 template <typename BaseT>
Chris@16 508 template <
Chris@16 509 typename A, typename B, typename C, typename D, typename E,
Chris@16 510 typename F, typename G, typename H, typename I, typename J,
Chris@16 511 typename K, typename L>
Chris@16 512 inline typename actor_result<BaseT,
Chris@16 513 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
Chris@16 514 >::type
Chris@16 515 actor<BaseT>::operator()(
Chris@16 516 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
Chris@16 517 K& k_, L& l_
Chris@16 518 ) const
Chris@16 519 {
Chris@16 520 return BaseT::eval(
Chris@16 521 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
Chris@16 522 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_)
Chris@16 523 );
Chris@16 524 }
Chris@16 525
Chris@16 526 #if PHOENIX_LIMIT > 12
Chris@16 527 //////////////////////////////////
Chris@16 528 template <typename BaseT>
Chris@16 529 template <
Chris@16 530 typename A, typename B, typename C, typename D, typename E,
Chris@16 531 typename F, typename G, typename H, typename I, typename J,
Chris@16 532 typename K, typename L, typename M>
Chris@16 533 inline typename actor_result<BaseT,
Chris@16 534 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
Chris@16 535 >::type
Chris@16 536 actor<BaseT>::operator()(
Chris@16 537 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
Chris@16 538 K& k_, L& l_, M& m_
Chris@16 539 ) const
Chris@16 540 {
Chris@16 541 return BaseT::eval(
Chris@16 542 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
Chris@16 543 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_)
Chris@16 544 );
Chris@16 545 }
Chris@16 546
Chris@16 547 //////////////////////////////////
Chris@16 548 template <typename BaseT>
Chris@16 549 template <
Chris@16 550 typename A, typename B, typename C, typename D, typename E,
Chris@16 551 typename F, typename G, typename H, typename I, typename J,
Chris@16 552 typename K, typename L, typename M, typename N>
Chris@16 553 inline typename actor_result<BaseT,
Chris@16 554 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
Chris@16 555 >::type
Chris@16 556 actor<BaseT>::operator()(
Chris@16 557 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
Chris@16 558 K& k_, L& l_, M& m_, N& n_
Chris@16 559 ) const
Chris@16 560 {
Chris@16 561 return BaseT::eval(
Chris@16 562 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
Chris@16 563 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_, n_)
Chris@16 564 );
Chris@16 565 }
Chris@16 566
Chris@16 567 //////////////////////////////////
Chris@16 568 template <typename BaseT>
Chris@16 569 template <
Chris@16 570 typename A, typename B, typename C, typename D, typename E,
Chris@16 571 typename F, typename G, typename H, typename I, typename J,
Chris@16 572 typename K, typename L, typename M, typename N, typename O>
Chris@16 573 inline typename actor_result<BaseT,
Chris@16 574 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
Chris@16 575 >::type
Chris@16 576 actor<BaseT>::operator()(
Chris@16 577 A& a_, B& b_, C& c_, D& d_, E& e_, F& f_, G& g_, H& h_, I& i_, J& j_,
Chris@16 578 K& k_, L& l_, M& m_, N& n_, O& o_
Chris@16 579 ) const
Chris@16 580 {
Chris@16 581 return BaseT::eval(
Chris@16 582 tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
Chris@16 583 (a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_, n_, o_)
Chris@16 584 );
Chris@16 585 }
Chris@16 586
Chris@16 587 #endif
Chris@16 588 #endif
Chris@16 589 #endif
Chris@16 590 #endif
Chris@16 591
Chris@16 592 //////////////////////////////////
Chris@16 593 template <typename BaseT>
Chris@16 594 template <typename TupleT>
Chris@16 595 typename actor_result<BaseT, unpack_tuple<TupleT> >::type
Chris@16 596 actor<BaseT>::operator()(unpack_tuple<TupleT> const &t) const
Chris@16 597 {
Chris@16 598 return BaseT::eval(t);
Chris@16 599 }
Chris@16 600
Chris@16 601 ///////////////////////////////////////////////////////////////////////////////
Chris@16 602 } // namespace phoenix
Chris@16 603
Chris@16 604 #endif