EVOLUTION-MANAGER

Edit File: closure.hpp

/*=============================================================================
    Copyright (c) 2001-2003 Joel de Guzman
    Copyright (c) 2002-2003 Hartmut Kaiser
    http://spirit.sourceforge.net/

Distributed under the Boost Software License, Version 1.0. (See accompanying
  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef BOOST_SPIRIT_CLOSURE_HPP
#define BOOST_SPIRIT_CLOSURE_HPP

///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/core/composite/composite.hpp>
#include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp>
#include <boost/spirit/home/classic/attribute/parametric.hpp>
#include <boost/spirit/home/classic/attribute/closure_context.hpp>
#include <boost/spirit/home/classic/attribute/closure_fwd.hpp>

#include <boost/spirit/home/classic/phoenix/closures.hpp>
#include <boost/spirit/home/classic/phoenix/primitives.hpp>
#include <boost/spirit/home/classic/phoenix/casts.hpp>
#include <boost/spirit/home/classic/phoenix/operators.hpp>
#include <boost/spirit/home/classic/phoenix/tuple_helpers.hpp>

#include <boost/static_assert.hpp>

///////////////////////////////////////////////////////////////////////////////
//
//  Spirit predefined maximum closure limit. This limit defines the maximum
//  number of elements a closure can hold. This number defaults to 3. The
//  actual maximum is rounded up in multiples of 3. Thus, if this value
//  is 4, the actual limit is 6. The ultimate maximum limit in this
//  implementation is 15.
//
//  It should NOT be greater than PHOENIX_LIMIT!
//
///////////////////////////////////////////////////////////////////////////////

#if !defined(BOOST_SPIRIT_CLOSURE_LIMIT)
#define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT
#endif

///////////////////////////////////////////////////////////////////////////////
//
// ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15
//
///////////////////////////////////////////////////////////////////////////////
BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT);
BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15);

///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {

BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////
 //
 // closure_context class
 //
 ///////////////////////////////////////////////////////////////////////////
 template <typename ClosureT>
 class closure_context : public parser_context_base
 {
 public:

typedef typename ::phoenix::tuple_element<0,
 typename ClosureT::tuple_t>::type attr_t;
 typedef ClosureT base_t;
 typedef closure_context_linker<closure_context<ClosureT> >
 context_linker_t;

closure_context(ClosureT const& clos)
        : frame(clos) {}

~closure_context() {}

template <typename ParserT, typename ScannerT>
 void pre_parse(ParserT const&, ScannerT const&) {}

template <typename ResultT, typename ParserT, typename ScannerT>
 ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
 { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; }

private:

::phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame;
 };

///////////////////////////////////////////////////////////////////////////
 //
 // init_closure_context class
 //
 // The init_closure_context class is a special parser context type
 // which additionally initializes a closure contained in the derived
 // parser with values from a given tuple. Please note, that this
 // given tuple does not contain the required values directly, it
 // contains phoenix::actor objects. These actors have to be
 // dereferenced to gain the values to be used for initialization
 // (this is done by the help of the phoenix::convert_actors<>
 // template).
 //
 ///////////////////////////////////////////////////////////////////////////

template <typename ClosureT>
 class init_closure_context : public parser_context_base
 {
 typedef typename ClosureT::tuple_t tuple_t;
 typedef typename ClosureT::closure_t closure_t;

public:

init_closure_context(ClosureT const& clos)
 : frame(clos.subject(), ::phoenix::convert_actors<tuple_t>(clos.init)) {}

~init_closure_context() {}

template <typename ParserT, typename ScannerT>
 void pre_parse(ParserT const& /*p*/, ScannerT const&) {}

private:

::phoenix::closure_frame<closure_t> frame;
 };

