Merge master 6.4.6 into DRTVWR-510

Includes the conversion to VS2017 build tools.

1 files changed, 68 insertions, 1 deletions

diff --git a/indra/llcommon/lleventtimer.h b/indra/llcommon/lleventtimer.h
index dc918121e1..dbbfe0c6e6 100644
--- a/indra/llcommon/lleventtimer.h
+++ b/indra/llcommon/lleventtimer.h
@@ -40,16 +40,83 @@ public:
 	LLEventTimer(F32 period);	// period is the amount of time between each call to tick() in seconds
 	LLEventTimer(const LLDate& time);
 	virtual ~LLEventTimer();
-	
+
 	//function to be called at the supplied frequency
 	// Normally return FALSE; TRUE will delete the timer after the function returns.
 	virtual BOOL tick() = 0;
 
 	static void updateClass();
 
+	/// Schedule recurring calls to generic callable every period seconds.
+	/// Returns a pointer; if you delete it, cancels the recurring calls.
+	template <typename CALLABLE>
+	static LLEventTimer* run_every(F32 period, const CALLABLE& callable);
+
+	/// Schedule a future call to generic callable. Returns a pointer.
+	/// CAUTION: The object referenced by that pointer WILL BE DELETED once
+	/// the callback has been called! LLEventTimer::getInstance(pointer) (NOT
+	/// pointer->getInstance(pointer)!) can be used to test whether the
+	/// pointer is still valid. If it is, deleting it will cancel the
+	/// callback.
+	template <typename CALLABLE>
+	static LLEventTimer* run_at(const LLDate& time, const CALLABLE& callable);
+
+	/// Like run_at(), but after a time delta rather than at a timestamp.
+	/// Same CAUTION.
+	template <typename CALLABLE>
+	static LLEventTimer* run_after(F32 interval, const CALLABLE& callable);
+
 protected:
 	LLTimer mEventTimer;
 	F32 mPeriod;
+
+private:
+	template <typename CALLABLE>
+	class Generic;
+};
+
+template <typename CALLABLE>
+class LLEventTimer::Generic: public LLEventTimer
+{
+public:
+    // making TIME generic allows engaging either LLEventTimer constructor
+    template <typename TIME>
+    Generic(const TIME& time, bool once, const CALLABLE& callable):
+        LLEventTimer(time),
+        mOnce(once),
+        mCallable(callable)
+    {}
+    BOOL tick() override
+    {
+        mCallable();
+        // true tells updateClass() to delete this instance
+        return mOnce;
+    }
+
+private:
+    bool mOnce;
+    CALLABLE mCallable;
 };
 
+template <typename CALLABLE>
+LLEventTimer* LLEventTimer::run_every(F32 period, const CALLABLE& callable)
+{
+    // return false to schedule recurring calls
+    return new Generic<CALLABLE>(period, false, callable);
+}
+
+template <typename CALLABLE>
+LLEventTimer* LLEventTimer::run_at(const LLDate& time, const CALLABLE& callable)
+{
+    // return true for one-shot callback
+    return new Generic<CALLABLE>(time, true, callable);
+}
+
+template <typename CALLABLE>
+LLEventTimer* LLEventTimer::run_after(F32 interval, const CALLABLE& callable)
+{
+    // one-shot callback after specified interval
+    return new Generic<CALLABLE>(interval, true, callable);
+}
+
 #endif //LL_EVENTTIMER_H