include/boost/corosio/native/native_local_stream_acceptor.hpp

92.2% Lines (59/64) 100.0% List of functions (17/17) 68.2% Branches (15/22)

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

native_local_stream_acceptor.hpp

f(x) Functions (17)

Function Calls Lines Branches Blocks

Line	Branch	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		4x	impl_type& get_impl() noexcept
74			{
75		4x	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		1x	native_wait_awaitable(
86			native_local_stream_acceptor& acc, wait_type w) noexcept
87		1x	: acc_(acc)
88		1x	, w_(w)
89			{
90		1x	}
91
92		1x	bool await_ready() const noexcept
93			{
94		1x	return token_.stop_requested();
95			}
96
97		1x	capy::io_result<> await_resume() const noexcept
98			{
99	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 6 taken 1 time.	1x	if (token_.stop_requested())
100		✗	return {make_error_code(std::errc::operation_canceled)};
101		1x	return {ec_};
102			}
103
104		1x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
105			-> std::coroutine_handle<>
106			{
107		1x	token_ = env->stop_token;
108	1/1 ✓ Branch 5 → 6 taken 1 time.	3x	return acc_.get_impl().wait(
109		3x	h, env->executor, w_, token_, &ec_);
110			}
111			};
112
113			struct native_accept_awaitable
114			{
115			native_local_stream_acceptor& acc_;
116			local_stream_socket& peer_;
117			std::stop_token token_;
118			mutable std::error_code ec_;
119			mutable io_object::implementation* peer_impl_ = nullptr;
120
121		2x	native_accept_awaitable(
122			native_local_stream_acceptor& acc,
123			local_stream_socket& peer) noexcept
124		2x	: acc_(acc)
125		2x	, peer_(peer)
126			{
127		2x	}
128
129		2x	bool await_ready() const noexcept
130			{
131		2x	return token_.stop_requested();
132			}
133
134		2x	capy::io_result<> await_resume() const noexcept
135			{
136	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 6 taken 2 times.	2x	if (token_.stop_requested())
137		✗	return {make_error_code(std::errc::operation_canceled)};
138	1/2 ✓ Branch 7 → 8 taken 2 times. ✗ Branch 7 → 9 not taken.	2x	if (!ec_)
139		2x	acc_.reset_peer_impl(peer_, peer_impl_);
140		2x	return {ec_};
141			}
142
143		2x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
144			-> std::coroutine_handle<>
145			{
146		2x	token_ = env->stop_token;
147	1/1 ✓ Branch 5 → 6 taken 2 times.	6x	return acc_.get_impl().accept(
148		6x	h, env->executor, token_, &ec_, &peer_impl_);
149			}
150			};
151
152			struct native_move_accept_awaitable
153			{
154			native_local_stream_acceptor& acc_;
155			std::stop_token token_;
156			mutable std::error_code ec_;
157			mutable io_object::implementation* peer_impl_ = nullptr;
158
159		1x	explicit native_move_accept_awaitable(
160			native_local_stream_acceptor& acc) noexcept
161		1x	: acc_(acc)
162			{
163		1x	}
164
165		1x	bool await_ready() const noexcept
166			{
167		1x	return token_.stop_requested();
168			}
169
170			capy::io_result<native_local_stream_socket<Backend>>
171		1x	await_resume() const noexcept
172			{
173	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 10 taken 1 time.	1x	if (token_.stop_requested())
174			return {
175		✗	make_error_code(std::errc::operation_canceled),
176		✗	native_local_stream_socket<Backend>(acc_.context())};
177	3/6 ✓ Branch 11 → 12 taken 1 time. ✗ Branch 11 → 13 not taken. ✗ Branch 12 → 13 not taken. ✓ Branch 12 → 14 taken 1 time. ✗ Branch 15 → 16 not taken. ✓ Branch 15 → 21 taken 1 time.	1x	if (ec_ \|\| !peer_impl_)
178			return {
179			ec_,
180		✗	native_local_stream_socket<Backend>(acc_.context())};
181
182		1x	native_local_stream_socket<Backend> peer(acc_.context());
183		1x	acc_.reset_peer_impl(peer, peer_impl_);
184		1x	return {ec_, std::move(peer)};
185		1x	}
186
187		1x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
188			-> std::coroutine_handle<>
189			{
190		1x	token_ = env->stop_token;
191	1/1 ✓ Branch 5 → 6 taken 1 time.	3x	return acc_.get_impl().accept(
192		3x	h, env->executor, token_, &ec_, &peer_impl_);
193			}
194			};
195
196			public:
197			/** Construct a native acceptor from an execution context.
198
199			@param ctx The execution context that will own this acceptor.
200			*/
201		6x	explicit native_local_stream_acceptor(capy::execution_context& ctx)
202	1/1 ✓ Branch 2 → 3 taken 6 times.	6x	: local_stream_acceptor(create_handle<service_type>(ctx), ctx)
203			{
204		6x	}
205
206			/** Construct a native acceptor from an executor.
207
208			@param ex The executor whose context will own the acceptor.
209			*/
210			template<class Ex>
211			requires(!std::same_as<
212			std::remove_cvref_t<Ex>,
213			native_local_stream_acceptor>) &&
214			capy::Executor<Ex>
215			explicit native_local_stream_acceptor(Ex const& ex)
216			: native_local_stream_acceptor(ex.context())
217			{
218			}
219
220			/// Move construct.
221			native_local_stream_acceptor(native_local_stream_acceptor&&) noexcept =
222			default;
223
224			/// Move assign.
225			native_local_stream_acceptor&
226			operator=(native_local_stream_acceptor&&) noexcept = default;
227
228			native_local_stream_acceptor(native_local_stream_acceptor const&) = delete;
229			native_local_stream_acceptor&
230			operator=(native_local_stream_acceptor const&) = delete;
231
232			/** Asynchronously accept an incoming connection.
233
234			Calls the backend implementation directly, bypassing virtual
235			dispatch. Otherwise identical to @ref local_stream_acceptor::accept.
236
237			@param peer The socket to receive the accepted connection.
238
239			@return An awaitable yielding `io_result<>`.
240
241			@throws std::logic_error if the acceptor is not listening.
242
243			Both this acceptor and @p peer must outlive the returned
244			awaitable.
245			*/
246		3x	auto accept(local_stream_socket& peer)
247			{
248	2/2 ✓ Branch 3 → 4 taken 1 time. ✓ Branch 3 → 5 taken 2 times.	3x	if (!is_open())
249		1x	detail::throw_logic_error("accept: acceptor not listening");
250		2x	return native_accept_awaitable(*this, peer);
251			}
252
253			/** Asynchronously accept an incoming connection, returning the peer.
254
255			Calls the backend implementation directly, bypassing virtual
256			dispatch. The accepted peer is returned as a
257			@ref native_local_stream_socket so that subsequent I/O on it
258			is also devirtualized.
259
260			@return An awaitable yielding
261			`io_result<native_local_stream_socket<Backend>>`.
262
263			@throws std::logic_error if the acceptor is not listening.
264
265			This acceptor must outlive the returned awaitable.
266			*/
267		2x	auto accept()
268			{
269	2/2 ✓ Branch 3 → 4 taken 1 time. ✓ Branch 3 → 5 taken 1 time.	2x	if (!is_open())
270		1x	detail::throw_logic_error("accept: acceptor not listening");
271		1x	return native_move_accept_awaitable(*this);
272			}
273
274			/** Asynchronously wait for the acceptor to be ready.
275
276			Calls the backend implementation directly, bypassing virtual
277			dispatch. Otherwise identical to @ref local_stream_acceptor::wait.
278
279			@param w The wait direction (typically `wait_type::read`).
280
281			@return An awaitable yielding `io_result<>`.
282			*/
283		1x	[[nodiscard]] auto wait(wait_type w)
284			{
285		1x	return native_wait_awaitable(*this, w);
286			}
287			};
288
289			} // namespace boost::corosio
290
291			#endif // BOOST_COROSIO_NATIVE_NATIVE_LOCAL_STREAM_ACCEPTOR_HPP
292