Ticket #864: djw_lambda_result.patch

boost/lambda/detail/function_adaptors.hpp

@@ -12 +12 @@
 #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
 #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
 
+#include "boost/mpl/has_template_xxx.hpp"
+#include "boost/preprocessor/repetition/enum.hpp"
+#include "boost/preprocessor/repetition/repeat.hpp"
+#include "boost/tuple/tuple.hpp"
 #include "boost/type_traits/same_traits.hpp"
+#include "boost/utility/result_of.hpp"
 
 namespace boost { 
 namespace lambda {
 
 template <class Func> struct function_adaptor {
 
+  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
+
+#if !defined(BOOST_NO_RESULT_OF)
+  // Support functors that use the boost::result_of return type convention.
+  template<class Tuple, int Length, bool HasSig>
+  struct result_converter;
+  template<class Tuple, int Length>
+  struct result_converter<Tuple, Length, true>
+      : plainF::template sig<Tuple>
+  {};
+#define BOOST_LAMBDA_RESULT_CONVERTER_ARGS(z, n, _) \
+    typename tuples::element<n, typename Tuple::tail_type>::type \
+    /**/
+#define BOOST_LAMBDA_RESULT_CONVERTER(z, n, _) \
+    template<class Tuple> \
+    struct result_converter<Tuple, n, false> \
+        : result_of< \
+              plainF( \
+                  BOOST_PP_ENUM(n, BOOST_LAMBDA_RESULT_CONVERTER_ARGS, _) \
+              ) \
+          > \
+    {}; \
+    /**/
+  BOOST_PP_REPEAT(
+      BOOST_RESULT_OF_NUM_ARGS
+    , BOOST_LAMBDA_RESULT_CONVERTER
+    , _
+  )
+#undef BOOST_LAMBDA_RESULT_CONVERTER
+#undef BOOST_LAMBDA_RESULT_CONVERTER_ARGS
+
+  BOOST_MPL_HAS_TEMPLATE_XXX_TRAIT_NAMED_DEF(has_template_sig, sig, 1, true)
+
   // we do not know the return type off-hand, we must ask it from Func
+  // To sig we pass a cons list, where the head is the function object type
+  // itself (potentially cv-qualified)
+  // and the tail contains the types of the actual arguments to be passed
+  // to the function object. The arguments can be cv qualified
+  // as well.
+  template <class Args>
+  struct sig
+      : result_converter<
+            Args
+          , tuples::length<typename Args::tail_type>::value
+          , has_template_sig<plainF, Args>::value 
+        >
+  {};
+#else // BOOST_NO_RESULT_OF
   template <class Args> class sig { 
     typedef typename Args::head_type F; 
-    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
   public:
-    // To sig we pass a cons list, where the head is the function object type
-    // itself (potentially cv-qualified)
-    // and the tail contains the types of the actual arguments to be passed
-    // to the function object. The arguments can be cv qualified
-    // as well.
     typedef typename plainF::template sig<Args>::type type;
   };
+#endif // BOOST_NO_RESULT_OF
 
   template<class RET, class A1>
   static RET apply(A1& a1) {

boost/lambda/detail/lambda_functors.hpp

@@ -13 +13 @@
 #ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 #define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
 
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/utility/result_of.hpp>
+
 namespace boost { 
 namespace lambda {
 
@@ -134 +138 @@
     inherited::template sig<null_type>::type
       nullary_return_type;
 
+  // Support for boost::result_of.
+#define BOOST_LAMBDA_FUNCTOR_NULL_RESULT_TYPE(n) \
+    typename F::nullary_return_type \
+    /**/
+#define BOOST_LAMBDA_FUNCTOR_NARY_RESULT_TYPE(n) \
+    typename sig<tuple<F, BOOST_PP_ENUM_PARAMS(n, A)> >::type \
+    /**/
+#define BOOST_LAMBDA_FUNCTOR_RESULT_TYPE(n) \
+    BOOST_PP_IF( \
+        n \
+      , BOOST_LAMBDA_FUNCTOR_NARY_RESULT_TYPE \
+      , BOOST_LAMBDA_FUNCTOR_NULL_RESULT_TYPE \
+    )(n) \
+    /**/
+  BOOST_VARIABLE_ARITY_FUNCTOR_RESULT(
+      0
+    , BOOST_RESULT_OF_NUM_ARGS
+    , BOOST_LAMBDA_FUNCTOR_RESULT_TYPE
+  )
+#undef BOOST_LAMBDA_FUNCTOR_RESULT_TYPE
+#undef BOOST_LAMBDA_FUNCTOR_NARY_RESULT_TYPE
+#undef BOOST_LAMBDA_FUNCTOR_NULL_RESULT_TYPE
+
   nullary_return_type operator()() const { 
     return inherited::template 
       call<nullary_return_type>

boost/utility/result_of.hpp

@@ -22 +22 @@
 #  define BOOST_RESULT_OF_NUM_ARGS 10
 #endif
 
+#define BOOST_RESULT_PARTIAL_SPECIALIZATION(z, n, macro) \
+    template < \
+        class F \
+        BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) \
+    > \
+    struct result<F(BOOST_PP_ENUM_PARAMS(n, A))> { \
+        typedef macro(n) type; \
+    }; \
+    /**/
+#define BOOST_VARIABLE_ARITY_FUNCTOR_RESULT(first, last, macro) \
+    template <class F> struct result; \
+    BOOST_PP_REPEAT_FROM_TO( \
+        first, last \
+      , BOOST_RESULT_PARTIAL_SPECIALIZATION \
+      , macro \
+    ) \
+    /**/
+#define BOOST_FIXED_ARITY_FUNCTOR_RESULT(n, data) \
+    template <class F> struct result; \
+    template < \
+        class F \
+        BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) \
+    > \
+    struct result<F(BOOST_PP_ENUM_PARAMS(n, A))> { \
+        typedef data type; \
+    }; \
+    /**/
+
 namespace boost {
 
 template<typename F> struct result_of;

new file libs/lambda/test/Jamfile.v2

@@ +1 @@
+# Lambda library
+
+# Copyright (C) 2001-2007 Jaakko Järvi, Daniel Walker
+
+# Use, modification and distribution is 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) 
+
+# For more information, see http://www.boost.org/
+
+# bring in rules for testing
+import testing ;
+
+test-suite lambda
+    : 
+        [ run algorithm_test.cpp ]
+
+        [ run bind_tests_simple.cpp ]
+
+        [ run bind_tests_advanced.cpp ]
+
+        [ run bind_tests_simple_f_refs.cpp ]
+
+        [ run bll_and_function.cpp ]
+
+        [ run cast_test.cpp ]
+
+        [ run constructor_tests.cpp ]
+
+        [ run control_structures.cpp ]
+
+        [ run exception_test.cpp ]
+
+        [ run extending_rt_traits.cpp ]
+
+        [ run is_instance_of_test.cpp ]
+
+        [ run member_pointer_test.cpp ]
+
+        [ run operator_tests_simple.cpp ]
+
+        [ run phoenix_control_structures.cpp ]
+
+        [ run switch_construct.cpp ]
+    ;