coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2026-10-28 18:07:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix the build when coroutines are enabled

Browse Source
This commit is contained in:
Denis Blank 2018-12-10 06:03:46 +01:00
parent 57bb43138b
commit b2726982ac
2 changed files with 17 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/continuable/continuable-coroutine.hpp
View File

@ -51,12 +51,12 @@ namespace std {
namespace experimental {
template <typename Data, typename... Args, typename... FunctionArgs>
struct coroutine_traits<
cti::continuable_base<Data,
cti::detail::traits::identity<Args...>>,
cti::continuable_base<Data, cti::detail::traits::identity<Args...>>,
FunctionArgs...> {
using promise_type =
cti::detail::awaiting::promise_type<cti::promise<Args...>, Args...>;
cti::detail::awaiting::promise_type<cti::continuable<Args...>,
cti::promise<Args...>, Args...>;
};
} // namespace experimental
} // namespace std

27
include/continuable/detail/other/coroutines.hpp
View File

@ -150,38 +150,39 @@ struct handle_takeover {
/// The type which is passed to the compiler that describes the properties
/// of a continuable_base used as coroutine promise type.
template <typename Promise, typename... Args>
template <typename Continuable, typename Promise, typename... Args>
struct promise_type;
/// Implements the resolving method return_void and return_value accordingly
template <typename Base>
struct promise_resolver_base;
template <typename Promise>
struct promise_resolver_base<promise_type<Promise>> {
template <typename Continuable, typename Promise>
struct promise_resolver_base<promise_type<Continuable, Promise>> {
void return_void() {
auto me = static_cast<promise_type<Promise>*>(this);
auto me = static_cast<promise_type<Continuable, Promise>*>(this);
me->promise_.set_value();
}
};
template <typename Promise, typename T>
struct promise_resolver_base<promise_type<Promise, T>> {
template <typename Continuable, typename Promise, typename T>
struct promise_resolver_base<promise_type<Continuable, Promise, T>> {
void return_value(T value) {
auto me = static_cast<promise_type<Promise, T>*>(this);
auto me = static_cast<promise_type<Continuable, Promise, T>*>(this);
me->promise_.set_value(std::move(value));
}
};
template <typename Promise, typename... Args>
struct promise_resolver_base<promise_type<Promise, Args...>> {
template <typename Continuable, typename Promise, typename... Args>
struct promise_resolver_base<promise_type<Continuable, Promise, Args...>> {
template <typename T>
void return_value(T&& tuple_like) {
auto me = static_cast<promise_type<Promise, Args...>*>(this);
auto me = static_cast<promise_type<Continuable, Promise, Args...>*>(this);
traits::unpack(std::move(me->promise_), std::forward<T>(tuple_like));
}
};
template <typename Promise, typename... Args>
struct promise_type : promise_resolver_base<promise_type<Promise, Args...>> {
template <typename Continuable, typename Promise, typename... Args>
struct promise_type
: promise_resolver_base<promise_type<Continuable, Promise, Args...>> {
coroutine_handle<> handle_;
Promise promise_;
@ -189,7 +190,7 @@ struct promise_type : promise_resolver_base<promise_type<Promise, Args...>> {
explicit promise_type() : promise_(types::promise_no_init_arg_t{}) {
}
auto get_return_object() {
Continuable get_return_object() {
return [this](auto&& promise) {
promise_ = std::forward<decltype(promise)>(promise);
handle_.resume();