TLA Line data 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 : #endif // !BOOST_COROSIO_MRDOCS
33 :
34 : namespace boost::corosio {
35 :
36 : /** An asynchronous TCP acceptor with devirtualized accept operations.
37 :
38 : This class template inherits from @ref tcp_acceptor and shadows
39 : the `accept` operation with a version that calls the backend
40 : implementation directly, allowing the compiler to inline through
41 : the entire call chain.
42 :
43 : Non-async operations (`listen`, `close`, `cancel`) remain
44 : unchanged and dispatch through the compiled library.
45 :
46 : A `native_tcp_acceptor` IS-A `tcp_acceptor` and can be passed
47 : to any function expecting `tcp_acceptor&`.
48 :
49 : @tparam Backend A backend tag value (e.g., `epoll`).
50 :
51 : @par Thread Safety
52 : Same as @ref tcp_acceptor.
53 :
54 : @see tcp_acceptor, epoll_t, iocp_t
55 : */
56 : template<auto Backend>
57 : class native_tcp_acceptor : public tcp_acceptor
58 : {
59 : using backend_type = decltype(Backend);
60 : using impl_type = typename backend_type::tcp_acceptor_type;
61 : using service_type = typename backend_type::tcp_acceptor_service_type;
62 :
63 HIT 10 : impl_type& get_impl() noexcept
64 : {
65 10 : return *static_cast<impl_type*>(h_.get());
66 : }
67 :
68 : struct native_wait_awaitable
69 : {
70 : native_tcp_acceptor& acc_;
71 : wait_type w_;
72 : std::stop_token token_;
73 : mutable std::error_code ec_;
74 :
75 2 : native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
76 2 : : acc_(acc)
77 2 : , w_(w)
78 : {
79 2 : }
80 :
81 2 : bool await_ready() const noexcept
82 : {
83 2 : return token_.stop_requested();
84 : }
85 :
86 2 : capy::io_result<> await_resume() const noexcept
87 : {
88 2 : if (token_.stop_requested())
89 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
90 HIT 2 : return {ec_};
91 : }
92 :
93 2 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
94 : -> std::coroutine_handle<>
95 : {
96 2 : token_ = env->stop_token;
97 6 : return acc_.get_impl().wait(
98 6 : h, env->executor, w_, token_, &ec_);
99 : }
100 : };
101 :
102 : struct native_accept_awaitable
103 : {
104 : native_tcp_acceptor& acc_;
105 : tcp_socket& peer_;
106 : std::stop_token token_;
107 : mutable std::error_code ec_;
108 : mutable io_object::implementation* peer_impl_ = nullptr;
109 :
110 8 : native_accept_awaitable(
111 : native_tcp_acceptor& acc, tcp_socket& peer) noexcept
112 8 : : acc_(acc)
113 8 : , peer_(peer)
114 : {
115 8 : }
116 :
117 8 : bool await_ready() const noexcept
118 : {
119 8 : return token_.stop_requested();
120 : }
121 :
122 8 : capy::io_result<> await_resume() const noexcept
123 : {
124 8 : if (token_.stop_requested())
125 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
126 HIT 8 : if (!ec_)
127 8 : acc_.reset_peer_impl(peer_, peer_impl_);
128 8 : return {ec_};
129 : }
130 :
131 8 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
132 : -> std::coroutine_handle<>
133 : {
134 8 : token_ = env->stop_token;
135 24 : return acc_.get_impl().accept(
136 24 : h, env->executor, token_, &ec_, &peer_impl_);
137 : }
138 : };
139 :
140 : public:
141 : /** Construct a native acceptor from an execution context.
142 :
143 : @param ctx The execution context that will own this acceptor.
144 : */
145 18 : explicit native_tcp_acceptor(capy::execution_context& ctx)
146 18 : : tcp_acceptor(create_handle<service_type>(ctx))
147 : {
148 18 : }
149 :
150 : /** Construct a native acceptor from an executor.
151 :
152 : @param ex The executor whose context will own the acceptor.
153 : */
154 : template<class Ex>
155 : requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
156 : capy::Executor<Ex>
157 : explicit native_tcp_acceptor(Ex const& ex)
158 : : native_tcp_acceptor(ex.context())
159 : {
160 : }
161 :
162 : /** Move construct.
163 :
164 : @param other The acceptor to move from.
165 :
166 : @pre No awaitables returned by @p other's methods exist.
167 : @pre The execution context associated with @p other must
168 : outlive this acceptor.
169 : */
170 2 : native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
171 :
172 : /** Move assign.
173 :
174 : @param other The acceptor to move from.
175 :
176 : @pre No awaitables returned by either `*this` or @p other's
177 : methods exist.
178 : @pre The execution context associated with @p other must
179 : outlive this acceptor.
180 : */
181 : native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
182 :
183 : native_tcp_acceptor(native_tcp_acceptor const&) = delete;
184 : native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
185 :
186 : /** Asynchronously accept an incoming connection.
187 :
188 : Calls the backend implementation directly, bypassing virtual
189 : dispatch. Otherwise identical to @ref tcp_acceptor::accept.
190 :
191 : @param peer The socket to receive the accepted connection.
192 :
193 : @return An awaitable yielding `io_result<>`.
194 :
195 : @throws std::logic_error if the acceptor is not listening.
196 :
197 : Both this acceptor and @p peer must outlive the returned
198 : awaitable.
199 : */
200 8 : auto accept(tcp_socket& peer)
201 : {
202 8 : if (!is_open())
203 MIS 0 : detail::throw_logic_error("accept: acceptor not listening");
204 HIT 8 : return native_accept_awaitable(*this, peer);
205 : }
206 :
207 : /** Asynchronously wait for the acceptor to be ready.
208 :
209 : Calls the backend implementation directly, bypassing virtual
210 : dispatch. Otherwise identical to @ref tcp_acceptor::wait.
211 :
212 : @param w The wait direction (typically `wait_type::read`).
213 :
214 : @return An awaitable yielding `io_result<>`.
215 : */
216 2 : [[nodiscard]] auto wait(wait_type w)
217 : {
218 2 : return native_wait_awaitable(*this, w);
219 : }
220 : };
221 :
222 : } // namespace boost::corosio
223 :
224 : #endif
|
