Added boost header

test/external/boost/phoenix/operator/arithmetic.hpp

@@ -0,0 +1,54 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_ARITHMETIC_HPP
+#define BOOST_PHOENIX_OPERATOR_ARITHMETIC_HPP
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_PHOENIX_UNARY_OPERATORS(
+        (negate)
+        (unary_plus)
+        (pre_inc)
+        (pre_dec)
+        (post_inc)
+        (post_dec)
+    )
+    
+    BOOST_PHOENIX_BINARY_OPERATORS(
+        (plus_assign)
+        (minus_assign)
+        (multiplies_assign)
+        (divides_assign)
+        (modulus_assign)
+        (plus)
+        (minus)
+        (multiplies)
+        (divides)
+        (modulus)
+    )
+
+    using proto::exprns_::operator++;
+    using proto::exprns_::operator--;
+    using proto::exprns_::operator+=;
+    using proto::exprns_::operator-=;
+    using proto::exprns_::operator*=;
+    using proto::exprns_::operator/=;
+    using proto::exprns_::operator+;
+    using proto::exprns_::operator-;
+    using proto::exprns_::operator*;
+    using proto::exprns_::operator/;
+    using proto::exprns_::operator%;
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#endif

test/external/boost/phoenix/operator/bitwise.hpp

@@ -0,0 +1,49 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_BITWISE_HPP
+#define BOOST_PHOENIX_OPERATOR_BITWISE_HPP
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_PHOENIX_UNARY_OPERATORS(
+        (complement)
+    )
+    
+    BOOST_PHOENIX_BINARY_OPERATORS(
+        (bitwise_and_assign)
+        (bitwise_or_assign)
+        (bitwise_xor_assign)
+        (shift_left_assign)
+        (shift_right_assign)
+        (bitwise_and)
+        (bitwise_or)
+        (bitwise_xor)
+        (shift_left)
+        (shift_right)
+    )
+
+    using proto::exprns_::operator~;
+    using proto::exprns_::operator&=;
+    using proto::exprns_::operator|=;
+    using proto::exprns_::operator^=;
+    using proto::exprns_::operator<<=;
+    using proto::exprns_::operator>>=;
+    using proto::exprns_::operator&;
+    using proto::exprns_::operator|;
+    using proto::exprns_::operator^;
+    using proto::exprns_::operator<<;
+    using proto::exprns_::operator>>;
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#endif

test/external/boost/phoenix/operator/comparison.hpp

@@ -0,0 +1,35 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_COMPARISON_HPP
+#define BOOST_PHOENIX_OPERATOR_COMPARISON_HPP
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_PHOENIX_BINARY_OPERATORS(
+        (equal_to)
+        (not_equal_to)
+        (less_equal)
+        (greater_equal)
+        (less)
+        (greater)
+    )
+    using proto::exprns_::operator==;
+    using proto::exprns_::operator!=;
+    using proto::exprns_::operator<=;
+    using proto::exprns_::operator>=;
+    using proto::exprns_::operator<;
+    using proto::exprns_::operator>;
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#endif

test/external/boost/phoenix/operator/detail/define_operator.hpp

