1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// { dg-additional-options "-fpreprocessed -std=gnu++20 -w -fconcepts" }
int _M_invoke___functor;
namespace std {
template <int __v> struct integral_constant {
static constexpr bool value = __v;
};
template <typename> struct decay { typedef int type; };
template <bool, typename> struct enable_if;
template <typename _Tp> struct enable_if<true, _Tp> { typedef _Tp type; };
template <typename, typename _Fn, typename... _Args>
void __invoke_impl(_Fn __f, _Args... __args) {
__f(__args...);
}
template <typename, typename _Callable, typename... _Args>
void __invoke_r(_Callable __fn, _Args... __args) {
using __result = int;
using __type = __result;
__invoke_impl<__type>(__fn, __args...);
}
template <typename> class function;
template <typename _Functor> struct _Base_manager {
static _Functor *_M_get_pointer(int) {}
};
template <typename, typename> class _Function_handler;
template <typename _Res, typename _Functor, typename... _ArgTypes>
struct _Function_handler<_Res(_ArgTypes...), _Functor> {
static _Res _M_invoke(_ArgTypes... __args) {
auto __trans_tmp_1 =
_Base_manager<_Functor>::_M_get_pointer(_M_invoke___functor);
__invoke_r<_Res>(*__trans_tmp_1, __args...);
}
};
template <typename _Res, typename... _ArgTypes>
struct function<_Res(_ArgTypes...)> {
template <typename _Functor> function(_Functor) {
_Function_handler<_Res(_ArgTypes...), _Functor>::_M_invoke;
}
};
template <typename _Tp> struct __shared_ptr_access {
using element_type = _Tp;
element_type *operator->();
};
template <typename> void make_shared();
} // namespace std
namespace boost {
using std::decay;
using std::enable_if;
using std::integral_constant;
namespace asio {
namespace detail {
template <typename> struct is_completion_signature;
template <typename R, typename... Args>
struct is_completion_signature<R(Args...)> : integral_constant<true> {};
} // namespace detail
template <typename T>
concept completion_signature = detail::is_completion_signature<T>::value;
template <typename...> struct async_result;
namespace detail {
template <completion_signature>
struct async_result_has_initiate_memfn : integral_constant<1> {};
} // namespace detail
template <typename CompletionToken, completion_signature... Signatures,
typename Initiation>
enable_if<detail::async_result_has_initiate_memfn<Signatures...>::value,
decltype(async_result<typename decay<CompletionToken>::type,
Signatures...>::initiate(0))>::type
async_initiate(Initiation) {}
} // namespace asio
} // namespace boost
namespace malloy::websocket {
struct connection {
auto read(auto, auto done) {
auto wrapper = [] {};
return boost::asio::async_initiate<decltype(done), void()>(wrapper);
}
};
} // namespace malloy::websocket
namespace std {
template <typename...> struct coroutine_traits;
template <typename = void> struct coroutine_handle {
operator coroutine_handle<>();
};
struct suspend_always {
bool await_ready();
void await_suspend(coroutine_handle<>);
void await_resume();
};
} // namespace std
namespace boost {
namespace asio {
namespace detail {
using std::coroutine_handle;
using std::suspend_always;
template <typename> class awaitable_frame;
} // namespace detail
template <typename, typename = int> struct awaitable {
bool await_ready();
template <class U>
void await_suspend(detail::coroutine_handle<detail::awaitable_frame<U>>);
void await_resume();
};
namespace detail {
struct awaitable_frame_base {
auto initial_suspend() { return suspend_always(); }
auto final_suspend() noexcept {
struct result {
bool await_ready() noexcept;
void await_suspend(coroutine_handle<>) noexcept;
void await_resume() noexcept;
};
return result{};
}
void unhandled_exception();
template <typename T> auto await_transform(T a) { return a; }
};
template <> struct awaitable_frame<void> : awaitable_frame_base {
void get_return_object();
};
} // namespace detail
} // namespace asio
} // namespace boost
namespace std {
template <typename T, typename Executor, typename... Args>
struct coroutine_traits<boost::asio::awaitable<T, Executor>, Args...> {
typedef boost::asio::detail::awaitable_frame<T> promise_type;
};
} // namespace std
namespace boost {
namespace asio {
struct use_awaitable_t {
use_awaitable_t(char, int, char);
} use_awaitable(0, 0, 0);
template <typename Executor, typename R, typename... Args>
struct async_result<Executor, R(Args...)> {
template <typename Initiation> static awaitable<int> initiate(Initiation);
};
} // namespace asio
} // namespace boost
namespace malloy::test {
void roundtrip_coro(std::function<void(int)>);
}
using boost::asio::awaitable;
template <int> awaitable<void> client_ws_handler_coro() {
std::__shared_ptr_access<malloy::websocket::connection> conn;
auto buffer = std::make_shared<int>;
co_await conn->read(buffer, boost::asio::use_awaitable);
}
void port() {
malloy::test::roundtrip_coro([](auto) { client_ws_handler_coro<false>; });
}
|
