anyhandler.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_ANYHANDLER_HPP
#define CPPWAMP_ANYHANDLER_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <cassert>
#include <cstddef>
#include <memory>
#include <functional>
#include <utility>
#include <tuple>
#include <type_traits>
#include <boost/asio/associated_allocator.hpp>
#include <boost/asio/associated_cancellation_slot.hpp>
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/cancellation_signal.hpp>
#include <boost/asio/defer.hpp>
#include <boost/asio/dispatch.hpp>
#include <boost/asio/post.hpp>
 
#ifdef CPPWAMP_WITHOUT_BUNDLED_ASIO_ANY_COMPLETION_HANDLER
#include <boost/asio/any_completion_handler.hpp>
#else
#include "bundled/boost_asio_any_completion_handler.hpp"
#endif
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
using AnyCompletionExecutor = boost::asio::any_completion_executor;
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSignature>
using AnyCompletionHandler = boost::asio::any_completion_handler<TSignature>;
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TSignature>
class AnyReusableHandler
{
private:
    using Function = std::function<TSignature>;
 
    template <typename F>
    static constexpr bool fnConstructible() noexcept
    {
        using Decayed = typename std::decay<F>::type;
        return !std::is_same<Decayed, AnyReusableHandler>::value &&
               !std::is_same<Decayed, std::nullptr_t>::value &&
               std::is_constructible<Function, F>::value;
    }
 
    template <typename F>
    static constexpr bool otherConstructible() noexcept
    {
        return std::is_constructible<Function, std::function<F>>::value;
    }
 
public:
    using Executor = AnyCompletionExecutor;
 
    using CancellationSlot = boost::asio::cancellation_slot;
 
    using executor_type = Executor;
 
    using cancellation_slot_type = CancellationSlot;
 
    AnyReusableHandler() = default;
 
    AnyReusableHandler(const AnyReusableHandler&) = default;
 
    AnyReusableHandler(AnyReusableHandler&&) noexcept = default;
 
    template <typename S,
              typename std::enable_if<otherConstructible<S>(), int>::type = 0>
    AnyReusableHandler(const AnyReusableHandler<S>& rhs)
        : executor_(rhs.executor_),
          handler_(rhs.handler_)
    {}
 
    template <typename S,
              typename std::enable_if<otherConstructible<S>(), int>::type = 0>
    AnyReusableHandler(AnyReusableHandler<S>&& rhs) noexcept
        : executor_(std::move(rhs.executor_)),
          handler_(std::move(rhs.handler_))
    {}
 
    template <typename F,
              typename std::enable_if<fnConstructible<F>(), int>::type = 0>
    AnyReusableHandler(F&& handler)
        : executor_(boost::asio::get_associated_executor(
                        handler, AnyCompletionExecutor{})),
          cancelSlot_(boost::asio::get_associated_cancellation_slot(handler)),
          handler_(std::forward<F>(handler))
    {}
 
    AnyReusableHandler(std::nullptr_t) noexcept {}
 
    AnyReusableHandler& operator=(std::nullptr_t) noexcept
    {
        executor_ = nullptr;
        handler_ = nullptr;
        return *this;
    }
 
    AnyReusableHandler& operator=(const AnyReusableHandler&) = default;
 
    AnyReusableHandler& operator=(AnyReusableHandler&&) noexcept = default;
 
    void swap(AnyReusableHandler& rhs) noexcept
    {
        // boost::asio::executor does not have member swap
        using std::swap;
        swap(executor_, rhs.executor_);
 
        handler_.swap(rhs.handler_);
    }
 
    explicit operator bool() const noexcept {return bool(handler_);}
 
    const Executor& get_executor() const {return executor_;}
 
    const CancellationSlot& get_cancellation_slot() const {return cancelSlot_;}
 
    template <typename... Ts>
    auto operator()(Ts&&... args) const
        -> decltype(std::declval<Function>()(std::forward<Ts>(args)...))
    {
        return handler_(std::forward<Ts>(args)...);
    }
 
private:
    Executor executor_;
    CancellationSlot cancelSlot_;
    Function handler_;
};
 
template <typename S>
void swap(AnyReusableHandler<S>& a, AnyReusableHandler<S>& b) noexcept
{
    return a.swap(b);
}
 
template <typename S>
bool operator==(const AnyReusableHandler<S>& f, std::nullptr_t) noexcept
{
    return !f;
}
 
template <typename S>
bool operator==(std::nullptr_t, const AnyReusableHandler<S>& f) noexcept
{
    return !f;
}
 
template <typename S>
bool operator!=(const AnyReusableHandler<S>& f, std::nullptr_t) noexcept
{
    return bool(f);
}
 
template <typename S>
bool operator!=(std::nullptr_t, const AnyReusableHandler<S>& f) noexcept
{
    return bool(f);
}
 
} // namespace wamp
 
 
namespace boost
{
namespace asio
{
 
// Enable boost::asio::get_associated_executor for AnyReusableHandler.
template <typename S, typename E>
struct associated_executor<wamp::AnyReusableHandler<S>, E>
{
    using type = typename wamp::AnyReusableHandler<S>::Executor;
 
    static type get(const wamp::AnyReusableHandler<S>& f, const E& e = E{})
    {
        return f.get_executor() ? f.get_executor() : e;
    }
};
 
// Enable boost::asio::get_associated_cancellation_slot for AnyReusableHandler.
template <typename S, typename C>
struct associated_cancellation_slot<wamp::AnyReusableHandler<S>, C>
{
    using type = typename wamp::AnyReusableHandler<S>::CancellationSlot;
 
    static type get(const wamp::AnyReusableHandler<S>& f, const C& = C{})
    {
        return f.get_cancellation_slot();
    }
};
 
// Enable boost::asio::get_associated_allocator for AnyReusableHandler.
template <typename S, typename A>
struct associated_allocator<wamp::AnyReusableHandler<S>, A>
{
    using type = A;
 
    static type get(const wamp::AnyReusableHandler<S>&, const A& a = A{})
    {
        // AnyReusableHandler does not use allocators, so always return
        // the fallback allocator.
        return a;
    }
};
 
} // namespace asio
} // namespace boost
 
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename F, typename... Ts>
void dispatchAny(F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler);
    boost::asio::dispatch(e, std::bind(std::forward<F>(handler),
                                       std::forward<Ts>(args)...));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template<typename F, typename E, typename... Ts>
void dispatchVia(const E& fallbackExec, F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler, fallbackExec);
    boost::asio::dispatch(e, std::bind(std::forward<F>(handler),
                                       std::forward<Ts>(args)...));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template<typename F, typename... Ts>
void postAny(F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler);
    boost::asio::post(e, std::bind(std::forward<F>(handler),
                                   std::forward<Ts>(args)...));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template<typename F, typename E, typename... Ts>
void postVia(const E& fallbackExec, F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler, fallbackExec);
    boost::asio::post(e, std::bind(std::forward<F>(handler),
                                   std::forward<Ts>(args)...));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template<typename F, typename... Ts>
void deferAny(F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler);
    boost::asio::defer(e, std::bind(std::forward<F>(handler),
                                    std::forward<Ts>(args)...));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template<typename F, typename E, typename... Ts>
void deferVia(const E& fallbackExec, F&& handler, Ts&&... args)
{
    auto e = boost::asio::get_associated_executor(handler, fallbackExec);
    boost::asio::defer(e, std::bind(std::forward<F>(handler),
                                    std::forward<Ts>(args)...));
}
 
} // namespace wamp
 
#endif // CPPWAMP_ANYHANDLER_HPP