Added boost header

test/external/boost/fusion/functional/adapter/detail/access.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_DETAIL_ACCESS_HPP_INCLUDED)
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_DETAIL_ACCESS_HPP_INCLUDED
+
+namespace boost { namespace fusion { namespace detail
+{
+    // const reference deduction for function templates that accept T const &
+    template <typename T> struct cref               { typedef T const& type; };
+    template <typename T> struct cref<T&>           { typedef T const& type; };
+    template <typename T> struct cref<T const>      { typedef T const& type; };
+
+    // mutable reference deduction for function templates that accept T &
+    template <typename T> struct mref               { typedef T      & type; };
+    template <typename T> struct mref<T&>           { typedef T      & type; };
+
+    // generic reference deduction for function templates that are overloaded
+    // to accept both T const & and T &
+    template <typename T> struct gref               { typedef T const& type; };
+    template <typename T> struct gref<T&>           { typedef T      & type; };
+    template <typename T> struct gref<T const>      { typedef T const& type; };
+
+    // appropriately qualified target function in const context
+    template <typename T> struct qf_c          { typedef T const  type; };
+    template <typename T> struct qf_c<T const> { typedef T const  type; };
+    template <typename T> struct qf_c<T &>     { typedef T        type; };
+
+    // appropriately qualified target function in non-const context
+    template <typename T> struct qf            { typedef T        type; };
+    template <typename T> struct qf<T const>   { typedef T const  type; };
+    template <typename T> struct qf<T &>       { typedef T        type; };
+}}}
+
+#endif
+

