Add a maximum number of forward/backward time steps that can be queued

scwx-qt/source/scwx/qt/util/queue_counter.cpp

@@ -0,0 +1,49 @@
+#include <scwx/qt/util/queue_counter.hpp>
+
+#include <atomic>
+
+namespace scwx::qt::util
+{
+
+class QueueCounter::Impl
+{
+public:
+   explicit Impl(size_t maxCount) : maxCount_ {maxCount} {}
+
+   const size_t        maxCount_;
+   std::atomic<size_t> count_ {0};
+};
+
+QueueCounter::QueueCounter(size_t maxCount) :
+    p {std::make_unique<Impl>(maxCount)}
+{
+}
+
+QueueCounter::~QueueCounter() = default;
+
+bool QueueCounter::add()
+{
+   const size_t count = p->count_.fetch_add(1);
+   // Must be >= (not ==) to avoid race conditions
+   if (count >= p->maxCount_)
+   {
+      p->count_.fetch_sub(1);
+      return false;
+   }
+   else
+   {
+      return true;
+   }
+}
+
+void QueueCounter::remove()
+{
+   p->count_.fetch_sub(1);
+}
+
+bool QueueCounter::is_lock_free()
+{
+   return p->count_.is_lock_free();
+}
+
+} // namespace scwx::qt::util

scwx-qt/source/scwx/qt/util/queue_counter.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <atomic>
+
+namespace scwx::qt::util
+{
+
+class QueueCounter
+{
+public:
+   /**
+    * Counts the number of items in a queue, and prevents it from exceeding a
+    * count in a thread safe manor. This is lock free, assuming
+    * std::atomic<size_t> supports lock free fetch_add and fetch_sub.
+    */
+
+   /**
+    * Construct a QueueCounter with a given maximum count
+    *
+    * @param maxCount The maximum number of items in the queue
+    */
+   explicit QueueCounter(size_t maxCount);
+
+   ~QueueCounter();
+   QueueCounter(const QueueCounter&)            = delete;
+   QueueCounter(QueueCounter&&)                 = delete;
+   QueueCounter& operator=(const QueueCounter&) = delete;
+   QueueCounter& operator=(QueueCounter&&)      = delete;
+
+   /**
+    * Called before adding an item. If it returns true, it is ok to add. If it
+    * returns false, it should not be added
+    *
+    * @return true if it is ok to add, false if the queue is full
+    */
+   bool add();
+
+   /**
+    * Called when item is removed from the queue. Should only be called after a
+    * corresponding and successful call to add.
+    */
+   void remove();
+
+   /**
+    * Tells if this instance is lock free
+    *
+    * @return true if it is lock free, false otherwise
+    */
+   bool is_lock_free();
+
+   /**
+    * Tells if this class is always lock free. True if it is lock free, false
+    * otherwise
+    */
+   static constexpr bool is_always_lock_free =
+      std::atomic<size_t>::is_always_lock_free;
+
+private:
+   class Impl;
+   std::unique_ptr<Impl> p;
+};
+
+} // namespace scwx::qt::util