1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/functions.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,761 @@
1.4 +/*=============================================================================
1.5 + Phoenix V1.2.1
1.6 + Copyright (c) 2001-2002 Joel de Guzman
1.7 +
1.8 + Use, modification and distribution is subject to the Boost Software
1.9 + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
1.10 + http://www.boost.org/LICENSE_1_0.txt)
1.11 +==============================================================================*/
1.12 +#ifndef PHOENIX_FUNCTIONS_HPP
1.13 +#define PHOENIX_FUNCTIONS_HPP
1.14 +
1.15 +///////////////////////////////////////////////////////////////////////////////
1.16 +#include <boost/spirit/phoenix/actor.hpp>
1.17 +#include <boost/spirit/phoenix/composite.hpp>
1.18 +
1.19 +///////////////////////////////////////////////////////////////////////////////
1.20 +namespace phoenix {
1.21 +
1.22 +///////////////////////////////////////////////////////////////////////////////
1.23 +//
1.24 +// function class
1.25 +//
1.26 +// Lazy functions
1.27 +//
1.28 +// This class provides a mechanism for lazily evaluating functions.
1.29 +// Syntactically, a lazy function looks like an ordinary C/C++
1.30 +// function. The function call looks the same. However, unlike
1.31 +// ordinary functions, the actual function execution is deferred.
1.32 +// (see actor.hpp, primitives.hpp and composite.hpp for an
1.33 +// overview). For example here are sample factorial function calls:
1.34 +//
1.35 +// factorial(4)
1.36 +// factorial(arg1)
1.37 +// factorial(arg1 * 6)
1.38 +//
1.39 +// These functions are automatically lazily bound unlike ordinary
1.40 +// function pointers or functor objects that need to be explicitly
1.41 +// bound through the bind function (see binders.hpp).
1.42 +//
1.43 +// A lazy function works in conjunction with a user defined functor
1.44 +// (as usual with a member operator()). Only special forms of
1.45 +// functor objects are allowed. This is required to enable true
1.46 +// polymorphism (STL style monomorphic functors and function
1.47 +// pointers can still be used through the bind facility in
1.48 +// binders.hpp).
1.49 +//
1.50 +// This special functor is expected to have a nested template class
1.51 +// result<A...TN> (where N is the number of arguments of its
1.52 +// member operator()). The nested template class result should have
1.53 +// a typedef 'type' that reflects the return type of its member
1.54 +// operator(). This is essentially a type computer that answers the
1.55 +// metaprogramming question "Given arguments of type A...TN, what
1.56 +// will be the operator()'s return type?".
1.57 +//
1.58 +// There is a special case for functors that accept no arguments.
1.59 +// Such nullary functors are only required to define a typedef
1.60 +// result_type that reflects the return type of its operator().
1.61 +//
1.62 +// Here's an example of a simple functor that computes the
1.63 +// factorial of a number:
1.64 +//
1.65 +// struct factorial_impl {
1.66 +//
1.67 +// template <typename Arg>
1.68 +// struct result { typedef Arg type; };
1.69 +//
1.70 +// template <typename Arg>
1.71 +// Arg operator()(Arg n) const
1.72 +// { return (n <= 0) ? 1 : n * this->operator()(n-1); }
1.73 +// };
1.74 +//
1.75 +// As can be seen, the functor can be polymorphic. Its arguments
1.76 +// and return type are not fixed to a particular type. The example
1.77 +// above for example, can handle any type as long as it can carry
1.78 +// out the required operations (i.e. <=, * and -).
1.79 +//
1.80 +// We can now declare and instantiate a lazy 'factorial' function:
1.81 +//
1.82 +// function<factorial_impl> factorial;
1.83 +//
1.84 +// Invoking a lazy function 'factorial' does not immediately
1.85 +// execute the functor factorial_impl. Instead, a composite (see
1.86 +// composite.hpp) object is created and returned to the caller.
1.87 +// Example:
1.88 +//
1.89 +// factorial(arg1)
1.90 +//
1.91 +// does nothing more than return a composite. A second function
1.92 +// call will invoke the actual factorial function. Example:
1.93 +//
1.94 +// int i = 4;
1.95 +// cout << factorial(arg1)(i);
1.96 +//
1.97 +// will print out "24".
1.98 +//
1.99 +// Take note that in certain cases (e.g. for functors with state),
1.100 +// an instance may be passed on to the constructor. Example:
1.101 +//
1.102 +// function<factorial_impl> factorial(ftor);
1.103 +//
1.104 +// where ftor is an instance of factorial_impl (this is not
1.105 +// necessary in this case since factorial is a simple stateless
1.106 +// functor). Take care though when using functors with state
1.107 +// because the functors are taken in by value. It is best to keep
1.108 +// the data manipulated by a functor outside the functor itself and
1.109 +// keep a reference to this data inside the functor. Also, it is
1.110 +// best to keep functors as small as possible.
1.111 +//
1.112 +///////////////////////////////////////////////////////////////////////////////
1.113 +template <typename OperationT>
1.114 +struct function {
1.115 +
1.116 + function() : op() {}
1.117 + function(OperationT const& op_) : op(op_) {}
1.118 +
1.119 + actor<composite<OperationT> >
1.120 + operator()() const;
1.121 +
1.122 + template <typename A>
1.123 + typename impl::make_composite<OperationT, A>::type
1.124 + operator()(A const& a) const;
1.125 +
1.126 + template <typename A, typename B>
1.127 + typename impl::make_composite<OperationT, A, B>::type
1.128 + operator()(A const& a, B const& b) const;
1.129 +
1.130 + template <typename A, typename B, typename C>
1.131 + typename impl::make_composite<OperationT, A, B, C>::type
1.132 + operator()(A const& a, B const& b, C const& c) const;
1.133 +
1.134 +#if PHOENIX_LIMIT > 3
1.135 +
1.136 + template <typename A, typename B, typename C, typename D>
1.137 + typename impl::make_composite<OperationT, A, B, C, D>::type
1.138 + operator()(A const& a, B const& b, C const& c, D const& d) const;
1.139 +
1.140 + template <typename A, typename B, typename C, typename D, typename E>
1.141 + typename impl::make_composite<
1.142 + OperationT, A, B, C, D, E
1.143 + >::type
1.144 + operator()(
1.145 + A const& a, B const& b, C const& c, D const& d, E const& e
1.146 + ) const;
1.147 +
1.148 + template <
1.149 + typename A, typename B, typename C, typename D, typename E,
1.150 + typename F
1.151 + >
1.152 + typename impl::make_composite<
1.153 + OperationT, A, B, C, D, E, F
1.154 + >::type
1.155 + operator()(
1.156 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.157 + F const& f
1.158 + ) const;
1.159 +
1.160 +#if PHOENIX_LIMIT > 6
1.161 +
1.162 + template <
1.163 + typename A, typename B, typename C, typename D, typename E,
1.164 + typename F, typename G
1.165 + >
1.166 + typename impl::make_composite<
1.167 + OperationT, A, B, C, D, E, F, G
1.168 + >::type
1.169 + operator()(
1.170 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.171 + F const& f, G const& g
1.172 + ) const;
1.173 +
1.174 + template <
1.175 + typename A, typename B, typename C, typename D, typename E,
1.176 + typename F, typename G, typename H
1.177 + >
1.178 + typename impl::make_composite<
1.179 + OperationT, A, B, C, D, E, F, G, H
1.180 + >::type
1.181 + operator()(
1.182 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.183 + F const& f, G const& g, H const& h
1.184 + ) const;
1.185 +
1.186 + template <
1.187 + typename A, typename B, typename C, typename D, typename E,
1.188 + typename F, typename G, typename H, typename I
1.189 + >
1.190 + typename impl::make_composite<
1.191 + OperationT, A, B, C, D, E, F, G, H, I
1.192 + >::type
1.193 + operator()(
1.194 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.195 + F const& f, G const& g, H const& h, I const& i
1.196 + ) const;
1.197 +
1.198 +#if PHOENIX_LIMIT > 9
1.199 +
1.200 + template <
1.201 + typename A, typename B, typename C, typename D, typename E,
1.202 + typename F, typename G, typename H, typename I, typename J
1.203 + >
1.204 + typename impl::make_composite<
1.205 + OperationT, A, B, C, D, E, F, G, H, I, J
1.206 + >::type
1.207 + operator()(
1.208 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.209 + F const& f, G const& g, H const& h, I const& i, J const& j
1.210 + ) const;
1.211 +
1.212 + template <
1.213 + typename A, typename B, typename C, typename D, typename E,
1.214 + typename F, typename G, typename H, typename I, typename J,
1.215 + typename K
1.216 + >
1.217 + typename impl::make_composite<
1.218 + OperationT, A, B, C, D, E, F, G, H, I, J, K
1.219 + >::type
1.220 + operator()(
1.221 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.222 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.223 + K const& k
1.224 + ) const;
1.225 +
1.226 + template <
1.227 + typename A, typename B, typename C, typename D, typename E,
1.228 + typename F, typename G, typename H, typename I, typename J,
1.229 + typename K, typename L
1.230 + >
1.231 + typename impl::make_composite<
1.232 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L
1.233 + >::type
1.234 + operator()(
1.235 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.236 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.237 + K const& k, L const& l
1.238 + ) const;
1.239 +
1.240 +#if PHOENIX_LIMIT > 12
1.241 +
1.242 + template <
1.243 + typename A, typename B, typename C, typename D, typename E,
1.244 + typename F, typename G, typename H, typename I, typename J,
1.245 + typename K, typename L, typename M
1.246 + >
1.247 + typename impl::make_composite<
1.248 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
1.249 + >::type
1.250 + operator()(
1.251 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.252 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.253 + K const& k, L const& l, M const& m
1.254 + ) const;
1.255 +
1.256 + template <
1.257 + typename A, typename B, typename C, typename D, typename E,
1.258 + typename F, typename G, typename H, typename I, typename J,
1.259 + typename K, typename L, typename M, typename N
1.260 + >
1.261 + typename impl::make_composite<
1.262 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1.263 + >::type
1.264 + operator()(
1.265 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.266 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.267 + K const& k, L const& l, M const& m, N const& n
1.268 + ) const;
1.269 +
1.270 + template <
1.271 + typename A, typename B, typename C, typename D, typename E,
1.272 + typename F, typename G, typename H, typename I, typename J,
1.273 + typename K, typename L, typename M, typename N, typename O
1.274 + >
1.275 + typename impl::make_composite<
1.276 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1.277 + >::type
1.278 + operator()(
1.279 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.280 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.281 + K const& k, L const& l, M const& m, N const& n, O const& o
1.282 + ) const;
1.283 +
1.284 +#endif
1.285 +#endif
1.286 +#endif
1.287 +#endif
1.288 +
1.289 + OperationT op;
1.290 +};
1.291 +
1.292 +///////////////////////////////////////////////////////////////////////////////
1.293 +//
1.294 +// function class implementation
1.295 +//
1.296 +///////////////////////////////////////////////////////////////////////////////
1.297 +template <typename OperationT>
1.298 +inline actor<composite<OperationT> >
1.299 +function<OperationT>::operator()() const
1.300 +{
1.301 + return actor<composite<OperationT> >(op);
1.302 +}
1.303 +
1.304 +//////////////////////////////////
1.305 +template <typename OperationT>
1.306 +template <typename A>
1.307 +inline typename impl::make_composite<OperationT, A>::type
1.308 +function<OperationT>::operator()(A const& a) const
1.309 +{
1.310 + typedef typename impl::make_composite<OperationT, A>::composite_type ret_t;
1.311 + return ret_t
1.312 + (
1.313 + op,
1.314 + as_actor<A>::convert(a)
1.315 + );
1.316 +}
1.317 +
1.318 +//////////////////////////////////
1.319 +template <typename OperationT>
1.320 +template <typename A, typename B>
1.321 +inline typename impl::make_composite<OperationT, A, B>::type
1.322 +function<OperationT>::operator()(A const& a, B const& b) const
1.323 +{
1.324 + typedef
1.325 + typename impl::make_composite<OperationT, A, B>::composite_type
1.326 + ret_t;
1.327 +
1.328 + return ret_t(
1.329 + op,
1.330 + as_actor<A>::convert(a),
1.331 + as_actor<B>::convert(b)
1.332 + );
1.333 +}
1.334 +
1.335 +//////////////////////////////////
1.336 +template <typename OperationT>
1.337 +template <typename A, typename B, typename C>
1.338 +inline typename impl::make_composite<OperationT, A, B, C>::type
1.339 +function<OperationT>::operator()(A const& a, B const& b, C const& c) const
1.340 +{
1.341 + typedef
1.342 + typename impl::make_composite<OperationT, A, B, C>::composite_type
1.343 + ret_t;
1.344 +
1.345 + return ret_t(
1.346 + op,
1.347 + as_actor<A>::convert(a),
1.348 + as_actor<B>::convert(b),
1.349 + as_actor<C>::convert(c)
1.350 + );
1.351 +}
1.352 +
1.353 +#if PHOENIX_LIMIT > 3
1.354 +//////////////////////////////////
1.355 +template <typename OperationT>
1.356 +template <
1.357 + typename A, typename B, typename C, typename D
1.358 +>
1.359 +inline typename impl::make_composite<
1.360 + OperationT, A, B, C, D
1.361 +>::type
1.362 +function<OperationT>::operator()(
1.363 + A const& a, B const& b, C const& c, D const& d
1.364 +) const
1.365 +{
1.366 + typedef typename impl::make_composite<
1.367 + OperationT, A, B, C, D
1.368 + >::composite_type ret_t;
1.369 +
1.370 + return ret_t(
1.371 + op,
1.372 + as_actor<A>::convert(a),
1.373 + as_actor<B>::convert(b),
1.374 + as_actor<C>::convert(c),
1.375 + as_actor<D>::convert(d)
1.376 + );
1.377 +}
1.378 +
1.379 +//////////////////////////////////
1.380 +template <typename OperationT>
1.381 +template <
1.382 + typename A, typename B, typename C, typename D, typename E
1.383 +>
1.384 +inline typename impl::make_composite<
1.385 + OperationT, A, B, C, D, E
1.386 +>::type
1.387 +function<OperationT>::operator()(
1.388 + A const& a, B const& b, C const& c, D const& d, E const& e
1.389 +) const
1.390 +{
1.391 + typedef typename impl::make_composite<
1.392 + OperationT, A, B, C, D, E
1.393 + >::composite_type ret_t;
1.394 +
1.395 + return ret_t(
1.396 + op,
1.397 + as_actor<A>::convert(a),
1.398 + as_actor<B>::convert(b),
1.399 + as_actor<C>::convert(c),
1.400 + as_actor<D>::convert(d),
1.401 + as_actor<E>::convert(e)
1.402 + );
1.403 +}
1.404 +
1.405 +//////////////////////////////////
1.406 +template <typename OperationT>
1.407 +template <
1.408 + typename A, typename B, typename C, typename D, typename E,
1.409 + typename F
1.410 +>
1.411 +inline typename impl::make_composite<
1.412 + OperationT, A, B, C, D, E, F
1.413 +>::type
1.414 +function<OperationT>::operator()(
1.415 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.416 + F const& f
1.417 +) const
1.418 +{
1.419 + typedef typename impl::make_composite<
1.420 + OperationT, A, B, C, D, E, F
1.421 + >::composite_type ret_t;
1.422 +
1.423 + return ret_t(
1.424 + op,
1.425 + as_actor<A>::convert(a),
1.426 + as_actor<B>::convert(b),
1.427 + as_actor<C>::convert(c),
1.428 + as_actor<D>::convert(d),
1.429 + as_actor<E>::convert(e),
1.430 + as_actor<F>::convert(f)
1.431 + );
1.432 +}
1.433 +
1.434 +#if PHOENIX_LIMIT > 6
1.435 +
1.436 +//////////////////////////////////
1.437 +template <typename OperationT>
1.438 +template <
1.439 + typename A, typename B, typename C, typename D, typename E,
1.440 + typename F, typename G
1.441 +>
1.442 +inline typename impl::make_composite<
1.443 + OperationT, A, B, C, D, E, F, G
1.444 +>::type
1.445 +function<OperationT>::operator()(
1.446 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.447 + F const& f, G const& g
1.448 +) const
1.449 +{
1.450 + typedef typename impl::make_composite<
1.451 + OperationT, A, B, C, D, E, F, G
1.452 + >::composite_type ret_t;
1.453 +
1.454 + return ret_t(
1.455 + op,
1.456 + as_actor<A>::convert(a),
1.457 + as_actor<B>::convert(b),
1.458 + as_actor<C>::convert(c),
1.459 + as_actor<D>::convert(d),
1.460 + as_actor<E>::convert(e),
1.461 + as_actor<F>::convert(f),
1.462 + as_actor<G>::convert(g)
1.463 + );
1.464 +}
1.465 +
1.466 +//////////////////////////////////
1.467 +template <typename OperationT>
1.468 +template <
1.469 + typename A, typename B, typename C, typename D, typename E,
1.470 + typename F, typename G, typename H
1.471 +>
1.472 +inline typename impl::make_composite<
1.473 + OperationT, A, B, C, D, E, F, G, H
1.474 +>::type
1.475 +function<OperationT>::operator()(
1.476 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.477 + F const& f, G const& g, H const& h
1.478 +) const
1.479 +{
1.480 + typedef typename impl::make_composite<
1.481 + OperationT, A, B, C, D, E, F, G, H
1.482 + >::composite_type ret_t;
1.483 +
1.484 + return ret_t(
1.485 + op,
1.486 + as_actor<A>::convert(a),
1.487 + as_actor<B>::convert(b),
1.488 + as_actor<C>::convert(c),
1.489 + as_actor<D>::convert(d),
1.490 + as_actor<E>::convert(e),
1.491 + as_actor<F>::convert(f),
1.492 + as_actor<G>::convert(g),
1.493 + as_actor<H>::convert(h)
1.494 + );
1.495 +}
1.496 +
1.497 +//////////////////////////////////
1.498 +template <typename OperationT>
1.499 +template <
1.500 + typename A, typename B, typename C, typename D, typename E,
1.501 + typename F, typename G, typename H, typename I
1.502 +>
1.503 +inline typename impl::make_composite<
1.504 + OperationT, A, B, C, D, E, F, G, H, I
1.505 +>::type
1.506 +function<OperationT>::operator()(
1.507 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.508 + F const& f, G const& g, H const& h, I const& i
1.509 +) const
1.510 +{
1.511 + typedef typename impl::make_composite<
1.512 + OperationT, A, B, C, D, E, F, G, H, I
1.513 + >::composite_type ret_t;
1.514 +
1.515 + return ret_t(
1.516 + op,
1.517 + as_actor<A>::convert(a),
1.518 + as_actor<B>::convert(b),
1.519 + as_actor<C>::convert(c),
1.520 + as_actor<D>::convert(d),
1.521 + as_actor<E>::convert(e),
1.522 + as_actor<F>::convert(f),
1.523 + as_actor<G>::convert(g),
1.524 + as_actor<H>::convert(h),
1.525 + as_actor<I>::convert(i)
1.526 + );
1.527 +}
1.528 +
1.529 +#if PHOENIX_LIMIT > 9
1.530 +
1.531 +//////////////////////////////////
1.532 +template <typename OperationT>
1.533 +template <
1.534 + typename A, typename B, typename C, typename D, typename E,
1.535 + typename F, typename G, typename H, typename I, typename J
1.536 +>
1.537 +inline typename impl::make_composite<
1.538 + OperationT, A, B, C, D, E, F, G, H, I, J
1.539 +>::type
1.540 +function<OperationT>::operator()(
1.541 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.542 + F const& f, G const& g, H const& h, I const& i, J const& j
1.543 +) const
1.544 +{
1.545 + typedef typename impl::make_composite<
1.546 + OperationT, A, B, C, D, E, F, G, H, I, J
1.547 + >::composite_type ret_t;
1.548 +
1.549 + return ret_t(
1.550 + op,
1.551 + as_actor<A>::convert(a),
1.552 + as_actor<B>::convert(b),
1.553 + as_actor<C>::convert(c),
1.554 + as_actor<D>::convert(d),
1.555 + as_actor<E>::convert(e),
1.556 + as_actor<F>::convert(f),
1.557 + as_actor<G>::convert(g),
1.558 + as_actor<H>::convert(h),
1.559 + as_actor<I>::convert(i),
1.560 + as_actor<J>::convert(j)
1.561 + );
1.562 +}
1.563 +
1.564 +//////////////////////////////////
1.565 +template <typename OperationT>
1.566 +template <
1.567 + typename A, typename B, typename C, typename D, typename E,
1.568 + typename F, typename G, typename H, typename I, typename J,
1.569 + typename K
1.570 +>
1.571 +inline typename impl::make_composite<
1.572 + OperationT, A, B, C, D, E, F, G, H, I, J, K
1.573 +>::type
1.574 +function<OperationT>::operator()(
1.575 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.576 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.577 + K const& k
1.578 +) const
1.579 +{
1.580 + typedef typename impl::make_composite<
1.581 + OperationT, A, B, C, D, E, F, G, H, I, J, K
1.582 + >::composite_type ret_t;
1.583 +
1.584 + return ret_t(
1.585 + op,
1.586 + as_actor<A>::convert(a),
1.587 + as_actor<B>::convert(b),
1.588 + as_actor<C>::convert(c),
1.589 + as_actor<D>::convert(d),
1.590 + as_actor<E>::convert(e),
1.591 + as_actor<F>::convert(f),
1.592 + as_actor<G>::convert(g),
1.593 + as_actor<H>::convert(h),
1.594 + as_actor<I>::convert(i),
1.595 + as_actor<J>::convert(j),
1.596 + as_actor<K>::convert(k)
1.597 + );
1.598 +}
1.599 +
1.600 +//////////////////////////////////
1.601 +template <typename OperationT>
1.602 +template <
1.603 + typename A, typename B, typename C, typename D, typename E,
1.604 + typename F, typename G, typename H, typename I, typename J,
1.605 + typename K, typename L
1.606 +>
1.607 +inline typename impl::make_composite<
1.608 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L
1.609 +>::type
1.610 +function<OperationT>::operator()(
1.611 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.612 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.613 + K const& k, L const& l
1.614 +) const
1.615 +{
1.616 + typedef typename impl::make_composite<
1.617 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L
1.618 + >::composite_type ret_t;
1.619 +
1.620 + return ret_t(
1.621 + op,
1.622 + as_actor<A>::convert(a),
1.623 + as_actor<B>::convert(b),
1.624 + as_actor<C>::convert(c),
1.625 + as_actor<D>::convert(d),
1.626 + as_actor<E>::convert(e),
1.627 + as_actor<F>::convert(f),
1.628 + as_actor<G>::convert(g),
1.629 + as_actor<H>::convert(h),
1.630 + as_actor<I>::convert(i),
1.631 + as_actor<J>::convert(j),
1.632 + as_actor<K>::convert(k),
1.633 + as_actor<L>::convert(l)
1.634 + );
1.635 +}
1.636 +
1.637 +#if PHOENIX_LIMIT > 12
1.638 +
1.639 +//////////////////////////////////
1.640 +template <typename OperationT>
1.641 +template <
1.642 + typename A, typename B, typename C, typename D, typename E,
1.643 + typename F, typename G, typename H, typename I, typename J,
1.644 + typename K, typename L, typename M
1.645 +>
1.646 +inline typename impl::make_composite<
1.647 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
1.648 +>::type
1.649 +function<OperationT>::operator()(
1.650 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.651 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.652 + K const& k, L const& l, M const& m
1.653 +) const
1.654 +{
1.655 + typedef typename impl::make_composite<
1.656 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
1.657 + >::composite_type ret_t;
1.658 +
1.659 + return ret_t(
1.660 + op,
1.661 + as_actor<A>::convert(a),
1.662 + as_actor<B>::convert(b),
1.663 + as_actor<C>::convert(c),
1.664 + as_actor<D>::convert(d),
1.665 + as_actor<E>::convert(e),
1.666 + as_actor<F>::convert(f),
1.667 + as_actor<G>::convert(g),
1.668 + as_actor<H>::convert(h),
1.669 + as_actor<I>::convert(i),
1.670 + as_actor<J>::convert(j),
1.671 + as_actor<K>::convert(k),
1.672 + as_actor<L>::convert(l),
1.673 + as_actor<M>::convert(m)
1.674 + );
1.675 +}
1.676 +
1.677 +//////////////////////////////////
1.678 +template <typename OperationT>
1.679 +template <
1.680 + typename A, typename B, typename C, typename D, typename E,
1.681 + typename F, typename G, typename H, typename I, typename J,
1.682 + typename K, typename L, typename M, typename N
1.683 +>
1.684 +inline typename impl::make_composite<
1.685 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1.686 +>::type
1.687 +function<OperationT>::operator()(
1.688 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.689 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.690 + K const& k, L const& l, M const& m, N const& n
1.691 +) const
1.692 +{
1.693 + typedef typename impl::make_composite<
1.694 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1.695 + >::composite_type ret_t;
1.696 +
1.697 + return ret_t(
1.698 + op,
1.699 + as_actor<A>::convert(a),
1.700 + as_actor<B>::convert(b),
1.701 + as_actor<C>::convert(c),
1.702 + as_actor<D>::convert(d),
1.703 + as_actor<E>::convert(e),
1.704 + as_actor<F>::convert(f),
1.705 + as_actor<G>::convert(g),
1.706 + as_actor<H>::convert(h),
1.707 + as_actor<I>::convert(i),
1.708 + as_actor<J>::convert(j),
1.709 + as_actor<K>::convert(k),
1.710 + as_actor<L>::convert(l),
1.711 + as_actor<M>::convert(m),
1.712 + as_actor<N>::convert(n)
1.713 + );
1.714 +}
1.715 +
1.716 +//////////////////////////////////
1.717 +template <typename OperationT>
1.718 +template <
1.719 + typename A, typename B, typename C, typename D, typename E,
1.720 + typename F, typename G, typename H, typename I, typename J,
1.721 + typename K, typename L, typename M, typename N, typename O
1.722 +>
1.723 +inline typename impl::make_composite<
1.724 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1.725 +>::type
1.726 +function<OperationT>::operator()(
1.727 + A const& a, B const& b, C const& c, D const& d, E const& e,
1.728 + F const& f, G const& g, H const& h, I const& i, J const& j,
1.729 + K const& k, L const& l, M const& m, N const& n, O const& o
1.730 +) const
1.731 +{
1.732 + typedef typename impl::make_composite<
1.733 + OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1.734 + >::composite_type ret_t;
1.735 +
1.736 + return ret_t(
1.737 + op,
1.738 + as_actor<A>::convert(a),
1.739 + as_actor<B>::convert(b),
1.740 + as_actor<C>::convert(c),
1.741 + as_actor<D>::convert(d),
1.742 + as_actor<E>::convert(e),
1.743 + as_actor<F>::convert(f),
1.744 + as_actor<G>::convert(g),
1.745 + as_actor<H>::convert(h),
1.746 + as_actor<I>::convert(i),
1.747 + as_actor<J>::convert(j),
1.748 + as_actor<K>::convert(k),
1.749 + as_actor<L>::convert(l),
1.750 + as_actor<M>::convert(m),
1.751 + as_actor<N>::convert(n),
1.752 + as_actor<O>::convert(o)
1.753 + );
1.754 +}
1.755 +
1.756 +#endif
1.757 +#endif
1.758 +#endif
1.759 +#endif
1.760 +
1.761 +///////////////////////////////////////////////////////////////////////////////
1.762 +} // namespace phoenix
1.763 +
1.764 +#endif