comparison DEPENDENCIES/generic/include/boost/fusion/functional/invocation/invoke.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 #include <boost/function_types/parameter_types.hpp>
 
 #include <boost/utility/result_of.hpp>
 
 #include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
 #include <boost/fusion/sequence/intrinsic/at.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/sequence/intrinsic/front.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/iterator/next.hpp>

 #include <boost/fusion/functional/invocation/limits.hpp>
 #include <boost/fusion/functional/invocation/detail/that_ptr.hpp>
 
 namespace boost { namespace fusion
 {
-    namespace result_of
-    {
-        template <typename Function, class Sequence> struct invoke;
-    }
-
-    //~ template <typename Function, class Sequence>
-    //~ inline typename result_of::invoke<Function, Sequence>::type
-    //~ invoke(Function, Sequence &);
-
-    //~ template <typename Function, class Sequence>
-    //~ inline typename result_of::invoke<Function, Sequence const>::type
-    //~ invoke(Function, Sequence const &);
-
-    //----- ---- --- -- - -  -   -
-
     namespace detail
     {
         namespace ft = function_types;
 
         template<
             typename Function, class Sequence,
             int N = result_of::size<Sequence>::value,
             bool CBI = ft::is_callable_builtin<Function>::value,
-            bool RandomAccess = traits::is_random_access<Sequence>::value
+            bool RandomAccess = traits::is_random_access<Sequence>::value,
+            typename Enable = void
             >
         struct invoke_impl;
 
         template <class Sequence, int N>
         struct invoke_param_types;

                 typename mpl::eval_if< ft::is_function<F>,
                     boost::add_reference<F>, boost::remove_cv<F> >::type,
                 Sequence, N, RandomAccess >
         { };
 
-        template <typename Function, class Sequence, int N, bool RandomAccess>
-        struct invoke_impl<Function,Sequence,N,true,RandomAccess>
+        template <typename Function, class Sequence, int N, bool RandomAccess, typename Enable>
+        struct invoke_impl<Function,Sequence,N,true,RandomAccess,Enable>
             : mpl::if_< ft::is_member_function_pointer<Function>,
                 invoke_mem_fn<Function,Sequence,N,RandomAccess>,
                 invoke_nonmember_builtin<Function,Sequence,N,RandomAccess>
             >::type
         { };
 
-        template <typename Function, class Sequence, bool RandomAccess>
-        struct invoke_impl<Function,Sequence,1,true,RandomAccess>
+        template <typename Function, class Sequence, bool RandomAccess, typename Enable>
+        struct invoke_impl<Function,Sequence,1,true,RandomAccess,Enable>
             : mpl::eval_if< ft::is_member_pointer<Function>,
                 mpl::if_< ft::is_member_function_pointer<Function>,
                     invoke_mem_fn<Function,Sequence,1,RandomAccess>,
                     invoke_data_member<Function, Sequence> >,
                 mpl::identity< invoke_nonmember_builtin<

         public:
 
             typedef typename boost::add_reference<qualified_type>::type
                 result_type;
 
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type call(T C::* f, Sequence & s)
             {
                 typename result_of::front<Sequence>::type c = fusion::front(s);
                 return that_ptr<qualified_class>::get(c)->*f;
             }
         };
     }
 
     namespace result_of
     {
-        template <typename Function, class Sequence> struct invoke
+        template <typename Function, class Sequence, typename = void>
+        struct invoke;
+
+        template <typename Function, class Sequence>
+        struct invoke<Function, Sequence,
+                      typename detail::enabler<
+                          typename detail::invoke_impl<
+                              typename boost::remove_reference<Function>::type, Sequence
+                          >::result_type
+                      >::type>
         {
             typedef typename detail::invoke_impl<
                 typename boost::remove_reference<Function>::type, Sequence
-              >::result_type type;
+            >::result_type type;
         };
     }
 
     template <typename Function, class Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::invoke<Function,Sequence>::type
     invoke(Function f, Sequence & s)
     {
         return detail::invoke_impl<
                 typename boost::remove_reference<Function>::type,Sequence
             >::call(f,s);
     }
 
     template <typename Function, class Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::invoke<Function,Sequence const>::type
     invoke(Function f, Sequence const & s)
     {
         return detail::invoke_impl<
                 typename boost::remove_reference<Function>::type,Sequence const

 //  Preprocessor vertical repetition code
 //
 ///////////////////////////////////////////////////////////////////////////////
 #define N BOOST_PP_ITERATION()
 
-        template <typename Function, class Sequence>
-        struct invoke_impl<Function,Sequence,N,false,true>
+#define M(z,j,data) typename result_of::at_c<Sequence,j>::type
+
+        template <typename Function, class Sequence>
+        struct invoke_impl<Function,Sequence,N,false,true,
+            typename enabler<
+                typename boost::result_of<Function(BOOST_PP_ENUM(N,M,~)) >::type
+              >::type>
         {
         public:
 
             typedef typename boost::result_of<
-#define M(z,j,data) typename result_of::at_c<Sequence,j>::type
                     Function(BOOST_PP_ENUM(N,M,~)) >::type result_type;
 #undef M
 
 #if N > 0
 
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
 #define M(z,j,data) fusion::at_c<j>(s)
                 return f( BOOST_PP_ENUM(N,M,~) );
             }
 
 #else
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & /*s*/)
             {
                 return f();
             }

             typedef typename ft::result_type<Function>::type result_type;
 
 #if N > 0
 
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
 #define M(z,j,data) fusion::at_c<j>(s)
                 return f( BOOST_PP_ENUM(N,M,~) );
             }
 
 #else
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & /*s*/)
             {
                 return f();
             }

         public:
 
             typedef typename ft::result_type<Function>::type result_type;
 
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
                 return (that_ptr<typename mpl::front<
                                 ft::parameter_types<Function> >::type

 #define M(z,j,data)                                                             \
             typename seq::I##j i##j =                                          \
                 fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(j)));
 
         template <typename Function, class Sequence>
-        struct invoke_impl<Function,Sequence,N,false,false>
+        struct invoke_impl<Function,Sequence,N,false,false,
+            typename enabler<
+#define L(z,j,data) typename invoke_param_types<Sequence,N>::BOOST_PP_CAT(T, j)
+                typename boost::result_of<Function(BOOST_PP_ENUM(N,L,~))>::type
+              >::type>
+#undef L
         {
         private:
             typedef invoke_param_types<Sequence,N> seq;
         public:
 

                 >::type result_type;
 
 #if N > 0
 
             template <typename F>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
                 typename seq::I0 i0 = fusion::begin(s);
                 BOOST_PP_REPEAT_FROM_TO(1,N,M,~)

             }
 
 #else
 
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & /*s*/)
             {
                 return f();
             }

             typedef typename ft::result_type<Function>::type result_type;
 
 #if N > 0
 
             template <typename F>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
                 typename seq::I0 i0 = fusion::begin(s);
                 BOOST_PP_REPEAT_FROM_TO(1,N,M,~)

             }
 
 #else
 
             template <typename F>
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & /*s*/)
             {
                 return f();
             }

         public:
 
             typedef typename ft::result_type<Function>::type result_type;
 
             template <typename F>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static inline result_type
             call(F & f, Sequence & s)
             {
                 typename seq::I0 i0 = fusion::begin(s);
                 BOOST_PP_REPEAT_FROM_TO(1,N,M,~)