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