diff options
Diffstat (limited to '3rdparty/asio/include/asio/bind_executor.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/bind_executor.hpp | 754 |
1 files changed, 754 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/bind_executor.hpp b/3rdparty/asio/include/asio/bind_executor.hpp new file mode 100644 index 00000000000..4da0b01e268 --- /dev/null +++ b/3rdparty/asio/include/asio/bind_executor.hpp @@ -0,0 +1,754 @@ +// +// bind_executor.hpp +// ~~~~~~~~~~~~~~~~~ +// +// 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) +// + +#ifndef ASIO_BIND_EXECUTOR_HPP +#define ASIO_BIND_EXECUTOR_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/variadic_templates.hpp" +#include "asio/associated_executor.hpp" +#include "asio/associator.hpp" +#include "asio/async_result.hpp" +#include "asio/execution/executor.hpp" +#include "asio/execution_context.hpp" +#include "asio/is_executor.hpp" +#include "asio/uses_executor.hpp" + +#include "asio/detail/push_options.hpp" + +namespace asio { +namespace detail { + +// Helper to automatically define nested typedef result_type. + +template <typename T, typename = void> +struct executor_binder_result_type +{ +protected: + typedef void result_type_or_void; +}; + +template <typename T> +struct executor_binder_result_type<T, + typename void_type<typename T::result_type>::type> +{ + typedef typename T::result_type result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R> +struct executor_binder_result_type<R(*)()> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R> +struct executor_binder_result_type<R(&)()> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R, typename A1> +struct executor_binder_result_type<R(*)(A1)> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R, typename A1> +struct executor_binder_result_type<R(&)(A1)> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R, typename A1, typename A2> +struct executor_binder_result_type<R(*)(A1, A2)> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +template <typename R, typename A1, typename A2> +struct executor_binder_result_type<R(&)(A1, A2)> +{ + typedef R result_type; +protected: + typedef result_type result_type_or_void; +}; + +// Helper to automatically define nested typedef argument_type. + +template <typename T, typename = void> +struct executor_binder_argument_type {}; + +template <typename T> +struct executor_binder_argument_type<T, + typename void_type<typename T::argument_type>::type> +{ + typedef typename T::argument_type argument_type; +}; + +template <typename R, typename A1> +struct executor_binder_argument_type<R(*)(A1)> +{ + typedef A1 argument_type; +}; + +template <typename R, typename A1> +struct executor_binder_argument_type<R(&)(A1)> +{ + typedef A1 argument_type; +}; + +// Helper to automatically define nested typedefs first_argument_type and +// second_argument_type. + +template <typename T, typename = void> +struct executor_binder_argument_types {}; + +template <typename T> +struct executor_binder_argument_types<T, + typename void_type<typename T::first_argument_type>::type> +{ + typedef typename T::first_argument_type first_argument_type; + typedef typename T::second_argument_type second_argument_type; +}; + +template <typename R, typename A1, typename A2> +struct executor_binder_argument_type<R(*)(A1, A2)> +{ + typedef A1 first_argument_type; + typedef A2 second_argument_type; +}; + +template <typename R, typename A1, typename A2> +struct executor_binder_argument_type<R(&)(A1, A2)> +{ + typedef A1 first_argument_type; + typedef A2 second_argument_type; +}; + +// Helper to perform uses_executor construction of the target type, if +// required. + +template <typename T, typename Executor, bool UsesExecutor> +class executor_binder_base; + +template <typename T, typename Executor> +class executor_binder_base<T, Executor, true> +{ +protected: + template <typename E, typename U> + executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u) + : executor_(ASIO_MOVE_CAST(E)(e)), + target_(executor_arg_t(), executor_, ASIO_MOVE_CAST(U)(u)) + { + } + + Executor executor_; + T target_; +}; + +template <typename T, typename Executor> +class executor_binder_base<T, Executor, false> +{ +protected: + template <typename E, typename U> + executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u) + : executor_(ASIO_MOVE_CAST(E)(e)), + target_(ASIO_MOVE_CAST(U)(u)) + { + } + + Executor executor_; + T target_; +}; + +// Helper to enable SFINAE on zero-argument operator() below. + +template <typename T, typename = void> +struct executor_binder_result_of0 +{ + typedef void type; +}; + +template <typename T> +struct executor_binder_result_of0<T, + typename void_type<typename result_of<T()>::type>::type> +{ + typedef typename result_of<T()>::type type; +}; + +} // namespace detail + +/// A call wrapper type to bind an executor of type @c Executor to an object of +/// type @c T. +template <typename T, typename Executor> +class executor_binder +#if !defined(GENERATING_DOCUMENTATION) + : public detail::executor_binder_result_type<T>, + public detail::executor_binder_argument_type<T>, + public detail::executor_binder_argument_types<T>, + private detail::executor_binder_base< + T, Executor, uses_executor<T, Executor>::value> +#endif // !defined(GENERATING_DOCUMENTATION) +{ +public: + /// The type of the target object. + typedef T target_type; + + /// The type of the associated executor. + typedef Executor executor_type; + +#if defined(GENERATING_DOCUMENTATION) + /// The return type if a function. + /** + * The type of @c result_type is based on the type @c T of the wrapper's + * target object: + * + * @li if @c T is a pointer to function type, @c result_type is a synonym for + * the return type of @c T; + * + * @li if @c T is a class type with a member type @c result_type, then @c + * result_type is a synonym for @c T::result_type; + * + * @li otherwise @c result_type is not defined. + */ + typedef see_below result_type; + + /// The type of the function's argument. + /** + * The type of @c argument_type is based on the type @c T of the wrapper's + * target object: + * + * @li if @c T is a pointer to a function type accepting a single argument, + * @c argument_type is a synonym for the return type of @c T; + * + * @li if @c T is a class type with a member type @c argument_type, then @c + * argument_type is a synonym for @c T::argument_type; + * + * @li otherwise @c argument_type is not defined. + */ + typedef see_below argument_type; + + /// The type of the function's first argument. + /** + * The type of @c first_argument_type is based on the type @c T of the + * wrapper's target object: + * + * @li if @c T is a pointer to a function type accepting two arguments, @c + * first_argument_type is a synonym for the return type of @c T; + * + * @li if @c T is a class type with a member type @c first_argument_type, + * then @c first_argument_type is a synonym for @c T::first_argument_type; + * + * @li otherwise @c first_argument_type is not defined. + */ + typedef see_below first_argument_type; + + /// The type of the function's second argument. + /** + * The type of @c second_argument_type is based on the type @c T of the + * wrapper's target object: + * + * @li if @c T is a pointer to a function type accepting two arguments, @c + * second_argument_type is a synonym for the return type of @c T; + * + * @li if @c T is a class type with a member type @c first_argument_type, + * then @c second_argument_type is a synonym for @c T::second_argument_type; + * + * @li otherwise @c second_argument_type is not defined. + */ + typedef see_below second_argument_type; +#endif // defined(GENERATING_DOCUMENTATION) + + /// Construct an executor wrapper for the specified object. + /** + * This constructor is only valid if the type @c T is constructible from type + * @c U. + */ + template <typename U> + executor_binder(executor_arg_t, const executor_type& e, + ASIO_MOVE_ARG(U) u) + : base_type(e, ASIO_MOVE_CAST(U)(u)) + { + } + + /// Copy constructor. + executor_binder(const executor_binder& other) + : base_type(other.get_executor(), other.get()) + { + } + + /// Construct a copy, but specify a different executor. + executor_binder(executor_arg_t, const executor_type& e, + const executor_binder& other) + : base_type(e, other.get()) + { + } + + /// Construct a copy of a different executor wrapper type. + /** + * This constructor is only valid if the @c Executor type is constructible + * from type @c OtherExecutor, and the type @c T is constructible from type + * @c U. + */ + template <typename U, typename OtherExecutor> + executor_binder(const executor_binder<U, OtherExecutor>& other) + : base_type(other.get_executor(), other.get()) + { + } + + /// Construct a copy of a different executor wrapper type, but specify a + /// different executor. + /** + * This constructor is only valid if the type @c T is constructible from type + * @c U. + */ + template <typename U, typename OtherExecutor> + executor_binder(executor_arg_t, const executor_type& e, + const executor_binder<U, OtherExecutor>& other) + : base_type(e, other.get()) + { + } + +#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + + /// Move constructor. + executor_binder(executor_binder&& other) + : base_type(ASIO_MOVE_CAST(executor_type)(other.get_executor()), + ASIO_MOVE_CAST(T)(other.get())) + { + } + + /// Move construct the target object, but specify a different executor. + executor_binder(executor_arg_t, const executor_type& e, + executor_binder&& other) + : base_type(e, ASIO_MOVE_CAST(T)(other.get())) + { + } + + /// Move construct from a different executor wrapper type. + template <typename U, typename OtherExecutor> + executor_binder(executor_binder<U, OtherExecutor>&& other) + : base_type(ASIO_MOVE_CAST(OtherExecutor)(other.get_executor()), + ASIO_MOVE_CAST(U)(other.get())) + { + } + + /// Move construct from a different executor wrapper type, but specify a + /// different executor. + template <typename U, typename OtherExecutor> + executor_binder(executor_arg_t, const executor_type& e, + executor_binder<U, OtherExecutor>&& other) + : base_type(e, ASIO_MOVE_CAST(U)(other.get())) + { + } + +#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + + /// Destructor. + ~executor_binder() + { + } + + /// Obtain a reference to the target object. + target_type& get() ASIO_NOEXCEPT + { + return this->target_; + } + + /// Obtain a reference to the target object. + const target_type& get() const ASIO_NOEXCEPT + { + return this->target_; + } + + /// Obtain the associated executor. + executor_type get_executor() const ASIO_NOEXCEPT + { + return this->executor_; + } + +#if defined(GENERATING_DOCUMENTATION) + + template <typename... Args> auto operator()(Args&& ...); + template <typename... Args> auto operator()(Args&& ...) const; + +#elif defined(ASIO_HAS_VARIADIC_TEMPLATES) + + /// Forwarding function call operator. + template <typename... Args> + typename result_of<T(Args...)>::type operator()( + ASIO_MOVE_ARG(Args)... args) + { + return this->target_(ASIO_MOVE_CAST(Args)(args)...); + } + + /// Forwarding function call operator. + template <typename... Args> + typename result_of<T(Args...)>::type operator()( + ASIO_MOVE_ARG(Args)... args) const + { + return this->target_(ASIO_MOVE_CAST(Args)(args)...); + } + +#elif defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER) + + typename detail::executor_binder_result_of0<T>::type operator()() + { + return this->target_(); + } + + typename detail::executor_binder_result_of0<T>::type operator()() const + { + return this->target_(); + } + +#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \ + template <ASIO_VARIADIC_TPARAMS(n)> \ + typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <ASIO_VARIADIC_TPARAMS(n)> \ + typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \ + ASIO_VARIADIC_MOVE_PARAMS(n)) const \ + { \ + return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF) +#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF + +#else // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER) + + typedef typename detail::executor_binder_result_type<T>::result_type_or_void + result_type_or_void; + + result_type_or_void operator()() + { + return this->target_(); + } + + result_type_or_void operator()() const + { + return this->target_(); + } + +#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \ + template <ASIO_VARIADIC_TPARAMS(n)> \ + result_type_or_void operator()( \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <ASIO_VARIADIC_TPARAMS(n)> \ + result_type_or_void operator()( \ + ASIO_VARIADIC_MOVE_PARAMS(n)) const \ + { \ + return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF) +#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF + +#endif // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER) + +private: + typedef detail::executor_binder_base<T, Executor, + uses_executor<T, Executor>::value> base_type; +}; + +/// Associate an object of type @c T with an executor of type @c Executor. +template <typename Executor, typename T> +inline executor_binder<typename decay<T>::type, Executor> +bind_executor(const Executor& ex, ASIO_MOVE_ARG(T) t, + typename constraint< + is_executor<Executor>::value || execution::is_executor<Executor>::value + >::type = 0) +{ + return executor_binder<typename decay<T>::type, Executor>( + executor_arg_t(), ex, ASIO_MOVE_CAST(T)(t)); +} + +/// Associate an object of type @c T with an execution context's executor. +template <typename ExecutionContext, typename T> +inline executor_binder<typename decay<T>::type, + typename ExecutionContext::executor_type> +bind_executor(ExecutionContext& ctx, ASIO_MOVE_ARG(T) t, + typename constraint<is_convertible< + ExecutionContext&, execution_context&>::value>::type = 0) +{ + return executor_binder<typename decay<T>::type, + typename ExecutionContext::executor_type>( + executor_arg_t(), ctx.get_executor(), ASIO_MOVE_CAST(T)(t)); +} + +#if !defined(GENERATING_DOCUMENTATION) + +template <typename T, typename Executor> +struct uses_executor<executor_binder<T, Executor>, Executor> + : true_type {}; + +namespace detail { + +template <typename TargetAsyncResult, typename Executor, typename = void> +struct executor_binder_async_result_completion_handler_type +{ +}; + +template <typename TargetAsyncResult, typename Executor> +struct executor_binder_async_result_completion_handler_type< + TargetAsyncResult, Executor, + typename void_type< + typename TargetAsyncResult::completion_handler_type + >::type> +{ + typedef executor_binder< + typename TargetAsyncResult::completion_handler_type, Executor> + completion_handler_type; +}; + +template <typename TargetAsyncResult, typename = void> +struct executor_binder_async_result_return_type +{ +}; + +template <typename TargetAsyncResult> +struct executor_binder_async_result_return_type< + TargetAsyncResult, + typename void_type< + typename TargetAsyncResult::return_type + >::type> +{ + typedef typename TargetAsyncResult::return_type return_type; +}; + +} // namespace detail + +template <typename T, typename Executor, typename Signature> +class async_result<executor_binder<T, Executor>, Signature> : + public detail::executor_binder_async_result_completion_handler_type< + async_result<T, Signature>, Executor>, + public detail::executor_binder_async_result_return_type< + async_result<T, Signature> > +{ +public: + explicit async_result(executor_binder<T, Executor>& b) + : target_(b.get()) + { + } + + typename async_result<T, Signature>::return_type get() + { + return target_.get(); + } + + template <typename Initiation> + struct init_wrapper + { + template <typename Init> + init_wrapper(const Executor& ex, ASIO_MOVE_ARG(Init) init) + : ex_(ex), + initiation_(ASIO_MOVE_CAST(Init)(init)) + { + } + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Handler, typename... Args> + void operator()( + ASIO_MOVE_ARG(Handler) handler, + ASIO_MOVE_ARG(Args)... args) + { + ASIO_MOVE_CAST(Initiation)(initiation_)( + executor_binder<typename decay<Handler>::type, Executor>( + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), + ASIO_MOVE_CAST(Args)(args)...); + } + + template <typename Handler, typename... Args> + void operator()( + ASIO_MOVE_ARG(Handler) handler, + ASIO_MOVE_ARG(Args)... args) const + { + initiation_( + executor_binder<typename decay<Handler>::type, Executor>( + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), + ASIO_MOVE_CAST(Args)(args)...); + } + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Handler> + void operator()( + ASIO_MOVE_ARG(Handler) handler) + { + ASIO_MOVE_CAST(Initiation)(initiation_)( + executor_binder<typename decay<Handler>::type, Executor>( + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler))); + } + + template <typename Handler> + void operator()( + ASIO_MOVE_ARG(Handler) handler) const + { + initiation_( + executor_binder<typename decay<Handler>::type, Executor>( + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler))); + } + +#define ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \ + template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \ + void operator()( \ + ASIO_MOVE_ARG(Handler) handler, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + ASIO_MOVE_CAST(Initiation)(initiation_)( \ + executor_binder<typename decay<Handler>::type, Executor>( \ + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \ + void operator()( \ + ASIO_MOVE_ARG(Handler) handler, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) const \ + { \ + initiation_( \ + executor_binder<typename decay<Handler>::type, Executor>( \ + executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INIT_WRAPPER_DEF) +#undef ASIO_PRIVATE_INIT_WRAPPER_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + + Executor ex_; + Initiation initiation_; + }; + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Initiation, typename RawCompletionToken, typename... Args> + static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, + (async_result<T, Signature>::initiate( + declval<init_wrapper<typename decay<Initiation>::type> >(), + declval<T>(), declval<ASIO_MOVE_ARG(Args)>()...))) + initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_MOVE_ARG(RawCompletionToken) token, + ASIO_MOVE_ARG(Args)... args) + { + return async_initiate<T, Signature>( + init_wrapper<typename decay<Initiation>::type>( + token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)), + token.get(), ASIO_MOVE_CAST(Args)(args)...); + } + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Initiation, typename RawCompletionToken> + static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, + (async_result<T, Signature>::initiate( + declval<init_wrapper<typename decay<Initiation>::type> >(), + declval<T>()))) + initiate( + ASIO_MOVE_ARG(Initiation) initiation, + ASIO_MOVE_ARG(RawCompletionToken) token) + { + return async_initiate<T, Signature>( + init_wrapper<typename decay<Initiation>::type>( + token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)), + token.get()); + } + +#define ASIO_PRIVATE_INITIATE_DEF(n) \ + template <typename Initiation, typename RawCompletionToken, \ + ASIO_VARIADIC_TPARAMS(n)> \ + static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \ + (async_result<T, Signature>::initiate( \ + declval<init_wrapper<typename decay<Initiation>::type> >(), \ + declval<T>(), ASIO_VARIADIC_MOVE_DECLVAL(n)))) \ + initiate( \ + ASIO_MOVE_ARG(Initiation) initiation, \ + ASIO_MOVE_ARG(RawCompletionToken) token, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + return async_initiate<T, Signature>( \ + init_wrapper<typename decay<Initiation>::type>( \ + token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)), \ + token.get(), ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF) +#undef ASIO_PRIVATE_INITIATE_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +private: + async_result(const async_result&) ASIO_DELETED; + async_result& operator=(const async_result&) ASIO_DELETED; + + async_result<T, Signature> target_; +}; + +template <template <typename, typename> class Associator, + typename T, typename Executor, typename DefaultCandidate> +struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate> +{ + typedef typename Associator<T, DefaultCandidate>::type type; + + static type get(const executor_binder<T, Executor>& b, + const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT + { + return Associator<T, DefaultCandidate>::get(b.get(), c); + } +}; + +template <typename T, typename Executor, typename Executor1> +struct associated_executor<executor_binder<T, Executor>, Executor1> +{ + typedef Executor type; + + static type get(const executor_binder<T, Executor>& b, + const Executor1& = Executor1()) ASIO_NOEXCEPT + { + return b.get_executor(); + } +}; + +#endif // !defined(GENERATING_DOCUMENTATION) + +} // namespace asio + +#include "asio/detail/pop_options.hpp" + +#endif // ASIO_BIND_EXECUTOR_HPP |