From 2f2478d2d3af5ae44834ce1051178770c716f0c2 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 29 Jul 2019 16:38:57 -0400
Subject: [PATCH] Implements AsyncJustInTimeActor, experimentally.

---
 ClockReceiver/JustInTime.hpp                  | 44 +++++++++++++++++--
 .../xcschemes/Clock Signal.xcscheme           |  2 +-
 2 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/ClockReceiver/JustInTime.hpp b/ClockReceiver/JustInTime.hpp
index 21d0cdf27..e5f9a5ef6 100644
--- a/ClockReceiver/JustInTime.hpp
+++ b/ClockReceiver/JustInTime.hpp
@@ -9,7 +9,7 @@
 #ifndef JustInTime_h
 #define JustInTime_h
 
-//#include "../Concurrency/AsyncTaskQueue.hpp"
+#include "../Concurrency/AsyncTaskQueue.hpp"
 
 /*!
 	A JustInTimeActor holds (i) an embedded object with a run_for method; and (ii) an amount
@@ -51,12 +51,50 @@ template <class T, class LocalTimeScale, class TargetTimeScale = LocalTimeScale>
 };
 
 /*!
-	A JustInTimeAsyncActor acts like a JustInTimeActor but additionally contains an AsyncTaskQueue.
+	A AsyncJustInTimeActor acts like a JustInTimeActor but additionally contains an AsyncTaskQueue.
 	Any time the amount of accumulated time crosses a threshold provided at construction time,
 	the object will be updated on the AsyncTaskQueue.
 */
-template <class T, class TimeScale> class JustInTimeAsyncActor {
+template <class T, class LocalTimeScale, class TargetTimeScale = LocalTimeScale> class AsyncJustInTimeActor {
+	public:
+		/// Constructs a new AsyncJustInTimeActor using the same construction arguments as the included object.
+		template<typename... Args> AsyncJustInTimeActor(TargetTimeScale threshold, Args&&... args) :
+			object_(std::forward<Args>(args)...),
+		 	threshold_(threshold) {}
 
+		/// Adds time to the actor.
+		inline void operator += (const LocalTimeScale &rhs) {
+			time_since_update_ += rhs;
+			if(time_since_update_ >= threshold_) {
+				time_since_update_ -= threshold_;
+				task_queue_.enqueue([this] () {
+					object_.run_for(threshold_);
+				});
+			}
+			is_flushed_ = false;
+		}
+
+		/// Flushes all accumulated time and returns a pointer to the included object.
+		inline T *operator->() {
+			flush();
+			return &object_;
+		}
+
+		/// Flushes all accumulated time.
+		inline void flush() {
+			if(!is_flushed_) {
+				task_queue_.flush();
+				object_.run_for(time_since_update_.template flush<TargetTimeScale>());
+				is_flushed_ = true;
+			}
+		}
+
+	private:
+		T object_;
+		LocalTimeScale time_since_update_;
+		TargetTimeScale threshold_;
+		bool is_flushed_ = true;
+		Concurrency::AsyncTaskQueue task_queue_;
 };
 
 #endif /* JustInTime_h */
diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index 0cd11b1be..3ae34802d 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
@@ -69,7 +69,7 @@
       </AdditionalOptions>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Release"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       enableASanStackUseAfterReturn = "YES"