@@ -0,0 +1,123 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_DEFINE_OPERATOR_HPP
+#define BOOST_PHOENIX_DEFINE_OPERATOR_HPP
+
+#include <boost/phoenix/core/meta_grammar.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+
+#define BOOST_PHOENIX_UNARY_EXPRESSION(__, ___, name)                           \
+    template <typename Operand>                                                 \
+    struct name                                                                 \
+        : expr<proto::tag::name, Operand>                                       \
+    {};                                                                         \
+/**/
+
+#define BOOST_PHOENIX_UNARY_RULE(__, ___, name)                                 \
+    struct name                                                                 \
+        : expression::name<meta_grammar>                                        \
+    {};                                                                         \
+/**/
+
+#define BOOST_PHOENIX_UNARY_FUNCTIONAL(__, ___, name)                           \
+    namespace functional                                                        \
+    {                                                                           \
+        typedef                                                                 \
+            proto::functional::make_expr<proto::tag::name>                      \
+            BOOST_PP_CAT(make_, name);                                          \
+    }                                                                           \
+    namespace result_of                                                         \
+    {                                                                           \
+        template <typename Operand>                                             \
+        struct BOOST_PP_CAT(make_, name)                                        \
+            : boost::result_of<                                                 \
+                functional:: BOOST_PP_CAT(make_, name)(                         \
+                    Operand                                                     \
+                )                                                               \
+            >                                                                   \
+        {};                                                                     \
+    }                                                                           \
+    template <typename Operand>                                                 \
+    typename result_of::BOOST_PP_CAT(make_, name)<Operand>::type                \
+    inline BOOST_PP_CAT(make_, name)(Operand const & operand)                   \
+    {                                                                           \
+        return functional::BOOST_PP_CAT(make_, name)()(operand);                \
+    }                                                                           \
+/**/
+
+#define BOOST_PHOENIX_BINARY_EXPRESSION(__, ___, name)                          \
+    template <typename Lhs, typename Rhs>                                       \
+    struct name                                                                 \
+        : expr<proto::tag::name, Lhs, Rhs>                                      \
+    {};                                                                         \
+/**/
+
+#define BOOST_PHOENIX_BINARY_RULE(__, ___, name)                                \
+    struct name                                                                 \
+        : expression::name<meta_grammar, meta_grammar>                          \
+    {};                                                                         \
+/**/
+
+#define BOOST_PHOENIX_BINARY_FUNCTIONAL(__, ___, name)                          \
+    namespace functional                                                        \
+    {                                                                           \
+        typedef                                                                 \
+            proto::functional::make_expr<proto::tag::name>                      \
+            BOOST_PP_CAT(make_, name);                                          \
+    }                                                                           \
+    namespace result_of                                                         \
+    {                                                                           \
+        template <typename Lhs, typename Rhs>                                   \
+        struct BOOST_PP_CAT(make_, name)                                        \
+            : boost::result_of<                                                 \
+                functional:: BOOST_PP_CAT(make_, name)(                         \
+                    Lhs, Rhs                                                    \
+                )                                                               \
+            >                                                                   \
+        {};                                                                     \
+    }                                                                           \
+    template <typename Rhs, typename Lhs>                                       \
+    typename result_of::BOOST_PP_CAT(make_, name)<Rhs, Lhs>::type               \
+    inline BOOST_PP_CAT(make_, name)(Lhs const & lhs, Rhs const & rhs)          \
+    {                                                                           \
+        return functional::BOOST_PP_CAT(make_, name)()(lhs, rhs);               \
+    }                                                                           \
+/**/
+
+#define BOOST_PHOENIX_GRAMMAR(_, __, name)                                      \
+    template <typename Dummy>                                                   \
+    struct meta_grammar::case_<proto::tag::name, Dummy>                         \
+        : enable_rule<rule::name, Dummy>                                        \
+    {};                                                                         \
+/**/
+
+#define BOOST_PHOENIX_UNARY_OPERATORS(ops)                                      \
+    namespace expression {                                                      \
+        BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_UNARY_EXPRESSION, _, ops)           \
+    }                                                                           \
+    namespace rule {                                                            \
+        BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_UNARY_RULE, _, ops)                 \
+    }                                                                           \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_GRAMMAR, _, ops)                        \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_UNARY_FUNCTIONAL, _, ops)               \
+/**/
+
+
+#define BOOST_PHOENIX_BINARY_OPERATORS(ops)                                     \
+    namespace expression {                                                      \
+        BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_BINARY_EXPRESSION, _, ops)          \
+    }                                                                           \
+    namespace rule {                                                            \
+        BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_BINARY_RULE, _, ops)                \
+    }                                                                           \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_GRAMMAR, _, ops)                        \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_PHOENIX_BINARY_FUNCTIONAL, _, ops)              \
+/**/
+
+#endif

test/external/boost/phoenix/operator/detail/mem_fun_ptr_eval_result_of.hpp

