threading.h

#pragma once
 
#include <chrono>
#include <condition_variable>
#include <mutex>
 
namespace util {

class latch {
public:
    latch(std::size_t count);
 
    latch(const latch&) = delete;
 
    latch& operator=(const latch&) = delete;

    void wait() const;

    template <typename Rep, typename Period>
    bool wait_for(const std::chrono::duration<Rep, Period>& dur) const {
        std::unique_lock lock(mutex);
        return cv.wait_for(lock, dur, [&]() { return count == 0; });
    }

    template <typename Clock, typename Duration>
    bool wait_until(const std::chrono::time_point<Clock, Duration>& tp) const {
        std::unique_lock lock(mutex);
        return cv.wait_until(lock, tp, [&]() { return count == 0; });
    }

    void count_down(std::size_t n = 1);
 
private:
    std::size_t count;
    mutable std::mutex mutex;
    mutable std::condition_variable cv;
};
 
} // namespace util