Simplify decoding of function signature

This gets rid of the FunctionSignature and FunctionArgs helper classes
by using a pointer-to-member-function and being able to get the
arguments as a pack directly. As a result the function signature no
longer has to be specified explicitly as a template parameter, it's
instead determined by the compiler using template type deduction.

This further simplifies the C++98 code to be ridiculously
straightforward and the C++11 is simpler because it no longer has to be
C++98 compatible.

Author: muggenhor

include/cucumber-cpp/internal/RegistrationMacros.hpp

@@ -25,7 +25,7 @@
 class class_name : public parent_class {                                  \
 public:                                                                   \
     void body() {                                                         \
-        return invokeBodyWithArgs<void args>(*this);                      \
+        return invokeWithArgs(*this, &class_name::bodyWithArgs);          \
     }                                                                     \
     void bodyWithArgs args;                                               \
 private:                                                                  \

include/cucumber-cpp/internal/hook/HookRegistrar.hpp

@@ -4,22 +4,13 @@
 #include "Tag.hpp"
 #include "../Scenario.hpp"
 #include "../step/StepManager.hpp"
-#include "../utils/FunctionSignature.hpp"
-#include "../utils/IndexSequence.hpp"
 
 #include <boost/make_shared.hpp>
 #include <boost/smart_ptr.hpp>
-#include <boost/static_assert.hpp>
 using boost::shared_ptr;
 
 #include <list>
 
-#ifdef BOOST_STATIC_ASSERT_MSG
-    #define CUKE_STATIC_ASSERT(cond, msg) BOOST_STATIC_ASSERT_MSG(cond, msg)
-#else
-    #define CUKE_STATIC_ASSERT(cond, msg) BOOST_STATIC_ASSERT(cond)
-#endif
-
 namespace cucumber {
 namespace internal {
 
@@ -37,20 +28,9 @@ class Hook {
 protected:
     bool tagsMatch(Scenario *scenario);
 
-    template <typename R, typename Derived>
-    static R invokeBodyWithIndexedArgs(Derived& that, FunctionArgs<>, index_sequence<>) {
-        return that.bodyWithArgs();
-    }
-
-    template <typename Signature, typename Derived>
-    static typename FunctionSignature<Signature>::result_type invokeBodyWithArgs(Derived& that) {
-        typedef typename FunctionSignature<Signature>::result_type result_type;
-        typedef typename FunctionSignature<Signature>::args_type   args_type;
-        CUKE_STATIC_ASSERT(args_type::size == 0, "Hooks don't support function arguments.");
-        return invokeBodyWithIndexedArgs<result_type>(
-                that,
-                args_type(),
-                make_index_sequence<args_type::size>());
+    template <typename Derived, typename R>
+    static R invokeWithArgs(Derived& that, R (Derived::* f)()) {
+        return (that.*f)();
     }
 private:
     shared_ptr<TagExpression> tagExpression;

include/cucumber-cpp/internal/step/StepManager.hpp

@@ -18,7 +18,6 @@ using boost::shared_ptr;
 #endif
 
 #include "../Table.hpp"
-#include "../utils/FunctionSignature.hpp"
 #include "../utils/IndexSequence.hpp"
 #include "../utils/Regex.hpp"
 
@@ -135,29 +134,27 @@ class BasicStep {
 
 #ifdef BOOST_NO_VARIADIC_TEMPLATES
     // Special case for zero arguments, only thing we bother to support on C++98
-    template <typename R, typename Derived>
-    static R invokeBodyWithIndexedArgs(Derived& that, FunctionArgs<>, index_sequence<>) {
-        return that.bodyWithArgs();
+    template <typename Derived, typename R>
+    static R invokeWithArgs(Derived& that, R (Derived::* f)()) {
+        return (that.*f)();
     }
 #else
-    template <typename R, typename Derived, typename... Args, std::size_t... N>
-    static R invokeBodyWithIndexedArgs(Derived& that, FunctionArgs<Args...>, index_sequence<N...>) {
-        return that.bodyWithArgs(
+    template <typename Derived, typename R, typename... Args, std::size_t... N>
+    static R invokeWithIndexedArgs(Derived& that, R (Derived::* f)(Args...), index_sequence<N...>) {
+        return (that.*f)(
                 that.pArgs->template getInvokeArg<typename std::decay<Args>::type>(N)...
             );
     }
-#endif
 
-    template <typename Signature, typename Derived>
-    static typename FunctionSignature<Signature>::result_type invokeBodyWithArgs(Derived& that) {
-        typedef typename FunctionSignature<Signature>::result_type result_type;
-        typedef typename FunctionSignature<Signature>::args_type   args_type;
-        that.currentArgIndex = args_type::size;
-        return invokeBodyWithIndexedArgs<result_type>(
+    template <typename Derived, typename R, typename... Args>
+    static R invokeWithArgs(Derived& that, R (Derived::* f)(Args...)) {
+        that.currentArgIndex = sizeof...(Args);
+        return invokeWithIndexedArgs(
                 that,
-                args_type(),
-                make_index_sequence<args_type::size>());
+                f,
+                index_sequence_for<Args...>{});
     }
+#endif
 
 private:
     // FIXME: awful hack because of Boost::Test

include/cucumber-cpp/internal/utils/FunctionSignature.hpp

@@ -3,7 +3,9 @@
 
 #include <boost/config.hpp>
 
-#if __cplusplus < 201402L && !(_MSC_VER > 1800) || defined(BOOST_NO_VARIADIC_TEMPLATES)
+#ifndef BOOST_NO_VARIADIC_TEMPLATES
+
+#if __cplusplus < 201402L && !(_MSC_VER > 1800)
     #include <cstddef> // for std::size_t
 #else
     #include <utility>
@@ -12,18 +14,7 @@
 namespace cucumber {
 namespace internal {
 
-#ifdef BOOST_NO_VARIADIC_TEMPLATES
-// Special case for zero, only thing we bother to support on C++98
-template <typename = void>
-struct index_sequence {
-    typedef index_sequence type;
-};
-
-template <std::size_t N>
-struct make_index_sequence;
-
-template <> struct make_index_sequence<0> : public index_sequence< > {};
-#elif __cplusplus < 201402L && !(_MSC_VER > 1800)
+#if __cplusplus < 201402L && !(_MSC_VER > 1800)
 // Based on https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
 
 template <std::size_t... N>
@@ -53,12 +44,17 @@ struct make_index_sequence : public concat_index_sequence<
 
 template <> struct make_index_sequence<0> : public index_sequence< > {};
 template <> struct make_index_sequence<1> : public index_sequence<0> {};
+
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 #else
 using ::std::index_sequence;
-using ::std::make_index_sequence;
+using ::std::index_sequence_for;
 #endif
 
 }
 }
 
+#endif /* !BOOST_NO_VARIADIC_TEMPLATES */
+
 #endif /* CUKE_INDEXSEQ_HPP_ */

include/cucumber-cpp/internal/utils/IndexSequence.hpp

@@ -102,7 +102,7 @@ class CheckAllParametersWithFuncArgs : public CheckAllParameters {
     }
 
     void body() {
-        return invokeBodyWithArgs<void ARGS>(*this);
+        return invokeWithArgs(*this, &CheckAllParametersWithFuncArgs::bodyWithArgs);
     }
 #undef ARGS
 };