latch.h

#pragma once
#include <asyncpp/event.h>
#include <atomic>
#include <cstddef>
#include <limits>
 
namespace asyncpp {
    class latch {
    public:
        static constexpr std::size_t max = std::numeric_limits<std::size_t>::max();
 
        explicit latch(std::size_t initial) noexcept : m_count{initial}, m_event{initial <= 0} {}
 
        latch(const latch&) = delete;
 
        latch& operator=(const latch&) = delete;
 
        [[nodiscard]] bool is_ready() const noexcept { return m_event.is_set(); }
 
        void decrement(std::size_t n = 1) noexcept {
            if (m_count.fetch_sub(n, std::memory_order::acq_rel) == 0) { m_event.set(); }
        }
 
        [[nodiscard]] auto operator co_await() noexcept { return m_event.wait(dispatcher::current()); }
 
        [[nodiscard]] auto wait(dispatcher* resume_dispatcher = nullptr) noexcept {
            return m_event.wait(resume_dispatcher);
        }
 
    private:
        std::atomic<std::size_t> m_count;
        multi_consumer_event m_event;
    };
} // namespace asyncpp