include/boost/corosio/native/native_tcp_acceptor.hpp

93.8% Lines (45/48) 100.0% List of functions (14/14) 80.0% Branches (16/20)

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

native_tcp_acceptor.hpp

f(x) Functions (14)

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_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			#include <boost/corosio/detail/op_base.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_tcp_acceptor_service.hpp>
32			#endif
33
34			#if BOOST_COROSIO_HAS_URING
35			#include <boost/corosio/native/detail/uring/uring_types.hpp>
36			#endif
37			#endif // !BOOST_COROSIO_MRDOCS
38
39			namespace boost::corosio {
40
41			/** Accepts TCP connections, calling the backend directly.
42
43			This class template inherits from @ref tcp_acceptor. It shadows the
44			`accept` operation with a version that calls the backend
45			implementation directly. The compiler can then inline through the
46			entire call chain.
47
48			Non-async operations (`listen`, `close`, `cancel`) remain
49			unchanged and dispatch through the compiled library.
50
51			A `native_tcp_acceptor` IS-A `tcp_acceptor` and can be passed
52			to any function expecting `tcp_acceptor&`.
53
54			@tparam Backend A backend tag value (e.g., `epoll`).
55
56			@par Thread Safety
57			Same as @ref tcp_acceptor.
58
59			@see tcp_acceptor, epoll_t, iocp_t
60			*/
61			template<auto Backend>
62			class native_tcp_acceptor : public tcp_acceptor
63			{
64			using backend_type = decltype(Backend);
65			using impl_type = typename backend_type::tcp_acceptor_type;
66			using service_type = typename backend_type::tcp_acceptor_service_type;
67
68		13x	impl_type& get_impl() noexcept
69			{
70		13x	return static_cast<impl_type>(h_.get());
71			}
72
73			struct native_wait_awaitable : detail::void_op_base<native_wait_awaitable>
74			{
75			native_tcp_acceptor& acc_;
76			wait_type w_;
77
78		3x	native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
79		3x	: acc_(acc)
80		3x	, w_(w)
81			{
82		3x	}
83
84			std::coroutine_handle<>
85		2x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
86			{
87	1/1 ✓ Branch 4 → 5 taken 2 times.	2x	return acc_.get_impl().wait(h, ex, w_, this->token_, &this->ec_);
88			}
89			};
90
91			struct native_accept_awaitable
92			: detail::void_op_base<native_accept_awaitable>
93			{
94			native_tcp_acceptor& acc_;
95			tcp_socket& peer_;
96			mutable io_object::implementation* peer_impl_ = nullptr;
97
98		11x	native_accept_awaitable(
99			native_tcp_acceptor& acc, tcp_socket& peer) noexcept
100		11x	: acc_(acc)
101		11x	, peer_(peer)
102			{
103		11x	}
104
105		11x	[[nodiscard]] capy::io_result<> await_resume() const noexcept
106			{
107	2/2 ✓ Branch 3 → 4 taken 10 times. ✓ Branch 3 → 5 taken 1 time.	11x	if (!this->ec_)
108		10x	acc_.reset_peer_impl(peer_, peer_impl_);
109		11x	return {this->ec_};
110			}
111
112			std::coroutine_handle<>
113		10x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
114			{
115	1/1 ✓ Branch 4 → 5 taken 10 times.	30x	return acc_.get_impl().accept(
116		30x	h, ex, this->token_, &this->ec_, &peer_impl_);
117			}
118			};
119
120			struct native_accept_value_awaitable
121			: detail::void_op_base<native_accept_value_awaitable>
122			{
123			native_tcp_acceptor& acc_;
124			tcp_socket peer_;
125			mutable io_object::implementation* peer_impl_ = nullptr;
126
127		2x	explicit native_accept_value_awaitable(native_tcp_acceptor& acc)
128		2x	: acc_(acc)
129	1/1 ✓ Branch 4 → 5 taken 2 times.	2x	, peer_(acc.context())
130			{
131		2x	}
132
133		2x	[[nodiscard]] capy::io_result<tcp_socket> await_resume() noexcept
134			{
135	5/6 ✓ Branch 3 → 4 taken 1 time. ✓ Branch 3 → 6 taken 1 time. ✓ Branch 4 → 5 taken 1 time. ✗ Branch 4 → 6 not taken. ✓ Branch 7 → 8 taken 1 time. ✓ Branch 7 → 9 taken 1 time.	2x	if (!this->ec_ && peer_impl_)
136		1x	acc_.reset_peer_impl(peer_, peer_impl_);
137		2x	return {this->ec_, std::move(peer_)};
138			}
139
140			std::coroutine_handle<>
141		1x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
142			{
143	1/1 ✓ Branch 4 → 5 taken 1 time.	3x	return acc_.get_impl().accept(
144		3x	h, ex, this->token_, &this->ec_, &peer_impl_);
145			}
146			};
147
148			public:
149			/** Construct a native acceptor from an execution context.
150
151			@param ctx The execution context that owns this acceptor.
152			*/
153		17x	explicit native_tcp_acceptor(capy::execution_context& ctx)
154	2/2 ✓ Branch 2 → 3 taken 17 times. ✓ Branch 3 → 4 taken 17 times.	17x	: tcp_acceptor(handle(ctx, ctx.use_service<service_type>()))
155			{
156		17x	}
157
158			/** Construct a native acceptor from an executor.
159
160			@param ex The executor whose context owns the acceptor.
161
162			@tparam Ex A type satisfying @ref capy::Executor. Must not
163			be `native_tcp_acceptor` itself (disables implicit
164			conversion from move).
165			*/
166			template<class Ex>
167			requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
168			capy::Executor<Ex>
169			explicit native_tcp_acceptor(Ex const& ex)
170			: native_tcp_acceptor(ex.context())
171			{
172			}
173
174			/** Move construct.
175
176			@param other The acceptor to move from.
177
178			@pre No awaitables returned by @p other's methods exist.
179			@pre The execution context associated with @p other must
180			outlive this acceptor.
181			*/
182		1x	native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
183
184			/** Move assign.
185
186			@param other The acceptor to move from.
187
188			@pre No awaitables returned by either `*this` or @p other's
189			methods exist.
190			@pre The execution context associated with @p other must
191			outlive this acceptor.
192			*/
193			native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
194
195			/// Copy construction is disabled; the handle is uniquely owned.
196			native_tcp_acceptor(native_tcp_acceptor const&) = delete;
197			/// Copy assignment is disabled; the handle is uniquely owned.
198			native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
199
200			/** Asynchronously accept an incoming connection.
201
202			Calls the backend implementation directly, bypassing virtual
203			dispatch. Otherwise identical to @ref tcp_acceptor::accept.
204
205			@param peer The socket to receive the accepted connection.
206
207			@return An awaitable yielding `io_result<>`.
208
209			A closed acceptor reports `errc::bad_file_descriptor`.
210
211			Both this acceptor and @p peer must outlive the returned
212			awaitable.
213			*/
214		11x	[[nodiscard]] auto accept(tcp_socket& peer)
215			{
216		11x	native_accept_awaitable aw(*this, peer);
217	1/2 ✗ Branch 4 → 5 not taken. ✓ Branch 4 → 6 taken 11 times.	11x	if (!is_open())
218		✗	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
219		11x	return aw;
220			}
221
222			/** Asynchronously accept an incoming connection, returning the peer.
223
224			Calls the backend implementation directly, bypassing virtual
225			dispatch. Otherwise identical to @ref tcp_acceptor::accept().
226
227			@return An awaitable yielding `io_result<tcp_socket>`.
228
229			A closed acceptor reports `errc::bad_file_descriptor`.
230
231			@throws std::logic_error If the acceptor is moved-from.
232
233			This acceptor must outlive the returned awaitable.
234			*/
235		2x	[[nodiscard]] auto accept()
236			{
237			// The awaitable builds the peer from context(), which a
238			// moved-from acceptor no longer has.
239	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 5 taken 2 times.	2x	if (!h_)
240		✗	detail::throw_logic_error("accept: acceptor moved-from");
241		2x	native_accept_value_awaitable aw(*this);
242	1/2 ✗ Branch 7 → 8 not taken. ✓ Branch 7 → 9 taken 2 times.	2x	if (!is_open())
243		✗	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
244		2x	return aw;
245			}
246
247			/** Asynchronously wait for the acceptor to be ready.
248
249			Calls the backend implementation directly, bypassing virtual
250			dispatch. Otherwise identical to @ref tcp_acceptor::wait.
251
252			@param w The wait direction (typically `wait_type::read`).
253
254			@return An awaitable yielding `io_result<>`.
255			*/
256		3x	[[nodiscard]] auto wait(wait_type w)
257			{
258		3x	return native_wait_awaitable(*this, w);
259			}
260			};
261
262			} // namespace boost::corosio
263
264			#endif
265