QTimer: add convenience singleShot methods for functors

This brings QTimer::singleShot on par with QObject::connect in
terms of the new Qt5 syntax. With this patch, it is now possible
to connect singleShot to a member pointer, a static function
pointer and a functor (with or without a context object).

The short code path for 0 msec is not yet implemented - it will
require further modifications to QMetaObject before it will be.

An additional SFINAE on the new singleShot overloads had to be
implemented to prevent tricking the compiler into believing
const char * might be a function pointer.

[ChangeLog][QtCore][QTimer] Implemented new style connect syntax,
including functors, in QTimer::singleShot

Task-number: QTBUG-26406
Change-Id: I31b2fa2c8369648030ec80b12e3ae10b92eb28b4
Reviewed-by: Olivier Goffart <ogoffart@woboq.com>

1 files changed, 64 insertions, 0 deletions

diff --git a/src/corelib/kernel/qtimer.h b/src/corelib/kernel/qtimer.h
index 3484f4dba8..6439070805 100644
--- a/src/corelib/kernel/qtimer.h
+++ b/src/corelib/kernel/qtimer.h
@@ -81,6 +81,67 @@ public:
     static void singleShot(int msec, const QObject *receiver, const char *member);
     static void singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, const char *member);
 
+#ifdef Q_QDOC
+    static void singleShot(int msec, const QObject *receiver, PointerToMemberFunction method);
+    static void singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, PointerToMemberFunction method);
+    static void singleShot(int msec, Functor functor);
+    static void singleShot(int msec, Qt::TimerType timerType, Functor functor);
+    static void singleShot(int msec, const QObject *context, Functor functor);
+    static void singleShot(int msec, Qt::TimerType timerType, const QObject *context, Functor functor);
+#else
+    // singleShot to a QObject slot
+    template <typename Func1>
+    static inline void singleShot(int msec, const typename QtPrivate::FunctionPointer<Func1>::Object *receiver, Func1 slot)
+    {
+        singleShot(msec, msec >= 2000 ? Qt::CoarseTimer : Qt::PreciseTimer, receiver, slot);
+    }
+    template <typename Func1>
+    static inline void singleShot(int msec, Qt::TimerType timerType, const typename QtPrivate::FunctionPointer<Func1>::Object *receiver,
+                                  Func1 slot)
+    {
+        typedef QtPrivate::FunctionPointer<Func1> SlotType;
+
+        //compilation error if the slot has arguments.
+        Q_STATIC_ASSERT_X(int(SlotType::ArgumentCount) == 0,
+                          "The slot must not have any arguments.");
+
+        singleShotImpl(msec, timerType, receiver,
+                       new QtPrivate::QSlotObject<Func1, typename SlotType::Arguments, void>(slot));
+    }
+    // singleShot to a functor or function pointer (without context)
+    template <typename Func1>
+    static inline void singleShot(int msec, Func1 slot)
+    {
+        singleShot(msec, msec >= 2000 ? Qt::CoarseTimer : Qt::PreciseTimer, Q_NULLPTR, slot);
+    }
+    template <typename Func1>
+    static inline void singleShot(int msec, Qt::TimerType timerType, Func1 slot)
+    {
+        singleShot(msec, timerType, Q_NULLPTR, slot);
+    }
+    // singleShot to a functor or function pointer (with context)
+    template <typename Func1>
+    static inline typename QtPrivate::QEnableIf<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
+                                                !QtPrivate::is_same<const char*, Func1>::value, void>::Type
+            singleShot(int msec, QObject *context, Func1 slot)
+    {
+        singleShot(msec, msec >= 2000 ? Qt::CoarseTimer : Qt::PreciseTimer, context, slot);
+    }
+    template <typename Func1>
+    static inline typename QtPrivate::QEnableIf<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
+                                                !QtPrivate::is_same<const char*, Func1>::value, void>::Type
+            singleShot(int msec, Qt::TimerType timerType, QObject *context, Func1 slot)
+    {
+        //compilation error if the slot has arguments.
+        typedef QtPrivate::FunctionPointer<Func1> SlotType;
+        Q_STATIC_ASSERT_X(int(SlotType::ArgumentCount) <= 0,  "The slot must not have any arguments.");
+
+        singleShotImpl(msec, timerType, context,
+                       new QtPrivate::QFunctorSlotObject<Func1, 0,
+                            typename QtPrivate::List_Left<void, 0>::Value, void>(slot));
+    }
+#endif
+
 public Q_SLOTS:
     void start(int msec);
 
@@ -103,6 +164,9 @@ private:
     inline int startTimer(int){ return -1;}
     inline void killTimer(int){}
 
+    static void singleShotImpl(int msec, Qt::TimerType timerType,
+                               const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj);
+
     int id, inter, del;
     uint single : 1;
     uint nulltimer : 1;