AsyncEvent.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <coroutine>
#include <type_traits>
#include <utility>
 
namespace corium::async {
 
template <typename T = void>
class AsyncEvent {
public:
    using ValueType = T;
 
    constexpr AsyncEvent() = default;
 
    template <typename U>
        requires (std::is_convertible_v<U, T>)
    void emit(U&& value) {
        _value = std::forward<U>(value);
        _ready.store(true, std::memory_order_release);
        auto h = _waiter.exchange(nullptr, std::memory_order_acq_rel);
        if (h && !h.done()) {
            h.resume();
        }
    }
 
    void reset() noexcept {
        _ready.store(false, std::memory_order_release);
        _waiter.store(nullptr, std::memory_order_release);
    }
 
    [[nodiscard]] bool isReady() const noexcept {
        return _ready.load(std::memory_order_acquire);
    }
 
    struct Awaiter {
        AsyncEvent& event;
 
        [[nodiscard]] bool await_ready() const noexcept {
            return event.isReady();
        }
 
        bool await_suspend(std::coroutine_handle<> h) noexcept {
            if (event.isReady()) {
                return false;
            }
            event._waiter.store(h, std::memory_order_release);
            return !event.isReady();
        }
 
        T await_resume() {
            event._ready.store(false, std::memory_order_release);
            return std::move(event._value);
        }
    };
 
    [[nodiscard]] Awaiter wait() noexcept {
        return Awaiter{*this};
    }
 
    [[nodiscard]] Awaiter operator co_await() noexcept {
        return Awaiter{*this};
    }
 
private:
    std::atomic<std::coroutine_handle<>> _waiter{nullptr};
    T _value{};
    std::atomic<bool> _ready{false};
};
 
template <>
class AsyncEvent<void> {
public:
    using ValueType = void;
 
    constexpr AsyncEvent() = default;
 
    void emit() noexcept {
        _ready.store(true, std::memory_order_release);
        auto h = _waiter.exchange(nullptr, std::memory_order_acq_rel);
        if (h && !h.done()) {
            h.resume();
        }
    }
 
    void reset() noexcept {
        _ready.store(false, std::memory_order_release);
        _waiter.store(nullptr, std::memory_order_release);
    }
 
    [[nodiscard]] bool isReady() const noexcept {
        return _ready.load(std::memory_order_acquire);
    }
 
    struct Awaiter {
        AsyncEvent<void>& event;
 
        [[nodiscard]] bool await_ready() const noexcept {
            return event.isReady();
        }
 
        bool await_suspend(std::coroutine_handle<> h) noexcept {
            if (event.isReady()) {
                return false;
            }
            event._waiter.store(h, std::memory_order_release);
            return !event.isReady();
        }
 
        constexpr void await_resume() const noexcept {}
    };
 
    [[nodiscard]] Awaiter wait() noexcept {
        return Awaiter{*this};
    }
 
    [[nodiscard]] Awaiter operator co_await() noexcept {
        return Awaiter{*this};
    }
 
private:
    std::atomic<std::coroutine_handle<>> _waiter{nullptr};
    std::atomic<bool> _ready{false};
};
 
} // namespace corium::async