include/boost/corosio/native/native_tcp_acceptor.hpp

100.0% Lines (66/0/66) 100.0% List of functions (34/0/34)

[ ] prev/next file

native_tcp_acceptor.hpp

f(x) Functions (34)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Steve Gerbino
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/corosio
8		//
9
10		#ifndef BOOST_COROSIO_NATIVE_NATIVE_TCP_ACCEPTOR_HPP
11		#define BOOST_COROSIO_NATIVE_NATIVE_TCP_ACCEPTOR_HPP
12
13		#include <boost/corosio/tcp_acceptor.hpp>
14		#include <boost/corosio/backend.hpp>
15
16		#ifndef BOOST_COROSIO_MRDOCS
17		#if BOOST_COROSIO_HAS_EPOLL
18		#include <boost/corosio/native/detail/epoll/epoll_types.hpp>
19		#endif
20
21		#if BOOST_COROSIO_HAS_SELECT
22		#include <boost/corosio/native/detail/select/select_types.hpp>
23		#endif
24
25		#if BOOST_COROSIO_HAS_KQUEUE
26		#include <boost/corosio/native/detail/kqueue/kqueue_types.hpp>
27		#endif
28
29		#if BOOST_COROSIO_HAS_IOCP
30		#include <boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp>
31		#endif
32
33		#if BOOST_COROSIO_HAS_URING
34		#include <boost/corosio/native/detail/uring/uring_types.hpp>
35		#endif
36		#endif // !BOOST_COROSIO_MRDOCS
37
38		namespace boost::corosio {
39
40		/** An asynchronous TCP acceptor with devirtualized accept operations.
41
42		This class template inherits from @ref tcp_acceptor and shadows
43		the `accept` operation with a version that calls the backend
44		implementation directly, allowing the compiler to inline through
45		the entire call chain.
46
47		Non-async operations (`listen`, `close`, `cancel`) remain
48		unchanged and dispatch through the compiled library.
49
50		A `native_tcp_acceptor` IS-A `tcp_acceptor` and can be passed
51		to any function expecting `tcp_acceptor&`.
52
53		@tparam Backend A backend tag value (e.g., `epoll`).
54
55		@par Thread Safety
56		Same as @ref tcp_acceptor.
57
58		@see tcp_acceptor, epoll_t, iocp_t
59		*/
60		template<auto Backend>
61		class native_tcp_acceptor : public tcp_acceptor
62		{
63		using backend_type = decltype(Backend);
64		using impl_type = typename backend_type::tcp_acceptor_type;
65		using service_type = typename backend_type::tcp_acceptor_service_type;
66
67	25x	impl_type& get_impl() noexcept
68		{
69	25x	return static_cast<impl_type>(h_.get());
70		}
71
72		struct native_wait_awaitable
73		{
74		native_tcp_acceptor& acc_;
75		wait_type w_;
76		std::stop_token token_;
77		mutable std::error_code ec_;
78
79	6x	native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
80	6x	: acc_(acc)
81	6x	, w_(w)
82		{
83	6x	}
84
85	6x	bool await_ready() const noexcept
86		{
87		// A pre-set ec_ means the initiator failed before
88		// dispatch (e.g. a closed object).
89	6x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
90		}
91
92	6x	[[nodiscard]] capy::io_result<> await_resume() const noexcept
93		{
94	6x	if (token_.stop_requested())
95	2x	return {make_error_code(std::errc::operation_canceled)};
96	4x	return {ec_};
97		}
98
99	6x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
100		-> std::coroutine_handle<>
101		{
102	6x	token_ = env->stop_token;
103	6x	return acc_.get_impl().wait(h, env->executor, w_, token_, &ec_);
104		}
105		};
106
107		struct native_accept_awaitable
108		{
109		native_tcp_acceptor& acc_;
110		tcp_socket& peer_;
111		std::stop_token token_;
112		mutable std::error_code ec_;
113		mutable io_object::implementation* peer_impl_ = nullptr;
114
115	17x	native_accept_awaitable(
116		native_tcp_acceptor& acc, tcp_socket& peer) noexcept
117	17x	: acc_(acc)
118	17x	, peer_(peer)
119		{
120	17x	}
121
122	17x	bool await_ready() const noexcept
123		{
124		// A pre-set ec_ means the initiator failed before
125		// dispatch (e.g. a closed object).
126	17x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
127		}
128
129	17x	[[nodiscard]] capy::io_result<> await_resume() const noexcept
130		{
131	17x	if (token_.stop_requested())
132	2x	return {make_error_code(std::errc::operation_canceled)};
133	15x	if (!ec_)
134	13x	acc_.reset_peer_impl(peer_, peer_impl_);
135	15x	return {ec_};
136		}
137
138	15x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
139		-> std::coroutine_handle<>
140		{
141	15x	token_ = env->stop_token;
142	45x	return acc_.get_impl().accept(
143	45x	h, env->executor, token_, &ec_, &peer_impl_);
144		}
145		};
146
147		struct native_accept_value_awaitable
148		{
149		native_tcp_acceptor& acc_;
150		tcp_socket peer_;
151		std::stop_token token_;
152		mutable std::error_code ec_;
153		mutable io_object::implementation* peer_impl_ = nullptr;
154
155	6x	explicit native_accept_value_awaitable(native_tcp_acceptor& acc)
156	6x	: acc_(acc)
157	6x	, peer_(acc.context())
158		{
159	6x	}
160
161	6x	bool await_ready() const noexcept
162		{
163		// A pre-set ec_ means the initiator failed before
164		// dispatch (e.g. a closed object).
165	6x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
166		}
167
168	6x	[[nodiscard]] capy::io_result<tcp_socket> await_resume() noexcept
169		{
170	6x	if (token_.stop_requested())
171		return {
172	4x	make_error_code(std::errc::operation_canceled),
173	2x	std::move(peer_)};
174	4x	if (!ec_ && peer_impl_)
175	2x	acc_.reset_peer_impl(peer_, peer_impl_);
176	4x	return {ec_, std::move(peer_)};
177		}
178
179	4x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
180		-> std::coroutine_handle<>
181		{
182	4x	token_ = env->stop_token;
183	12x	return acc_.get_impl().accept(
184	12x	h, env->executor, token_, &ec_, &peer_impl_);
185		}
186		};
187
188		public:
189		/** Construct a native acceptor from an execution context.
190
191		@param ctx The execution context that will own this acceptor.
192		*/
193	33x	explicit native_tcp_acceptor(capy::execution_context& ctx)
194	33x	: tcp_acceptor(create_handle<service_type>(ctx))
195		{
196	33x	}
197
198		/** Construct a native acceptor from an executor.
199
200		@param ex The executor whose context will own the acceptor.
201		*/
202		template<class Ex>
203		requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
204		capy::Executor<Ex>
205		explicit native_tcp_acceptor(Ex const& ex)
206		: native_tcp_acceptor(ex.context())
207		{
208		}
209
210		/** Move construct.
211
212		@param other The acceptor to move from.
213
214		@pre No awaitables returned by @p other's methods exist.
215		@pre The execution context associated with @p other must
216		outlive this acceptor.
217		*/
218	4x	native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
219
220		/** Move assign.
221
222		@param other The acceptor to move from.
223
224		@pre No awaitables returned by either `*this` or @p other's
225		methods exist.
226		@pre The execution context associated with @p other must
227		outlive this acceptor.
228		*/
229		native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
230
231		native_tcp_acceptor(native_tcp_acceptor const&) = delete;
232		native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
233
234		/** Asynchronously accept an incoming connection.
235
236		Calls the backend implementation directly, bypassing virtual
237		dispatch. Otherwise identical to @ref tcp_acceptor::accept.
238
239		@param peer The socket to receive the accepted connection.
240
241		@return An awaitable yielding `io_result<>`.
242
243		A closed acceptor reports `errc::bad_file_descriptor`.
244
245		Both this acceptor and @p peer must outlive the returned
246		awaitable.
247		*/
248	17x	[[nodiscard]] auto accept(tcp_socket& peer)
249		{
250	17x	native_accept_awaitable aw(*this, peer);
251	17x	if (!is_open())
252	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
253	17x	return aw;
254		}
255
256		/** Asynchronously accept an incoming connection, returning the peer.
257
258		Calls the backend implementation directly, bypassing virtual
259		dispatch. Otherwise identical to @ref tcp_acceptor::accept().
260
261		@return An awaitable yielding `io_result<tcp_socket>`.
262
263		A closed acceptor reports `errc::bad_file_descriptor`.
264
265		@throws std::logic_error If the acceptor has been moved from.
266
267		This acceptor must outlive the returned awaitable.
268		*/
269	8x	[[nodiscard]] auto accept()
270		{
271		// The awaitable builds the peer from context(), which a
272		// moved-from acceptor no longer has.
273	8x	if (!h_)
274	2x	detail::throw_logic_error("accept: acceptor moved-from");
275	6x	native_accept_value_awaitable aw(*this);
276	6x	if (!is_open())
277	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
278	6x	return aw;
279		}
280
281		/** Asynchronously wait for the acceptor to be ready.
282
283		Calls the backend implementation directly, bypassing virtual
284		dispatch. Otherwise identical to @ref tcp_acceptor::wait.
285
286		@param w The wait direction (typically `wait_type::read`).
287
288		@return An awaitable yielding `io_result<>`.
289		*/
290	6x	[[nodiscard]] auto wait(wait_type w)
291		{
292	6x	return native_wait_awaitable(*this, w);
293		}
294		};
295
296		} // namespace boost::corosio
297
298		#endif
299