From 04c80b63f0d165c0ee2738031820eeb55d6925f2 Mon Sep 17 00:00:00 2001
From: heck <heck@pep.foundation>
Date: Mon, 28 Feb 2022 23:28:15 +0100
Subject: [PATCH] Moved: module 'CountingSemaphore' to libpEpCxx11

---
 src/CountingSemaphore.hh | 69 ----------------------------------------
 1 file changed, 69 deletions(-)
 delete mode 100644 src/CountingSemaphore.hh

diff --git a/src/CountingSemaphore.hh b/src/CountingSemaphore.hh
deleted file mode 100644
index ddd632c..0000000
--- a/src/CountingSemaphore.hh
+++ /dev/null
@@ -1,69 +0,0 @@
-// This file is under GNU General Public License 3.0
-// see LICENSE.txt
-
-#ifndef LIBPEPADAPTER_COUNTING_SEMAPHORE_HH
-#define LIBPEPADAPTER_COUNTING_SEMAPHORE_HH
-
-#include <mutex>
-#include <condition_variable>
-#include <atomic>
-
-namespace pEp {
-    class CountingSemaphore {
-        std::mutex mtx;
-        std::condition_variable cv;
-
-        // To synchronize threads, ALWAYS use <atomic> types
-        std::atomic_uint _count;
-
-    public:
-        CountingSemaphore(unsigned count = 0) : _count(count) {}
-
-        // Change the stored count.
-        CountingSemaphore& operator=(unsigned count)
-        {
-            std::unique_lock<std::mutex> lock(mtx);
-            _count.store (count);
-            if (count != 0)
-                cv.notify_one ();
-            return *this;
-        }
-
-        // Return the current stored count.
-        unsigned load()
-        {
-            return _count.load ();
-        }
-
-        // Atomically decrement the stored count, blocking in case the count
-        // is currently zero.  When the method terminates the counter is
-        // guaranteed to have been decremented by one unit.
-        //
-        // This is Dijkstra's P operation, used to atomically acquire a resource.
-        void p()
-        {
-            std::unique_lock<std::mutex> lock(mtx);
-            // FIXME: is the loop even needed?  Any received notification will
-            // wake up only one thread, which will see the count as non-zero...
-            // I guess an if conditional would work just as well as a while
-            // loop, but I will follow the canonical pattern just in case some
-            // new bizarre operation other than V is added later.
-            while (_count.load() == 0)
-                cv.wait(lock);
-            _count --;
-        }
-
-        // Atomically increment the stored count.  This may wake up one thread
-        // which is currently executing the p method.
-        //
-        // This is Dijkstra's V operation, used to atomically release a resource.
-        void v()
-        {
-            std::unique_lock<std::mutex> lock(mtx);
-            _count ++;
-            cv.notify_one();
-        }
-    };
-} // namespace pEp
-
-#endif // LIBPEPADAPTER_COUNTING_SEMAPHORE_HH