include/boost/corosio/native/native_resolver.hpp

94.4% Lines (17/18) 100.0% List of functions (16/16) 50.0% Branches (8/16)

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

native_resolver.hpp

f(x) Functions (16)

Function Calls Lines Branches Blocks

Line	Branch	Hits	Source Code
1			//
2			// Copyright (c) 2026 Steve Gerbino
3			// Copyright (c) 2026 Michael Vandeberg
4			//
5			// Distributed under the Boost Software License, Version 1.0. (See accompanying
6			// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7			//
8			// Official repository: https://github.com/cppalliance/corosio
9			//
10
11			#ifndef BOOST_COROSIO_NATIVE_NATIVE_RESOLVER_HPP
12			#define BOOST_COROSIO_NATIVE_NATIVE_RESOLVER_HPP
13
14			#include <boost/corosio/resolver.hpp>
15			#include <boost/corosio/backend.hpp>
16			#include <boost/corosio/detail/op_base.hpp>
17
18			#ifndef BOOST_COROSIO_MRDOCS
19			#if BOOST_COROSIO_HAS_EPOLL \|\| BOOST_COROSIO_HAS_SELECT \|\| \
20			BOOST_COROSIO_HAS_KQUEUE
21			#include <boost/corosio/native/detail/posix/posix_resolver_service.hpp>
22			#endif
23
24			#if BOOST_COROSIO_HAS_IOCP
25			#include <boost/corosio/native/detail/iocp/win_resolver_service.hpp>
26			#endif
27			#endif // !BOOST_COROSIO_MRDOCS
28
29			namespace boost::corosio {
30
31			/** Resolves host names to endpoints, calling the backend directly.
32
33			This class template inherits from @ref resolver. It shadows the
34			`resolve` operations with versions that call the backend
35			implementation directly. The compiler can then inline through the
36			entire call chain.
37
38			Non-async operations (`cancel`) remain unchanged and dispatch
39			through the compiled library.
40
41			A `native_resolver` IS-A `resolver` and can be passed to any
42			function expecting `resolver&`.
43
44			@tparam Backend A backend tag value (e.g., `epoll`).
45
46			@par Thread Safety
47			Same as @ref resolver.
48
49			@see resolver, epoll_t, iocp_t
50			*/
51			template<auto Backend>
52			class native_resolver : public resolver
53			{
54			using backend_type = decltype(Backend);
55			using impl_type = typename backend_type::resolver_type;
56
57		2x	impl_type& get_impl() noexcept
58			{
59		2x	return static_cast<impl_type>(h_.get());
60			}
61
62			struct native_resolve_awaitable
63			: detail::value_op_base<native_resolve_awaitable, std::vector<endpoint>>
64			{
65			native_resolver& self_;
66			std::string host_;
67			std::string service_;
68			resolve_flags flags_;
69
70		8x	native_resolve_awaitable(
71			native_resolver& self,
72			std::string_view host,
73			std::string_view service,
74			resolve_flags flags) noexcept
75		4x	: self_(self)
76	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 2 times. ✗ Branch 3 not taken.	4x	, host_(host)
77	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 2 times. ✗ Branch 3 not taken.	4x	, service_(service)
78		4x	, flags_(flags)
79		4x	{
80		8x	}
81
82			std::coroutine_handle<>
83		2x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
84			{
85	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 self_.get_impl().resolve(
86		2x	h, ex, host_, service_, flags_, this->token_, &this->ec_,
87		2x	&this->value_);
88		✗	}
89			};
90
91			struct native_reverse_awaitable
92			: detail::value_op_base<native_reverse_awaitable, endpoint_name>
93			{
94			native_resolver& self_;
95			endpoint ep_;
96			reverse_flags flags_;
97
98			native_reverse_awaitable(
99			native_resolver& self,
100			endpoint const& ep,
101			reverse_flags flags) noexcept
102			: self_(self)
103			, ep_(ep)
104			, flags_(flags)
105			{
106			}
107
108			std::coroutine_handle<>
109			dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
110			{
111			return self_.get_impl().reverse_resolve(
112			h, ex, ep_, flags_, this->token_, &this->ec_, &this->value_);
113			}
114			};
115
116			public:
117			/** Construct a native resolver from an execution context.
118
119			@param ctx The execution context that owns this resolver.
120			*/
121		16x	explicit native_resolver(capy::execution_context& ctx) : resolver(ctx) {}
122
123			/** Construct a native resolver from an executor.
124
125			@param ex The executor whose context owns the resolver.
126			*/
127			template<class Ex>
128			requires(!std::same_as<std::remove_cvref_t<Ex>, native_resolver>) &&
129			capy::Executor<Ex>
130			explicit native_resolver(Ex const& ex) : native_resolver(ex.context())
131			{
132			}
133
134			/** Move construct.
135
136			@pre No awaitables returned by the source's `resolve` methods
137			exist.
138			@pre The execution context associated with the source must
139			outlive this resolver.
140			*/
141			native_resolver(native_resolver&&) noexcept = default;
142
143			/** Move assign.
144
145			@return Reference to this resolver.
146
147			@pre No awaitables returned by either `*this` or the source's
148			`resolve` methods exist.
149			@pre The execution context associated with the source must
150			outlive this resolver.
151			*/
152			native_resolver& operator=(native_resolver&&) noexcept = default;
153
154			/// Copy construction is disabled; the handle is uniquely owned.
155			native_resolver(native_resolver const&) = delete;
156			/// Copy assignment is disabled; the handle is uniquely owned.
157			native_resolver& operator=(native_resolver const&) = delete;
158
159			/** Asynchronously resolve a host and service to endpoints.
160
161			Calls the backend implementation directly, bypassing virtual
162			dispatch. Otherwise identical to @ref resolver::resolve.
163
164			This resolver must outlive the returned awaitable.
165
166			@param host The host name or address string.
167			@param service The service name or port string.
168
169			@return An awaitable yielding `io_result<std::vector<endpoint>>`.
170			*/
171		4x	[[nodiscard]] auto resolve(std::string_view host, std::string_view service)
172			{
173		4x	return native_resolve_awaitable(
174		4x	*this, host, service, resolve_flags::none);
175			}
176
177			/** Asynchronously resolve a host and service with flags.
178
179			This resolver must outlive the returned awaitable.
180
181			@param host The host name or address string.
182			@param service The service name or port string.
183			@param flags Flags controlling resolution behavior.
184
185			@return An awaitable yielding
186			`io_result<std::vector<endpoint>>`.
187			*/
188			[[nodiscard]] auto resolve(
189			std::string_view host, std::string_view service, resolve_flags flags)
190			{
191			return native_resolve_awaitable(*this, host, service, flags);
192			}
193
194			/** Asynchronously reverse-resolve an endpoint.
195
196			Calls the backend implementation directly, bypassing virtual
197			dispatch. Otherwise identical to the endpoint overload of
198			@ref resolver::resolve.
199
200			This resolver must outlive the returned awaitable.
201
202			@param ep The endpoint to resolve.
203
204			@return An awaitable yielding
205			`io_result<endpoint_name>`.
206			*/
207			[[nodiscard]] auto resolve(endpoint const& ep)
208			{
209			return native_reverse_awaitable(*this, ep, reverse_flags::none);
210			}
211
212			/** Asynchronously reverse-resolve an endpoint with flags.
213
214			This resolver must outlive the returned awaitable.
215
216			@param ep The endpoint to resolve.
217			@param flags Flags controlling resolution behavior.
218
219			@return An awaitable yielding
220			`io_result<endpoint_name>`.
221			*/
222			[[nodiscard]] auto resolve(endpoint const& ep, reverse_flags flags)
223			{
224			return native_reverse_awaitable(*this, ep, flags);
225			}
226			};
227
228			} // namespace boost::corosio
229
230			#endif
231