///////////////////////////////////////////////////////////////////////////
 //
 // init_closure_parser class
 //
 ///////////////////////////////////////////////////////////////////////////
 template <typename ParserT, typename ActorTupleT>
 struct init_closure_parser
 : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > >
 {
 typedef init_closure_parser<ParserT, ActorTupleT> self_t;
 typedef unary<ParserT, parser<self_t> > base_t;
 typedef typename ParserT::phoenix_closure_t closure_t;
 typedef typename ParserT::tuple_t tuple_t;
 typedef typename ::phoenix::tuple_element<0, tuple_t>::type attr_t;

template <typename ScannerT>
 struct result
 {
 typedef typename match_result<ScannerT, attr_t>::type type;
 };

init_closure_parser(ParserT const& p, ActorTupleT const& init_)
        : base_t(p), init(init_) {}

template <typename ScannerT>
 typename parser_result<self_t, ScannerT>::type
 parse_main(ScannerT const& scan) const
 {
 return this->subject().parse_main(scan);
 }

template <typename ScannerT>
 typename parser_result<self_t, ScannerT>::type
 parse(ScannerT const& scan) const
 {
 typedef init_closure_context<self_t> init_context_t;
 typedef parser_scanner_linker<ScannerT> scanner_t;
 typedef closure_context_linker<init_context_t> context_t;
 typedef typename parser_result<self_t, ScannerT>::type result_t;
 BOOST_SPIRIT_CONTEXT_PARSE(
 scan, *this, scanner_t, context_t, result_t);
 }

ActorTupleT init;
    };

///////////////////////////////////////////////////////////////////////////
 //
 // closure class
 //
 ///////////////////////////////////////////////////////////////////////////
 template <
 typename DerivedT
 , typename T0
 , typename T1
 , typename T2

#if BOOST_SPIRIT_CLOSURE_LIMIT > 3
        ,   typename T3
        ,   typename T4
        ,   typename T5

#if BOOST_SPIRIT_CLOSURE_LIMIT > 6
        ,   typename T6
        ,   typename T7
        ,   typename T8

#if BOOST_SPIRIT_CLOSURE_LIMIT > 9
        ,   typename T9
        ,   typename T10
        ,   typename T11

#if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 , typename T12
 , typename T13
 , typename T14
 #endif
 #endif
 #endif
 #endif
 >
 struct closure :
 public ::phoenix::closure<
 T0, T1, T2
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 , T3, T4, T5
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 , T6, T7, T8
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 , T9, T10, T11
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 , T12, T13, T14
 #endif
 #endif
 #endif
 #endif
 >
 {
 typedef ::phoenix::closure<
 T0, T1, T2
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
 , T3, T4, T5
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
 , T6, T7, T8
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
 , T9, T10, T11
 #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
 , T12, T13, T14
 #endif
 #endif
 #endif
 #endif
 > phoenix_closure_t;

typedef closure_context<DerivedT> context_t;

template <typename DerivedT2>
 struct aux
 {
 DerivedT2& aux_derived()
 { return *static_cast<DerivedT2*>(this); }

DerivedT2 const& aux_derived() const
 { return *static_cast<DerivedT2 const*>(this); }

// initialization functions
 template <typename A>
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type
 >
 >
 operator()(A const &a) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef ::phoenix::tuple<a_t> actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a)
 )
 );
 }

template <typename A, typename B>
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type
 >
 >
 operator()(A const &a, B const &b) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef ::phoenix::tuple<a_t, b_t> actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b)
 )
 );
 }

template <typename A, typename B, typename C>
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type
 >
 >
 operator()(A const &a, B const &b, C const &c) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef ::phoenix::tuple<a_t, b_t, c_t> actor_tuple_t;

#if BOOST_SPIRIT_CLOSURE_LIMIT > 3

template <
 typename A, typename B, typename C, typename D
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t
 > actor_tuple_t;

template <
 typename A, typename B, typename C, typename D, typename E
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t
 > actor_tuple_t;

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t
 > actor_tuple_t;

#if BOOST_SPIRIT_CLOSURE_LIMIT > 6

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t
 > actor_tuple_t;

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t
 > actor_tuple_t;

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t
 > actor_tuple_t;

