mirror of
https://github.com/llvm-mirror/libcxx.git
synced 2025-10-24 12:02:36 +08:00
4abbf7dac3
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351636 91177308-0d34-0410-b5e6-96231b3b80d8
336 lines
10 KiB
C++
336 lines
10 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------- coroutine -----------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE
|
|
#define _LIBCPP_EXPERIMENTAL_COROUTINE
|
|
|
|
/**
|
|
experimental/coroutine synopsis
|
|
|
|
// C++next
|
|
|
|
namespace std {
|
|
namespace experimental {
|
|
inline namespace coroutines_v1 {
|
|
|
|
// 18.11.1 coroutine traits
|
|
template <typename R, typename... ArgTypes>
|
|
class coroutine_traits;
|
|
// 18.11.2 coroutine handle
|
|
template <typename Promise = void>
|
|
class coroutine_handle;
|
|
// 18.11.2.7 comparison operators:
|
|
bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
|
|
// 18.11.3 trivial awaitables
|
|
struct suspend_never;
|
|
struct suspend_always;
|
|
// 18.11.2.8 hash support:
|
|
template <class T> struct hash;
|
|
template <class P> struct hash<coroutine_handle<P>>;
|
|
|
|
} // namespace coroutines_v1
|
|
} // namespace experimental
|
|
} // namespace std
|
|
|
|
*/
|
|
|
|
#include <experimental/__config>
|
|
#include <new>
|
|
#include <type_traits>
|
|
#include <functional>
|
|
#include <memory> // for hash<T*>
|
|
#include <cstddef>
|
|
#include <cassert>
|
|
#include <__debug>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
#ifdef _LIBCPP_HAS_NO_COROUTINES
|
|
# if defined(_LIBCPP_WARNING)
|
|
_LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler")
|
|
# else
|
|
# warning <experimental/coroutine> cannot be used with this compiler
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef _LIBCPP_HAS_NO_COROUTINES
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
|
|
|
|
template <class _Tp, class = void>
|
|
struct __coroutine_traits_sfinae {};
|
|
|
|
template <class _Tp>
|
|
struct __coroutine_traits_sfinae<
|
|
_Tp, typename __void_t<typename _Tp::promise_type>::type>
|
|
{
|
|
using promise_type = typename _Tp::promise_type;
|
|
};
|
|
|
|
template <typename _Ret, typename... _Args>
|
|
struct _LIBCPP_TEMPLATE_VIS coroutine_traits
|
|
: public __coroutine_traits_sfinae<_Ret>
|
|
{
|
|
};
|
|
|
|
template <typename _Promise = void>
|
|
class _LIBCPP_TEMPLATE_VIS coroutine_handle;
|
|
|
|
template <>
|
|
class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
|
|
__handle_ = nullptr;
|
|
return *this;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void operator()() { resume(); }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void resume() {
|
|
_LIBCPP_ASSERT(__is_suspended(),
|
|
"resume() can only be called on suspended coroutines");
|
|
_LIBCPP_ASSERT(!done(),
|
|
"resume() has undefined behavior when the coroutine is done");
|
|
__builtin_coro_resume(__handle_);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void destroy() {
|
|
_LIBCPP_ASSERT(__is_suspended(),
|
|
"destroy() can only be called on suspended coroutines");
|
|
__builtin_coro_destroy(__handle_);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool done() const {
|
|
_LIBCPP_ASSERT(__is_suspended(),
|
|
"done() can only be called on suspended coroutines");
|
|
return __builtin_coro_done(__handle_);
|
|
}
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static coroutine_handle from_address(void* __addr) _NOEXCEPT {
|
|
coroutine_handle __tmp;
|
|
__tmp.__handle_ = __addr;
|
|
return __tmp;
|
|
}
|
|
|
|
// FIXME: Should from_address(nullptr) be allowed?
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
|
|
return coroutine_handle(nullptr);
|
|
}
|
|
|
|
template <class _Tp, bool _CallIsValid = false>
|
|
static coroutine_handle from_address(_Tp*) {
|
|
static_assert(_CallIsValid,
|
|
"coroutine_handle<void>::from_address cannot be called with "
|
|
"non-void pointers");
|
|
}
|
|
|
|
private:
|
|
bool __is_suspended() const _NOEXCEPT {
|
|
// FIXME actually implement a check for if the coro is suspended.
|
|
return __handle_;
|
|
}
|
|
|
|
template <class _PromiseT> friend class coroutine_handle;
|
|
void* __handle_;
|
|
};
|
|
|
|
// 18.11.2.7 comparison operators:
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return __x.address() == __y.address();
|
|
}
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return !(__x == __y);
|
|
}
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return less<void*>()(__x.address(), __y.address());
|
|
}
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return __y < __x;
|
|
}
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return !(__x > __y);
|
|
}
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
|
|
return !(__x < __y);
|
|
}
|
|
|
|
template <typename _Promise>
|
|
class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> {
|
|
using _Base = coroutine_handle<>;
|
|
public:
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
// 18.11.2.1 construct/reset
|
|
using coroutine_handle<>::coroutine_handle;
|
|
#else
|
|
_LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {}
|
|
_LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {}
|
|
#endif
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
|
|
_Base::operator=(nullptr);
|
|
return *this;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Promise& promise() const {
|
|
return *static_cast<_Promise*>(
|
|
__builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
|
|
}
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static coroutine_handle from_address(void* __addr) _NOEXCEPT {
|
|
coroutine_handle __tmp;
|
|
__tmp.__handle_ = __addr;
|
|
return __tmp;
|
|
}
|
|
|
|
// NOTE: this overload isn't required by the standard but is needed so
|
|
// the deleted _Promise* overload doesn't make from_address(nullptr)
|
|
// ambiguous.
|
|
// FIXME: should from_address work with nullptr?
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
|
|
return coroutine_handle(nullptr);
|
|
}
|
|
|
|
template <class _Tp, bool _CallIsValid = false>
|
|
static coroutine_handle from_address(_Tp*) {
|
|
static_assert(_CallIsValid,
|
|
"coroutine_handle<promise_type>::from_address cannot be called with "
|
|
"non-void pointers");
|
|
}
|
|
|
|
template <bool _CallIsValid = false>
|
|
static coroutine_handle from_address(_Promise*) {
|
|
static_assert(_CallIsValid,
|
|
"coroutine_handle<promise_type>::from_address cannot be used with "
|
|
"pointers to the coroutine's promise type; use 'from_promise' instead");
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
|
|
typedef typename remove_cv<_Promise>::type _RawPromise;
|
|
coroutine_handle __tmp;
|
|
__tmp.__handle_ = __builtin_coro_promise(
|
|
_VSTD::addressof(const_cast<_RawPromise&>(__promise)),
|
|
_LIBCPP_ALIGNOF(_Promise), true);
|
|
return __tmp;
|
|
}
|
|
};
|
|
|
|
#if __has_builtin(__builtin_coro_noop)
|
|
struct noop_coroutine_promise {};
|
|
|
|
template <>
|
|
class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise>
|
|
: public coroutine_handle<> {
|
|
using _Base = coroutine_handle<>;
|
|
using _Promise = noop_coroutine_promise;
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_Promise& promise() const {
|
|
return *static_cast<_Promise*>(
|
|
__builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
|
|
}
|
|
|
|
_LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
|
|
_LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; }
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {}
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {}
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {}
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
|
|
this->__handle_ = __builtin_coro_noop();
|
|
}
|
|
};
|
|
|
|
using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
noop_coroutine_handle noop_coroutine() _NOEXCEPT {
|
|
return noop_coroutine_handle();
|
|
}
|
|
#endif // __has_builtin(__builtin_coro_noop)
|
|
|
|
struct _LIBCPP_TYPE_VIS suspend_never {
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool await_ready() const _NOEXCEPT { return true; }
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void await_resume() const _NOEXCEPT {}
|
|
};
|
|
|
|
struct _LIBCPP_TYPE_VIS suspend_always {
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool await_ready() const _NOEXCEPT { return false; }
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void await_resume() const _NOEXCEPT {}
|
|
};
|
|
|
|
_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template <class _Tp>
|
|
struct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
|
|
using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_t operator()(__arg_type const& __v) const _NOEXCEPT
|
|
{return hash<void*>()(__v.address());}
|
|
};
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // !defined(_LIBCPP_HAS_NO_COROUTINES)
|
|
|
|
#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */
|