@@ -0,0 +1,56 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+#if !BOOST_PHOENIX_IS_ITERATING
+
+#ifndef BOOST_PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_RESULT_OF_HPP
+#define BOOST_PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_RESULT_OF_HPP
+
+#define BOOST_PHOENIX_MEM_FUN_PTR_EVAL_RESULT_OF_CHILD(Z, N, D)                 \
+            typedef                                                             \
+                typename                                                        \
+                evaluator::impl<                                                \
+                    BOOST_PP_CAT(A, N)                                          \
+                  , Context                                                     \
+                  , int                                                         \
+                >::result_type                                                  \
+                BOOST_PP_CAT(child, N);                                         \
+        /**/
+
+        #define BOOST_PHOENIX_ITERATION_PARAMS                                  \
+            (3, (2, BOOST_PHOENIX_LIMIT,                                        \
+                 <boost/phoenix/operator/detail/mem_fun_ptr_eval_result_of.hpp>))
+        #include BOOST_PHOENIX_ITERATE()
+
+#undef BOOST_PHOENIX_MEM_FUN_PTR_EVAL_RESULT_OF_CHILD
+
+#endif
+
+#else
+
+        template <typename Context, BOOST_PHOENIX_typename_A>
+        struct mem_fun_ptr_eval<Context, BOOST_PHOENIX_A>
+        {
+            BOOST_PP_REPEAT(
+                BOOST_PHOENIX_ITERATION
+              , BOOST_PHOENIX_MEM_FUN_PTR_EVAL_RESULT_OF_CHILD
+              , _
+            )
+
+            typedef
+                typename boost::result_of<
+                    child1(
+                        BOOST_PP_ENUM_SHIFTED_PARAMS(
+                            BOOST_PHOENIX_ITERATION
+                          , child
+                        )
+                    )
+                >::type
+                type;
+        };
+
+#endif

test/external/boost/phoenix/operator/detail/mem_fun_ptr_gen.hpp

@@ -0,0 +1,94 @@
+
+#if !BOOST_PHOENIX_IS_ITERATING
+
+#ifndef BOOST_PHOENIX_OPERATOR_MEMBER_DETAIL_MEM_FUN_PTR_GEN_HPP
+#define BOOST_PHOENIX_OPERATOR_MEMBER_DETAIL_MEM_FUN_PTR_GEN_HPP
+
+#include <boost/phoenix/core/limits.hpp>
+#include <boost/phoenix/support/iterate.hpp>
+#include <boost/phoenix/core/expression.hpp>
+
+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
+
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen.hpp>
+
+#else
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/mem_fun_ptr_gen_" BOOST_PHOENIX_LIMIT_STR ".hpp")
+#endif
+
+/*==============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(
+    (boost)(phoenix)(mem_fun_ptr)
+  , (meta_grammar)
+    (meta_grammar)
+  , BOOST_PHOENIX_LIMIT
+)
+
+namespace boost { namespace phoenix
+{
+    namespace detail {
+        template <typename Object, typename MemPtr>
+        struct mem_fun_ptr_gen
+        {
+            mem_fun_ptr_gen(Object const& obj, MemPtr ptr)
+              : obj(obj)
+              , ptr(ptr)
+            {}
+
+            typename phoenix::expression::mem_fun_ptr<Object, MemPtr>::type const
+            operator()() const
+            {
+                return phoenix::expression::mem_fun_ptr<Object, MemPtr>::make(obj, ptr);
+            }
+
+#define BOOST_PHOENIX_ITERATION_PARAMS                                          \
+        (3, (1, BOOST_PHOENIX_MEMBER_LIMIT,                                     \
+        <boost/phoenix/operator/detail/mem_fun_ptr_gen.hpp>))                   \
+
+#include BOOST_PHOENIX_ITERATE()
+
+            Object const& obj;
+            MemPtr ptr;
+
+        };
+
+    }
+}}
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
+
+#endif
+
+#else
+            template <BOOST_PHOENIX_typename_A>
+            typename phoenix::expression::mem_fun_ptr<
+                Object
+              , MemPtr
+              , BOOST_PHOENIX_A
+            >::type const
+            operator()(BOOST_PHOENIX_A_const_ref_a) const
+            {
+                return phoenix::expression::mem_fun_ptr<
+                    Object
+                  , MemPtr
+                  , BOOST_PHOENIX_A
+                >::make(obj, ptr, BOOST_PHOENIX_a);
+            }
+#endif

test/external/boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen.hpp

@@ -0,0 +1,25 @@
+/*==============================================================================
+    Copyright (c) 2011 Hartmut Kaiser
+
+    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)
+==============================================================================*/
+
+#if !defined(BOOST_PHOENIX_PREPROCESSED_MEM_FUN_PTR_GEN)
+#define BOOST_PHOENIX_PREPROCESSED_MEM_FUN_PTR_GEN
+
+#if BOOST_PHOENIX_LIMIT <= 10
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen_10.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 20
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen_20.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 30
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen_30.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 40
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen_40.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 50
+#include <boost/phoenix/operator/detail/preprocessed/mem_fun_ptr_gen_50.hpp>
+#else
+#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"
+#endif
+
+#endif

