include/boost/corosio/native/native_local_stream_acceptor.hpp

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

[ ] prev/next file n p prev/next uncovered line

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