#if BOOST_SPIRIT_CLOSURE_LIMIT > 9

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j)
 )
 );
 }

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J,
 typename K
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type,
 typename ::phoenix::as_actor<K>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j,
 K const &k
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef typename ::phoenix::as_actor<K>::type k_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 k_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j),
 ::phoenix::as_actor<K>::convert(k)
 )
 );
 }

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J,
 typename K, typename L
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type,
 typename ::phoenix::as_actor<K>::type,
 typename ::phoenix::as_actor<L>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j,
 K const &k, L const &l
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef typename ::phoenix::as_actor<K>::type k_t;
 typedef typename ::phoenix::as_actor<L>::type l_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 k_t, l_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j),
 ::phoenix::as_actor<K>::convert(k),
 ::phoenix::as_actor<L>::convert(l)
 )
 );
 }

#if BOOST_SPIRIT_CLOSURE_LIMIT > 12

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J,
 typename K, typename L, typename M
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type,
 typename ::phoenix::as_actor<K>::type,
 typename ::phoenix::as_actor<L>::type,
 typename ::phoenix::as_actor<M>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j,
 K const &k, L const &l, M const &m
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef typename ::phoenix::as_actor<K>::type k_t;
 typedef typename ::phoenix::as_actor<L>::type l_t;
 typedef typename ::phoenix::as_actor<M>::type m_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 k_t, l_t, m_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j),
 ::phoenix::as_actor<K>::convert(k),
 ::phoenix::as_actor<L>::convert(l),
 ::phoenix::as_actor<M>::convert(m)
 )
 );
 }

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J,
 typename K, typename L, typename M, typename N
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type,
 typename ::phoenix::as_actor<K>::type,
 typename ::phoenix::as_actor<L>::type,
 typename ::phoenix::as_actor<M>::type,
 typename ::phoenix::as_actor<N>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j,
 K const &k, L const &l, M const &m, N const &n
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef typename ::phoenix::as_actor<K>::type k_t;
 typedef typename ::phoenix::as_actor<L>::type l_t;
 typedef typename ::phoenix::as_actor<M>::type m_t;
 typedef typename ::phoenix::as_actor<N>::type n_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 k_t, l_t, m_t, n_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j),
 ::phoenix::as_actor<K>::convert(k),
 ::phoenix::as_actor<L>::convert(l),
 ::phoenix::as_actor<M>::convert(m),
 ::phoenix::as_actor<N>::convert(n)
 )
 );
 }

