99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
/*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* Licensed under the Apache License Version 2.0 with LLVM Exceptions
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* https://llvm.org/LICENSE.txt
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#pragma once
|
|
|
|
#include <unifex/coroutine.hpp>
|
|
#include <unifex/std_concepts.hpp>
|
|
|
|
#if UNIFEX_NO_COROUTINES
|
|
# error "Coroutine support is required to use <unifex/coroutine_concepts.hpp>"
|
|
#endif
|
|
|
|
#include <type_traits>
|
|
|
|
#include <unifex/detail/prologue.hpp>
|
|
|
|
namespace unifex {
|
|
|
|
namespace detail {
|
|
template <typename Awaitable, typename = void>
|
|
constexpr bool has_member_operator_co_await_v = false;
|
|
|
|
template <typename Awaitable>
|
|
constexpr bool has_member_operator_co_await_v<
|
|
Awaitable,
|
|
std::void_t<decltype(std::declval<Awaitable>().operator co_await())>> =
|
|
true;
|
|
|
|
template <typename Awaitable, typename = void>
|
|
constexpr bool has_free_operator_co_await_v = false;
|
|
|
|
template <typename Awaitable>
|
|
constexpr bool has_free_operator_co_await_v<
|
|
Awaitable,
|
|
std::void_t<decltype(operator co_await(std::declval<Awaitable>()))>> = true;
|
|
|
|
template <typename Awaiter, typename = void>
|
|
struct await_result_impl {};
|
|
|
|
template <typename Awaiter>
|
|
struct await_result_impl<
|
|
Awaiter,
|
|
std::void_t<
|
|
decltype(std::declval<Awaiter&>().await_ready() ? (void)0 : (void)0),
|
|
decltype(std::declval<Awaiter&>().await_resume())>> {
|
|
using type = decltype(std::declval<Awaiter&>().await_resume());
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
inline const struct _get_awaiter_fn {
|
|
template <typename Awaitable>
|
|
constexpr decltype(auto) operator()(Awaitable&& awaitable) const noexcept {
|
|
if constexpr (detail::has_member_operator_co_await_v<Awaitable>) {
|
|
return static_cast<Awaitable&&>(awaitable).operator co_await();
|
|
} else if constexpr (detail::has_free_operator_co_await_v<Awaitable>) {
|
|
return operator co_await(static_cast<Awaitable&&>(awaitable));
|
|
} else {
|
|
return static_cast<Awaitable&&>(awaitable);
|
|
}
|
|
}
|
|
} get_awaiter {};
|
|
|
|
template <typename Awaitable>
|
|
using awaiter_type_t = decltype(get_awaiter(std::declval<Awaitable>()));
|
|
|
|
template <typename Awaitable>
|
|
using await_result_t =
|
|
typename detail::await_result_impl<awaiter_type_t<Awaitable>>::type;
|
|
|
|
namespace detail {
|
|
template <typename Awaitable>
|
|
UNIFEX_CONCEPT_FRAGMENT( //
|
|
_awaitable_impl, //
|
|
requires() ( //
|
|
typename(await_result_t<Awaitable>)
|
|
));
|
|
template <typename Awaitable>
|
|
UNIFEX_CONCEPT //
|
|
_awaitable = //
|
|
UNIFEX_FRAGMENT(detail::_awaitable_impl, Awaitable);
|
|
} // namespace detail
|
|
|
|
} // namespace unifex
|
|
|
|
#include <unifex/detail/epilogue.hpp>
|