include/boost/corosio/native/native_tcp_acceptor.hpp

92.9% Lines (39/42) 100.0% List of functions (22/22)

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

native_tcp_acceptor.hpp

f(x) Functions (22)

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_IO_URING
34		#include <boost/corosio/native/detail/io_uring/io_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	10x	impl_type& get_impl() noexcept
68		{
69	10x	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	2x	native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
80	2x	: acc_(acc)
81	2x	, w_(w)
82		{
83	2x	}
84
85	2x	bool await_ready() const noexcept
86		{
87	2x	return token_.stop_requested();
88		}
89
90	2x	capy::io_result<> await_resume() const noexcept
91		{
92	2x	if (token_.stop_requested())
93	✗	return {make_error_code(std::errc::operation_canceled)};
94	2x	return {ec_};
95		}
96
97	2x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
98		-> std::coroutine_handle<>
99		{
100	2x	token_ = env->stop_token;
101	6x	return acc_.get_impl().wait(
102	6x	h, env->executor, w_, token_, &ec_);
103		}
104		};
105
106		struct native_accept_awaitable
107		{
108		native_tcp_acceptor& acc_;
109		tcp_socket& peer_;
110		std::stop_token token_;
111		mutable std::error_code ec_;
112		mutable io_object::implementation* peer_impl_ = nullptr;
113
114	8x	native_accept_awaitable(
115		native_tcp_acceptor& acc, tcp_socket& peer) noexcept
116	8x	: acc_(acc)
117	8x	, peer_(peer)
118		{
119	8x	}
120
121	8x	bool await_ready() const noexcept
122		{
123	8x	return token_.stop_requested();
124		}
125
126	8x	capy::io_result<> await_resume() const noexcept
127		{
128	8x	if (token_.stop_requested())
129	✗	return {make_error_code(std::errc::operation_canceled)};
130	8x	if (!ec_)
131	8x	acc_.reset_peer_impl(peer_, peer_impl_);
132	8x	return {ec_};
133		}
134
135	8x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
136		-> std::coroutine_handle<>
137		{
138	8x	token_ = env->stop_token;
139	24x	return acc_.get_impl().accept(
140	24x	h, env->executor, token_, &ec_, &peer_impl_);
141		}
142		};
143
144		public:
145		/** Construct a native acceptor from an execution context.
146
147		@param ctx The execution context that will own this acceptor.
148		*/
149	18x	explicit native_tcp_acceptor(capy::execution_context& ctx)
150	18x	: tcp_acceptor(create_handle<service_type>(ctx))
151		{
152	18x	}
153
154		/** Construct a native acceptor from an executor.
155
156		@param ex The executor whose context will own the acceptor.
157		*/
158		template<class Ex>
159		requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
160		capy::Executor<Ex>
161		explicit native_tcp_acceptor(Ex const& ex)
162		: native_tcp_acceptor(ex.context())
163		{
164		}
165
166		/** Move construct.
167
168		@param other The acceptor to move from.
169
170		@pre No awaitables returned by @p other's methods exist.
171		@pre The execution context associated with @p other must
172		outlive this acceptor.
173		*/
174	2x	native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
175
176		/** Move assign.
177
178		@param other The acceptor to move from.
179
180		@pre No awaitables returned by either `*this` or @p other's
181		methods exist.
182		@pre The execution context associated with @p other must
183		outlive this acceptor.
184		*/
185		native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
186
187		native_tcp_acceptor(native_tcp_acceptor const&) = delete;
188		native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
189
190		/** Asynchronously accept an incoming connection.
191
192		Calls the backend implementation directly, bypassing virtual
193		dispatch. Otherwise identical to @ref tcp_acceptor::accept.
194
195		@param peer The socket to receive the accepted connection.
196
197		@return An awaitable yielding `io_result<>`.
198
199		@throws std::logic_error if the acceptor is not listening.
200
201		Both this acceptor and @p peer must outlive the returned
202		awaitable.
203		*/
204	8x	auto accept(tcp_socket& peer)
205		{
206	8x	if (!is_open())
207	✗	detail::throw_logic_error("accept: acceptor not listening");
208	8x	return native_accept_awaitable(*this, peer);
209		}
210
211		/** Asynchronously wait for the acceptor to be ready.
212
213		Calls the backend implementation directly, bypassing virtual
214		dispatch. Otherwise identical to @ref tcp_acceptor::wait.
215
216		@param w The wait direction (typically `wait_type::read`).
217
218		@return An awaitable yielding `io_result<>`.
219		*/
220	2x	[[nodiscard]] auto wait(wait_type w)
221		{
222	2x	return native_wait_awaitable(*this, w);
223		}
224		};
225
226		} // namespace boost::corosio
227
228		#endif
229