test/external/boost/phoenix/operator/detail/undef_operator.hpp

@@ -0,0 +1,17 @@
+/*==============================================================================
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+
+#undef BOOST_PHOENIX_UNARY_RULE
+#undef BOOST_PHOENIX_UNARY_FUNCTIONAL
+#undef BOOST_PHOENIX_BINARY_RULE
+#undef BOOST_PHOENIX_BINARY_FUNCTIONAL
+#undef BOOST_PHOENIX_UNARY_EXPRESSION
+#undef BOOST_PHOENIX_BINARY_EXPRESSION
+#undef BOOST_PHOENIX_GRAMMAR
+#undef BOOST_PHOENIX_UNARY_OPERATORS
+#undef BOOST_PHOENIX_BINARY_OPERATORS
+#undef BOOST_PHOENIX_DEFINE_OPERATOR_HPP

test/external/boost/phoenix/operator/if_else.hpp

@@ -0,0 +1,50 @@
+/*==============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_IF_ELSE_HPP
+#define BOOST_PHOENIX_OPERATOR_IF_ELSE_HPP
+
+#include <boost/phoenix/core/limits.hpp>
+#include <boost/phoenix/core/meta_grammar.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    namespace tag
+    {
+        typedef proto::tag::if_else_ if_else_operator;
+    }
+
+    namespace expression
+    {
+        template <typename A0, typename A1, typename A2>
+        struct if_else_operator
+            : expr<tag::if_else_operator, A0, A1, A2>
+        {};
+    }
+
+    namespace rule
+    {
+        struct if_else_operator
+            : expression::if_else_operator<
+                meta_grammar
+              , meta_grammar
+              , meta_grammar
+            >
+        {};
+    }
+
+    template <typename Dummy>
+    struct meta_grammar::case_<tag::if_else_operator, Dummy>
+        : enable_rule<rule::if_else_operator, Dummy>
+    {};
+
+    using proto::if_else;
+}}
+
+#endif

test/external/boost/phoenix/operator/io.hpp

@@ -0,0 +1,94 @@
+/*==============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_IO_HPP
+#define BOOST_PHOENIX_OPERATOR_IO_HPP
+
+#include <iosfwd>
+
+#include <boost/phoenix/core/limits.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/phoenix/core/domain.hpp>
+#include <boost/proto/make_expr.hpp>
+#include <boost/proto/tags.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        typedef std::ios_base&  (*iomanip_type)(std::ios_base&);
+        typedef std::istream&   (*imanip_type)(std::istream&);
+        typedef std::ostream&   (*omanip_type)(std::ostream&);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    //
+    //  overloads for I/O manipulators.
+    //
+    /////////////////////////////////////////////////////////////////////////////
+    template <typename Expr>
+    inline
+    typename proto::result_of::make_expr<
+          proto::tag::shift_left
+        , phoenix_domain
+        , actor<Expr>
+        , detail::iomanip_type
+        >::type const
+    operator<<(actor<Expr> const& a0, detail::iomanip_type a1)
+    {
+        return proto::make_expr<
+            proto::tag::shift_left, phoenix_domain>(a0, a1);
+    }
+
+    template <typename Expr>
+    inline
+    typename proto::result_of::make_expr<
+          proto::tag::shift_left
+        , phoenix_domain
+        , actor<Expr>
+        , detail::omanip_type
+        >::type const
+    operator<<(actor<Expr> const& a0, detail::omanip_type a1)
+    {
+        return proto::make_expr<
+            proto::tag::shift_left, phoenix_domain>(a0, a1);
+    }
+
+    template <typename Expr>
+    inline
+    typename proto::result_of::make_expr<
+          proto::tag::shift_right
+        , phoenix_domain
+        , actor<Expr>
+        , detail::iomanip_type
+        >::type const
+    operator>>(actor<Expr> const& a0, detail::iomanip_type a1)
+    {
+        return proto::make_expr<
+            proto::tag::shift_right, phoenix_domain>(a0, a1);
+    }
+
+    template <typename Expr>
+    inline
+    typename proto::result_of::make_expr<
+          proto::tag::shift_right
+        , phoenix_domain
+        , actor<Expr>
+        , detail::imanip_type
+        >::type const
+    operator>>(actor<Expr> const& a0, detail::imanip_type a1)
+    {
+        return proto::make_expr<
+            proto::tag::shift_right, phoenix_domain>(a0, a1);
+    }
+    
+    using proto::exprns_::operator<<;
+    using proto::exprns_::operator>>;
+}}
+
+#endif

test/external/boost/phoenix/operator/logical.hpp

@@ -0,0 +1,33 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_LOGICAL_HPP
+#define BOOST_PHOENIX_OPERATOR_LOGICAL_HPP
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    
+    BOOST_PHOENIX_UNARY_OPERATORS(
+        (logical_not)
+    )
+    BOOST_PHOENIX_BINARY_OPERATORS(
+        (logical_and)
+        (logical_or)
+    )
+    
+    using proto::exprns_::operator!;
+    using proto::exprns_::operator&&;
+    using proto::exprns_::operator||;
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#endif

test/external/boost/phoenix/operator/member.hpp

@@ -0,0 +1,138 @@
+
+#if !BOOST_PHOENIX_IS_ITERATING
+
+#ifndef BOOST_PHOENIX_OPERATOR_MEMBER_HPP
+#define BOOST_PHOENIX_OPERATOR_MEMBER_HPP
+
+#include <boost/phoenix/core/limits.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/phoenix/core/domain.hpp>
+#include <boost/phoenix/core/meta_grammar.hpp>
+#include <boost/phoenix/core/call.hpp>
+#include <boost/phoenix/operator/detail/mem_fun_ptr_gen.hpp>
+#include <boost/phoenix/support/iterate.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/proto/operators.hpp>
+
+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
+
+#include <boost/phoenix/operator/preprocessed/member.hpp>
+
+#else
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/member_" BOOST_PHOENIX_LIMIT_STR ".hpp")
+#endif
+
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_PHOENIX_BINARY_OPERATORS((mem_ptr))
+
+    template <typename Object, typename MemPtr>
+    inline
+    typename enable_if<
+        is_member_function_pointer<MemPtr>
+      , detail::mem_fun_ptr_gen<actor<Object>, MemPtr> const
+    >::type
+    operator->*(actor<Object> const& obj, MemPtr ptr)
+    {
+        return detail::mem_fun_ptr_gen<actor<Object>, MemPtr>(obj, ptr);
+    }
+
+    using proto::exprns_::operator->*;
+
+    namespace result_of
+    {
+        template <
+            typename Context
+          , BOOST_PHOENIX_typename_A_void(BOOST_PHOENIX_LIMIT)
+          , typename Dummy = void
+        >
+        struct mem_fun_ptr_eval;
+
+        #include <boost/phoenix/operator/detail/mem_fun_ptr_eval_result_of.hpp>
+    }
+
+    struct mem_fun_ptr_eval
+    {
+        template<typename Sig>
+        struct result;
+
+    #define BOOST_PHOENIX_MEMBER_EVAL(Z, N, D)                                  \
+        BOOST_PP_COMMA_IF(BOOST_PP_NOT(BOOST_PP_EQUAL(N, 2)))                   \
+        boost::phoenix::eval(BOOST_PP_CAT(a, N), ctx)                           \
+    /**/
+
+    #define BOOST_PHOENIX_ITERATION_PARAMS                                      \
+        (3, (2, BOOST_PHOENIX_LIMIT,                                            \
+        <boost/phoenix/operator/member.hpp>))                                   \
+    /**/
+        #include BOOST_PHOENIX_ITERATE()
+    #undef BOOST_PHOENIX_MEMBER_EVAL
+    };
+
+    template <typename Dummy>
+    struct default_actions::when<rule::mem_fun_ptr, Dummy>
+        : call<mem_fun_ptr_eval>
+    {};
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
+
+#endif
+
+#else // BOOST_PHOENIX_IS_ITERATING
+
+        template <typename This, BOOST_PHOENIX_typename_A, typename Context>
+        struct result<This(BOOST_PHOENIX_A, Context)>
+            : result<This(BOOST_PHOENIX_A_const_ref, Context)>
+        {};
+
+        template <typename This, BOOST_PHOENIX_typename_A, typename Context>
+        struct result<This(BOOST_PHOENIX_A_ref, Context)>
+            : result_of::mem_fun_ptr_eval<Context, BOOST_PHOENIX_A>
+        {};
+
+        template <BOOST_PHOENIX_typename_A, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, BOOST_PHOENIX_A>::type
+        operator()(
+            BOOST_PHOENIX_A_const_ref_a
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    BOOST_PP_REPEAT_FROM_TO(
+                        2
+                      , BOOST_PHOENIX_ITERATION
+                      , BOOST_PHOENIX_MEMBER_EVAL
+                      , BOOST_PHOENIX_ITERATION
+                    )
+                );
+        }
+        
+
+#endif