template <
 typename A, typename B, typename C, typename D, typename E,
 typename F, typename G, typename H, typename I, typename J,
 typename K, typename L, typename M, typename N, typename O
 >
 init_closure_parser<
 DerivedT2,
 ::phoenix::tuple<
 typename ::phoenix::as_actor<A>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<C>::type,
 typename ::phoenix::as_actor<D>::type,
 typename ::phoenix::as_actor<E>::type,
 typename ::phoenix::as_actor<F>::type,
 typename ::phoenix::as_actor<G>::type,
 typename ::phoenix::as_actor<H>::type,
 typename ::phoenix::as_actor::type,
 typename ::phoenix::as_actor<J>::type,
 typename ::phoenix::as_actor<K>::type,
 typename ::phoenix::as_actor<L>::type,
 typename ::phoenix::as_actor<M>::type,
 typename ::phoenix::as_actor<N>::type,
 typename ::phoenix::as_actor<O>::type
 >
 >
 operator()(
 A const &a, B const &b, C const &c, D const &d, E const &e,
 F const &f, G const &g, H const &h, I const &i, J const &j,
 K const &k, L const &l, M const &m, N const &n, O const &o
 ) const
 {
 typedef typename ::phoenix::as_actor<A>::type a_t;
 typedef typename ::phoenix::as_actor::type b_t;
 typedef typename ::phoenix::as_actor<C>::type c_t;
 typedef typename ::phoenix::as_actor<D>::type d_t;
 typedef typename ::phoenix::as_actor<E>::type e_t;
 typedef typename ::phoenix::as_actor<F>::type f_t;
 typedef typename ::phoenix::as_actor<G>::type g_t;
 typedef typename ::phoenix::as_actor<H>::type h_t;
 typedef typename ::phoenix::as_actor::type i_t;
 typedef typename ::phoenix::as_actor<J>::type j_t;
 typedef typename ::phoenix::as_actor<K>::type k_t;
 typedef typename ::phoenix::as_actor<L>::type l_t;
 typedef typename ::phoenix::as_actor<M>::type m_t;
 typedef typename ::phoenix::as_actor<N>::type n_t;
 typedef typename ::phoenix::as_actor<O>::type o_t;
 typedef ::phoenix::tuple<
 a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
 k_t, l_t, m_t, n_t, o_t
 > actor_tuple_t;

return init_closure_parser<DerivedT2, actor_tuple_t>(
 aux_derived(),
 actor_tuple_t(
 ::phoenix::as_actor<A>::convert(a),
 ::phoenix::as_actor::convert(b),
 ::phoenix::as_actor<C>::convert(c),
 ::phoenix::as_actor<D>::convert(d),
 ::phoenix::as_actor<E>::convert(e),
 ::phoenix::as_actor<F>::convert(f),
 ::phoenix::as_actor<G>::convert(g),
 ::phoenix::as_actor<H>::convert(h),
 ::phoenix::as_actor::convert(i),
 ::phoenix::as_actor<J>::convert(j),
 ::phoenix::as_actor<K>::convert(k),
 ::phoenix::as_actor<L>::convert(l),
 ::phoenix::as_actor<M>::convert(m),
 ::phoenix::as_actor<N>::convert(n),
 ::phoenix::as_actor<O>::convert(o)
 )
 );
 }

#endif
    #endif
    #endif
    #endif
        };

~closure() {}
    };

///////////////////////////////////////////////////////////////////////////
 //
 // overloads for chseq_p and str_p taking in phoenix actors
 //
 ///////////////////////////////////////////////////////////////////////////
 template <typename ActorT>
 struct container_begin
 {
 typedef container_begin<ActorT> self_t;

template <typename TupleT>
 struct result
 {
 typedef typename ::phoenix::actor_result<ActorT, TupleT>
 ::plain_type::iterator type;
 };

container_begin(ActorT actor_)
        : actor(actor_) {}

template <typename TupleT>
 typename ::phoenix::actor_result<self_t, TupleT>::type
 eval(TupleT const& /*args*/) const
 { return actor().begin(); }

ActorT actor;
    };

template <typename ActorT>
 struct container_end
 {
 typedef container_begin<ActorT> self_t;

template <typename TupleT>
 struct result
 {
 typedef typename ::phoenix::actor_result<ActorT, TupleT>
 ::plain_type::iterator type;
 };

container_end(ActorT actor_)
        : actor(actor_) {}

template <typename TupleT>
 typename ::phoenix::actor_result<self_t, TupleT>::type
 eval(TupleT const& /*args*/) const
 { return actor().end(); }

ActorT actor;
    };

template <typename BaseT>
 inline f_chseq<
 ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
 ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
 >
 f_chseq_p(::phoenix::actor<BaseT> const& a)
 {
 typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
 container_begin_t;
 typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
 container_end_t;
 typedef f_chseq<container_begin_t, container_end_t> result_t;

return result_t(container_begin_t(a), container_end_t(a));
    }

template <typename BaseT>
 inline f_strlit<
 ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >,
 ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
 >
 f_str_p(::phoenix::actor<BaseT> const& a)
 {
 typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >
 container_begin_t;
 typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > >
 container_end_t;
 typedef f_strlit<container_begin_t, container_end_t> result_t;

return result_t(container_begin_t(a), container_end_t(a));
    }

BOOST_SPIRIT_CLASSIC_NAMESPACE_END

}} // namespace BOOST_SPIRIT_CLASSIC_NS

#endif