diff options
Diffstat (limited to '3rdparty/asio/include/asio/async_result.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/async_result.hpp | 1186 |
1 files changed, 1115 insertions, 71 deletions
diff --git a/3rdparty/asio/include/asio/async_result.hpp b/3rdparty/asio/include/asio/async_result.hpp index cd866bbd0e6..1750e19e3a4 100644 --- a/3rdparty/asio/include/asio/async_result.hpp +++ b/3rdparty/asio/include/asio/async_result.hpp @@ -2,7 +2,7 @@ // async_result.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,12 +17,507 @@ #include "asio/detail/config.hpp" #include "asio/detail/type_traits.hpp" -#include "asio/handler_type.hpp" +#include "asio/detail/variadic_templates.hpp" #include "asio/detail/push_options.hpp" namespace asio { +#if defined(ASIO_HAS_CONCEPTS) \ + && defined(ASIO_HAS_VARIADIC_TEMPLATES) \ + && defined(ASIO_HAS_DECLTYPE) + +namespace detail { + +template <typename T> +struct is_completion_signature : false_type +{ +}; + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...)> : true_type +{ +}; + +#if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...) &> : true_type +{ +}; + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...) &&> : true_type +{ +}; + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...) noexcept> : true_type +{ +}; + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...) & noexcept> : true_type +{ +}; + +template <typename R, typename... Args> +struct is_completion_signature<R(Args...) && noexcept> : true_type +{ +}; + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +#endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename... T> +struct are_completion_signatures : false_type +{ +}; + +template <typename T0> +struct are_completion_signatures<T0> + : is_completion_signature<T0> +{ +}; + +template <typename T0, typename... TN> +struct are_completion_signatures<T0, TN...> + : integral_constant<bool, ( + is_completion_signature<T0>::value + && are_completion_signatures<TN...>::value)> +{ +}; + +template <typename T, typename... Args> +ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args) +{ + static_cast<T&&>(t)(static_cast<Args&&>(args)...); +}; + +template <typename T, typename... Signatures> +struct is_completion_handler_for : false_type +{ +}; + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...)> + : integral_constant<bool, (callable_with<T, Args...>)> +{ +}; + +#if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...) &> + : integral_constant<bool, (callable_with<T&, Args...>)> +{ +}; + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...) &&> + : integral_constant<bool, (callable_with<T&&, Args...>)> +{ +}; + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...) noexcept> + : integral_constant<bool, (callable_with<T, Args...>)> +{ +}; + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...) & noexcept> + : integral_constant<bool, (callable_with<T&, Args...>)> +{ +}; + +template <typename T, typename R, typename... Args> +struct is_completion_handler_for<T, R(Args...) && noexcept> + : integral_constant<bool, (callable_with<T&&, Args...>)> +{ +}; + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +#endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename T, typename Signature0, typename... SignatureN> +struct is_completion_handler_for<T, Signature0, SignatureN...> + : integral_constant<bool, ( + is_completion_handler_for<T, Signature0>::value + && is_completion_handler_for<T, SignatureN...>::value)> +{ +}; + +} // namespace detail + +template <typename T> +ASIO_CONCEPT completion_signature = + detail::is_completion_signature<T>::value; + +#define ASIO_COMPLETION_SIGNATURE \ + ::asio::completion_signature + +template <typename T, typename... Signatures> +ASIO_CONCEPT completion_handler_for = + detail::are_completion_signatures<Signatures...>::value + && detail::is_completion_handler_for<T, Signatures...>::value; + +#define ASIO_COMPLETION_HANDLER_FOR(sig) \ + ::asio::completion_handler_for<sig> +#define ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) \ + ::asio::completion_handler_for<sig0, sig1> +#define ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) \ + ::asio::completion_handler_for<sig0, sig1, sig2> + +#else // defined(ASIO_HAS_CONCEPTS) + // && defined(ASIO_HAS_VARIADIC_TEMPLATES) + // && defined(ASIO_HAS_DECLTYPE) + +#define ASIO_COMPLETION_SIGNATURE typename +#define ASIO_COMPLETION_HANDLER_FOR(sig) typename +#define ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) typename +#define ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) typename + +#endif // defined(ASIO_HAS_CONCEPTS) + // && defined(ASIO_HAS_VARIADIC_TEMPLATES) + // && defined(ASIO_HAS_DECLTYPE) + +namespace detail { + +template <typename T> +struct is_simple_completion_signature : false_type +{ +}; + +template <typename T> +struct simple_completion_signature; + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename R, typename... Args> +struct is_simple_completion_signature<R(Args...)> : true_type +{ +}; + +template <typename... Signatures> +struct are_simple_completion_signatures : false_type +{ +}; + +template <typename Sig0> +struct are_simple_completion_signatures<Sig0> + : is_simple_completion_signature<Sig0> +{ +}; + +template <typename Sig0, typename... SigN> +struct are_simple_completion_signatures<Sig0, SigN...> + : integral_constant<bool, ( + is_simple_completion_signature<Sig0>::value + && are_simple_completion_signatures<SigN...>::value)> +{ +}; + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...)> +{ + typedef R type(Args...); +}; + +#if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...) &> +{ + typedef R type(Args...); +}; + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...) &&> +{ + typedef R type(Args...); +}; + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...) noexcept> +{ + typedef R type(Args...); +}; + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...) & noexcept> +{ + typedef R type(Args...); +}; + +template <typename R, typename... Args> +struct simple_completion_signature<R(Args...) && noexcept> +{ + typedef R type(Args...); +}; + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +#endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename R> +struct is_simple_completion_signature<R()> : true_type +{ +}; + +#define ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct is_simple_completion_signature<R(ASIO_VARIADIC_TARGS(n))> \ + : true_type \ + { \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_SIMPLE_SIG_DEF) +#undef ASIO_PRIVATE_SIMPLE_SIG_DEF + +template <typename Sig0 = void, typename Sig1 = void, + typename Sig2 = void, typename = void> +struct are_simple_completion_signatures : false_type +{ +}; + +template <typename Sig0> +struct are_simple_completion_signatures<Sig0> + : is_simple_completion_signature<Sig0> +{ +}; + +template <typename Sig0, typename Sig1> +struct are_simple_completion_signatures<Sig0, Sig1> + : integral_constant<bool, + (is_simple_completion_signature<Sig0>::value + && is_simple_completion_signature<Sig1>::value)> +{ +}; + +template <typename Sig0, typename Sig1, typename Sig2> +struct are_simple_completion_signatures<Sig0, Sig1, Sig2> + : integral_constant<bool, + (is_simple_completion_signature<Sig0>::value + && is_simple_completion_signature<Sig1>::value + && is_simple_completion_signature<Sig2>::value)> +{ +}; + +template <typename R> +struct simple_completion_signature<R()> +{ + typedef R type(); +}; + +#define ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature<R(ASIO_VARIADIC_TARGS(n))> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_SIMPLE_SIG_DEF) +#undef ASIO_PRIVATE_SIMPLE_SIG_DEF + +#if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename R> +struct simple_completion_signature<R() &> +{ + typedef R type(); +}; + +template <typename R> +struct simple_completion_signature<R() &&> +{ + typedef R type(); +}; + +#define ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature< \ + R(ASIO_VARIADIC_TARGS(n)) &> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature< \ + R(ASIO_VARIADIC_TARGS(n)) &&> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_SIMPLE_SIG_DEF) +#undef ASIO_PRIVATE_SIMPLE_SIG_DEF + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename R> +struct simple_completion_signature<R() noexcept> +{ + typedef R type(); +}; + +template <typename R> +struct simple_completion_signature<R() & noexcept> +{ + typedef R type(); +}; + +template <typename R> +struct simple_completion_signature<R() && noexcept> +{ + typedef R type(); +}; + +#define ASIO_PRIVATE_SIMPLE_SIG_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature< \ + R(ASIO_VARIADIC_TARGS(n)) noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature< \ + R(ASIO_VARIADIC_TARGS(n)) & noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct simple_completion_signature< \ + R(ASIO_VARIADIC_TARGS(n)) && noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_SIMPLE_SIG_DEF) +#undef ASIO_PRIVATE_SIMPLE_SIG_DEF + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +#endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \ + || defined(GENERATING_DOCUMENTATION) + +# define ASIO_COMPLETION_SIGNATURES_TPARAMS \ + ASIO_COMPLETION_SIGNATURE... Signatures + +# define ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \ + ASIO_COMPLETION_SIGNATURE... Signatures + +# define ASIO_COMPLETION_SIGNATURES_TARGS Signatures... + +# define ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \ + typename asio::detail::simple_completion_signature< \ + Signatures>::type... + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + // || defined(GENERATING_DOCUMENTATION) + +# define ASIO_COMPLETION_SIGNATURES_TPARAMS \ + typename Sig0 = void, \ + typename Sig1 = void, \ + typename Sig2 = void + +# define ASIO_COMPLETION_SIGNATURES_TSPECPARAMS \ + typename Sig0, \ + typename Sig1, \ + typename Sig2 + +# define ASIO_COMPLETION_SIGNATURES_TARGS Sig0, Sig1, Sig2 + +# define ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS \ + typename ::asio::detail::simple_completion_signature<Sig0>::type, \ + typename ::asio::detail::simple_completion_signature<Sig1>::type, \ + typename ::asio::detail::simple_completion_signature<Sig2>::type + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + // || defined(GENERATING_DOCUMENTATION) + +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> +class completion_handler_async_result +{ +public: + typedef CompletionToken completion_handler_type; + typedef void return_type; + + explicit completion_handler_async_result(completion_handler_type&) + { + } + + return_type get() + { + } + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Initiation, + ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken, + typename... Args> + static return_type initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_MOVE_ARG(RawCompletionToken) token, + ASIO_MOVE_ARG(Args)... args) + { + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(RawCompletionToken)(token), + ASIO_MOVE_CAST(Args)(args)...); + } + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Initiation, typename RawCompletionToken> + static return_type initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_MOVE_ARG(RawCompletionToken) token) + { + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(RawCompletionToken)(token)); + } + +#define ASIO_PRIVATE_INITIATE_DEF(n) \ + template <typename Initiation, \ + typename RawCompletionToken, \ + ASIO_VARIADIC_TPARAMS(n)> \ + static return_type initiate( \ + ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_MOVE_ARG(RawCompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + ASIO_MOVE_CAST(Initiation)(initiation)( \ + ASIO_MOVE_CAST(RawCompletionToken)(token), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF) +#undef ASIO_PRIVATE_INITIATE_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +private: + completion_handler_async_result( + const completion_handler_async_result&) ASIO_DELETED; + completion_handler_async_result& operator=( + const completion_handler_async_result&) ASIO_DELETED; +}; + +} // namespace detail + +#if defined(GENERATING_DOCUMENTATION) + /// An interface for customising the behaviour of an initiating function. /** * The async_result traits class is used for determining: @@ -41,30 +536,15 @@ namespace asio { * The primary template assumes that the CompletionToken is the completion * handler. */ -#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) -template <typename CompletionToken, typename Signature> -#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) -template <typename CompletionToken, typename Signature = void> -#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> class async_result { public: -#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) /// The concrete completion handler type for the specific signature. typedef CompletionToken completion_handler_type; /// The return type of the initiating function. typedef void return_type; -#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - // For backward compatibility, determine the concrete completion handler type - // by using the legacy handler_type trait. - typedef typename handler_type<CompletionToken, Signature>::type - completion_handler_type; - - // For backward compatibility, determine the initiating function return type - // using the legacy single-parameter version of async_result. - typedef typename async_result<completion_handler_type>::type return_type; -#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) /// Construct an async result from a given handler. /** @@ -72,79 +552,96 @@ public: * to initialise some state associated with the completion handler, which is * then returned from the initiating function. */ - explicit async_result(completion_handler_type& h) -#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - // No data members to initialise. -#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - : legacy_result_(h) -#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - { - (void)h; - } + explicit async_result(completion_handler_type& h); /// Obtain the value to be returned from the initiating function. - return_type get() - { -#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - // Nothing to do. -#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - return legacy_result_.get(); -#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - } + return_type get(); + + /// Initiate the asynchronous operation that will produce the result, and + /// obtain the value to be returned from the initiating function. + template <typename Initiation, typename RawCompletionToken, typename... Args> + static return_type initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_MOVE_ARG(RawCompletionToken) token, + ASIO_MOVE_ARG(Args)... args); private: async_result(const async_result&) ASIO_DELETED; async_result& operator=(const async_result&) ASIO_DELETED; - -#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - // No data members. -#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) - async_result<completion_handler_type> legacy_result_; -#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION) }; -#if !defined(ASIO_NO_DEPRECATED) +#else // defined(GENERATING_DOCUMENTATION) -/// (Deprecated: Use two-parameter version of async_result.) An interface for -/// customising the behaviour of an initiating function. -/** - * This template may be specialised for user-defined handler types. - */ -template <typename Handler> -class async_result<Handler> +#if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> +class async_result : + public conditional< + detail::are_simple_completion_signatures< + ASIO_COMPLETION_SIGNATURES_TARGS>::value, + detail::completion_handler_async_result< + CompletionToken, ASIO_COMPLETION_SIGNATURES_TARGS>, + async_result<CompletionToken, + ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS> + >::type { public: - /// The return type of the initiating function. - typedef void type; + typedef typename conditional< + detail::are_simple_completion_signatures< + ASIO_COMPLETION_SIGNATURES_TARGS>::value, + detail::completion_handler_async_result< + CompletionToken, ASIO_COMPLETION_SIGNATURES_TARGS>, + async_result<CompletionToken, + ASIO_COMPLETION_SIGNATURES_TSIMPLEARGS> + >::type base_type; - /// Construct an async result from a given handler. - /** - * When using a specalised async_result, the constructor has an opportunity - * to initialise some state associated with the handler, which is then - * returned from the initiating function. - */ - explicit async_result(Handler&) - { - } + using base_type::base_type; - /// Obtain the value to be returned from the initiating function. - type get() +private: + async_result(const async_result&) ASIO_DELETED; + async_result& operator=(const async_result&) ASIO_DELETED; +}; + +#else // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> +class async_result : + public detail::completion_handler_async_result< + CompletionToken, ASIO_COMPLETION_SIGNATURES_TARGS> +{ +public: + explicit async_result(CompletionToken& h) + : detail::completion_handler_async_result< + CompletionToken, ASIO_COMPLETION_SIGNATURES_TARGS>(h) { } + +private: + async_result(const async_result&) ASIO_DELETED; + async_result& operator=(const async_result&) ASIO_DELETED; +}; + +#endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <ASIO_COMPLETION_SIGNATURES_TSPECPARAMS> +class async_result<void, ASIO_COMPLETION_SIGNATURES_TARGS> +{ + // Empty. }; -#endif // !defined(ASIO_NO_DEPRECATED) +#endif // defined(GENERATING_DOCUMENTATION) /// Helper template to deduce the handler type from a CompletionToken, capture /// a local copy of the handler, and then create an async_result for the /// handler. -template <typename CompletionToken, typename Signature> +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> struct async_completion { /// The real handler type to be used for the asynchronous operation. typedef typename asio::async_result< typename decay<CompletionToken>::type, - Signature>::completion_handler_type completion_handler_type; + ASIO_COMPLETION_SIGNATURES_TARGS>::completion_handler_type + completion_handler_type; #if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Constructor. @@ -183,39 +680,586 @@ struct async_completion #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// The result of the asynchronous operation's initiating function. - async_result<typename decay<CompletionToken>::type, Signature> result; + async_result<typename decay<CompletionToken>::type, + ASIO_COMPLETION_SIGNATURES_TARGS> result; }; namespace detail { -template <typename CompletionToken, typename Signature> +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> struct async_result_helper - : async_result<typename decay<CompletionToken>::type, Signature> + : async_result<typename decay<CompletionToken>::type, + ASIO_COMPLETION_SIGNATURES_TARGS> { }; -} // namespace detail -} // namespace asio +struct async_result_memfns_base +{ + void initiate(); +}; -#include "asio/detail/pop_options.hpp" +template <typename T> +struct async_result_memfns_derived + : T, async_result_memfns_base +{ +}; + +template <typename T, T> +struct async_result_memfns_check +{ +}; + +template <typename> +char (&async_result_initiate_memfn_helper(...))[2]; + +template <typename T> +char async_result_initiate_memfn_helper( + async_result_memfns_check< + void (async_result_memfns_base::*)(), + &async_result_memfns_derived<T>::initiate>*); + +template <typename CompletionToken, ASIO_COMPLETION_SIGNATURES_TPARAMS> +struct async_result_has_initiate_memfn + : integral_constant<bool, sizeof(async_result_initiate_memfn_helper< + async_result<typename decay<CompletionToken>::type, + ASIO_COMPLETION_SIGNATURES_TARGS> + >(0)) != 1> +{ +}; + +} // namespace detail #if defined(GENERATING_DOCUMENTATION) # define ASIO_INITFN_RESULT_TYPE(ct, sig) \ void_or_deduced +# define ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ + void_or_deduced +# define ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + void_or_deduced #elif defined(_MSC_VER) && (_MSC_VER < 1500) # define ASIO_INITFN_RESULT_TYPE(ct, sig) \ typename ::asio::detail::async_result_helper< \ ct, sig>::return_type +# define ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ + typename ::asio::detail::async_result_helper< \ + ct, sig0, sig1>::return_type +# define ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + typename ::asio::detail::async_result_helper< \ + ct, sig0, sig1, sig2>::return_type #define ASIO_HANDLER_TYPE(ct, sig) \ typename ::asio::detail::async_result_helper< \ ct, sig>::completion_handler_type +#define ASIO_HANDLER_TYPE2(ct, sig0, sig1) \ + typename ::asio::detail::async_result_helper< \ + ct, sig0, sig1>::completion_handler_type +#define ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \ + typename ::asio::detail::async_result_helper< \ + ct, sig0, sig1, sig2>::completion_handler_type #else # define ASIO_INITFN_RESULT_TYPE(ct, sig) \ typename ::asio::async_result< \ typename ::asio::decay<ct>::type, sig>::return_type +# define ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \ + typename ::asio::async_result< \ + typename ::asio::decay<ct>::type, sig0, sig1>::return_type +# define ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + typename ::asio::async_result< \ + typename ::asio::decay<ct>::type, sig0, sig1, sig2>::return_type #define ASIO_HANDLER_TYPE(ct, sig) \ typename ::asio::async_result< \ typename ::asio::decay<ct>::type, sig>::completion_handler_type +#define ASIO_HANDLER_TYPE2(ct, sig0, sig1) \ + typename ::asio::async_result< \ + typename ::asio::decay<ct>::type, \ + sig0, sig1>::completion_handler_type +#define ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \ + typename ::asio::async_result< \ + typename ::asio::decay<ct>::type, \ + sig0, sig1, sig2>::completion_handler_type +#endif + +#if defined(GENERATING_DOCUMENTATION) +# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ + auto +# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ + auto +# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + auto +#elif defined(ASIO_HAS_RETURN_TYPE_DEDUCTION) +# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ + auto +# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ + auto +# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + auto +#else +# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \ + ASIO_INITFN_RESULT_TYPE(ct, sig) +# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \ + ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) +# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \ + ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) +#endif + +#if defined(GENERATING_DOCUMENTATION) +# define ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ + void_or_deduced +# define ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ + void_or_deduced +# define ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ + void_or_deduced +#elif defined(ASIO_HAS_DECLTYPE) +# define ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ + decltype expr +# define ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ + decltype expr +# define ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ + decltype expr +#else +# define ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \ + ASIO_INITFN_RESULT_TYPE(ct, sig) +# define ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \ + ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) +# define ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \ + ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) +#endif + +#if defined(GENERATING_DOCUMENTATION) + +template <typename CompletionToken, + completion_signature... Signatures, + typename Initiation, typename... Args> +void_or_deduced async_initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken), + ASIO_MOVE_ARG(Args)... args); + +#elif defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE... Signatures, + typename Initiation, typename... Args> +inline typename constraint< + detail::async_result_has_initiate_memfn< + CompletionToken, Signatures...>::value, + ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Signatures..., + (async_result<typename decay<CompletionToken>::type, + Signatures...>::initiate(declval<ASIO_MOVE_ARG(Initiation)>(), + declval<ASIO_MOVE_ARG(CompletionToken)>(), + declval<ASIO_MOVE_ARG(Args)>()...)))>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, + ASIO_MOVE_ARG(Args)... args) +{ + return async_result<typename decay<CompletionToken>::type, + Signatures...>::initiate(ASIO_MOVE_CAST(Initiation)(initiation), + ASIO_MOVE_CAST(CompletionToken)(token), + ASIO_MOVE_CAST(Args)(args)...); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE... Signatures, + typename Initiation, typename... Args> +inline typename constraint< + !detail::async_result_has_initiate_memfn< + CompletionToken, Signatures...>::value, + ASIO_INITFN_RESULT_TYPE(CompletionToken, Signatures...)>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, + ASIO_MOVE_ARG(Args)... args) +{ + async_completion<CompletionToken, Signatures...> completion(token); + + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(CompletionToken, + Signatures...))(completion.completion_handler), + ASIO_MOVE_CAST(Args)(args)...); + + return completion.result.get(); +} + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + typename Initiation> +inline typename constraint< + detail::async_result_has_initiate_memfn< + CompletionToken, Sig0>::value, + ASIO_INITFN_DEDUCED_RESULT_TYPE(CompletionToken, Sig0, + (async_result<typename decay<CompletionToken>::type, + Sig0>::initiate(declval<ASIO_MOVE_ARG(Initiation)>(), + declval<ASIO_MOVE_ARG(CompletionToken)>())))>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + return async_result<typename decay<CompletionToken>::type, + Sig0>::initiate(ASIO_MOVE_CAST(Initiation)(initiation), + ASIO_MOVE_CAST(CompletionToken)(token)); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + ASIO_COMPLETION_SIGNATURE Sig1, + typename Initiation> +inline typename constraint< + detail::async_result_has_initiate_memfn< + CompletionToken, Sig0, Sig1>::value, + ASIO_INITFN_DEDUCED_RESULT_TYPE2(CompletionToken, Sig0, Sig1, + (async_result<typename decay<CompletionToken>::type, + Sig0, Sig1>::initiate(declval<ASIO_MOVE_ARG(Initiation)>(), + declval<ASIO_MOVE_ARG(CompletionToken)>())))>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + return async_result<typename decay<CompletionToken>::type, + Sig0, Sig1>::initiate(ASIO_MOVE_CAST(Initiation)(initiation), + ASIO_MOVE_CAST(CompletionToken)(token)); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + ASIO_COMPLETION_SIGNATURE Sig1, + ASIO_COMPLETION_SIGNATURE Sig2, + typename Initiation> +inline typename constraint< + detail::async_result_has_initiate_memfn< + CompletionToken, Sig0, Sig1, Sig2>::value, + ASIO_INITFN_DEDUCED_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2, + (async_result<typename decay<CompletionToken>::type, + Sig0, Sig1, Sig2>::initiate(declval<ASIO_MOVE_ARG(Initiation)>(), + declval<ASIO_MOVE_ARG(CompletionToken)>())))>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + return async_result<typename decay<CompletionToken>::type, + Sig0, Sig1, Sig2>::initiate(ASIO_MOVE_CAST(Initiation)(initiation), + ASIO_MOVE_CAST(CompletionToken)(token)); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + typename Initiation> +inline typename constraint< + !detail::async_result_has_initiate_memfn< + CompletionToken, Sig0>::value, + ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + async_completion<CompletionToken, Sig0> completion(token); + + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(CompletionToken, + Sig0))(completion.completion_handler)); + + return completion.result.get(); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + ASIO_COMPLETION_SIGNATURE Sig1, + typename Initiation> +inline typename constraint< + !detail::async_result_has_initiate_memfn< + CompletionToken, Sig0, Sig1>::value, + ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + async_completion<CompletionToken, Sig0, Sig1> completion(token); + + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE2(CompletionToken, + Sig0, Sig1))(completion.completion_handler)); + + return completion.result.get(); +} + +template <typename CompletionToken, + ASIO_COMPLETION_SIGNATURE Sig0, + ASIO_COMPLETION_SIGNATURE Sig1, + ASIO_COMPLETION_SIGNATURE Sig2, + typename Initiation> +inline typename constraint< + !detail::async_result_has_initiate_memfn< + CompletionToken, Sig0, Sig1, Sig2>::value, + ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type +async_initiate(ASIO_MOVE_ARG(Initiation) initiation, + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token) +{ + async_completion<CompletionToken, Sig0, Sig1, Sig2> completion(token); + + ASIO_MOVE_CAST(Initiation)(initiation)( + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE3(CompletionToken, + Sig0, Sig1, Sig2))(completion.completion_handler)); + + return completion.result.get(); +} + +#define ASIO_PRIVATE_INITIATE_DEF(n) \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0>::value, \ + ASIO_INITFN_DEDUCED_RESULT_TYPE( \ + CompletionToken, Sig0, \ + (async_result<typename decay<CompletionToken>::type, \ + Sig0>::initiate( \ + declval<ASIO_MOVE_ARG(Initiation)>(), \ + declval<ASIO_MOVE_ARG(CompletionToken)>(), \ + ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return async_result<typename decay<CompletionToken>::type, \ + Sig0>::initiate( \ + ASIO_MOVE_CAST(Initiation)(initiation), \ + ASIO_MOVE_CAST(CompletionToken)(token), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + ASIO_COMPLETION_SIGNATURE Sig1, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0, Sig1>::value, \ + ASIO_INITFN_DEDUCED_RESULT_TYPE2( \ + CompletionToken, Sig0, Sig1, \ + (async_result<typename decay<CompletionToken>::type, \ + Sig0, Sig1>::initiate( \ + declval<ASIO_MOVE_ARG(Initiation)>(), \ + declval<ASIO_MOVE_ARG(CompletionToken)>(), \ + ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return async_result<typename decay<CompletionToken>::type, \ + Sig0, Sig1>::initiate( \ + ASIO_MOVE_CAST(Initiation)(initiation), \ + ASIO_MOVE_CAST(CompletionToken)(token), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + ASIO_COMPLETION_SIGNATURE Sig1, \ + ASIO_COMPLETION_SIGNATURE Sig2, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0, Sig1, Sig2>::value, \ + ASIO_INITFN_DEDUCED_RESULT_TYPE3( \ + CompletionToken, Sig0, Sig1, Sig2, \ + (async_result<typename decay<CompletionToken>::type, \ + Sig0, Sig1, Sig2>::initiate( \ + declval<ASIO_MOVE_ARG(Initiation)>(), \ + declval<ASIO_MOVE_ARG(CompletionToken)>(), \ + ASIO_VARIADIC_MOVE_DECLVAL(n))))>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return async_result<typename decay<CompletionToken>::type, \ + Sig0, Sig1, Sig2>::initiate( \ + ASIO_MOVE_CAST(Initiation)(initiation), \ + ASIO_MOVE_CAST(CompletionToken)(token), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + !detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0>::value, \ + ASIO_INITFN_RESULT_TYPE(CompletionToken, Sig0)>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + async_completion<CompletionToken, \ + Sig0> completion(token); \ + \ + ASIO_MOVE_CAST(Initiation)(initiation)( \ + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE(CompletionToken, \ + Sig0))(completion.completion_handler), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + \ + return completion.result.get(); \ + } \ + \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + ASIO_COMPLETION_SIGNATURE Sig1, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + !detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0, Sig1>::value, \ + ASIO_INITFN_RESULT_TYPE2(CompletionToken, Sig0, Sig1)>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + async_completion<CompletionToken, \ + Sig0, Sig1> completion(token); \ + \ + ASIO_MOVE_CAST(Initiation)(initiation)( \ + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE2(CompletionToken, \ + Sig0, Sig1))(completion.completion_handler), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + \ + return completion.result.get(); \ + } \ + \ + template <typename CompletionToken, \ + ASIO_COMPLETION_SIGNATURE Sig0, \ + ASIO_COMPLETION_SIGNATURE Sig1, \ + ASIO_COMPLETION_SIGNATURE Sig2, \ + typename Initiation, ASIO_VARIADIC_TPARAMS(n)> \ + inline typename constraint< \ + !detail::async_result_has_initiate_memfn< \ + CompletionToken, Sig0, Sig1, Sig2>::value, \ + ASIO_INITFN_RESULT_TYPE3(CompletionToken, Sig0, Sig1, Sig2)>::type \ + async_initiate(ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + async_completion<CompletionToken, \ + Sig0, Sig1, Sig2> completion(token); \ + \ + ASIO_MOVE_CAST(Initiation)(initiation)( \ + ASIO_MOVE_CAST(ASIO_HANDLER_TYPE3(CompletionToken, \ + Sig0, Sig1, Sig2))(completion.completion_handler), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + \ + return completion.result.get(); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF) +#undef ASIO_PRIVATE_INITIATE_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +#if defined(ASIO_HAS_CONCEPTS) \ + && defined(ASIO_HAS_VARIADIC_TEMPLATES) \ + && defined(ASIO_HAS_DECLTYPE) + +namespace detail { + +template <typename... Signatures> +struct initiation_archetype +{ + template <completion_handler_for<Signatures...> CompletionHandler> + void operator()(CompletionHandler&&) const + { + } +}; + +} // namespace detail + +template <typename T, typename... Signatures> +ASIO_CONCEPT completion_token_for = + detail::are_completion_signatures<Signatures...>::value + && + requires(T&& t) + { + async_initiate<T, Signatures...>( + detail::initiation_archetype<Signatures...>{}, t); + }; + +#define ASIO_COMPLETION_TOKEN_FOR(sig) \ + ::asio::completion_token_for<sig> +#define ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) \ + ::asio::completion_token_for<sig0, sig1> +#define ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) \ + ::asio::completion_token_for<sig0, sig1, sig2> + +#else // defined(ASIO_HAS_CONCEPTS) + // && defined(ASIO_HAS_VARIADIC_TEMPLATES) + // && defined(ASIO_HAS_DECLTYPE) + +#define ASIO_COMPLETION_TOKEN_FOR(sig) typename +#define ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) typename +#define ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) typename + +#endif // defined(ASIO_HAS_CONCEPTS) + // && defined(ASIO_HAS_VARIADIC_TEMPLATES) + // && defined(ASIO_HAS_DECLTYPE) + +namespace detail { + +template <typename T, typename = void> +struct default_completion_token_impl +{ + typedef void type; +}; + +template <typename T> +struct default_completion_token_impl<T, + typename void_type<typename T::default_completion_token_type>::type> +{ + typedef typename T::default_completion_token_type type; +}; + +} // namespace detail + +#if defined(GENERATING_DOCUMENTATION) + +/// Traits type used to determine the default completion token type associated +/// with a type (such as an executor). +/** + * A program may specialise this traits type if the @c T template parameter in + * the specialisation is a user-defined type. + * + * Specialisations of this trait may provide a nested typedef @c type, which is + * a default-constructible completion token type. + */ +template <typename T> +struct default_completion_token +{ + /// If @c T has a nested type @c default_completion_token_type, + /// <tt>T::default_completion_token_type</tt>. Otherwise the typedef @c type + /// is not defined. + typedef see_below type; +}; +#else +template <typename T> +struct default_completion_token + : detail::default_completion_token_impl<T> +{ +}; #endif +#if defined(ASIO_HAS_ALIAS_TEMPLATES) + +template <typename T> +using default_completion_token_t = typename default_completion_token<T>::type; + +#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) + +#if defined(ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) + +#define ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \ + = typename ::asio::default_completion_token<e>::type +#define ASIO_DEFAULT_COMPLETION_TOKEN(e) \ + = typename ::asio::default_completion_token<e>::type() + +#else // defined(ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) + +#define ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) +#define ASIO_DEFAULT_COMPLETION_TOKEN(e) + +#endif // defined(ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) + +} // namespace asio + +#include "asio/detail/pop_options.hpp" + #endif // ASIO_ASYNC_RESULT_HPP |