test/external/boost/phoenix/operator/preprocessed/member.hpp

@@ -0,0 +1,25 @@
+/*==============================================================================
+    Copyright (c) 2011 Hartmut Kaiser
+
+    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)
+==============================================================================*/
+
+#if !defined(BOOST_PHOENIX_PREPROCESSED_MEMBER)
+#define BOOST_PHOENIX_PREPROCESSED_MEMBER
+
+#if BOOST_PHOENIX_LIMIT <= 10
+#include <boost/phoenix/operator/preprocessed/member_10.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 20
+#include <boost/phoenix/operator/preprocessed/member_20.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 30
+#include <boost/phoenix/operator/preprocessed/member_30.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 40
+#include <boost/phoenix/operator/preprocessed/member_40.hpp>
+#elif BOOST_PHOENIX_LIMIT <= 50
+#include <boost/phoenix/operator/preprocessed/member_50.hpp>
+#else
+#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"
+#endif
+
+#endif

test/external/boost/phoenix/operator/preprocessed/member_10.hpp

@@ -0,0 +1,490 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+namespace boost { namespace phoenix
+{
+    namespace expression { template <typename Lhs, typename Rhs> struct mem_ptr : expr<proto::tag:: mem_ptr, Lhs, Rhs> {}; typedef proto::functional::make_expr<proto::tag:: mem_ptr> make_mem_ptr; } namespace rule { struct mem_ptr : expression:: mem_ptr<meta_grammar, meta_grammar> {}; } template <typename Dummy> struct meta_grammar::case_<proto::tag:: mem_ptr, Dummy> : enable_rule<rule:: mem_ptr, Dummy> {};
+    template <typename Object, typename MemPtr>
+    inline
+    typename enable_if<
+        is_member_function_pointer<MemPtr>
+      , detail::mem_fun_ptr_gen<actor<Object>, MemPtr> const
+    >::type
+    operator->*(actor<Object> const& obj, MemPtr ptr)
+    {
+        return detail::mem_fun_ptr_gen<actor<Object>, MemPtr>(obj, ptr);
+    }
+    using proto::exprns_::operator->*;
+    namespace result_of
+    {
+        template <
+            typename Context
+          , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
+          , typename Dummy = void
+        >
+        struct mem_fun_ptr_eval;
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1>
+        struct mem_fun_ptr_eval<Context, A0 , A1>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9
+                    )
+                >::type
+                type;
+        };
+    }
+    struct mem_fun_ptr_eval
+    {
+        template<typename Sig>
+        struct result;
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1, typename Context>
+        struct result<This(A0 , A1, Context)>
+            : result<This(A0 const& , A1 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1, typename Context>
+        struct result<This(A0 & , A1 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1>
+        {};
+        template <typename A0 , typename A1, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1>::type
+        operator()(
+            A0 const& a0 , A1 const& a1
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2, typename Context>
+        struct result<This(A0 , A1 , A2, Context)>
+            : result<This(A0 const& , A1 const& , A2 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2, typename Context>
+        struct result<This(A0 & , A1 & , A2 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2>
+        {};
+        template <typename A0 , typename A1 , typename A2, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        struct result<This(A0 , A1 , A2 , A3, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx)
+                );
+        }
+        
+    };
+    template <typename Dummy>
+    struct default_actions::when<rule::mem_fun_ptr, Dummy>
+        : call<mem_fun_ptr_eval>
+    {};
+}}

test/external/boost/phoenix/operator/preprocessed/member_20.hpp

@@ -0,0 +1,990 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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)
+==============================================================================*/
+namespace boost { namespace phoenix
+{
+    namespace expression { template <typename Lhs, typename Rhs> struct mem_ptr : expr<proto::tag:: mem_ptr, Lhs, Rhs> {}; typedef proto::functional::make_expr<proto::tag:: mem_ptr> make_mem_ptr; } namespace rule { struct mem_ptr : expression:: mem_ptr<meta_grammar, meta_grammar> {}; } template <typename Dummy> struct meta_grammar::case_<proto::tag:: mem_ptr, Dummy> : enable_rule<rule:: mem_ptr, Dummy> {};
+    template <typename Object, typename MemPtr>
+    inline
+    typename enable_if<
+        is_member_function_pointer<MemPtr>
+      , detail::mem_fun_ptr_gen<actor<Object>, MemPtr> const
+    >::type
+    operator->*(actor<Object> const& obj, MemPtr ptr)
+    {
+        return detail::mem_fun_ptr_gen<actor<Object>, MemPtr>(obj, ptr);
+    }
+    using proto::exprns_::operator->*;
+    namespace result_of
+    {
+        template <
+            typename Context
+          , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void , typename A10 = void , typename A11 = void , typename A12 = void , typename A13 = void , typename A14 = void , typename A15 = void , typename A16 = void , typename A17 = void , typename A18 = void , typename A19 = void
+          , typename Dummy = void
+        >
+        struct mem_fun_ptr_eval;
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1>
+        struct mem_fun_ptr_eval<Context, A0 , A1>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14; typedef typename evaluator::impl< A15 , Context , int >::result_type child15;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14 , child15
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14; typedef typename evaluator::impl< A15 , Context , int >::result_type child15; typedef typename evaluator::impl< A16 , Context , int >::result_type child16;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14 , child15 , child16
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14; typedef typename evaluator::impl< A15 , Context , int >::result_type child15; typedef typename evaluator::impl< A16 , Context , int >::result_type child16; typedef typename evaluator::impl< A17 , Context , int >::result_type child17;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14 , child15 , child16 , child17
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14; typedef typename evaluator::impl< A15 , Context , int >::result_type child15; typedef typename evaluator::impl< A16 , Context , int >::result_type child16; typedef typename evaluator::impl< A17 , Context , int >::result_type child17; typedef typename evaluator::impl< A18 , Context , int >::result_type child18;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14 , child15 , child16 , child17 , child18
+                    )
+                >::type
+                type;
+        };
+    
+    
+    
+    
+    
+    
+    
+        template <typename Context, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>
+        struct mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19>
+        {
+            typedef typename evaluator::impl< A0 , Context , int >::result_type child0; typedef typename evaluator::impl< A1 , Context , int >::result_type child1; typedef typename evaluator::impl< A2 , Context , int >::result_type child2; typedef typename evaluator::impl< A3 , Context , int >::result_type child3; typedef typename evaluator::impl< A4 , Context , int >::result_type child4; typedef typename evaluator::impl< A5 , Context , int >::result_type child5; typedef typename evaluator::impl< A6 , Context , int >::result_type child6; typedef typename evaluator::impl< A7 , Context , int >::result_type child7; typedef typename evaluator::impl< A8 , Context , int >::result_type child8; typedef typename evaluator::impl< A9 , Context , int >::result_type child9; typedef typename evaluator::impl< A10 , Context , int >::result_type child10; typedef typename evaluator::impl< A11 , Context , int >::result_type child11; typedef typename evaluator::impl< A12 , Context , int >::result_type child12; typedef typename evaluator::impl< A13 , Context , int >::result_type child13; typedef typename evaluator::impl< A14 , Context , int >::result_type child14; typedef typename evaluator::impl< A15 , Context , int >::result_type child15; typedef typename evaluator::impl< A16 , Context , int >::result_type child16; typedef typename evaluator::impl< A17 , Context , int >::result_type child17; typedef typename evaluator::impl< A18 , Context , int >::result_type child18; typedef typename evaluator::impl< A19 , Context , int >::result_type child19;
+            typedef
+                typename boost::result_of<
+                    child1(
+                        child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 , child10 , child11 , child12 , child13 , child14 , child15 , child16 , child17 , child18 , child19
+                    )
+                >::type
+                type;
+        };
+    }
+    struct mem_fun_ptr_eval
+    {
+        template<typename Sig>
+        struct result;
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1, typename Context>
+        struct result<This(A0 , A1, Context)>
+            : result<This(A0 const& , A1 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1, typename Context>
+        struct result<This(A0 & , A1 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1>
+        {};
+        template <typename A0 , typename A1, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1>::type
+        operator()(
+            A0 const& a0 , A1 const& a1
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2, typename Context>
+        struct result<This(A0 , A1 , A2, Context)>
+            : result<This(A0 const& , A1 const& , A2 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2, typename Context>
+        struct result<This(A0 & , A1 & , A2 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2>
+        {};
+        template <typename A0 , typename A1 , typename A2, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        struct result<This(A0 , A1 , A2 , A3, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx) , boost::phoenix::eval(a15, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx) , boost::phoenix::eval(a15, ctx) , boost::phoenix::eval(a16, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const& , A17 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 & , A17 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx) , boost::phoenix::eval(a15, ctx) , boost::phoenix::eval(a16, ctx) , boost::phoenix::eval(a17, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const& , A17 const& , A18 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 & , A17 & , A18 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17 , A18 const& a18
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx) , boost::phoenix::eval(a15, ctx) , boost::phoenix::eval(a16, ctx) , boost::phoenix::eval(a17, ctx) , boost::phoenix::eval(a18, ctx)
+                );
+        }
+        
+    
+    
+    
+    
+    
+    
+    
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19, typename Context>
+        struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19, Context)>
+            : result<This(A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const& , A17 const& , A18 const& , A19 const&, Context)>
+        {};
+        template <typename This, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19, typename Context>
+        struct result<This(A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 & , A17 & , A18 & , A19 &, Context)>
+            : result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19>
+        {};
+        template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19, typename Context>
+        typename result_of::mem_fun_ptr_eval<Context, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19>::type
+        operator()(
+            A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17 , A18 const& a18 , A19 const& a19
+          , Context & ctx
+        ) const
+        {
+            return
+                (
+                    get_pointer(boost::phoenix::eval(a0, ctx))
+                    ->*boost::phoenix::eval(a1, ctx)
+                )(
+                    boost::phoenix::eval(a2, ctx) , boost::phoenix::eval(a3, ctx) , boost::phoenix::eval(a4, ctx) , boost::phoenix::eval(a5, ctx) , boost::phoenix::eval(a6, ctx) , boost::phoenix::eval(a7, ctx) , boost::phoenix::eval(a8, ctx) , boost::phoenix::eval(a9, ctx) , boost::phoenix::eval(a10, ctx) , boost::phoenix::eval(a11, ctx) , boost::phoenix::eval(a12, ctx) , boost::phoenix::eval(a13, ctx) , boost::phoenix::eval(a14, ctx) , boost::phoenix::eval(a15, ctx) , boost::phoenix::eval(a16, ctx) , boost::phoenix::eval(a17, ctx) , boost::phoenix::eval(a18, ctx) , boost::phoenix::eval(a19, ctx)
+                );
+        }
+        
+    };
+    template <typename Dummy>
+    struct default_actions::when<rule::mem_fun_ptr, Dummy>
+        : call<mem_fun_ptr_eval>
+    {};
+}}

test/external/boost/phoenix/operator/self.hpp

@@ -0,0 +1,32 @@
+/*==============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Thomas Heller
+
+    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_PHOENIX_OPERATOR_SELF_HPP
+#define BOOST_PHOENIX_OPERATOR_SELF_HPP
+
+#include <boost/phoenix/operator/detail/define_operator.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/proto/operators.hpp>
+
+namespace boost { namespace phoenix
+{
+    BOOST_PHOENIX_UNARY_OPERATORS(
+        (address_of)
+        (dereference)
+    )
+    BOOST_PHOENIX_BINARY_OPERATORS(
+        (assign)
+        (subscript)
+    )
+    
+    using proto::exprns_::operator&;
+    using proto::exprns_::operator*;
+}}
+
+#include <boost/phoenix/operator/detail/undef_operator.hpp>
+
+#endif