diff options
Diffstat (limited to '3rdparty/asio/include/asio/impl/redirect_error.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/impl/redirect_error.hpp | 609 |
1 files changed, 609 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/impl/redirect_error.hpp b/3rdparty/asio/include/asio/impl/redirect_error.hpp new file mode 100644 index 00000000000..79162868959 --- /dev/null +++ b/3rdparty/asio/include/asio/impl/redirect_error.hpp @@ -0,0 +1,609 @@ + +// impl/redirect_error.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_IMPL_REDIRECT_ERROR_HPP +#define ASIO_IMPL_REDIRECT_ERROR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include "asio/detail/config.hpp" +#include "asio/associator.hpp" +#include "asio/async_result.hpp" +#include "asio/detail/handler_alloc_helpers.hpp" +#include "asio/detail/handler_cont_helpers.hpp" +#include "asio/detail/handler_invoke_helpers.hpp" +#include "asio/detail/type_traits.hpp" +#include "asio/detail/variadic_templates.hpp" +#include "asio/system_error.hpp" + +#include "asio/detail/push_options.hpp" + +namespace asio { +namespace detail { + +// Class to adapt a redirect_error_t as a completion handler. +template <typename Handler> +class redirect_error_handler +{ +public: + typedef void result_type; + + template <typename CompletionToken> + redirect_error_handler(redirect_error_t<CompletionToken> e) + : ec_(e.ec_), + handler_(ASIO_MOVE_CAST(CompletionToken)(e.token_)) + { + } + + template <typename RedirectedHandler> + redirect_error_handler(asio::error_code& ec, + ASIO_MOVE_ARG(RedirectedHandler) h) + : ec_(ec), + handler_(ASIO_MOVE_CAST(RedirectedHandler)(h)) + { + } + + void operator()() + { + ASIO_MOVE_OR_LVALUE(Handler)(handler_)(); + } + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Arg, typename... Args> + typename enable_if< + !is_same<typename decay<Arg>::type, asio::error_code>::value + >::type + operator()(ASIO_MOVE_ARG(Arg) arg, ASIO_MOVE_ARG(Args)... args) + { + ASIO_MOVE_OR_LVALUE(Handler)(handler_)( + ASIO_MOVE_CAST(Arg)(arg), + ASIO_MOVE_CAST(Args)(args)...); + } + + template <typename... Args> + void operator()(const asio::error_code& ec, + ASIO_MOVE_ARG(Args)... args) + { + ec_ = ec; + ASIO_MOVE_OR_LVALUE(Handler)(handler_)( + ASIO_MOVE_CAST(Args)(args)...); + } + +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + + template <typename Arg> + typename enable_if< + !is_same<typename decay<Arg>::type, asio::error_code>::value + >::type + operator()(ASIO_MOVE_ARG(Arg) arg) + { + ASIO_MOVE_OR_LVALUE(Handler)(handler_)( + ASIO_MOVE_CAST(Arg)(arg)); + } + + void operator()(const asio::error_code& ec) + { + ec_ = ec; + ASIO_MOVE_OR_LVALUE(Handler)(handler_)(); + } + +#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \ + template <typename Arg, ASIO_VARIADIC_TPARAMS(n)> \ + typename enable_if< \ + !is_same<typename decay<Arg>::type, asio::error_code>::value \ + >::type \ + operator()(ASIO_MOVE_ARG(Arg) arg, ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + ASIO_MOVE_OR_LVALUE(Handler)(handler_)( \ + ASIO_MOVE_CAST(Arg)(arg), \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + \ + template <ASIO_VARIADIC_TPARAMS(n)> \ + void operator()(const asio::error_code& ec, \ + ASIO_VARIADIC_MOVE_PARAMS(n)) \ + { \ + ec_ = ec; \ + ASIO_MOVE_OR_LVALUE(Handler)(handler_)( \ + ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF) +#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +//private: + asio::error_code& ec_; + Handler handler_; +}; + +template <typename Handler> +inline asio_handler_allocate_is_deprecated +asio_handler_allocate(std::size_t size, + redirect_error_handler<Handler>* this_handler) +{ +#if defined(ASIO_NO_DEPRECATED) + asio_handler_alloc_helpers::allocate(size, this_handler->handler_); + return asio_handler_allocate_is_no_longer_used(); +#else // defined(ASIO_NO_DEPRECATED) + return asio_handler_alloc_helpers::allocate( + size, this_handler->handler_); +#endif // defined(ASIO_NO_DEPRECATED) +} + +template <typename Handler> +inline asio_handler_deallocate_is_deprecated +asio_handler_deallocate(void* pointer, std::size_t size, + redirect_error_handler<Handler>* this_handler) +{ + asio_handler_alloc_helpers::deallocate( + pointer, size, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_deallocate_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) +} + +template <typename Handler> +inline bool asio_handler_is_continuation( + redirect_error_handler<Handler>* this_handler) +{ + return asio_handler_cont_helpers::is_continuation( + this_handler->handler_); +} + +template <typename Function, typename Handler> +inline asio_handler_invoke_is_deprecated +asio_handler_invoke(Function& function, + redirect_error_handler<Handler>* this_handler) +{ + asio_handler_invoke_helpers::invoke( + function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) +} + +template <typename Function, typename Handler> +inline asio_handler_invoke_is_deprecated +asio_handler_invoke(const Function& function, + redirect_error_handler<Handler>* this_handler) +{ + asio_handler_invoke_helpers::invoke( + function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) +} + +template <typename Signature> +struct redirect_error_signature +{ + typedef Signature type; +}; + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename R, typename... Args> +struct redirect_error_signature<R(asio::error_code, Args...)> +{ + typedef R type(Args...); +}; + +template <typename R, typename... Args> +struct redirect_error_signature<R(const asio::error_code&, Args...)> +{ + typedef R type(Args...); +}; + +# if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename R, typename... Args> +struct redirect_error_signature<R(asio::error_code, Args...) &> +{ + typedef R type(Args...) &; +}; + +template <typename R, typename... Args> +struct redirect_error_signature<R(const asio::error_code&, Args...) &> +{ + typedef R type(Args...) &; +}; + +template <typename R, typename... Args> +struct redirect_error_signature<R(asio::error_code, Args...) &&> +{ + typedef R type(Args...) &&; +}; + +template <typename R, typename... Args> +struct redirect_error_signature<R(const asio::error_code&, Args...) &&> +{ + typedef R type(Args...) &&; +}; + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename R, typename... Args> +struct redirect_error_signature< + R(asio::error_code, Args...) noexcept> +{ + typedef R type(Args...) & noexcept; +}; + +template <typename R, typename... Args> +struct redirect_error_signature< + R(const asio::error_code&, Args...) noexcept> +{ + typedef R type(Args...) & noexcept; +}; + +template <typename R, typename... Args> +struct redirect_error_signature< + R(asio::error_code, Args...) & noexcept> +{ + typedef R type(Args...) & noexcept; +}; + +template <typename R, typename... Args> +struct redirect_error_signature< + R(const asio::error_code&, Args...) & noexcept> +{ + typedef R type(Args...) & noexcept; +}; + +template <typename R, typename... Args> +struct redirect_error_signature< + R(asio::error_code, Args...) && noexcept> +{ + typedef R type(Args...) && noexcept; +}; + +template <typename R, typename... Args> +struct redirect_error_signature< + R(const asio::error_code&, Args...) && noexcept> +{ + typedef R type(Args...) && noexcept; +}; + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +# endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) +#else // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +template <typename R> +struct redirect_error_signature<R(asio::error_code)> +{ + typedef R type(); +}; + +template <typename R> +struct redirect_error_signature<R(const asio::error_code&)> +{ + typedef R type(); +}; + +#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, ASIO_VARIADIC_TARGS(n))> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, ASIO_VARIADIC_TARGS(n))> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)); \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF) +#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF + +# if defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) + +template <typename R> +struct redirect_error_signature<R(asio::error_code) &> +{ + typedef R type() &; +}; + +template <typename R> +struct redirect_error_signature<R(const asio::error_code&) &> +{ + typedef R type() &; +}; + +template <typename R> +struct redirect_error_signature<R(asio::error_code) &&> +{ + typedef R type() &&; +}; + +template <typename R> +struct redirect_error_signature<R(const asio::error_code&) &&> +{ + typedef R type() &&; +}; + +#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, ASIO_VARIADIC_TARGS(n)) &> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) &; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, ASIO_VARIADIC_TARGS(n)) &> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) &; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, ASIO_VARIADIC_TARGS(n)) &&> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) &&; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, ASIO_VARIADIC_TARGS(n)) &&> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) &&; \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF) +#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF + +# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) + +template <typename R> +struct redirect_error_signature< + R(asio::error_code) noexcept> +{ + typedef R type() noexcept; +}; + +template <typename R> +struct redirect_error_signature< + R(const asio::error_code&) noexcept> +{ + typedef R type() noexcept; +}; + +template <typename R> +struct redirect_error_signature< + R(asio::error_code) & noexcept> +{ + typedef R type() & noexcept; +}; + +template <typename R> +struct redirect_error_signature< + R(const asio::error_code&) & noexcept> +{ + typedef R type() & noexcept; +}; + +template <typename R> +struct redirect_error_signature< + R(asio::error_code) && noexcept> +{ + typedef R type() && noexcept; +}; + +template <typename R> +struct redirect_error_signature< + R(const asio::error_code&) && noexcept> +{ + typedef R type() && noexcept; +}; + +#define ASIO_PRIVATE_REDIRECT_ERROR_DEF(n) \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, ASIO_VARIADIC_TARGS(n)) noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) noexcept; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, \ + ASIO_VARIADIC_TARGS(n)) noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) noexcept; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, \ + ASIO_VARIADIC_TARGS(n)) & noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) & noexcept; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, \ + ASIO_VARIADIC_TARGS(n)) & noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) & noexcept; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(asio::error_code, \ + ASIO_VARIADIC_TARGS(n)) && noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) && noexcept; \ + }; \ + \ + template <typename R, ASIO_VARIADIC_TPARAMS(n)> \ + struct redirect_error_signature< \ + R(const asio::error_code&, \ + ASIO_VARIADIC_TARGS(n)) && noexcept> \ + { \ + typedef R type(ASIO_VARIADIC_TARGS(n)) && noexcept; \ + }; \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_REDIRECT_ERROR_DEF) +#undef ASIO_PRIVATE_REDIRECT_ERROR_DEF + +# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE) +# endif // defined(ASIO_HAS_REF_QUALIFIED_FUNCTIONS) +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) + +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <typename CompletionToken, typename Signature> +struct async_result<redirect_error_t<CompletionToken>, Signature> +{ + typedef typename async_result<CompletionToken, + typename detail::redirect_error_signature<Signature>::type> + ::return_type return_type; + + template <typename Initiation> + struct init_wrapper + { + template <typename Init> + init_wrapper(asio::error_code& ec, ASIO_MOVE_ARG(Init) init) + : ec_(ec), + 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_)( + detail::redirect_error_handler< + typename decay<Handler>::type>( + ec_, 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_)( + detail::redirect_error_handler< + typename decay<Handler>::type>( + ec_, 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_)( \ + detail::redirect_error_handler< \ + typename decay<Handler>::type>( \ + ec_, 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) + + asio::error_code& ec_; + Initiation initiation_; + }; + +#if defined(ASIO_HAS_VARIADIC_TEMPLATES) + + 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) + { + return async_initiate<CompletionToken, + typename detail::redirect_error_signature<Signature>::type>( + init_wrapper<typename decay<Initiation>::type>( + token.ec_, ASIO_MOVE_CAST(Initiation)(initiation)), + token.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) + { + return async_initiate<CompletionToken, + typename detail::redirect_error_signature<Signature>::type>( + init_wrapper<typename decay<Initiation>::type>( + token.ec_, ASIO_MOVE_CAST(Initiation)(initiation)), + token.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)) \ + { \ + return async_initiate<CompletionToken, \ + typename detail::redirect_error_signature<Signature>::type>( \ + init_wrapper<typename decay<Initiation>::type>( \ + token.ec_, ASIO_MOVE_CAST(Initiation)(initiation)), \ + token.token_, ASIO_VARIADIC_MOVE_ARGS(n)); \ + } \ + /**/ + ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF) +#undef ASIO_PRIVATE_INITIATE_DEF + +#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES) +}; + +template <template <typename, typename> class Associator, + typename Handler, typename DefaultCandidate> +struct associator<Associator, + detail::redirect_error_handler<Handler>, DefaultCandidate> + : Associator<Handler, DefaultCandidate> +{ + static typename Associator<Handler, DefaultCandidate>::type get( + const detail::redirect_error_handler<Handler>& h, + const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT + { + return Associator<Handler, DefaultCandidate>::get(h.handler_, c); + } +}; + +#endif // !defined(GENERATING_DOCUMENTATION) + +} // namespace asio + +#include "asio/detail/pop_options.hpp" + +#endif // ASIO_IMPL_REDIRECT_ERROR_HPP |