ceph/src/boost/libs/spirit/include/boost/spirit/home/classic/attribute/closure.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2003 Joel de Guzman
   3     Copyright (c) 2002-2003 Hartmut Kaiser
   4     http://spirit.sourceforge.net/
   5
   6   Distributed under the Boost Software License, Version 1.0. (See accompanying
   7   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8 =============================================================================*/
   9 #ifndef BOOST_SPIRIT_CLOSURE_HPP
  10 #define BOOST_SPIRIT_CLOSURE_HPP
  11
  12 ///////////////////////////////////////////////////////////////////////////////
  13 #include <boost/spirit/home/classic/namespace.hpp>
  14 #include <boost/spirit/home/classic/core/parser.hpp>
  15 #include <boost/spirit/home/classic/core/composite/composite.hpp>
  16 #include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp>
  17 #include <boost/spirit/home/classic/attribute/parametric.hpp>
  18 #include <boost/spirit/home/classic/attribute/closure_context.hpp>
  19 #include <boost/spirit/home/classic/attribute/closure_fwd.hpp>
  20
  21 #include <boost/spirit/home/classic/phoenix/closures.hpp>
  22 #include <boost/spirit/home/classic/phoenix/primitives.hpp>
  23 #include <boost/spirit/home/classic/phoenix/casts.hpp>
  24 #include <boost/spirit/home/classic/phoenix/operators.hpp>
  25 #include <boost/spirit/home/classic/phoenix/tuple_helpers.hpp>
  26
  27 #include <boost/static_assert.hpp>
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 //
  31 //  Spirit predefined maximum closure limit. This limit defines the maximum
  32 //  number of elements a closure can hold. This number defaults to 3. The
  33 //  actual maximum is rounded up in multiples of 3. Thus, if this value
  34 //  is 4, the actual limit is 6. The ultimate maximum limit in this
  35 //  implementation is 15.
  36 //
  37 //  It should NOT be greater than PHOENIX_LIMIT!
  38 //
  39 ///////////////////////////////////////////////////////////////////////////////
  40
  41 #if !defined(BOOST_SPIRIT_CLOSURE_LIMIT)
  42 #define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT
  43 #endif
  44
  45 ///////////////////////////////////////////////////////////////////////////////
  46 //
  47 // ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15
  48 //
  49 ///////////////////////////////////////////////////////////////////////////////
  50 BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT);
  51 BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15);
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54 namespace boost { namespace spirit {
  55
  56 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
  57
  58     ///////////////////////////////////////////////////////////////////////////
  59     //
  60     //  closure_context class
  61     //
  62     ///////////////////////////////////////////////////////////////////////////
  63     template <typename ClosureT>
  64     class closure_context : public parser_context_base
  65     {
  66     public:
  67
  68         typedef typename ::phoenix::tuple_element<0,
  69             typename ClosureT::tuple_t>::type attr_t;
  70         typedef ClosureT base_t;
  71         typedef closure_context_linker<closure_context<ClosureT> >
  72         context_linker_t;
  73
  74         closure_context(ClosureT const& clos)
  75         : frame(clos) {}
  76
  77         ~closure_context() {}
  78
  79         template <typename ParserT, typename ScannerT>
  80         void pre_parse(ParserT const&, ScannerT const&) {}
  81
  82         template <typename ResultT, typename ParserT, typename ScannerT>
  83         ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
  84         { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; }
  85
  86     private:
  87
  88         ::phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame;
  89     };
  90
  91     ///////////////////////////////////////////////////////////////////////////
  92     //
  93     //  init_closure_context class
  94     //
  95     //      The init_closure_context class is a special parser context type
  96     //      which additionally initializes a closure contained in the derived
  97     //      parser with values from a given tuple. Please note, that this
  98     //      given tuple does not contain the required values directly, it
  99     //      contains phoenix::actor objects. These actors have to be
 100     //      dereferenced to gain the values to be used for initialization
 101     //      (this is done by the help of the phoenix::convert_actors<>
 102     //      template).
 103     //
 104     ///////////////////////////////////////////////////////////////////////////
 105
 106     template <typename ClosureT>
 107     class init_closure_context : public parser_context_base
 108     {
 109         typedef typename ClosureT::tuple_t      tuple_t;
 110         typedef typename ClosureT::closure_t    closure_t;
 111
 112     public:
 113
 114         init_closure_context(ClosureT const& clos)
 115         : frame(clos.subject(), ::phoenix::convert_actors<tuple_t>(clos.init)) {}
 116
 117         ~init_closure_context() {}
 118
 119         template <typename ParserT, typename ScannerT>
 120         void pre_parse(ParserT const& /*p*/, ScannerT const&) {}
 121
 122         template <typename ResultT, typename ParserT, typename ScannerT>
 123         ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
 124         { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; }
 125
 126     private:
 127
 128         ::phoenix::closure_frame<closure_t> frame;
 129     };
 130
 131     ///////////////////////////////////////////////////////////////////////////
 132     //
 133     //  init_closure_parser class
 134     //
 135     ///////////////////////////////////////////////////////////////////////////
 136     template <typename ParserT, typename ActorTupleT>
 137     struct init_closure_parser
 138     : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > >
 139     {
 140         typedef init_closure_parser<ParserT, ActorTupleT>           self_t;
 141         typedef unary<ParserT, parser<self_t> >                     base_t;
 142         typedef typename ParserT::phoenix_closure_t                 closure_t;
 143         typedef typename ParserT::tuple_t                           tuple_t;
 144         typedef typename ::phoenix::tuple_element<0, tuple_t>::type   attr_t;
 145
 146         template <typename ScannerT>
 147         struct result
 148         {
 149             typedef typename match_result<ScannerT, attr_t>::type type;
 150         };
 151
 152         init_closure_parser(ParserT const& p, ActorTupleT const& init_)
 153         : base_t(p), init(init_) {}
 154
 155         template <typename ScannerT>
 156         typename parser_result<self_t, ScannerT>::type
 157         parse_main(ScannerT const& scan) const
 158         {
 159             return this->subject().parse_main(scan);
 160         }
 161
 162         template <typename ScannerT>
 163         typename parser_result<self_t, ScannerT>::type
 164         parse(ScannerT const& scan) const
 165         {
 166             typedef init_closure_context<self_t> init_context_t;
 167             typedef parser_scanner_linker<ScannerT> scanner_t;
 168             typedef closure_context_linker<init_context_t> context_t;
 169             typedef typename parser_result<self_t, ScannerT>::type result_t;
 170             BOOST_SPIRIT_CONTEXT_PARSE(
 171                 scan, *this, scanner_t, context_t, result_t);
 172         }
 173
 174         ActorTupleT init;
 175     };
 176
 177     ///////////////////////////////////////////////////////////////////////////
 178     //
 179     //  closure class
 180     //
 181     ///////////////////////////////////////////////////////////////////////////
 182     template <
 183             typename DerivedT
 184         ,   typename T0
 185         ,   typename T1
 186         ,   typename T2
 187
 188     #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 189         ,   typename T3
 190         ,   typename T4
 191         ,   typename T5
 192
 193     #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 194         ,   typename T6
 195         ,   typename T7
 196         ,   typename T8
 197
 198     #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 199         ,   typename T9
 200         ,   typename T10
 201         ,   typename T11
 202
 203     #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 204         ,   typename T12
 205         ,   typename T13
 206         ,   typename T14
 207     #endif
 208     #endif
 209     #endif
 210     #endif
 211     >
 212     struct closure :
 213         public ::phoenix::closure<
 214             T0, T1, T2
 215     #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 216         ,   T3, T4, T5
 217     #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 218         ,   T6, T7, T8
 219     #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 220         ,   T9, T10, T11
 221     #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 222         ,   T12, T13, T14
 223     #endif
 224     #endif
 225     #endif
 226     #endif
 227         >
 228     {
 229         typedef ::phoenix::closure<
 230                 T0, T1, T2
 231     #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 232             ,   T3, T4, T5
 233     #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 234             ,   T6, T7, T8
 235     #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 236             ,   T9, T10, T11
 237     #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 238             ,   T12, T13, T14
 239     #endif
 240     #endif
 241     #endif
 242     #endif
 243             > phoenix_closure_t;
 244
 245         typedef closure_context<DerivedT> context_t;
 246
 247         template <typename DerivedT2>
 248         struct aux
 249         {
 250             DerivedT2& aux_derived()
 251             { return *static_cast<DerivedT2*>(this); }
 252
 253             DerivedT2 const& aux_derived() const
 254             { return *static_cast<DerivedT2 const*>(this); }
 255
 256         // initialization functions
 257             template <typename A>
 258             init_closure_parser<
 259                 DerivedT2,
 260                 ::phoenix::tuple<
 261                     typename ::phoenix::as_actor<A>::type
 262                 >
 263             >
 264             operator()(A const &a) const
 265             {
 266                 typedef typename ::phoenix::as_actor<A>::type a_t;
 267                 typedef ::phoenix::tuple<a_t> actor_tuple_t;
 268
 269                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 270                         aux_derived(),
 271                         actor_tuple_t(
 272                             ::phoenix::as_actor<A>::convert(a)
 273                         )
 274                     );
 275             }
 276
 277             template <typename A, typename B>
 278             init_closure_parser<
 279                 DerivedT2,
 280                 ::phoenix::tuple<
 281                     typename ::phoenix::as_actor<A>::type,
 282                     typename ::phoenix::as_actor<B>::type
 283                 >
 284             >
 285             operator()(A const &a, B const &b) const
 286             {
 287                 typedef typename ::phoenix::as_actor<A>::type a_t;
 288                 typedef typename ::phoenix::as_actor<B>::type b_t;
 289                 typedef ::phoenix::tuple<a_t, b_t> actor_tuple_t;
 290
 291                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 292                         aux_derived(),
 293                         actor_tuple_t(
 294                             ::phoenix::as_actor<A>::convert(a),
 295                             ::phoenix::as_actor<B>::convert(b)
 296                         )
 297                     );
 298             }
 299
 300             template <typename A, typename B, typename C>
 301             init_closure_parser<
 302                 DerivedT2,
 303                 ::phoenix::tuple<
 304                     typename ::phoenix::as_actor<A>::type,
 305                     typename ::phoenix::as_actor<B>::type,
 306                     typename ::phoenix::as_actor<C>::type
 307                 >
 308             >
 309             operator()(A const &a, B const &b, C const &c) const
 310             {
 311                 typedef typename ::phoenix::as_actor<A>::type a_t;
 312                 typedef typename ::phoenix::as_actor<B>::type b_t;
 313                 typedef typename ::phoenix::as_actor<C>::type c_t;
 314                 typedef ::phoenix::tuple<a_t, b_t, c_t> actor_tuple_t;
 315
 316                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 317                         aux_derived(),
 318                         actor_tuple_t(
 319                             ::phoenix::as_actor<A>::convert(a),
 320                             ::phoenix::as_actor<B>::convert(b),
 321                             ::phoenix::as_actor<C>::convert(c)
 322                         )
 323                     );
 324             }
 325
 326     #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 327
 328             template <
 329                 typename A, typename B, typename C, typename D
 330             >
 331             init_closure_parser<
 332                 DerivedT2,
 333                 ::phoenix::tuple<
 334                     typename ::phoenix::as_actor<A>::type,
 335                     typename ::phoenix::as_actor<B>::type,
 336                     typename ::phoenix::as_actor<C>::type,
 337                     typename ::phoenix::as_actor<D>::type
 338                 >
 339             >
 340             operator()(
 341                 A const &a, B const &b, C const &c, D const &d
 342             ) const
 343             {
 344                 typedef typename ::phoenix::as_actor<A>::type a_t;
 345                 typedef typename ::phoenix::as_actor<B>::type b_t;
 346                 typedef typename ::phoenix::as_actor<C>::type c_t;
 347                 typedef typename ::phoenix::as_actor<D>::type d_t;
 348                 typedef ::phoenix::tuple<
 349                             a_t, b_t, c_t, d_t
 350                         > actor_tuple_t;
 351
 352                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 353                         aux_derived(),
 354                         actor_tuple_t(
 355                             ::phoenix::as_actor<A>::convert(a),
 356                             ::phoenix::as_actor<B>::convert(b),
 357                             ::phoenix::as_actor<C>::convert(c),
 358                             ::phoenix::as_actor<D>::convert(d)
 359                         )
 360                     );
 361             }
 362
 363             template <
 364                 typename A, typename B, typename C, typename D, typename E
 365             >
 366             init_closure_parser<
 367                 DerivedT2,
 368                 ::phoenix::tuple<
 369                     typename ::phoenix::as_actor<A>::type,
 370                     typename ::phoenix::as_actor<B>::type,
 371                     typename ::phoenix::as_actor<C>::type,
 372                     typename ::phoenix::as_actor<D>::type,
 373                     typename ::phoenix::as_actor<E>::type
 374                 >
 375             >
 376             operator()(
 377                 A const &a, B const &b, C const &c, D const &d, E const &e
 378             ) const
 379             {
 380                 typedef typename ::phoenix::as_actor<A>::type a_t;
 381                 typedef typename ::phoenix::as_actor<B>::type b_t;
 382                 typedef typename ::phoenix::as_actor<C>::type c_t;
 383                 typedef typename ::phoenix::as_actor<D>::type d_t;
 384                 typedef typename ::phoenix::as_actor<E>::type e_t;
 385                 typedef ::phoenix::tuple<
 386                             a_t, b_t, c_t, d_t, e_t
 387                         > actor_tuple_t;
 388
 389                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 390                         aux_derived(),
 391                         actor_tuple_t(
 392                             ::phoenix::as_actor<A>::convert(a),
 393                             ::phoenix::as_actor<B>::convert(b),
 394                             ::phoenix::as_actor<C>::convert(c),
 395                             ::phoenix::as_actor<D>::convert(d),
 396                             ::phoenix::as_actor<E>::convert(e)
 397                         )
 398                     );
 399             }
 400
 401             template <
 402                 typename A, typename B, typename C, typename D, typename E,
 403                 typename F
 404             >
 405             init_closure_parser<
 406                 DerivedT2,
 407                 ::phoenix::tuple<
 408                     typename ::phoenix::as_actor<A>::type,
 409                     typename ::phoenix::as_actor<B>::type,
 410                     typename ::phoenix::as_actor<C>::type,
 411                     typename ::phoenix::as_actor<D>::type,
 412                     typename ::phoenix::as_actor<E>::type,
 413                     typename ::phoenix::as_actor<F>::type
 414                 >
 415             >
 416             operator()(
 417                 A const &a, B const &b, C const &c, D const &d, E const &e,
 418                 F const &f
 419             ) const
 420             {
 421                 typedef typename ::phoenix::as_actor<A>::type a_t;
 422                 typedef typename ::phoenix::as_actor<B>::type b_t;
 423                 typedef typename ::phoenix::as_actor<C>::type c_t;
 424                 typedef typename ::phoenix::as_actor<D>::type d_t;
 425                 typedef typename ::phoenix::as_actor<E>::type e_t;
 426                 typedef typename ::phoenix::as_actor<F>::type f_t;
 427                 typedef ::phoenix::tuple<
 428                             a_t, b_t, c_t, d_t, e_t, f_t
 429                         > actor_tuple_t;
 430
 431                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 432                         aux_derived(),
 433                         actor_tuple_t(
 434                             ::phoenix::as_actor<A>::convert(a),
 435                             ::phoenix::as_actor<B>::convert(b),
 436                             ::phoenix::as_actor<C>::convert(c),
 437                             ::phoenix::as_actor<D>::convert(d),
 438                             ::phoenix::as_actor<E>::convert(e),
 439                             ::phoenix::as_actor<F>::convert(f)
 440                         )
 441                     );
 442             }
 443
 444     #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 445
 446             template <
 447                 typename A, typename B, typename C, typename D, typename E,
 448                 typename F, typename G
 449             >
 450             init_closure_parser<
 451                 DerivedT2,
 452                 ::phoenix::tuple<
 453                     typename ::phoenix::as_actor<A>::type,
 454                     typename ::phoenix::as_actor<B>::type,
 455                     typename ::phoenix::as_actor<C>::type,
 456                     typename ::phoenix::as_actor<D>::type,
 457                     typename ::phoenix::as_actor<E>::type,
 458                     typename ::phoenix::as_actor<F>::type,
 459                     typename ::phoenix::as_actor<G>::type
 460                 >
 461             >
 462             operator()(
 463                 A const &a, B const &b, C const &c, D const &d, E const &e,
 464                 F const &f, G const &g
 465             ) const
 466             {
 467                 typedef typename ::phoenix::as_actor<A>::type a_t;
 468                 typedef typename ::phoenix::as_actor<B>::type b_t;
 469                 typedef typename ::phoenix::as_actor<C>::type c_t;
 470                 typedef typename ::phoenix::as_actor<D>::type d_t;
 471                 typedef typename ::phoenix::as_actor<E>::type e_t;
 472                 typedef typename ::phoenix::as_actor<F>::type f_t;
 473                 typedef typename ::phoenix::as_actor<G>::type g_t;
 474                 typedef ::phoenix::tuple<
 475                             a_t, b_t, c_t, d_t, e_t, f_t, g_t
 476                         > actor_tuple_t;
 477
 478                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 479                         aux_derived(),
 480                         actor_tuple_t(
 481                             ::phoenix::as_actor<A>::convert(a),
 482                             ::phoenix::as_actor<B>::convert(b),
 483                             ::phoenix::as_actor<C>::convert(c),
 484                             ::phoenix::as_actor<D>::convert(d),
 485                             ::phoenix::as_actor<E>::convert(e),
 486                             ::phoenix::as_actor<F>::convert(f),
 487                             ::phoenix::as_actor<G>::convert(g)
 488                         )
 489                     );
 490             }
 491
 492             template <
 493                 typename A, typename B, typename C, typename D, typename E,
 494                 typename F, typename G, typename H
 495             >
 496             init_closure_parser<
 497                 DerivedT2,
 498                 ::phoenix::tuple<
 499                     typename ::phoenix::as_actor<A>::type,
 500                     typename ::phoenix::as_actor<B>::type,
 501                     typename ::phoenix::as_actor<C>::type,
 502                     typename ::phoenix::as_actor<D>::type,
 503                     typename ::phoenix::as_actor<E>::type,
 504                     typename ::phoenix::as_actor<F>::type,
 505                     typename ::phoenix::as_actor<G>::type,
 506                     typename ::phoenix::as_actor<H>::type
 507                 >
 508             >
 509             operator()(
 510                 A const &a, B const &b, C const &c, D const &d, E const &e,
 511                 F const &f, G const &g, H const &h
 512             ) const
 513             {
 514                 typedef typename ::phoenix::as_actor<A>::type a_t;
 515                 typedef typename ::phoenix::as_actor<B>::type b_t;
 516                 typedef typename ::phoenix::as_actor<C>::type c_t;
 517                 typedef typename ::phoenix::as_actor<D>::type d_t;
 518                 typedef typename ::phoenix::as_actor<E>::type e_t;
 519                 typedef typename ::phoenix::as_actor<F>::type f_t;
 520                 typedef typename ::phoenix::as_actor<G>::type g_t;
 521                 typedef typename ::phoenix::as_actor<H>::type h_t;
 522                 typedef ::phoenix::tuple<
 523                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t
 524                         > actor_tuple_t;
 525
 526                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 527                         aux_derived(),
 528                         actor_tuple_t(
 529                             ::phoenix::as_actor<A>::convert(a),
 530                             ::phoenix::as_actor<B>::convert(b),
 531                             ::phoenix::as_actor<C>::convert(c),
 532                             ::phoenix::as_actor<D>::convert(d),
 533                             ::phoenix::as_actor<E>::convert(e),
 534                             ::phoenix::as_actor<F>::convert(f),
 535                             ::phoenix::as_actor<G>::convert(g),
 536                             ::phoenix::as_actor<H>::convert(h)
 537                         )
 538                     );
 539             }
 540
 541             template <
 542                 typename A, typename B, typename C, typename D, typename E,
 543                 typename F, typename G, typename H, typename I
 544             >
 545             init_closure_parser<
 546                 DerivedT2,
 547                 ::phoenix::tuple<
 548                     typename ::phoenix::as_actor<A>::type,
 549                     typename ::phoenix::as_actor<B>::type,
 550                     typename ::phoenix::as_actor<C>::type,
 551                     typename ::phoenix::as_actor<D>::type,
 552                     typename ::phoenix::as_actor<E>::type,
 553                     typename ::phoenix::as_actor<F>::type,
 554                     typename ::phoenix::as_actor<G>::type,
 555                     typename ::phoenix::as_actor<H>::type,
 556                     typename ::phoenix::as_actor<I>::type
 557                 >
 558             >
 559             operator()(
 560                 A const &a, B const &b, C const &c, D const &d, E const &e,
 561                 F const &f, G const &g, H const &h, I const &i
 562             ) const
 563             {
 564                 typedef typename ::phoenix::as_actor<A>::type a_t;
 565                 typedef typename ::phoenix::as_actor<B>::type b_t;
 566                 typedef typename ::phoenix::as_actor<C>::type c_t;
 567                 typedef typename ::phoenix::as_actor<D>::type d_t;
 568                 typedef typename ::phoenix::as_actor<E>::type e_t;
 569                 typedef typename ::phoenix::as_actor<F>::type f_t;
 570                 typedef typename ::phoenix::as_actor<G>::type g_t;
 571                 typedef typename ::phoenix::as_actor<H>::type h_t;
 572                 typedef typename ::phoenix::as_actor<I>::type i_t;
 573                 typedef ::phoenix::tuple<
 574                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t
 575                         > actor_tuple_t;
 576
 577                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 578                         aux_derived(),
 579                         actor_tuple_t(
 580                             ::phoenix::as_actor<A>::convert(a),
 581                             ::phoenix::as_actor<B>::convert(b),
 582                             ::phoenix::as_actor<C>::convert(c),
 583                             ::phoenix::as_actor<D>::convert(d),
 584                             ::phoenix::as_actor<E>::convert(e),
 585                             ::phoenix::as_actor<F>::convert(f),
 586                             ::phoenix::as_actor<G>::convert(g),
 587                             ::phoenix::as_actor<H>::convert(h),
 588                             ::phoenix::as_actor<I>::convert(i)
 589                         )
 590                     );
 591             }
 592
 593     #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 594
 595             template <
 596                 typename A, typename B, typename C, typename D, typename E,
 597                 typename F, typename G, typename H, typename I, typename J
 598             >
 599             init_closure_parser<
 600                 DerivedT2,
 601                 ::phoenix::tuple<
 602                     typename ::phoenix::as_actor<A>::type,
 603                     typename ::phoenix::as_actor<B>::type,
 604                     typename ::phoenix::as_actor<C>::type,
 605                     typename ::phoenix::as_actor<D>::type,
 606                     typename ::phoenix::as_actor<E>::type,
 607                     typename ::phoenix::as_actor<F>::type,
 608                     typename ::phoenix::as_actor<G>::type,
 609                     typename ::phoenix::as_actor<H>::type,
 610                     typename ::phoenix::as_actor<I>::type,
 611                     typename ::phoenix::as_actor<J>::type
 612                 >
 613             >
 614             operator()(
 615                 A const &a, B const &b, C const &c, D const &d, E const &e,
 616                 F const &f, G const &g, H const &h, I const &i, J const &j
 617             ) const
 618             {
 619                 typedef typename ::phoenix::as_actor<A>::type a_t;
 620                 typedef typename ::phoenix::as_actor<B>::type b_t;
 621                 typedef typename ::phoenix::as_actor<C>::type c_t;
 622                 typedef typename ::phoenix::as_actor<D>::type d_t;
 623                 typedef typename ::phoenix::as_actor<E>::type e_t;
 624                 typedef typename ::phoenix::as_actor<F>::type f_t;
 625                 typedef typename ::phoenix::as_actor<G>::type g_t;
 626                 typedef typename ::phoenix::as_actor<H>::type h_t;
 627                 typedef typename ::phoenix::as_actor<I>::type i_t;
 628                 typedef typename ::phoenix::as_actor<J>::type j_t;
 629                 typedef ::phoenix::tuple<
 630                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t
 631                         > actor_tuple_t;
 632
 633                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 634                         aux_derived(),
 635                         actor_tuple_t(
 636                             ::phoenix::as_actor<A>::convert(a),
 637                             ::phoenix::as_actor<B>::convert(b),
 638                             ::phoenix::as_actor<C>::convert(c),
 639                             ::phoenix::as_actor<D>::convert(d),
 640                             ::phoenix::as_actor<E>::convert(e),
 641                             ::phoenix::as_actor<F>::convert(f),
 642                             ::phoenix::as_actor<G>::convert(g),
 643                             ::phoenix::as_actor<H>::convert(h),
 644                             ::phoenix::as_actor<I>::convert(i),
 645                             ::phoenix::as_actor<J>::convert(j)
 646                         )
 647                     );
 648             }
 649
 650             template <
 651                 typename A, typename B, typename C, typename D, typename E,
 652                 typename F, typename G, typename H, typename I, typename J,
 653                 typename K
 654             >
 655             init_closure_parser<
 656                 DerivedT2,
 657                 ::phoenix::tuple<
 658                     typename ::phoenix::as_actor<A>::type,
 659                     typename ::phoenix::as_actor<B>::type,
 660                     typename ::phoenix::as_actor<C>::type,
 661                     typename ::phoenix::as_actor<D>::type,
 662                     typename ::phoenix::as_actor<E>::type,
 663                     typename ::phoenix::as_actor<F>::type,
 664                     typename ::phoenix::as_actor<G>::type,
 665                     typename ::phoenix::as_actor<H>::type,
 666                     typename ::phoenix::as_actor<I>::type,
 667                     typename ::phoenix::as_actor<J>::type,
 668                     typename ::phoenix::as_actor<K>::type
 669                 >
 670             >
 671             operator()(
 672                 A const &a, B const &b, C const &c, D const &d, E const &e,
 673                 F const &f, G const &g, H const &h, I const &i, J const &j,
 674                 K const &k
 675             ) const
 676             {
 677                 typedef typename ::phoenix::as_actor<A>::type a_t;
 678                 typedef typename ::phoenix::as_actor<B>::type b_t;
 679                 typedef typename ::phoenix::as_actor<C>::type c_t;
 680                 typedef typename ::phoenix::as_actor<D>::type d_t;
 681                 typedef typename ::phoenix::as_actor<E>::type e_t;
 682                 typedef typename ::phoenix::as_actor<F>::type f_t;
 683                 typedef typename ::phoenix::as_actor<G>::type g_t;
 684                 typedef typename ::phoenix::as_actor<H>::type h_t;
 685                 typedef typename ::phoenix::as_actor<I>::type i_t;
 686                 typedef typename ::phoenix::as_actor<J>::type j_t;
 687                 typedef typename ::phoenix::as_actor<K>::type k_t;
 688                 typedef ::phoenix::tuple<
 689                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 690                             k_t
 691                         > actor_tuple_t;
 692
 693                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 694                         aux_derived(),
 695                         actor_tuple_t(
 696                             ::phoenix::as_actor<A>::convert(a),
 697                             ::phoenix::as_actor<B>::convert(b),
 698                             ::phoenix::as_actor<C>::convert(c),
 699                             ::phoenix::as_actor<D>::convert(d),
 700                             ::phoenix::as_actor<E>::convert(e),
 701                             ::phoenix::as_actor<F>::convert(f),
 702                             ::phoenix::as_actor<G>::convert(g),
 703                             ::phoenix::as_actor<H>::convert(h),
 704                             ::phoenix::as_actor<I>::convert(i),
 705                             ::phoenix::as_actor<J>::convert(j),
 706                             ::phoenix::as_actor<K>::convert(k)
 707                         )
 708                     );
 709             }
 710
 711             template <
 712                 typename A, typename B, typename C, typename D, typename E,
 713                 typename F, typename G, typename H, typename I, typename J,
 714                 typename K, typename L
 715             >
 716             init_closure_parser<
 717                 DerivedT2,
 718                 ::phoenix::tuple<
 719                     typename ::phoenix::as_actor<A>::type,
 720                     typename ::phoenix::as_actor<B>::type,
 721                     typename ::phoenix::as_actor<C>::type,
 722                     typename ::phoenix::as_actor<D>::type,
 723                     typename ::phoenix::as_actor<E>::type,
 724                     typename ::phoenix::as_actor<F>::type,
 725                     typename ::phoenix::as_actor<G>::type,
 726                     typename ::phoenix::as_actor<H>::type,
 727                     typename ::phoenix::as_actor<I>::type,
 728                     typename ::phoenix::as_actor<J>::type,
 729                     typename ::phoenix::as_actor<K>::type,
 730                     typename ::phoenix::as_actor<L>::type
 731                 >
 732             >
 733             operator()(
 734                 A const &a, B const &b, C const &c, D const &d, E const &e,
 735                 F const &f, G const &g, H const &h, I const &i, J const &j,
 736                 K const &k, L const &l
 737             ) const
 738             {
 739                 typedef typename ::phoenix::as_actor<A>::type a_t;
 740                 typedef typename ::phoenix::as_actor<B>::type b_t;
 741                 typedef typename ::phoenix::as_actor<C>::type c_t;
 742                 typedef typename ::phoenix::as_actor<D>::type d_t;
 743                 typedef typename ::phoenix::as_actor<E>::type e_t;
 744                 typedef typename ::phoenix::as_actor<F>::type f_t;
 745                 typedef typename ::phoenix::as_actor<G>::type g_t;
 746                 typedef typename ::phoenix::as_actor<H>::type h_t;
 747                 typedef typename ::phoenix::as_actor<I>::type i_t;
 748                 typedef typename ::phoenix::as_actor<J>::type j_t;
 749                 typedef typename ::phoenix::as_actor<K>::type k_t;
 750                 typedef typename ::phoenix::as_actor<L>::type l_t;
 751                 typedef ::phoenix::tuple<
 752                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 753                             k_t, l_t
 754                         > actor_tuple_t;
 755
 756                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 757                         aux_derived(),
 758                         actor_tuple_t(
 759                             ::phoenix::as_actor<A>::convert(a),
 760                             ::phoenix::as_actor<B>::convert(b),
 761                             ::phoenix::as_actor<C>::convert(c),
 762                             ::phoenix::as_actor<D>::convert(d),
 763                             ::phoenix::as_actor<E>::convert(e),
 764                             ::phoenix::as_actor<F>::convert(f),
 765                             ::phoenix::as_actor<G>::convert(g),
 766                             ::phoenix::as_actor<H>::convert(h),
 767                             ::phoenix::as_actor<I>::convert(i),
 768                             ::phoenix::as_actor<J>::convert(j),
 769                             ::phoenix::as_actor<K>::convert(k),
 770                             ::phoenix::as_actor<L>::convert(l)
 771                         )
 772                     );
 773             }
 774
 775     #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 776
 777             template <
 778                 typename A, typename B, typename C, typename D, typename E,
 779                 typename F, typename G, typename H, typename I, typename J,
 780                 typename K, typename L, typename M
 781             >
 782             init_closure_parser<
 783                 DerivedT2,
 784                 ::phoenix::tuple<
 785                     typename ::phoenix::as_actor<A>::type,
 786                     typename ::phoenix::as_actor<B>::type,
 787                     typename ::phoenix::as_actor<C>::type,
 788                     typename ::phoenix::as_actor<D>::type,
 789                     typename ::phoenix::as_actor<E>::type,
 790                     typename ::phoenix::as_actor<F>::type,
 791                     typename ::phoenix::as_actor<G>::type,
 792                     typename ::phoenix::as_actor<H>::type,
 793                     typename ::phoenix::as_actor<I>::type,
 794                     typename ::phoenix::as_actor<J>::type,
 795                     typename ::phoenix::as_actor<K>::type,
 796                     typename ::phoenix::as_actor<L>::type,
 797                     typename ::phoenix::as_actor<M>::type
 798                 >
 799             >
 800             operator()(
 801                 A const &a, B const &b, C const &c, D const &d, E const &e,
 802                 F const &f, G const &g, H const &h, I const &i, J const &j,
 803                 K const &k, L const &l, M const &m
 804             ) const
 805             {
 806                 typedef typename ::phoenix::as_actor<A>::type a_t;
 807                 typedef typename ::phoenix::as_actor<B>::type b_t;
 808                 typedef typename ::phoenix::as_actor<C>::type c_t;
 809                 typedef typename ::phoenix::as_actor<D>::type d_t;
 810                 typedef typename ::phoenix::as_actor<E>::type e_t;
 811                 typedef typename ::phoenix::as_actor<F>::type f_t;
 812                 typedef typename ::phoenix::as_actor<G>::type g_t;
 813                 typedef typename ::phoenix::as_actor<H>::type h_t;
 814                 typedef typename ::phoenix::as_actor<I>::type i_t;
 815                 typedef typename ::phoenix::as_actor<J>::type j_t;
 816                 typedef typename ::phoenix::as_actor<K>::type k_t;
 817                 typedef typename ::phoenix::as_actor<L>::type l_t;
 818                 typedef typename ::phoenix::as_actor<M>::type m_t;
 819                 typedef ::phoenix::tuple<
 820                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 821                             k_t, l_t, m_t
 822                         > actor_tuple_t;
 823
 824                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 825                         aux_derived(),
 826                         actor_tuple_t(
 827                             ::phoenix::as_actor<A>::convert(a),
 828                             ::phoenix::as_actor<B>::convert(b),
 829                             ::phoenix::as_actor<C>::convert(c),
 830                             ::phoenix::as_actor<D>::convert(d),
 831                             ::phoenix::as_actor<E>::convert(e),
 832                             ::phoenix::as_actor<F>::convert(f),
 833                             ::phoenix::as_actor<G>::convert(g),
 834                             ::phoenix::as_actor<H>::convert(h),
 835                             ::phoenix::as_actor<I>::convert(i),
 836                             ::phoenix::as_actor<J>::convert(j),
 837                             ::phoenix::as_actor<K>::convert(k),
 838                             ::phoenix::as_actor<L>::convert(l),
 839                             ::phoenix::as_actor<M>::convert(m)
 840                         )
 841                     );
 842             }
 843
 844             template <
 845                 typename A, typename B, typename C, typename D, typename E,
 846                 typename F, typename G, typename H, typename I, typename J,
 847                 typename K, typename L, typename M, typename N
 848             >
 849             init_closure_parser<
 850                 DerivedT2,
 851                 ::phoenix::tuple<
 852                     typename ::phoenix::as_actor<A>::type,
 853                     typename ::phoenix::as_actor<B>::type,
 854                     typename ::phoenix::as_actor<C>::type,
 855                     typename ::phoenix::as_actor<D>::type,
 856                     typename ::phoenix::as_actor<E>::type,
 857                     typename ::phoenix::as_actor<F>::type,
 858                     typename ::phoenix::as_actor<G>::type,
 859                     typename ::phoenix::as_actor<H>::type,
 860                     typename ::phoenix::as_actor<I>::type,
 861                     typename ::phoenix::as_actor<J>::type,
 862                     typename ::phoenix::as_actor<K>::type,
 863                     typename ::phoenix::as_actor<L>::type,
 864                     typename ::phoenix::as_actor<M>::type,
 865                     typename ::phoenix::as_actor<N>::type
 866                 >
 867             >
 868             operator()(
 869                 A const &a, B const &b, C const &c, D const &d, E const &e,
 870                 F const &f, G const &g, H const &h, I const &i, J const &j,
 871                 K const &k, L const &l, M const &m, N const &n
 872             ) const
 873             {
 874                 typedef typename ::phoenix::as_actor<A>::type a_t;
 875                 typedef typename ::phoenix::as_actor<B>::type b_t;
 876                 typedef typename ::phoenix::as_actor<C>::type c_t;
 877                 typedef typename ::phoenix::as_actor<D>::type d_t;
 878                 typedef typename ::phoenix::as_actor<E>::type e_t;
 879                 typedef typename ::phoenix::as_actor<F>::type f_t;
 880                 typedef typename ::phoenix::as_actor<G>::type g_t;
 881                 typedef typename ::phoenix::as_actor<H>::type h_t;
 882                 typedef typename ::phoenix::as_actor<I>::type i_t;
 883                 typedef typename ::phoenix::as_actor<J>::type j_t;
 884                 typedef typename ::phoenix::as_actor<K>::type k_t;
 885                 typedef typename ::phoenix::as_actor<L>::type l_t;
 886                 typedef typename ::phoenix::as_actor<M>::type m_t;
 887                 typedef typename ::phoenix::as_actor<N>::type n_t;
 888                 typedef ::phoenix::tuple<
 889                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 890                             k_t, l_t, m_t, n_t
 891                         > actor_tuple_t;
 892
 893                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 894                         aux_derived(),
 895                         actor_tuple_t(
 896                             ::phoenix::as_actor<A>::convert(a),
 897                             ::phoenix::as_actor<B>::convert(b),
 898                             ::phoenix::as_actor<C>::convert(c),
 899                             ::phoenix::as_actor<D>::convert(d),
 900                             ::phoenix::as_actor<E>::convert(e),
 901                             ::phoenix::as_actor<F>::convert(f),
 902                             ::phoenix::as_actor<G>::convert(g),
 903                             ::phoenix::as_actor<H>::convert(h),
 904                             ::phoenix::as_actor<I>::convert(i),
 905                             ::phoenix::as_actor<J>::convert(j),
 906                             ::phoenix::as_actor<K>::convert(k),
 907                             ::phoenix::as_actor<L>::convert(l),
 908                             ::phoenix::as_actor<M>::convert(m),
 909                             ::phoenix::as_actor<N>::convert(n)
 910                         )
 911                     );
 912             }
 913
 914             template <
 915                 typename A, typename B, typename C, typename D, typename E,
 916                 typename F, typename G, typename H, typename I, typename J,
 917                 typename K, typename L, typename M, typename N, typename O
 918             >
 919             init_closure_parser<
 920                 DerivedT2,
 921                 ::phoenix::tuple<
 922                     typename ::phoenix::as_actor<A>::type,
 923                     typename ::phoenix::as_actor<B>::type,
 924                     typename ::phoenix::as_actor<C>::type,
 925                     typename ::phoenix::as_actor<D>::type,
 926                     typename ::phoenix::as_actor<E>::type,
 927                     typename ::phoenix::as_actor<F>::type,
 928                     typename ::phoenix::as_actor<G>::type,
 929                     typename ::phoenix::as_actor<H>::type,
 930                     typename ::phoenix::as_actor<I>::type,
 931                     typename ::phoenix::as_actor<J>::type,
 932                     typename ::phoenix::as_actor<K>::type,
 933                     typename ::phoenix::as_actor<L>::type,
 934                     typename ::phoenix::as_actor<M>::type,
 935                     typename ::phoenix::as_actor<N>::type,
 936                     typename ::phoenix::as_actor<O>::type
 937                 >
 938             >
 939             operator()(
 940                 A const &a, B const &b, C const &c, D const &d, E const &e,
 941                 F const &f, G const &g, H const &h, I const &i, J const &j,
 942                 K const &k, L const &l, M const &m, N const &n, O const &o
 943             ) const
 944             {
 945                 typedef typename ::phoenix::as_actor<A>::type a_t;
 946                 typedef typename ::phoenix::as_actor<B>::type b_t;
 947                 typedef typename ::phoenix::as_actor<C>::type c_t;
 948                 typedef typename ::phoenix::as_actor<D>::type d_t;
 949                 typedef typename ::phoenix::as_actor<E>::type e_t;
 950                 typedef typename ::phoenix::as_actor<F>::type f_t;
 951                 typedef typename ::phoenix::as_actor<G>::type g_t;
 952                 typedef typename ::phoenix::as_actor<H>::type h_t;
 953                 typedef typename ::phoenix::as_actor<I>::type i_t;
 954                 typedef typename ::phoenix::as_actor<J>::type j_t;
 955                 typedef typename ::phoenix::as_actor<K>::type k_t;
 956                 typedef typename ::phoenix::as_actor<L>::type l_t;
 957                 typedef typename ::phoenix::as_actor<M>::type m_t;
 958                 typedef typename ::phoenix::as_actor<N>::type n_t;
 959                 typedef typename ::phoenix::as_actor<O>::type o_t;
 960                 typedef ::phoenix::tuple<
 961                             a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 962                             k_t, l_t, m_t, n_t, o_t
 963                         > actor_tuple_t;
 964
 965                 return init_closure_parser<DerivedT2, actor_tuple_t>(
 966                         aux_derived(),
 967                         actor_tuple_t(
 968                             ::phoenix::as_actor<A>::convert(a),
 969                             ::phoenix::as_actor<B>::convert(b),
 970                             ::phoenix::as_actor<C>::convert(c),
 971                             ::phoenix::as_actor<D>::convert(d),
 972                             ::phoenix::as_actor<E>::convert(e),
 973                             ::phoenix::as_actor<F>::convert(f),
 974                             ::phoenix::as_actor<G>::convert(g),
 975                             ::phoenix::as_actor<H>::convert(h),
 976                             ::phoenix::as_actor<I>::convert(i),
 977                             ::phoenix::as_actor<J>::convert(j),
 978                             ::phoenix::as_actor<K>::convert(k),
 979                             ::phoenix::as_actor<L>::convert(l),
 980                             ::phoenix::as_actor<M>::convert(m),
 981                             ::phoenix::as_actor<N>::convert(n),
 982                             ::phoenix::as_actor<O>::convert(o)
 983                         )
 984                     );
 985             }
 986
 987     #endif
 988     #endif
 989     #endif
 990     #endif
 991         };
 992
 993         ~closure() {}
 994     };
 995
 996     ///////////////////////////////////////////////////////////////////////////
 997     //
 998     //  overloads for chseq_p and str_p taking in phoenix actors
 999     //
