Support connection to functor with multiple operator()

When variadic templates and decltype are supported, detect the best
overload of operator() to call.
Currently, the code takes the type of the operator(), which requires that
the functor only has one, and that it has no template parameter.

This feature is required if we want to connect to c++1y generic lambda
(N3418)

Change-Id: Ifa957da6955ea39ab804b58f320da9f98ff47d63
Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@digia.com>

2 files changed, 64 insertions, 6 deletions

diff --git a/src/corelib/kernel/qobject.h b/src/corelib/kernel/qobject.h
index 7beaa32855..aaa09fac50 100644
--- a/src/corelib/kernel/qobject.h
+++ b/src/corelib/kernel/qobject.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -265,27 +266,50 @@ public:
     static inline typename QtPrivate::QEnableIf<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::Type
             connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
     {
+#if defined (Q_COMPILER_DECLTYPE) && defined (Q_COMPILER_VARIADIC_TEMPLATES)
+        typedef QtPrivate::FunctionPointer<Func1> SignalType;
+        const int FunctorArgumentCount = QtPrivate::ComputeFunctorArgumentCount<Func2 , typename SignalType::Arguments>::Value;
+
+        Q_STATIC_ASSERT_X((FunctorArgumentCount >= 0),
+                          "Signal and slot arguments are not compatible.");
+        const int SlotArgumentCount = (FunctorArgumentCount >= 0) ? FunctorArgumentCount : 0;
+        typedef typename QtPrivate::FunctorReturnType<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value>::Value SlotReturnType;
+#else
+      // Without variadic template, we don't detect the best overload of operator(). We just
+      // assume there is only one simple operator() and connect to &Func2::operator()
+
+      /* If you get an error such as:
+             couldn't deduce template parameter 'Func2Operator'
+        or
+             cannot resolve address of overloaded function
+        It means the functor does not have a single operator().
+        Functors with overloaded or templated operator() are only supported if the compiler supports
+        C++11 variadic templates
+      */
 #ifndef Q_COMPILER_DECLTYPE  //Workaround the lack of decltype using another function as indirection
         return connect_functor(sender, signal, slot, &Func2::operator()); }
     template <typename Func1, typename Func2, typename Func2Operator>
     static inline QMetaObject::Connection connect_functor(const QObject *sender, Func1 signal, Func2 slot, Func2Operator) {
         typedef QtPrivate::FunctionPointer<Func2Operator> SlotType ;
 #else
-
         typedef QtPrivate::FunctionPointer<decltype(&Func2::operator())> SlotType ;
 #endif
         typedef QtPrivate::FunctionPointer<Func1> SignalType;
+        typedef typename SlotType::ReturnType SlotReturnType;
+        const int SlotArgumentCount = SlotType::ArgumentCount;
 
-        Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount),
+        Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= SlotArgumentCount,
                           "The slot requires more arguments than the signal provides.");
         Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value),
                           "Signal and slot arguments are not compatible.");
-        Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value),
+#endif
+
+        Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<SlotReturnType, typename SignalType::ReturnType>::value),
                           "Return type of the slot is not compatible with the return type of the signal.");
 
         return connectImpl(sender, reinterpret_cast<void **>(&signal), sender, 0,
-                           new QtPrivate::QFunctorSlotObject<Func2, SlotType::ArgumentCount,
-                                typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
+                           new QtPrivate::QFunctorSlotObject<Func2, SlotArgumentCount,
+                                typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value,
                                 typename SignalType::ReturnType>(slot),
                            Qt::DirectConnection, 0, &SignalType::Object::staticMetaObject);
     }
diff --git a/src/corelib/kernel/qobjectdefs_impl.h b/src/corelib/kernel/qobjectdefs_impl.h
index 46a6eab253..4f44d9204e 100644
--- a/src/corelib/kernel/qobjectdefs_impl.h
+++ b/src/corelib/kernel/qobjectdefs_impl.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -597,10 +598,43 @@ namespace QtPrivate {
         enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
                     && CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>::value };
     };
+#endif
+
+#if defined(Q_COMPILER_DECLTYPE) && defined(Q_COMPILER_VARIADIC_TEMPLATES)
+    /*
+       Find the maximum number of arguments a functor object can take and be still compatible with
+       the arguments from the signal.
+       Value is the number of arguments, or -1 if nothing matches.
+     */
+    template <typename Functor, typename ArgList> struct ComputeFunctorArgumentCount;
+
+    template <typename Functor, typename ArgList, bool Done> struct ComputeFunctorArgumentCountHelper
+    { enum { Value = -1 }; };
+    template <typename Functor, typename First, typename... ArgList>
+    struct ComputeFunctorArgumentCountHelper<Functor, List<First, ArgList...>, false>
+        : ComputeFunctorArgumentCount<Functor,
+            typename List_Left<List<First, ArgList...>, sizeof...(ArgList)>::Value> {};
+
+    template <typename Functor, typename... ArgList> struct ComputeFunctorArgumentCount<Functor, List<ArgList...>>
+    {
+        template <typename D> static D dummy();
+        template <typename F> static auto test(F f) -> decltype(((f.operator()((dummy<ArgList>())...)), int()));
+        static char test(...);
+        enum {
+            Ok = sizeof(test(dummy<Functor>())) == sizeof(int),
+            Value = Ok ? sizeof...(ArgList) : int(ComputeFunctorArgumentCountHelper<Functor, List<ArgList...>, Ok>::Value)
+        };
+    };
 
+    /* get the return type of a functor, given the signal argument list  */
+    template <typename Functor, typename ArgList> struct FunctorReturnType;
+    template <typename Functor, typename ... ArgList> struct FunctorReturnType<Functor, List<ArgList...>> {
+        template <typename D> static D dummy();
+        typedef decltype(dummy<Functor>().operator()((dummy<ArgList>())...)) Value;
+    };
 #endif
-}
 
+}
 
 QT_END_NAMESPACE