1 | // |
2 | // ip/basic_resolver.hpp |
3 | // ~~~~~~~~~~~~~~~~~~~~~ |
4 | // |
5 | // Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
6 | // |
7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying |
8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
9 | // |
10 | |
11 | #ifndef BOOST_ASIO_IP_BASIC_RESOLVER_HPP |
12 | #define BOOST_ASIO_IP_BASIC_RESOLVER_HPP |
13 | |
14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) |
15 | # pragma once |
16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) |
17 | |
18 | #include <boost/asio/detail/config.hpp> |
19 | #include <boost/asio/basic_io_object.hpp> |
20 | #include <boost/asio/detail/handler_type_requirements.hpp> |
21 | #include <boost/asio/detail/throw_error.hpp> |
22 | #include <boost/asio/error.hpp> |
23 | #include <boost/asio/ip/basic_resolver_iterator.hpp> |
24 | #include <boost/asio/ip/basic_resolver_query.hpp> |
25 | #include <boost/asio/ip/resolver_service.hpp> |
26 | |
27 | #include <boost/asio/detail/push_options.hpp> |
28 | |
29 | namespace boost { |
30 | namespace asio { |
31 | namespace ip { |
32 | |
33 | /// Provides endpoint resolution functionality. |
34 | /** |
35 | * The basic_resolver class template provides the ability to resolve a query |
36 | * to a list of endpoints. |
37 | * |
38 | * @par Thread Safety |
39 | * @e Distinct @e objects: Safe.@n |
40 | * @e Shared @e objects: Unsafe. |
41 | */ |
42 | template <typename InternetProtocol, |
43 | typename ResolverService = resolver_service<InternetProtocol> > |
44 | class basic_resolver |
45 | : public basic_io_object<ResolverService> |
46 | { |
47 | public: |
48 | /// The protocol type. |
49 | typedef InternetProtocol protocol_type; |
50 | |
51 | /// The endpoint type. |
52 | typedef typename InternetProtocol::endpoint endpoint_type; |
53 | |
54 | /// The query type. |
55 | typedef basic_resolver_query<InternetProtocol> query; |
56 | |
57 | /// The iterator type. |
58 | typedef basic_resolver_iterator<InternetProtocol> iterator; |
59 | |
60 | /// Constructor. |
61 | /** |
62 | * This constructor creates a basic_resolver. |
63 | * |
64 | * @param io_service The io_service object that the resolver will use to |
65 | * dispatch handlers for any asynchronous operations performed on the timer. |
66 | */ |
67 | explicit basic_resolver(boost::asio::io_service& io_service) |
68 | : basic_io_object<ResolverService>(io_service) |
69 | { |
70 | } |
71 | |
72 | /// Cancel any asynchronous operations that are waiting on the resolver. |
73 | /** |
74 | * This function forces the completion of any pending asynchronous |
75 | * operations on the host resolver. The handler for each cancelled operation |
76 | * will be invoked with the boost::asio::error::operation_aborted error code. |
77 | */ |
78 | void cancel() |
79 | { |
80 | return this->service.cancel(this->implementation); |
81 | } |
82 | |
83 | /// Perform forward resolution of a query to a list of entries. |
84 | /** |
85 | * This function is used to resolve a query into a list of endpoint entries. |
86 | * |
87 | * @param q A query object that determines what endpoints will be returned. |
88 | * |
89 | * @returns A forward-only iterator that can be used to traverse the list |
90 | * of endpoint entries. |
91 | * |
92 | * @throws boost::system::system_error Thrown on failure. |
93 | * |
94 | * @note A default constructed iterator represents the end of the list. |
95 | * |
96 | * A successful call to this function is guaranteed to return at least one |
97 | * entry. |
98 | */ |
99 | iterator resolve(const query& q) |
100 | { |
101 | boost::system::error_code ec; |
102 | iterator i = this->service.resolve(this->implementation, q, ec); |
103 | boost::asio::detail::throw_error(err: ec, location: "resolve" ); |
104 | return i; |
105 | } |
106 | |
107 | /// Perform forward resolution of a query to a list of entries. |
108 | /** |
109 | * This function is used to resolve a query into a list of endpoint entries. |
110 | * |
111 | * @param q A query object that determines what endpoints will be returned. |
112 | * |
113 | * @param ec Set to indicate what error occurred, if any. |
114 | * |
115 | * @returns A forward-only iterator that can be used to traverse the list |
116 | * of endpoint entries. Returns a default constructed iterator if an error |
117 | * occurs. |
118 | * |
119 | * @note A default constructed iterator represents the end of the list. |
120 | * |
121 | * A successful call to this function is guaranteed to return at least one |
122 | * entry. |
123 | */ |
124 | iterator resolve(const query& q, boost::system::error_code& ec) |
125 | { |
126 | return this->service.resolve(this->implementation, q, ec); |
127 | } |
128 | |
129 | /// Asynchronously perform forward resolution of a query to a list of entries. |
130 | /** |
131 | * This function is used to asynchronously resolve a query into a list of |
132 | * endpoint entries. |
133 | * |
134 | * @param q A query object that determines what endpoints will be returned. |
135 | * |
136 | * @param handler The handler to be called when the resolve operation |
137 | * completes. Copies will be made of the handler as required. The function |
138 | * signature of the handler must be: |
139 | * @code void handler( |
140 | * const boost::system::error_code& error, // Result of operation. |
141 | * resolver::iterator iterator // Forward-only iterator that can |
142 | * // be used to traverse the list |
143 | * // of endpoint entries. |
144 | * ); @endcode |
145 | * Regardless of whether the asynchronous operation completes immediately or |
146 | * not, the handler will not be invoked from within this function. Invocation |
147 | * of the handler will be performed in a manner equivalent to using |
148 | * boost::asio::io_service::post(). |
149 | * |
150 | * @note A default constructed iterator represents the end of the list. |
151 | * |
152 | * A successful resolve operation is guaranteed to pass at least one entry to |
153 | * the handler. |
154 | */ |
155 | template <typename ResolveHandler> |
156 | BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler, |
157 | void (boost::system::error_code, iterator)) |
158 | async_resolve(const query& q, |
159 | BOOST_ASIO_MOVE_ARG(ResolveHandler) handler) |
160 | { |
161 | // If you get an error on the following line it means that your handler does |
162 | // not meet the documented type requirements for a ResolveHandler. |
163 | BOOST_ASIO_RESOLVE_HANDLER_CHECK( |
164 | ResolveHandler, handler, iterator) type_check; |
165 | |
166 | return this->service.async_resolve(this->implementation, q, |
167 | BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler)); |
168 | } |
169 | |
170 | /// Perform reverse resolution of an endpoint to a list of entries. |
171 | /** |
172 | * This function is used to resolve an endpoint into a list of endpoint |
173 | * entries. |
174 | * |
175 | * @param e An endpoint object that determines what endpoints will be |
176 | * returned. |
177 | * |
178 | * @returns A forward-only iterator that can be used to traverse the list |
179 | * of endpoint entries. |
180 | * |
181 | * @throws boost::system::system_error Thrown on failure. |
182 | * |
183 | * @note A default constructed iterator represents the end of the list. |
184 | * |
185 | * A successful call to this function is guaranteed to return at least one |
186 | * entry. |
187 | */ |
188 | iterator resolve(const endpoint_type& e) |
189 | { |
190 | boost::system::error_code ec; |
191 | iterator i = this->service.resolve(this->implementation, e, ec); |
192 | boost::asio::detail::throw_error(err: ec, location: "resolve" ); |
193 | return i; |
194 | } |
195 | |
196 | /// Perform reverse resolution of an endpoint to a list of entries. |
197 | /** |
198 | * This function is used to resolve an endpoint into a list of endpoint |
199 | * entries. |
200 | * |
201 | * @param e An endpoint object that determines what endpoints will be |
202 | * returned. |
203 | * |
204 | * @param ec Set to indicate what error occurred, if any. |
205 | * |
206 | * @returns A forward-only iterator that can be used to traverse the list |
207 | * of endpoint entries. Returns a default constructed iterator if an error |
208 | * occurs. |
209 | * |
210 | * @note A default constructed iterator represents the end of the list. |
211 | * |
212 | * A successful call to this function is guaranteed to return at least one |
213 | * entry. |
214 | */ |
215 | iterator resolve(const endpoint_type& e, boost::system::error_code& ec) |
216 | { |
217 | return this->service.resolve(this->implementation, e, ec); |
218 | } |
219 | |
220 | /// Asynchronously perform reverse resolution of an endpoint to a list of |
221 | /// entries. |
222 | /** |
223 | * This function is used to asynchronously resolve an endpoint into a list of |
224 | * endpoint entries. |
225 | * |
226 | * @param e An endpoint object that determines what endpoints will be |
227 | * returned. |
228 | * |
229 | * @param handler The handler to be called when the resolve operation |
230 | * completes. Copies will be made of the handler as required. The function |
231 | * signature of the handler must be: |
232 | * @code void handler( |
233 | * const boost::system::error_code& error, // Result of operation. |
234 | * resolver::iterator iterator // Forward-only iterator that can |
235 | * // be used to traverse the list |
236 | * // of endpoint entries. |
237 | * ); @endcode |
238 | * Regardless of whether the asynchronous operation completes immediately or |
239 | * not, the handler will not be invoked from within this function. Invocation |
240 | * of the handler will be performed in a manner equivalent to using |
241 | * boost::asio::io_service::post(). |
242 | * |
243 | * @note A default constructed iterator represents the end of the list. |
244 | * |
245 | * A successful resolve operation is guaranteed to pass at least one entry to |
246 | * the handler. |
247 | */ |
248 | template <typename ResolveHandler> |
249 | BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler, |
250 | void (boost::system::error_code, iterator)) |
251 | async_resolve(const endpoint_type& e, |
252 | BOOST_ASIO_MOVE_ARG(ResolveHandler) handler) |
253 | { |
254 | // If you get an error on the following line it means that your handler does |
255 | // not meet the documented type requirements for a ResolveHandler. |
256 | BOOST_ASIO_RESOLVE_HANDLER_CHECK( |
257 | ResolveHandler, handler, iterator) type_check; |
258 | |
259 | return this->service.async_resolve(this->implementation, e, |
260 | BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler)); |
261 | } |
262 | }; |
263 | |
264 | } // namespace ip |
265 | } // namespace asio |
266 | } // namespace boost |
267 | |
268 | #include <boost/asio/detail/pop_options.hpp> |
269 | |
270 | #endif // BOOST_ASIO_IP_BASIC_RESOLVER_HPP |
271 | |