test/external/boost/fusion/functional/adapter/fused.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_FUSED_HPP_INCLUDED)
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_FUSED_HPP_INCLUDED
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/config.hpp>
+
+#include <boost/fusion/functional/adapter/detail/access.hpp>
+#include <boost/fusion/functional/invocation/invoke.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Function> class fused;
+
+    //----- ---- --- -- - -  -   -
+
+    template <typename Function>
+    class fused
+    {
+        Function fnc_transformed;
+
+        typedef typename detail::qf_c<Function>::type & func_const_fwd_t;
+        typedef typename detail::qf<Function>::type & func_fwd_t;
+
+    public:
+
+        inline explicit fused(func_const_fwd_t f = Function())
+            : fnc_transformed(f)
+        { }
+
+        template <class Seq> 
+        inline typename result_of::invoke<func_const_fwd_t,Seq const>::type 
+        operator()(Seq const & s) const
+        {
+            return fusion::invoke<func_const_fwd_t>(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke<func_fwd_t,Seq const>::type 
+        operator()(Seq const & s) 
+        {
+            return fusion::invoke<func_fwd_t>(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke<func_const_fwd_t,Seq>::type 
+        operator()(Seq & s) const
+        {
+            return fusion::invoke<func_const_fwd_t>(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke<func_fwd_t,Seq>::type 
+        operator()(Seq & s) 
+        {
+            return fusion::invoke<func_fwd_t>(this->fnc_transformed,s);
+        }
+
+        template <typename Sig>
+        struct result;
+
+        template <class Self, class Seq>
+        struct result< Self const (Seq) >
+            : result_of::invoke<func_const_fwd_t,
+                typename boost::remove_reference<Seq>::type >
+        { };
+
+        template <class Self, class Seq>
+        struct result< Self(Seq) >
+            : result_of::invoke<func_fwd_t,
+                typename boost::remove_reference<Seq>::type >
+        { };
+
+    };
+
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif
+

test/external/boost/fusion/functional/adapter/fused_function_object.hpp

@@ -0,0 +1,100 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_FUSED_FUNCTION_OBJECT_HPP_INCLUDED)
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_FUSED_FUNCTION_OBJECT_HPP_INCLUDED
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/config.hpp>
+
+#include <boost/fusion/functional/adapter/detail/access.hpp>
+#include <boost/fusion/functional/invocation/invoke_function_object.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion
+{
+    template <class Function> class fused_function_object;
+
+    //----- ---- --- -- - -  -   -
+
+    template <class Function>
+    class fused_function_object
+    {
+        Function fnc_transformed;
+
+        typedef typename detail::qf_c<Function>::type & func_const_fwd_t;
+        typedef typename detail::qf<Function>::type & func_fwd_t;
+
+    public:
+
+        inline explicit fused_function_object(func_const_fwd_t f = Function())
+            : fnc_transformed(f)
+        { }
+
+        template <class Seq> 
+        inline typename result_of::invoke_function_object<func_const_fwd_t,
+            Seq const>::type operator()(Seq const & s) const
+        {
+          return fusion::invoke_function_object<
+              func_const_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke_function_object<func_fwd_t,
+            Seq const>::type 
+        operator()(Seq const & s) 
+        {
+          return fusion::invoke_function_object<
+              func_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke_function_object<func_const_fwd_t,
+            Seq>::type
+        operator()(Seq & s) const
+        {
+          return fusion::invoke_function_object<
+              func_const_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline typename result_of::invoke_function_object<func_fwd_t,Seq>::type
+        operator()(Seq & s) 
+        {
+          return fusion::invoke_function_object<
+              func_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <typename Sig>
+        struct result;
+
+        template <class Self, class Seq>
+        struct result< Self const (Seq) >
+            : result_of::invoke_function_object<func_const_fwd_t, 
+                typename boost::remove_reference<Seq>::type >
+        { };
+
+        template <class Self, class Seq>
+        struct result< Self(Seq) >
+            : result_of::invoke_function_object<func_fwd_t,
+                typename boost::remove_reference<Seq>::type >
+        { };
+    };
+
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif
+

test/external/boost/fusion/functional/adapter/fused_procedure.hpp

@@ -0,0 +1,80 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_FUSED_PROCEDURE_HPP_INCLUDED)
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_FUSED_PROCEDURE_HPP_INCLUDED
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/config.hpp>
+
+#include <boost/fusion/functional/adapter/detail/access.hpp>
+#include <boost/fusion/functional/invocation/invoke_procedure.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion
+{
+    template <typename Function> class fused_procedure;
+
+    //----- ---- --- -- - -  -   -
+
+    template <typename Function>
+    class fused_procedure
+    {
+        Function fnc_transformed;
+
+        typedef typename detail::qf_c<Function>::type & func_const_fwd_t;
+        typedef typename detail::qf<Function>::type & func_fwd_t;
+
+    public:
+
+        inline explicit fused_procedure(func_const_fwd_t f = Function())
+            : fnc_transformed(f)
+        { }
+
+        template <class Seq> 
+        inline void operator()(Seq const & s) const
+        {
+            fusion::invoke_procedure<
+                func_const_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline void operator()(Seq const & s) 
+        {
+            fusion::invoke_procedure<
+                func_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline void operator()(Seq & s) const
+        {
+            fusion::invoke_procedure<
+                func_const_fwd_t >(this->fnc_transformed,s);
+        }
+
+        template <class Seq> 
+        inline void operator()(Seq & s) 
+        {
+            return fusion::invoke_procedure<
+                func_fwd_t >(this->fnc_transformed,s);
+        }
+
+        typedef void result_type;
+    };
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif
+

test/external/boost/fusion/functional/adapter/limits.hpp

@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_LIMITS_HPP_INCLUDED)
+#   define BOOST_FUSION_FUNCTIONAL_ADAPTER_LIMITS_HPP_INCLUDED
+
+#   include <boost/fusion/container/vector/limits.hpp>
+
+#   if !defined(BOOST_FUSION_UNFUSED_MAX_ARITY)
+#       define BOOST_FUSION_UNFUSED_MAX_ARITY 6
+#   elif BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
+#       error "BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
+#   endif
+#   if !defined(BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY)
+#       define BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY 6
+#   elif BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
+#       error "BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
+#   endif
+
+#endif
+

test/external/boost/fusion/functional/adapter/unfused.hpp

@@ -0,0 +1,162 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_HPP_INCLUDED)
+#if !defined(BOOST_PP_IS_ITERATING)
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
+#include <boost/utility/result_of.hpp>
+
+#include <boost/config.hpp>
+
+#include <boost/fusion/container/vector/vector.hpp>
+
+#include <boost/fusion/functional/adapter/limits.hpp>
+#include <boost/fusion/functional/adapter/detail/access.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion
+{
+    template <class Function, bool AllowNullary = true>
+    class unfused;
+
+    //----- ---- --- -- - -  -   -
+
+    template <class Function> 
+    class unfused<Function,true>
+      : public unfused<Function,false>
+    {
+        typedef typename detail::qf_c<Function>::type function_c;
+        typedef typename detail::qf<Function>::type function;
+        typedef typename detail::call_param<Function>::type func_const_fwd_t;
+      public:
+
+        using unfused<Function,false>::operator();
+
+        inline explicit unfused(func_const_fwd_t f = function())
+            : unfused<Function,false>(f)
+        { }
+
+        typedef typename boost::result_of<
+            function_c(fusion::vector0<> &) >::type call_const_0_result;
+
+        inline call_const_0_result operator()() const
+        {
+            fusion::vector0<> arg;
+            return this->fnc_transformed(arg);
+        }
+
+        typedef typename boost::result_of< 
+            function(fusion::vector0<> &) >::type call_0_result;
+
+        inline call_0_result operator()() 
+        {
+            fusion::vector0<> arg;
+            return this->fnc_transformed(arg);
+        }
+    };
+
+    template <class Function> class unfused<Function,false>
+    {
+      protected:
+        Function fnc_transformed;
+        typedef typename detail::qf_c<Function>::type function_c;
+        typedef typename detail::qf<Function>::type function;
+        typedef typename detail::call_param<Function>::type func_const_fwd_t;
+      public:
+
+        inline explicit unfused(func_const_fwd_t f = function())
+            : fnc_transformed(f)
+        { }
+
+        template <typename Sig>
+        struct result;
+
+        #define  BOOST_PP_FILENAME_1 \
+            <boost/fusion/functional/adapter/unfused.hpp>
+        #define  BOOST_PP_ITERATION_LIMITS \
+            (1,BOOST_FUSION_UNFUSED_MAX_ARITY)
+        #include BOOST_PP_ITERATE()
+    };
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+namespace boost 
+{
+    template<class F>
+    struct result_of< boost::fusion::unfused<F> const () >
+    {
+        typedef typename boost::fusion::unfused<F>::call_const_0_result type;
+    };
+    template<class F>
+    struct result_of< boost::fusion::unfused<F>() >
+    {
+        typedef typename boost::fusion::unfused<F>::call_0_result type;
+    };
+}
+
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_HPP_INCLUDED
+#else // defined(BOOST_PP_IS_ITERATING)
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+////////////////////////////////////////////////////////////////////////////////
+#define N BOOST_PP_ITERATION()
+
+        template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
+        struct result< Self const (BOOST_PP_ENUM_PARAMS(N,T)) >
+            : boost::result_of< function_c(
+                BOOST_PP_CAT(fusion::vector,N)< BOOST_PP_ENUM_BINARY_PARAMS(N,
+                    typename detail::mref<T,>::type BOOST_PP_INTERCEPT) > & )>
+        { };
+
+        template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
+        struct result< Self(BOOST_PP_ENUM_PARAMS(N,T)) >
+            : boost::result_of< function(
+                BOOST_PP_CAT(fusion::vector,N)< BOOST_PP_ENUM_BINARY_PARAMS(N,
+                    typename detail::mref<T,>::type BOOST_PP_INTERCEPT) > & )>
+        { };
+
+        template <BOOST_PP_ENUM_PARAMS(N,typename T)>
+        inline typename boost::result_of<function_c(BOOST_PP_CAT(fusion::vector,N)
+            <BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)> & )>::type
+        operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
+        {
+            BOOST_PP_CAT(fusion::vector,N)<
+                  BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT) >
+                arg(BOOST_PP_ENUM_PARAMS(N,a));
+            return this->fnc_transformed(arg);
+        }
+
+        template <BOOST_PP_ENUM_PARAMS(N,typename T)>
+        inline typename boost::result_of<function(BOOST_PP_CAT(fusion::vector,N)
+            <BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)> & )>::type
+        operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) 
+        {
+            BOOST_PP_CAT(fusion::vector,N)<
+                  BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT) >
+                arg(BOOST_PP_ENUM_PARAMS(N,a));
+            return this->fnc_transformed(arg);
+        }
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+#endif
+

test/external/boost/fusion/functional/adapter/unfused_typed.hpp

@@ -0,0 +1,164 @@
+/*=============================================================================
+    Copyright (c) 2006-2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to 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_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_TYPED_HPP_INCLUDED)
+#if !defined(BOOST_PP_IS_ITERATING)
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+#include <boost/config.hpp>
+
+#include <boost/utility/result_of.hpp>
+
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+
+#include <boost/fusion/functional/adapter/limits.hpp>
+#include <boost/fusion/functional/adapter/detail/access.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+
+namespace boost { namespace fusion
+{
+
+    template <class Function, class Sequence> class unfused_typed;
+
+    //----- ---- --- -- - -  -   -
+
+    namespace detail
+    {
+        template <class Derived, class Function, 
+            class Sequence, long Arity>
+        struct unfused_typed_impl;
+    }
+
+    template <class Function, class Sequence>
+    class unfused_typed
+        : public detail::unfused_typed_impl
+          < unfused_typed<Function,Sequence>, Function, Sequence, 
+            result_of::size<Sequence>::value > 
+    {
+        Function fnc_transformed;
+
+        template <class D, class F, class S, long A>
+        friend struct detail::unfused_typed_impl;
+
+        typedef typename detail::call_param<Function>::type func_const_fwd_t;
+
+    public:
+
+        inline explicit unfused_typed(func_const_fwd_t f = Function())
+            : fnc_transformed(f)
+        { }
+    }; 
+
+    #define  BOOST_PP_FILENAME_1 <boost/fusion/functional/adapter/unfused_typed.hpp>
+    #define  BOOST_PP_ITERATION_LIMITS (0,BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY)
+    #include BOOST_PP_ITERATE() 
+
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+namespace boost 
+{
+    template<class F, class Seq>
+    struct result_of< boost::fusion::unfused_typed<F,Seq> const () >
+        : boost::fusion::unfused_typed<F,Seq>::template result< 
+            boost::fusion::unfused_typed<F,Seq> const () >
+    { };
+    template<class F, class Seq>
+    struct result_of< boost::fusion::unfused_typed<F,Seq>() >
+        : boost::fusion::unfused_typed<F,Seq>::template result< 
+            boost::fusion::unfused_typed<F,Seq> () >
+    { };
+}
+
+
+#define BOOST_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_TYPED_HPP_INCLUDED
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+#define N BOOST_PP_ITERATION()
+
+    namespace detail
+    {
+
+        template <class Derived, class Function, class Sequence>
+        struct unfused_typed_impl<Derived,Function,Sequence,N>
+        {
+            typedef typename detail::qf_c<Function>::type function_c;
+            typedef typename detail::qf<Function>::type function;
+            typedef typename result_of::as_vector<Sequence>::type arg_vector_t;
+
+        public:
+
+#define M(z,i,s)                                                                \
+    typename call_param<typename result_of::value_at_c<s,i>::type>::type a##i
+
+            inline typename boost::result_of< 
+                function_c(arg_vector_t &) >::type
+            operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) const
+            {
+#if N > 0
+                arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a));
+#else
+                arg_vector_t arg;
+#endif
+                return static_cast<Derived const *>(this)->fnc_transformed(arg);
+            }
+
+            inline typename boost::result_of<
+                function(arg_vector_t &) >::type 
+            operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) 
+            {
+#if N > 0
+                arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a));
+#else
+                arg_vector_t arg;
+#endif
+                return static_cast<Derived *>(this)->fnc_transformed(arg);
+            }
+
+#undef M
+
+            template <typename Sig> struct result { typedef void type; };
+
+            template <class Self BOOST_PP_ENUM_TRAILING_PARAMS(N,typename T)>
+            struct result< Self const (BOOST_PP_ENUM_PARAMS(N,T)) >
+                : boost::result_of< function_c(arg_vector_t &) > 
+            { };
+
+            template <class Self BOOST_PP_ENUM_TRAILING_PARAMS(N,typename T)>
+            struct result< Self (BOOST_PP_ENUM_PARAMS(N,T)) >
+                : boost::result_of< function(arg_vector_t &) >
+            { };
+        };
+
+    } // namespace detail
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+#endif
+