semaphore.h

 
#pragma once
 
#include <condition_variable>
#include <cstddef>
#include <mutex>
 
namespace xrpl {
 
template <class Mutex, class CondVar>
class BasicSemaphore
{
private:
    Mutex mutex_;
    CondVar cond_;
    std::size_t count_;
 
public:
    using size_type = std::size_t;

    explicit BasicSemaphore(size_type count = 0) : count_(count)
    {
    }

    void
    notify()
    {
        std::scoped_lock const lock{mutex_};
        ++count_;
        cond_.notify_one();
    }

    void
    wait()
    {
        std::unique_lock lock{mutex_};
        while (count_ == 0)
            cond_.wait(lock);
        --count_;
    }

    bool
    tryWait()
    {
        std::scoped_lock lock{mutex_};
        if (count_ == 0)
            return false;
        --count_;
        return true;
    }
};
 
using Semaphore = BasicSemaphore<std::mutex, std::condition_variable>;
 
}  // namespace xrpl