ExpectedCompletionHandler.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TRINITYCORE_EXPECTED_COMPLETION_HANDLER_H
#define TRINITYCORE_EXPECTED_COMPLETION_HANDLER_H
 
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/outcome/result.hpp>
#include <boost/preprocessor/empty.hpp>
#include <boost/preprocessor/comma.hpp>
#include <type_traits>
 
namespace Trinity::Asio
{
template <typename CompletionToken>
class AsExpected
{
public:
    // First dummy argument is used to prevent the "default" constructor from being used for implicit conversions
    constexpr AsExpected(std::type_identity<void> = {}, CompletionToken token = {})
        : token_(std::forward<CompletionToken>(token))
    {
    }
 
    template <typename T> requires (!std::same_as<T, AsExpected>)
    constexpr explicit AsExpected(T&& completion_token)
        : token_(std::forward<T>(completion_token))
    {
    }
 
    template <typename InnerExecutor>
    struct executor_with_default : InnerExecutor
    {
        typedef AsExpected default_completion_token_type;
 
        template <typename InnerExecutor1>
        executor_with_default(InnerExecutor1 const& ex,
            std::enable_if_t<
                std::conditional_t<
                    !std::is_same_v<InnerExecutor1, executor_with_default>,
                    std::is_convertible<InnerExecutor1, InnerExecutor>,
                    std::false_type
                >::value,
                int
            > = 0) noexcept
            : InnerExecutor(ex)
        {
        }
    };
 
    template <typename T>
    using as_default_on_t = typename T::template rebind_executor<executor_with_default<typename T::executor_type>>::other;
 
    template <typename T>
    static auto as_default_on(T&& object)
    {
        return as_default_on_t<std::decay_t<T>>(static_cast<T&&>(object));
    }
 
    CompletionToken token_;
};
 
struct AsExpectedFn
{
    template <typename CompletionToken>
    [[nodiscard]] inline constexpr AsExpected<std::decay_t<CompletionToken>> operator()(CompletionToken&& completion_token) const
    {
        return AsExpected<std::decay_t<CompletionToken>>(static_cast<CompletionToken&&>(completion_token));
    }
};
 
inline constexpr AsExpectedFn as_expected;
 
namespace Impl
{
template <typename T>
concept CompletionTokenError = std::same_as<std::remove_cvref_t<T>, boost::system::error_code>
    || std::same_as<std::remove_cvref_t<T>, std::exception_ptr>;
 
template <typename Handler>
class AsExpectedHandler
{
public:
    typedef void result_type;
 
    template <typename CompletionToken>
    AsExpectedHandler(AsExpected<CompletionToken> e) : handler_(static_cast<CompletionToken&&>(e.token_)) { }
 
    template <typename RedirectedHandler> requires (!std::same_as<RedirectedHandler, AsExpectedHandler>)
    AsExpectedHandler(RedirectedHandler&& h) : handler_(std::forward<RedirectedHandler>(h)) { }
 
    template <CompletionTokenError Error>
    inline void operator()(Error&& e)
    {
        using return_type = boost::outcome_v2::result<void, std::remove_cvref_t<Error>>;
 
        if (e)
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::failure(std::forward<Error>(e))));
        else
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::success()));
    }
 
    template <CompletionTokenError Error, typename Arg>
    inline void operator()(Error&& e, Arg&& value)
    {
        using return_type = boost::outcome_v2::result<std::decay_t<Arg>, std::remove_cvref_t<Error>>;
 
        if (e)
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::failure(std::forward<Error>(e))));
        else
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::success(std::forward<Arg>(value))));
    }
 
    template <CompletionTokenError Error, typename Arg, typename... Args>
    inline void operator()(Error&& e, Arg&& first, Args&&... rest)
    {
        using return_type = boost::outcome_v2::result<std::tuple<std::decay_t<Arg>, std::decay_t<Args>...>, std::remove_cvref_t<Error>>;
 
        if (e)
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::failure(std::forward<Error>(e))));
        else
            static_cast<Handler&&>(handler_)(return_type(boost::outcome_v2::success(std::make_tuple(std::forward<Arg>(first), std::forward<Args>(rest)...))));
    }
 
    Handler handler_;
};
 
