include/boost/corosio/native/native_local_stream_acceptor.hpp

85.9% Lines (67/78) 100.0% List of functions (48/48) 41.7% Branches (40/96)

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

native_local_stream_acceptor.hpp

f(x) Functions (48)

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