Starts trying to formalise just-in-time execution.

Which, at least, simplifies Cycle/HalfCycle to Cycle run_for usage via template.

ClockReceiver/ClockReceiver.hpp

@@ -149,8 +149,8 @@ template <class T> class WrappedInt {
 			Flushes the value in @c this. The current value is returned, and the internal value
 			is reset to zero.
 		*/
-		forceinline T flush() {
-			T result(length_);
+		template <typename Target> forceinline Target flush() {
+			const Target result(length_);
 			length_ = 0;
 			return result;
 		}
@@ -185,8 +185,8 @@ class HalfCycles: public WrappedInt<HalfCycles> {
 		}
 
 		/// Flushes the whole cycles in @c this, subtracting that many from the total stored here.
-		forceinline Cycles flush_cycles() {
-			Cycles result(length_ >> 1);
+		template <typename Cycles> forceinline Cycles flush() {
+			const Cycles result(length_ >> 1);
 			length_ &= 1;
 			return result;
 		}
@@ -220,7 +220,7 @@ template <class T> class HalfClockReceiver: public T {
 
 		forceinline void run_for(const HalfCycles half_cycles) {
 			half_cycles_ += half_cycles;
-			T::run_for(half_cycles_.flush_cycles());
+			T::run_for(half_cycles_.flush<Cycles>());
 		}
 
 	private:

ClockReceiver/DeferredQueue.hpp

@@ -1,26 +1,26 @@
 //
-//  ClockDeferrer.hpp
+//  DeferredQueue.hpp
 //  Clock Signal
 //
 //  Created by Thomas Harte on 23/08/2018.
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ClockDeferrer_h
-#define ClockDeferrer_h
+#ifndef DeferredQueue_h
+#define DeferredQueue_h
 
 #include <functional>
 #include <vector>
 
 /*!
-	A ClockDeferrer maintains a list of ordered actions and the times at which
+	A DeferredQueue maintains a list of ordered actions and the times at which
 	they should happen, and divides a total execution period up into the portions
 	that occur between those actions, triggering each action when it is reached.
 */
-template <typename TimeUnit> class ClockDeferrer {
+template <typename TimeUnit> class DeferredQueue {
 	public:
-		/// Constructs a ClockDeferrer that will call target(period) in between deferred actions.
-		ClockDeferrer(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
+		/// Constructs a DeferredQueue that will call target(period) in between deferred actions.
+		DeferredQueue(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
 
 		/*!
 			Schedules @c action to occur in @c delay units of time.
@@ -79,4 +79,4 @@ template <typename TimeUnit> class ClockDeferrer {
 		std::vector<DeferredAction> pending_actions_;
 };
 
-#endif /* ClockDeferrer_h */
+#endif /* DeferredQueue_h */

ClockReceiver/JustInTime.hpp

@@ -0,0 +1,55 @@
+//
+//  JustInTime.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 28/07/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef JustInTime_h
+#define JustInTime_h
+
+//#include "../Concurrency/AsyncTaskQueue.hpp"
+
+/*!
+	A JustInTimeActor holds (i) an embedded object with a run_for method; and (ii) an amount
+	of time since run_for was last called.
+
+	Time can be added using the += operator. The -> operator can be used to access the
+	embedded object. All time accumulated will be pushed to object before the pointer is returned.
+
+	Machines that accumulate HalfCycle time but supply to a Cycle-counted device may supply a
+	separate @c TargetTimeScale at template declaration.
+*/
+template <class T, class LocalTimeScale, class TargetTimeScale = LocalTimeScale> class JustInTimeActor {
+	public:
+		/// Constructs a new JustInTimeActor using the same construction arguments as the included object.
+		template<typename... Args> JustInTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {}
+
+		/// Adds time to the actor.
+		inline void operator += (const TimeScale &rhs) {
+			time_since_update_ += rhs;
+		}
+
+		/// Flushes all accumulated time and returns a pointer to the included object.
+		inline T *operator->() {
+			object_.run_for(time_since_update_.template flush<TargetTimeScale>());
+			return &object_;
+		}
+
+	private:
+		T object_;
+		LocalTimeScale time_since_update_;
+
+};
+
+/*!
+	A JustInTimeAsyncActor 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 {
+
+};
+
+#endif /* JustInTime_h */