template <typename Handler>
inline bool asio_handler_is_continuation(AsExpectedHandler<Handler>* this_handler)
{
    using boost::asio::asio_handler_is_continuation;
    return asio_handler_is_continuation(std::addressof(this_handler->handler_));
}
 
template <typename Signature>
struct AsExpectedSignature;
 
#define STAMP_AS_EXPECTED_SIGNATURE(qualifier) \
    template <typename R, CompletionTokenError Error> \
    struct AsExpectedSignature<R(Error) qualifier> \
    { \
        using type = R(boost::outcome_v2::result<void, std::remove_cvref_t<Error>>) qualifier; \
    }; \
    template <typename R, CompletionTokenError Error, typename Arg> \
    struct AsExpectedSignature<R(Error, Arg) qualifier> \
    { \
        using type = R(boost::outcome_v2::result<std::decay_t<Arg>, std::remove_cvref_t<Error>>) qualifier; \
    }; \
    template <typename R, CompletionTokenError Error, typename Arg, typename... Args> \
    struct AsExpectedSignature<R(Error, Arg, Args...) qualifier> \
    { \
        using type = R(boost::outcome_v2::result<std::tuple<std::decay_t<Arg>, std::decay_t<Args>...>, std::remove_cvref_t<Error>>) qualifier; \
    };
 
STAMP_AS_EXPECTED_SIGNATURE(BOOST_PP_EMPTY());
STAMP_AS_EXPECTED_SIGNATURE(&);
STAMP_AS_EXPECTED_SIGNATURE(&&);
STAMP_AS_EXPECTED_SIGNATURE(noexcept);
STAMP_AS_EXPECTED_SIGNATURE(& noexcept);
STAMP_AS_EXPECTED_SIGNATURE(&& noexcept);
 
#undef STAMP_AS_EXPECTED_SIGNATURE
 
} // namespace Impl
}
 
namespace boost::asio
{
#if BOOST_VERSION >= 107700
template <typename CompletionToken, typename... Signatures>
class async_result<Trinity::Asio::AsExpected<CompletionToken>, Signatures...> : async_result<CompletionToken, typename Trinity::Asio::Impl::AsExpectedSignature<Signatures>::type...>
{
    template <typename Initiation>
    struct init_wrapper
    {
        explicit init_wrapper(Initiation const& initiation) : initiation_(initiation) { }
        explicit init_wrapper(Initiation&& initiation) : initiation_(std::move(initiation)) { }
 
        template <typename Handler, typename... Args>
        inline void operator()(Handler&& handler, Args&&... args) &&
        {
            static_cast<Initiation&&>(initiation_)(Trinity::Asio::Impl::AsExpectedHandler<std::decay_t<Handler>>(std::forward<Handler>(handler)), std::forward<Args>(args)...);
        }
 
        template <typename Handler, typename... Args>
        inline void operator()(Handler&& handler, Args&&... args) const &
        {
            static_cast<Initiation const&>(initiation_)(Trinity::Asio::Impl::AsExpectedHandler<std::decay_t<Handler>>(std::forward<Handler>(handler)), std::forward<Args>(args)...);
        }
 