1000     ///////////////////////////////////////////////////////////////////////////
1001     template <typename ActorT>
1002     struct container_begin
1003     {
1004         typedef container_begin<ActorT> self_t;
1005
1006         template <typename TupleT>
1007         struct result
1008         {
1009             typedef typename ::phoenix::actor_result<ActorT, TupleT>
1010                 ::plain_type::iterator type;
1011         };
1012
1013         container_begin(ActorT actor_)
1014         : actor(actor_) {}
1015
1016         template <typename TupleT>
1017         typename ::phoenix::actor_result<self_t, TupleT>::type
1018         eval(TupleT const& /*args*/) const
1019         { return actor().begin(); }
1020
1021         ActorT actor;
1022     };
1023
1024     template <typename ActorT>
1025     struct container_end
1026     {
1027         typedef container_begin<ActorT> self_t;
1028
1029         template <typename TupleT>
1030         struct result
1031         {
1032             typedef typename ::phoenix::actor_result<ActorT, TupleT>
1033                 ::plain_type::iterator type;
1034         };
1035
1036         container_end(ActorT actor_)
1037         : actor(actor_) {}
1038
1039         template <typename TupleT>
1040         typename ::phoenix::actor_result<self_t, TupleT>::type
1041         eval(TupleT const& /*args*/) const
1042         { return actor().end(); }
1043
1044         ActorT actor;
1045     };
1046
1047     template <typename BaseT>
1048     inline f_chseq<
1049         ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
1050         ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
1051     >
1052     f_chseq_p(::phoenix::actor<BaseT> const& a)
1053     {
1054         typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
1055             container_begin_t;
1056         typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
1057             container_end_t;
1058         typedef f_chseq<container_begin_t, container_end_t> result_t;
1059
1060         return result_t(container_begin_t(a), container_end_t(a));
1061     }
1062
1063     template <typename BaseT>
1064     inline f_strlit<
1065         ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
1066         ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
1067     >
1068     f_str_p(::phoenix::actor<BaseT> const& a)
1069     {
1070         typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
1071             container_begin_t;
1072         typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
1073             container_end_t;
1074         typedef f_strlit<container_begin_t, container_end_t> result_t;
1075
1076         return result_t(container_begin_t(a), container_end_t(a));
1077     }
1078
1079 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
1080
1081 }} // namespace BOOST_SPIRIT_CLASSIC_NS
1082
1083 #endif