awaitable.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "required.hpp"
#include "architecture.hpp"
#include <coroutine>
#include <type_traits>
 
namespace hi::inline v1 {
 
template<typename T>
concept awaitable_direct = requires(T a, std::coroutine_handle<> b)
{
    // clang-format off
    { a.await_ready() } -> std::convertible_to<bool>;
    a.await_suspend(b);
    a.await_resume();
    // clang-format on
};
 
template<typename T>
concept awaitable_member = requires(T a)
{
    a.operator co_await();
};
 
template<typename T>
concept awaitable_non_member = requires(T a)
{
    operator co_await(static_cast<T&&>(a));
};
 
template<typename T>
struct awaitable_cast {
    using type = void;
};
 
template<awaitable_direct T>
struct awaitable_cast<T> {
    using type = std::decay_t<T>;
 
    [[nodiscard]] type operator()(auto&& rhs) const noexcept
    {
        return hi_forward(rhs);
    }
};
 
template<awaitable_member T>
struct awaitable_cast<T> {
    using type = std::decay_t<decltype(std::declval<T>().operator co_await())>;
 
    [[nodiscard]] type operator()(auto&& rhs) const noexcept
    {
        return hi_forward(rhs).operator co_await();
    }
};
 
template<awaitable_non_member T>
struct awaitable_cast<T> {
    using type = std::decay_t<decltype(operator co_await(std::declval<T>()))>;
 
    [[nodiscard]] type operator()(auto&& rhs) const noexcept
    {
        return operator co_await(hi_forward(rhs));
    }
};
 
template<typename T>
using awaitable_cast_t = hi_typename awaitable_cast<T>::type;
 
template<typename T>
concept awaitable = not std::is_same_v<awaitable_cast_t<T>, void>;
 
template<typename T>
struct await_resume_result {
    using type = decltype(std::declval<T>().await_resume());
};
 
template<typename T>
using await_resume_result_t = hi_typename await_resume_result<T>::type;
 
}