common.h

Go to the documentation of this file.

 
#pragma once
 
#include <coroutine>
#include <atomic>
#include <concepts>
#include <bit>
 
namespace coro {
 
template<typename T>
concept await_suspend_valid_return_value = (std::is_void_v<T>||std::is_convertible_v<T, bool>||std::is_convertible_v<T, std::coroutine_handle<> >);
 
template<typename T>
concept directly_awaitable = requires(T v, std::coroutine_handle<> h) {
    {v.await_ready()}->std::convertible_to<bool>;
    {v.await_suspend(h)}->await_suspend_valid_return_value;
    {v.await_resume()};
};
 
template<typename T>
concept indirectly_awaitable = requires(T v) {
    {v.operator co_await()} -> directly_awaitable;
};
 
template<typename T>
concept awaitable = directly_awaitable<T> || indirectly_awaitable<T>;
 
template<typename T, typename RetVal>
concept directly_awaitable_r = requires(T v, std::coroutine_handle<> h) {
    {v.await_ready()}->std::convertible_to<bool>;
    {v.await_suspend(h)}->await_suspend_valid_return_value;
    {v.await_resume()}->std::convertible_to<RetVal>;
};
 
template<typename T, typename RetVal>
concept indirectly_awaitable_r = requires(T v) {
    {v.operator co_await()} -> directly_awaitable_r<RetVal>;
};
 
template<typename T, typename RetVal>
concept awaitable_r = directly_awaitable_r<T,RetVal> || indirectly_awaitable_r<T,RetVal>;
 
template<typename T>
struct awaitable_result_impl;
 
template<directly_awaitable T>
struct awaitable_result_impl<T> {
    using type = decltype(std::declval<T>().await_resume());
};
 
template<indirectly_awaitable T>
struct awaitable_result_impl<T> {
    using type = typename awaitable_result_impl<decltype(std::declval<T>().operator co_await())>::type;
};
 
template<awaitable T>
using awaitable_result = typename awaitable_result_impl<T>::type;
 
 
#ifdef __clang__
#define CORO_OPT_BARRIER [[clang::optnone]]
#else
 
#define CORO_OPT_BARRIER
#endif
 
class ident_t {
public:
    ident_t() = default;
    template<typename X>
    ident_t(std::coroutine_handle<X> h):_addr(h.address()) {}
    bool operator==(const ident_t &other) const = default;
    bool operator<=>(const ident_t &other) const = default;
 
    friend std::size_t hash(const ident_t &other) {
        return std::bit_cast<std::size_t>(other._addr);
    }
    
    const void *address() const {return _addr;}
 
protected:
    const void *_addr = 0;
};
 
 
 
 
}