diff options
Diffstat (limited to '3rdparty/asio/include/asio/ip/basic_resolver.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/ip/basic_resolver.hpp | 446 |
1 files changed, 252 insertions, 194 deletions
diff --git a/3rdparty/asio/include/asio/ip/basic_resolver.hpp b/3rdparty/asio/include/asio/ip/basic_resolver.hpp index 3aa61fb8dac..cfadba4af9d 100644 --- a/3rdparty/asio/include/asio/ip/basic_resolver.hpp +++ b/3rdparty/asio/include/asio/ip/basic_resolver.hpp @@ -2,7 +2,7 @@ // ip/basic_resolver.hpp // ~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -17,41 +17,43 @@ #include "asio/detail/config.hpp" #include <string> +#include "asio/any_io_executor.hpp" #include "asio/async_result.hpp" -#include "asio/basic_io_object.hpp" #include "asio/detail/handler_type_requirements.hpp" +#include "asio/detail/io_object_impl.hpp" +#include "asio/detail/non_const_lvalue.hpp" #include "asio/detail/string_view.hpp" #include "asio/detail/throw_error.hpp" #include "asio/error.hpp" -#include "asio/io_context.hpp" +#include "asio/execution_context.hpp" #include "asio/ip/basic_resolver_iterator.hpp" #include "asio/ip/basic_resolver_query.hpp" #include "asio/ip/basic_resolver_results.hpp" #include "asio/ip/resolver_base.hpp" +#if defined(ASIO_WINDOWS_RUNTIME) +# include "asio/detail/winrt_resolver_service.hpp" +#else +# include "asio/detail/resolver_service.hpp" +#endif #if defined(ASIO_HAS_MOVE) # include <utility> #endif // defined(ASIO_HAS_MOVE) -#if defined(ASIO_ENABLE_OLD_SERVICES) -# include "asio/ip/resolver_service.hpp" -#else // defined(ASIO_ENABLE_OLD_SERVICES) -# if defined(ASIO_WINDOWS_RUNTIME) -# include "asio/detail/winrt_resolver_service.hpp" -# define ASIO_SVC_T \ - asio::detail::winrt_resolver_service<InternetProtocol> -# else -# include "asio/detail/resolver_service.hpp" -# define ASIO_SVC_T \ - asio::detail::resolver_service<InternetProtocol> -# endif -#endif // defined(ASIO_ENABLE_OLD_SERVICES) - #include "asio/detail/push_options.hpp" namespace asio { namespace ip { +#if !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL) +#define ASIO_IP_BASIC_RESOLVER_FWD_DECL + +// Forward declaration with defaulted arguments. +template <typename InternetProtocol, typename Executor = any_io_executor> +class basic_resolver; + +#endif // !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL) + /// Provides endpoint resolution functionality. /** * The basic_resolver class template provides the ability to resolve a query @@ -61,15 +63,21 @@ namespace ip { * @e Distinct @e objects: Safe.@n * @e Shared @e objects: Unsafe. */ -template <typename InternetProtocol - ASIO_SVC_TPARAM_DEF1(= resolver_service<InternetProtocol>)> +template <typename InternetProtocol, typename Executor> class basic_resolver - : ASIO_SVC_ACCESS basic_io_object<ASIO_SVC_T>, - public resolver_base + : public resolver_base { public: /// The type of the executor associated with the object. - typedef io_context::executor_type executor_type; + typedef Executor executor_type; + + /// Rebinds the resolver type to another executor. + template <typename Executor1> + struct rebind_executor + { + /// The resolver type when rebound to the specified executor. + typedef basic_resolver<InternetProtocol, Executor1> other; + }; /// The protocol type. typedef InternetProtocol protocol_type; @@ -88,16 +96,33 @@ public: /// The results type. typedef basic_resolver_results<InternetProtocol> results_type; - /// Constructor. + /// Construct with executor. /** * This constructor creates a basic_resolver. * - * @param io_context The io_context object that the resolver will use to + * @param ex The I/O executor that the resolver will use, by default, to * dispatch handlers for any asynchronous operations performed on the * resolver. */ - explicit basic_resolver(asio::io_context& io_context) - : basic_io_object<ASIO_SVC_T>(io_context) + explicit basic_resolver(const executor_type& ex) + : impl_(0, ex) + { + } + + /// Construct with execution context. + /** + * This constructor creates a basic_resolver. + * + * @param context An execution context which provides the I/O executor that + * the resolver will use, by default, to dispatch handlers for any + * asynchronous operations performed on the resolver. + */ + template <typename ExecutionContext> + explicit basic_resolver(ExecutionContext& context, + typename constraint< + is_convertible<ExecutionContext&, execution_context&>::value + >::type = 0) + : impl_(0, 0, context) { } @@ -110,10 +135,33 @@ public: * occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_resolver(io_context&) constructor. + * constructed using the @c basic_resolver(const executor_type&) constructor. */ basic_resolver(basic_resolver&& other) - : basic_io_object<ASIO_SVC_T>(std::move(other)) + : impl_(std::move(other.impl_)) + { + } + + // All resolvers have access to each other's implementations. + template <typename InternetProtocol1, typename Executor1> + friend class basic_resolver; + + /// Move-construct a basic_resolver from another. + /** + * This constructor moves a resolver from one object to another. + * + * @param other The other basic_resolver object from which the move will + * occur. + * + * @note Following the move, the moved-from object is in the same state as if + * constructed using the @c basic_resolver(const executor_type&) constructor. + */ + template <typename Executor1> + basic_resolver(basic_resolver<InternetProtocol, Executor1>&& other, + typename constraint< + is_convertible<Executor1, Executor>::value + >::type = 0) + : impl_(std::move(other.impl_)) { } @@ -127,64 +175,53 @@ public: * occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_resolver(io_context&) constructor. + * constructed using the @c basic_resolver(const executor_type&) constructor. */ basic_resolver& operator=(basic_resolver&& other) { - basic_io_object<ASIO_SVC_T>::operator=(std::move(other)); + impl_ = std::move(other.impl_); return *this; } -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) - /// Destroys the resolver. - /** - * This function destroys the resolver, cancelling any outstanding - * asynchronous wait operations associated with the resolver as if by calling - * @c cancel. - */ - ~basic_resolver() - { - } - -#if defined(ASIO_ENABLE_OLD_SERVICES) - // These functions are provided by basic_io_object<>. -#else // defined(ASIO_ENABLE_OLD_SERVICES) -#if !defined(ASIO_NO_DEPRECATED) - /// (Deprecated: Use get_executor().) Get the io_context associated with the - /// object. + /// Move-assign a basic_resolver from another. /** - * This function may be used to obtain the io_context object that the I/O - * object uses to dispatch handlers for asynchronous operations. + * This assignment operator moves a resolver from one object to another. + * Cancels any outstanding asynchronous operations associated with the target + * object. + * + * @param other The other basic_resolver object from which the move will + * occur. * - * @return A reference to the io_context object that the I/O object will use - * to dispatch handlers. Ownership is not transferred to the caller. + * @note Following the move, the moved-from object is in the same state as if + * constructed using the @c basic_resolver(const executor_type&) constructor. */ - asio::io_context& get_io_context() + template <typename Executor1> + typename constraint< + is_convertible<Executor1, Executor>::value, + basic_resolver& + >::type operator=(basic_resolver<InternetProtocol, Executor1>&& other) { - return basic_io_object<ASIO_SVC_T>::get_io_context(); + basic_resolver tmp(std::move(other)); + impl_ = std::move(tmp.impl_); + return *this; } +#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) - /// (Deprecated: Use get_executor().) Get the io_context associated with the - /// object. + /// Destroys the resolver. /** - * This function may be used to obtain the io_context object that the I/O - * object uses to dispatch handlers for asynchronous operations. - * - * @return A reference to the io_context object that the I/O object will use - * to dispatch handlers. Ownership is not transferred to the caller. + * This function destroys the resolver, cancelling any outstanding + * asynchronous wait operations associated with the resolver as if by calling + * @c cancel. */ - asio::io_context& get_io_service() + ~basic_resolver() { - return basic_io_object<ASIO_SVC_T>::get_io_service(); } -#endif // !defined(ASIO_NO_DEPRECATED) /// Get the executor associated with the object. executor_type get_executor() ASIO_NOEXCEPT { - return basic_io_object<ASIO_SVC_T>::get_executor(); + return impl_.get_executor(); } -#endif // defined(ASIO_ENABLE_OLD_SERVICES) /// Cancel any asynchronous operations that are waiting on the resolver. /** @@ -194,11 +231,12 @@ public: */ void cancel() { - return this->get_service().cancel(this->get_implementation()); + return impl_.get_service().cancel(impl_.get_implementation()); } #if !defined(ASIO_NO_DEPRECATED) - /// (Deprecated.) Perform forward resolution of a query to a list of entries. + /// (Deprecated: Use overload with separate host and service parameters.) + /// Perform forward resolution of a query to a list of entries. /** * This function is used to resolve a query into a list of endpoint entries. * @@ -213,13 +251,14 @@ public: results_type resolve(const query& q) { asio::error_code ec; - results_type r = this->get_service().resolve( - this->get_implementation(), q, ec); + results_type r = impl_.get_service().resolve( + impl_.get_implementation(), q, ec); asio::detail::throw_error(ec, "resolve"); return r; } - /// (Deprecated.) Perform forward resolution of a query to a list of entries. + /// (Deprecated: Use overload with separate host and service parameters.) + /// Perform forward resolution of a query to a list of entries. /** * This function is used to resolve a query into a list of endpoint entries. * @@ -233,7 +272,7 @@ public: */ results_type resolve(const query& q, asio::error_code& ec) { - return this->get_service().resolve(this->get_implementation(), q, ec); + return impl_.get_service().resolve(impl_.get_implementation(), q, ec); } #endif // !defined(ASIO_NO_DEPRECATED) @@ -333,7 +372,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @returns A range object representing the list of endpoint entries. A * successful call to this function is guaranteed to return a non-empty @@ -358,8 +398,8 @@ public: asio::error_code ec; basic_resolver_query<protocol_type> q(static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); - results_type r = this->get_service().resolve( - this->get_implementation(), q, ec); + results_type r = impl_.get_service().resolve( + impl_.get_implementation(), q, ec); asio::detail::throw_error(ec, "resolve"); return r; } @@ -382,7 +422,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @param ec Set to indicate what error occurred, if any. * @@ -407,7 +448,7 @@ public: { basic_resolver_query<protocol_type> q(static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); - return this->get_service().resolve(this->get_implementation(), q, ec); + return impl_.get_service().resolve(impl_.get_implementation(), q, ec); } /// Perform forward resolution of a query to a list of entries. @@ -516,7 +557,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @returns A range object representing the list of endpoint entries. A * successful call to this function is guaranteed to return a non-empty @@ -543,8 +585,8 @@ public: basic_resolver_query<protocol_type> q( protocol, static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); - results_type r = this->get_service().resolve( - this->get_implementation(), q, ec); + results_type r = impl_.get_service().resolve( + impl_.get_implementation(), q, ec); asio::detail::throw_error(ec, "resolve"); return r; } @@ -570,7 +612,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @param ec Set to indicate what error occurred, if any. * @@ -596,12 +639,12 @@ public: basic_resolver_query<protocol_type> q( protocol, static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); - return this->get_service().resolve(this->get_implementation(), q, ec); + return impl_.get_service().resolve(impl_.get_implementation(), q, ec); } #if !defined(ASIO_NO_DEPRECATED) - /// (Deprecated.) Asynchronously perform forward resolution of a query to a - /// list of entries. + /// (Deprecated: Use overload with separate host and service parameters.) + /// Asynchronously perform forward resolution of a query to a list of entries. /** * This function is used to asynchronously resolve a query into a list of * endpoint entries. @@ -616,36 +659,26 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(const query& q, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ResolveHandler. - ASIO_RESOLVE_HANDLER_CHECK( - ResolveHandler, handler, results_type) type_check; - -#if defined(ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_resolve(this->get_implementation(), q, - ASIO_MOVE_CAST(ResolveHandler)(handler)); -#else // defined(ASIO_ENABLE_OLD_SERVICES) - asio::async_completion<ResolveHandler, - void (asio::error_code, results_type)> init(handler); - - this->get_service().async_resolve( - this->get_implementation(), q, init.completion_handler); - - return init.result.get(); -#endif // defined(ASIO_ENABLE_OLD_SERVICES) + return asio::async_initiate<ResolveHandler, + void (asio::error_code, results_type)>( + initiate_async_resolve(this), handler, q); } #endif // !defined(ASIO_NO_DEPRECATED) @@ -673,9 +706,9 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. @@ -691,12 +724,16 @@ public: * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems * may use additional locations when resolving service names. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { return async_resolve(host, service, resolver_base::flags(), ASIO_MOVE_CAST(ResolveHandler)(handler)); @@ -720,7 +757,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @param handler The handler to be called when the resolve operation * completes. Copies will be made of the handler as required. The function @@ -730,9 +768,9 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. @@ -748,34 +786,24 @@ public: * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems * may use additional locations when resolving service names. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ResolveHandler. - ASIO_RESOLVE_HANDLER_CHECK( - ResolveHandler, handler, results_type) type_check; - basic_resolver_query<protocol_type> q(static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); -#if defined(ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_resolve(this->get_implementation(), q, - ASIO_MOVE_CAST(ResolveHandler)(handler)); -#else // defined(ASIO_ENABLE_OLD_SERVICES) - asio::async_completion<ResolveHandler, - void (asio::error_code, results_type)> init(handler); - - this->get_service().async_resolve( - this->get_implementation(), q, init.completion_handler); - - return init.result.get(); -#endif // defined(ASIO_ENABLE_OLD_SERVICES) + return asio::async_initiate<ResolveHandler, + void (asio::error_code, results_type)>( + initiate_async_resolve(this), handler, q); } /// Asynchronously perform forward resolution of a query to a list of entries. @@ -805,9 +833,9 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. @@ -823,12 +851,16 @@ public: * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems * may use additional locations when resolving service names. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(const protocol_type& protocol, ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { return async_resolve(protocol, host, service, resolver_base::flags(), ASIO_MOVE_CAST(ResolveHandler)(handler)); @@ -855,7 +887,8 @@ public: * * @param resolve_flags A set of flags that determine how name resolution * should be performed. The default flags are suitable for communication with - * remote hosts. + * remote hosts. See the @ref resolver_base documentation for the set of + * available flags. * * @param handler The handler to be called when the resolve operation * completes. Copies will be made of the handler as required. The function @@ -865,9 +898,9 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. @@ -883,35 +916,25 @@ public: * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems * may use additional locations when resolving service names. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(const protocol_type& protocol, ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ResolveHandler. - ASIO_RESOLVE_HANDLER_CHECK( - ResolveHandler, handler, results_type) type_check; - basic_resolver_query<protocol_type> q( protocol, static_cast<std::string>(host), static_cast<std::string>(service), resolve_flags); -#if defined(ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_resolve(this->get_implementation(), q, - ASIO_MOVE_CAST(ResolveHandler)(handler)); -#else // defined(ASIO_ENABLE_OLD_SERVICES) - asio::async_completion<ResolveHandler, - void (asio::error_code, results_type)> init(handler); - - this->get_service().async_resolve( - this->get_implementation(), q, init.completion_handler); - - return init.result.get(); -#endif // defined(ASIO_ENABLE_OLD_SERVICES) + return asio::async_initiate<ResolveHandler, + void (asio::error_code, results_type)>( + initiate_async_resolve(this), handler, q); } /// Perform reverse resolution of an endpoint to a list of entries. @@ -931,8 +954,8 @@ public: results_type resolve(const endpoint_type& e) { asio::error_code ec; - results_type i = this->get_service().resolve( - this->get_implementation(), e, ec); + results_type i = impl_.get_service().resolve( + impl_.get_implementation(), e, ec); asio::detail::throw_error(ec, "resolve"); return i; } @@ -953,7 +976,7 @@ public: */ results_type resolve(const endpoint_type& e, asio::error_code& ec) { - return this->get_service().resolve(this->get_implementation(), e, ec); + return impl_.get_service().resolve(impl_.get_implementation(), e, ec); } /// Asynchronously perform reverse resolution of an endpoint to a list of @@ -973,37 +996,76 @@ public: * resolver::results_type results // Resolved endpoints as a range. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation - * of the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * A successful resolve operation is guaranteed to pass a non-empty range to * the handler. */ - template <typename ResolveHandler> - ASIO_INITFN_RESULT_TYPE(ResolveHandler, + template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + results_type)) ResolveHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> + ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, void (asio::error_code, results_type)) async_resolve(const endpoint_type& e, - ASIO_MOVE_ARG(ResolveHandler) handler) + ASIO_MOVE_ARG(ResolveHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ResolveHandler. - ASIO_RESOLVE_HANDLER_CHECK( - ResolveHandler, handler, results_type) type_check; + return asio::async_initiate<ResolveHandler, + void (asio::error_code, results_type)>( + initiate_async_resolve(this), handler, e); + } -#if defined(ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_resolve(this->get_implementation(), e, - ASIO_MOVE_CAST(ResolveHandler)(handler)); -#else // defined(ASIO_ENABLE_OLD_SERVICES) - asio::async_completion<ResolveHandler, - void (asio::error_code, results_type)> init(handler); +private: + // Disallow copying and assignment. + basic_resolver(const basic_resolver&) ASIO_DELETED; + basic_resolver& operator=(const basic_resolver&) ASIO_DELETED; - this->get_service().async_resolve( - this->get_implementation(), e, init.completion_handler); + class initiate_async_resolve + { + public: + typedef Executor executor_type; - return init.result.get(); -#endif // defined(ASIO_ENABLE_OLD_SERVICES) - } + explicit initiate_async_resolve(basic_resolver* self) + : self_(self) + { + } + + executor_type get_executor() const ASIO_NOEXCEPT + { + return self_->get_executor(); + } + + template <typename ResolveHandler, typename Query> + void operator()(ASIO_MOVE_ARG(ResolveHandler) handler, + const Query& q) const + { + // If you get an error on the following line it means that your handler + // does not meet the documented type requirements for a ResolveHandler. + ASIO_RESOLVE_HANDLER_CHECK( + ResolveHandler, handler, results_type) type_check; + + asio::detail::non_const_lvalue<ResolveHandler> handler2(handler); + self_->impl_.get_service().async_resolve( + self_->impl_.get_implementation(), q, + handler2.value, self_->impl_.get_executor()); + } + + private: + basic_resolver* self_; + }; + +# if defined(ASIO_WINDOWS_RUNTIME) + asio::detail::io_object_impl< + asio::detail::winrt_resolver_service<InternetProtocol>, + Executor> impl_; +# else + asio::detail::io_object_impl< + asio::detail::resolver_service<InternetProtocol>, + Executor> impl_; +# endif }; } // namespace ip @@ -1011,8 +1073,4 @@ public: #include "asio/detail/pop_options.hpp" -#if !defined(ASIO_ENABLE_OLD_SERVICES) -# undef ASIO_SVC_T -#endif // !defined(ASIO_ENABLE_OLD_SERVICES) - #endif // ASIO_IP_BASIC_RESOLVER_HPP |