        Initiation initiation_;
    };
 
public:
    template <typename Initiation, typename RawCompletionToken, typename... Args>
    static inline auto initiate(Initiation&& initiation, RawCompletionToken&& token, Args&&... args)
    {
        return async_initiate<
            std::conditional_t<
            is_const<remove_reference_t<RawCompletionToken>>::value,
            CompletionToken const, CompletionToken>,
            typename Trinity::Asio::Impl::AsExpectedSignature<Signatures>::type...>(
                init_wrapper<std::decay_t<Initiation>>(
                    std::forward<Initiation>(initiation)),
                token.token_, std::forward<Args>(args)...);
    }
};
 
#if BOOST_VERSION >= 108600
#define TRINITY_BOOST_ASIO_ASSOCIATOR_SFINAE_PARAM(param) param
#else
#define TRINITY_BOOST_ASIO_ASSOCIATOR_SFINAE_PARAM(param)
#endif
 
template <template <typename, typename> class Associator, typename Handler, typename DefaultCandidate TRINITY_BOOST_ASIO_ASSOCIATOR_SFINAE_PARAM(BOOST_PP_COMMA() typename _)>
struct associator;
 
template <template <typename, typename> class Associator, typename Handler, typename DefaultCandidate>
struct associator<Associator, Trinity::Asio::Impl::AsExpectedHandler<Handler>, DefaultCandidate TRINITY_BOOST_ASIO_ASSOCIATOR_SFINAE_PARAM(BOOST_PP_COMMA() void)> : Associator<Handler, DefaultCandidate>
{
    static inline auto get(Trinity::Asio::Impl::AsExpectedHandler<Handler> const& h) noexcept
    {
        return Associator<Handler, DefaultCandidate>::get(h.handler_);
    }
 
    static inline auto get(Trinity::Asio::Impl::AsExpectedHandler<Handler> const& h, DefaultCandidate const& c) noexcept
    {
        return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
    }
};
 
#undef TRINITY_BOOST_ASIO_ASSOCIATOR_SFINAE_PARAM
 
template <typename... Signatures>
class async_result<Trinity::Asio::AsExpectedFn, Signatures...>
{
public:
    template <typename Initiation, typename RawCompletionToken, typename... Args>
    static inline auto initiate(Initiation&& initiation, RawCompletionToken&&, Args&&... args)
    {
        return async_initiate<Signatures...>(
            std::forward<Initiation>(initiation),
            Trinity::Asio::AsExpected<
            default_completion_token_t<associated_executor_t<Initiation>>>{},
            std::forward<Args>(args)...);
    }
};
#else
template <typename CompletionToken, typename Signature>
class async_result<Trinity::Asio::AsExpected<CompletionToken>, Signature> : async_result<CompletionToken, typename Trinity::Asio::Impl::AsExpectedSignature<Signature>::type>
{
    template <typename Initiation>
    struct init_wrapper
    {
        explicit init_wrapper(Initiation const& initiation) : initiation_(initiation) { }
        explicit init_wrapper(Initiation&& initiation) : initiation_(std::move(initiation)) { }
 
        template <typename Handler, typename... Args>
        inline void operator()(Handler&& handler, Args&&... args) &&
        {
            static_cast<Initiation&&>(initiation_)(Trinity::Asio::Impl::AsExpectedHandler<std::decay_t<Handler>>(std::forward<Handler>(handler)), std::forward<Args>(args)...);
        }
 
        template <typename Handler, typename... Args>
        inline void operator()(Handler&& handler, Args&&... args) const &
        {
            static_cast<Initiation const&>(initiation_)(Trinity::Asio::Impl::AsExpectedHandler<std::decay_t<Handler>>(std::forward<Handler>(handler)), std::forward<Args>(args)...);
        }
 
        Initiation initiation_;
    };
 
public:
    template <typename Initiation, typename RawCompletionToken, typename... Args>
    static inline auto initiate(Initiation&& initiation, RawCompletionToken&& token, Args&&... args)
    {
        return async_initiate<
            std::conditional_t<
            is_const<remove_reference_t<RawCompletionToken>>::value,
            CompletionToken const, CompletionToken>,
            typename Trinity::Asio::Impl::AsExpectedSignature<Signature>::type>(
                init_wrapper<std::decay_t<Initiation>>(
                    std::forward<Initiation>(initiation)),
                token.token_, std::forward<Args>(args)...);
    }
};
#endif
} // namespace boost::asio
 
#endif // TRINITYCORE_EXPECTED_COMPLETION_HANDLER_H