summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/include/asio/async_result.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/include/asio/async_result.hpp')
-rw-r--r--3rdparty/asio/include/asio/async_result.hpp942
1 files changed, 942 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/async_result.hpp b/3rdparty/asio/include/asio/async_result.hpp
new file mode 100644
index 00000000000..cdae9ede687
--- /dev/null
+++ b/3rdparty/asio/include/asio/async_result.hpp
@@ -0,0 +1,942 @@
+//
+// async_result.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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)
+//
+
+#ifndef ASIO_ASYNC_RESULT_HPP
+#define ASIO_ASYNC_RESULT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/detail/type_traits.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+namespace detail {
+
+template <typename T>
+struct is_completion_signature : false_type
+{
+};
+
+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
+{
+};
+
+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)
+
+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<decay_t<T>, Args...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) &>
+ : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) &&>
+ : integral_constant<bool, (callable_with<decay_t<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<decay_t<T>, Args...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) & noexcept>
+ : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
+{
+};
+
+template <typename T, typename R, typename... Args>
+struct is_completion_handler_for<T, R(Args...) && noexcept>
+ : integral_constant<bool, (callable_with<decay_t<T>&&, Args...>)>
+{
+};
+
+# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+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)
+
+#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)
+
+namespace detail {
+
+template <typename T>
+struct is_lvalue_completion_signature : false_type
+{
+};
+
+template <typename R, typename... Args>
+struct is_lvalue_completion_signature<R(Args...) &> : true_type
+{
+};
+
+# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct is_lvalue_completion_signature<R(Args...) & noexcept> : true_type
+{
+};
+
+# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename... Signatures>
+struct are_any_lvalue_completion_signatures : false_type
+{
+};
+
+template <typename Sig0>
+struct are_any_lvalue_completion_signatures<Sig0>
+ : is_lvalue_completion_signature<Sig0>
+{
+};
+
+template <typename Sig0, typename... SigN>
+struct are_any_lvalue_completion_signatures<Sig0, SigN...>
+ : integral_constant<bool, (
+ is_lvalue_completion_signature<Sig0>::value
+ || are_any_lvalue_completion_signatures<SigN...>::value)>
+{
+};
+
+template <typename T>
+struct is_rvalue_completion_signature : false_type
+{
+};
+
+template <typename R, typename... Args>
+struct is_rvalue_completion_signature<R(Args...) &&> : true_type
+{
+};
+
+# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename R, typename... Args>
+struct is_rvalue_completion_signature<R(Args...) && noexcept> : true_type
+{
+};
+
+# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+
+template <typename... Signatures>
+struct are_any_rvalue_completion_signatures : false_type
+{
+};
+
+template <typename Sig0>
+struct are_any_rvalue_completion_signatures<Sig0>
+ : is_rvalue_completion_signature<Sig0>
+{
+};
+
+template <typename Sig0, typename... SigN>
+struct are_any_rvalue_completion_signatures<Sig0, SigN...>
+ : integral_constant<bool, (
+ is_rvalue_completion_signature<Sig0>::value
+ || are_any_rvalue_completion_signatures<SigN...>::value)>
+{
+};
+
+template <typename T>
+struct simple_completion_signature;
+
+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...);
+};
+
+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)
+
+template <typename CompletionToken,
+ ASIO_COMPLETION_SIGNATURE... Signatures>
+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()
+ {
+ }
+
+ template <typename Initiation,
+ ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken,
+ typename... Args>
+ static return_type initiate(Initiation&& initiation,
+ RawCompletionToken&& token, Args&&... args)
+ {
+ static_cast<Initiation&&>(initiation)(
+ static_cast<RawCompletionToken&&>(token),
+ static_cast<Args&&>(args)...);
+ }
+
+private:
+ completion_handler_async_result(
+ const completion_handler_async_result&) = delete;
+ completion_handler_async_result& operator=(
+ const completion_handler_async_result&) = delete;
+};
+
+} // 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:
+ *
+ * @li the concrete completion handler type to be called at the end of the
+ * asynchronous operation;
+ *
+ * @li the initiating function return type; and
+ *
+ * @li how the return value of the initiating function is obtained.
+ *
+ * The trait allows the handler and return types to be determined at the point
+ * where the specific completion handler signature is known.
+ *
+ * This template may be specialised for user-defined completion token types.
+ * The primary template assumes that the CompletionToken is the completion
+ * handler.
+ */
+template <typename CompletionToken,
+ ASIO_COMPLETION_SIGNATURE... Signatures>
+class async_result
+{
+public:
+ /// 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;
+
+ /// 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 completion handler, which is
+ * then returned from the initiating function.
+ */
+ explicit async_result(completion_handler_type& h);
+
+ /// Obtain the value to be returned from the initiating function.
+ 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(
+ Initiation&& initiation,
+ RawCompletionToken&& token,
+ Args&&... args);
+
+private:
+ async_result(const async_result&) = delete;
+ async_result& operator=(const async_result&) = delete;
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken,
+ ASIO_COMPLETION_SIGNATURE... Signatures>
+class async_result :
+ public conditional_t<
+ detail::are_any_lvalue_completion_signatures<Signatures...>::value
+ || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
+ detail::completion_handler_async_result<CompletionToken, Signatures...>,
+ async_result<CompletionToken,
+ typename detail::simple_completion_signature<Signatures>::type...>
+ >
+{
+public:
+ typedef conditional_t<
+ detail::are_any_lvalue_completion_signatures<Signatures...>::value
+ || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
+ detail::completion_handler_async_result<CompletionToken, Signatures...>,
+ async_result<CompletionToken,
+ typename detail::simple_completion_signature<Signatures>::type...>
+ > base_type;
+
+ using base_type::base_type;
+
+private:
+ async_result(const async_result&) = delete;
+ async_result& operator=(const async_result&) = delete;
+};
+
+template <ASIO_COMPLETION_SIGNATURE... Signatures>
+class async_result<void, Signatures...>
+{
+ // Empty.
+};
+
+#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,
+ ASIO_COMPLETION_SIGNATURE... Signatures>
+struct async_completion
+{
+ /// The real handler type to be used for the asynchronous operation.
+ typedef typename asio::async_result<
+ decay_t<CompletionToken>, Signatures...>::completion_handler_type
+ completion_handler_type;
+
+ /// Constructor.
+ /**
+ * The constructor creates the concrete completion handler and makes the link
+ * between the handler and the asynchronous result.
+ */
+ explicit async_completion(CompletionToken& token)
+ : completion_handler(static_cast<conditional_t<
+ is_same<CompletionToken, completion_handler_type>::value,
+ completion_handler_type&, CompletionToken&&>>(token)),
+ result(completion_handler)
+ {
+ }
+
+ /// A copy of, or reference to, a real handler object.
+ conditional_t<
+ is_same<CompletionToken, completion_handler_type>::value,
+ completion_handler_type&, completion_handler_type> completion_handler;
+
+ /// The result of the asynchronous operation's initiating function.
+ async_result<decay_t<CompletionToken>, Signatures...> result;
+};
+
+namespace detail {
+
+struct async_result_memfns_base
+{
+ void initiate();
+};
+
+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_SIGNATURE... Signatures>
+struct async_result_has_initiate_memfn
+ : integral_constant<bool, sizeof(async_result_initiate_memfn_helper<
+ async_result<decay_t<CompletionToken>, Signatures...>
+ >(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
+#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_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
+#elif defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
+#else
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+ auto
+# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr) -> decltype expr
+#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
+#else
+# 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
+#endif
+
+#if defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken,
+ completion_signature... Signatures,
+ typename Initiation, typename... Args>
+void_or_deduced async_initiate(
+ Initiation&& initiation,
+ type_identity_t<CompletionToken>& token,
+ Args&&... args);
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename CompletionToken,
+ ASIO_COMPLETION_SIGNATURE... Signatures,
+ typename Initiation, typename... Args>
+inline auto async_initiate(Initiation&& initiation,
+ type_identity_t<CompletionToken>& token, Args&&... args)
+ -> constraint_t<
+ detail::async_result_has_initiate_memfn<
+ CompletionToken, Signatures...>::value,
+ decltype(
+ async_result<decay_t<CompletionToken>, Signatures...>::initiate(
+ static_cast<Initiation&&>(initiation),
+ static_cast<CompletionToken&&>(token),
+ static_cast<Args&&>(args)...))>
+{
+ return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
+ static_cast<Initiation&&>(initiation),
+ static_cast<CompletionToken&&>(token),
+ static_cast<Args&&>(args)...);
+}
+
+template <typename CompletionToken,
+ ASIO_COMPLETION_SIGNATURE... Signatures,
+ typename Initiation, typename... Args>
+inline constraint_t<
+ !detail::async_result_has_initiate_memfn<
+ CompletionToken, Signatures...>::value,
+ typename async_result<decay_t<CompletionToken>, Signatures...>::return_type>
+async_initiate(Initiation&& initiation,
+ type_identity_t<CompletionToken>& token, Args&&... args)
+{
+ async_completion<CompletionToken, Signatures...> completion(token);
+
+ static_cast<Initiation&&>(initiation)(
+ static_cast<
+ typename async_result<decay_t<CompletionToken>,
+ Signatures...>::completion_handler_type&&>(
+ completion.completion_handler),
+ static_cast<Args&&>(args)...);
+
+ return completion.result.get();
+}
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+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)
+
+#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)
+
+namespace detail {
+
+struct async_operation_probe {};
+struct async_operation_probe_result {};
+
+template <typename Call, typename = void>
+struct is_async_operation_call : false_type
+{
+};
+
+template <typename Call>
+struct is_async_operation_call<Call,
+ void_t<
+ enable_if_t<
+ is_same<
+ result_of_t<Call>,
+ async_operation_probe_result
+ >::value
+ >
+ >
+ > : true_type
+{
+};
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename... Signatures>
+class async_result<detail::async_operation_probe, Signatures...>
+{
+public:
+ typedef detail::async_operation_probe_result return_type;
+
+ template <typename Initiation, typename... InitArgs>
+ static return_type initiate(Initiation&&,
+ detail::async_operation_probe, InitArgs&&...)
+ {
+ return return_type();
+ }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// The is_async_operation trait detects whether a type @c T and arguments
+/// @c Args... may be used to initiate an asynchronous operation.
+/**
+ * Class template @c is_async_operation is a trait is derived from @c true_type
+ * if the expression <tt>T(Args..., token)</tt> initiates an asynchronous
+ * operation, where @c token is an unspecified completion token type. Otherwise,
+ * @c is_async_operation is derived from @c false_type.
+ */
+template <typename T, typename... Args>
+struct is_async_operation : integral_constant<bool, automatically_determined>
+{
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename... Args>
+struct is_async_operation :
+ detail::is_async_operation_call<
+ T(Args..., detail::async_operation_probe)>
+{
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#if defined(ASIO_HAS_CONCEPTS)
+
+template <typename T, typename... Args>
+ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
+
+#define ASIO_ASYNC_OPERATION(t) \
+ ::asio::async_operation<t>
+#define ASIO_ASYNC_OPERATION1(t, a0) \
+ ::asio::async_operation<t, a0>
+#define ASIO_ASYNC_OPERATION2(t, a0, a1) \
+ ::asio::async_operation<t, a0, a1>
+#define ASIO_ASYNC_OPERATION3(t, a0, a1, a2) \
+ ::asio::async_operation<t, a0, a1, a2>
+
+#else // defined(ASIO_HAS_CONCEPTS)
+
+#define ASIO_ASYNC_OPERATION(t) typename
+#define ASIO_ASYNC_OPERATION1(t, a0) typename
+#define ASIO_ASYNC_OPERATION2(t, a0, a1) typename
+#define ASIO_ASYNC_OPERATION3(t, a0, a1, a2) typename
+
+#endif // defined(ASIO_HAS_CONCEPTS)
+
+namespace detail {
+
+struct completion_signature_probe {};
+
+template <typename... T>
+struct completion_signature_probe_result
+{
+ template <template <typename...> class Op>
+ struct apply
+ {
+ typedef Op<T...> type;
+ };
+};
+
+template <typename T>
+struct completion_signature_probe_result<T>
+{
+ typedef T type;
+
+ template <template <typename...> class Op>
+ struct apply
+ {
+ typedef Op<T> type;
+ };
+};
+
+template <>
+struct completion_signature_probe_result<void>
+{
+ template <template <typename...> class Op>
+ struct apply
+ {
+ typedef Op<> type;
+ };
+};
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename... Signatures>
+class async_result<detail::completion_signature_probe, Signatures...>
+{
+public:
+ typedef detail::completion_signature_probe_result<Signatures...> return_type;
+
+ template <typename Initiation, typename... InitArgs>
+ static return_type initiate(Initiation&&,
+ detail::completion_signature_probe, InitArgs&&...)
+ {
+ return return_type();
+ }
+};
+
+template <typename Signature>
+class async_result<detail::completion_signature_probe, Signature>
+{
+public:
+ typedef detail::completion_signature_probe_result<Signature> return_type;
+
+ template <typename Initiation, typename... InitArgs>
+ static return_type initiate(Initiation&&,
+ detail::completion_signature_probe, InitArgs&&...)
+ {
+ return return_type();
+ }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// The completion_signature_of trait determines the completion signature
+/// of an asynchronous operation.
+/**
+ * Class template @c completion_signature_of is a trait with a member type
+ * alias @c type that denotes the completion signature of the asynchronous
+ * operation initiated by the expression <tt>T(Args..., token)</tt> operation,
+ * where @c token is an unspecified completion token type. If the asynchronous
+ * operation does not have exactly one completion signature, the instantion of
+ * the trait is well-formed but the member type alias @c type is omitted. If
+ * the expression <tt>T(Args..., token)</tt> is not an asynchronous operation
+ * then use of the trait is ill-formed.
+ */
+template <typename T, typename... Args>
+struct completion_signature_of
+{
+ typedef automatically_determined type;
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename... Args>
+struct completion_signature_of :
+ result_of_t<T(Args..., detail::completion_signature_probe)>
+{
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+template <typename T, typename... Args>
+using completion_signature_of_t =
+ typename completion_signature_of<T, Args...>::type;
+
+namespace detail {
+
+template <typename T, typename = void>
+struct default_completion_token_impl
+{
+ typedef void type;
+};
+
+template <typename T>
+struct default_completion_token_impl<T,
+ void_t<typename T::default_completion_token_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
+
+template <typename T>
+using default_completion_token_t = typename default_completion_token<T>::type;
+
+#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()
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_ASYNC_RESULT_HPP