forwarder.hpp

#pragma once
 
//
// Copyright (c) 2019-2022 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "rotor/actor_base.h"
#include "rotor/asio/supervisor_asio.h"
#include <boost/asio.hpp>
#include <tuple>
 
namespace rotor::asio {
 
namespace {
namespace to {
struct supervisor {};
} // namespace to
} // namespace
} // namespace rotor::asio
 
namespace rotor {
 
template <> inline auto &actor_base_t::access<asio::to::supervisor>() noexcept { return supervisor; }
 
namespace asio {
 
namespace asio = boost::asio;
 
namespace details {
 
namespace count {
using _0 = std::integral_constant<size_t, 0>;
using _1 = std::integral_constant<size_t, 1>;
} // namespace count
 
template <typename T> struct callback_traits {};
 
template <typename Class, typename M> struct callback_traits<void (Class::*)(M &) noexcept> {
    using args_count = count::_1;
 
    using arg_type = M &;
};
 
template <typename Class, typename M> struct callback_traits<void (Class::*)(M) noexcept> {
    using args_count = count::_1;
 
    using arg_type = M;
};
 
template <typename Class> struct callback_traits<void (Class::*)() noexcept> {
    using args_count = count::_0;
 
    using arg_type = void;
};
 
} // namespace details
 
template <typename Actor> inline boost::asio::io_context::strand &get_strand(Actor &actor);
 
template <typename Actor, typename Handler, typename ErrHandler> struct forwarder_base_t;
 
template <typename Actor, typename Handler> struct forwarder_base_t<Actor, Handler, void> {
    using typed_actor_ptr_t = intrusive_ptr_t<Actor>;
 
    using typed_sup_t = supervisor_asio_t;
 
    forwarder_base_t(Actor &actor_, Handler &&handler_) : typed_actor{&actor_}, handler{std::move(handler_)} {}
 
    typed_actor_ptr_t typed_actor;
 
    Handler handler;
};
 
template <typename Actor, typename Handler, typename ErrHandler>
struct forwarder_base_t : forwarder_base_t<Actor, Handler, void> {
    using base_t = forwarder_base_t<Actor, Handler, void>;
 
    forwarder_base_t(Actor &actor_, Handler &&handler_, ErrHandler &&err_handler_)
        : base_t{actor_, std::move(handler_)}, err_handler{std::move(err_handler_)} {}
 
    ErrHandler err_handler;
};
 
template <typename Actor, typename Handler, typename ArgsCount, typename ErrHandler> struct forwarder_t {};
 
template <typename Actor, typename Handler, typename ErrHandler>
struct forwarder_t<Actor, Handler, details::count::_0, ErrHandler> : forwarder_base_t<Actor, Handler, ErrHandler> {
    using base_t = forwarder_base_t<Actor, Handler, ErrHandler>;
    using base_t::base_t;
 
    template <typename T = void> inline void operator()(const boost::system::error_code &ec) noexcept {
        auto &typed_actor = base_t::typed_actor;
        auto &sup = static_cast<supervisor_asio_t &>(typed_actor->get_supervisor());
        auto &strand = get_strand(sup);
        if (ec) {
            asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::err_handler), ec]() {
                ((*actor).*handler)(ec);
                actor->get_supervisor().do_process();
            });
        } else {
            asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::handler)]() {
                ((*actor).*handler)();
                actor->get_supervisor().do_process();
            });
        }
    }
};
 
template <typename Actor, typename Handler, typename ErrHandler>
struct forwarder_t<Actor, Handler, details::count::_1, ErrHandler> : forwarder_base_t<Actor, Handler, ErrHandler> {
    using base_t = forwarder_base_t<Actor, Handler, ErrHandler>;
    using base_t::base_t;
 
    template <typename T> inline void operator()(const boost::system::error_code &ec, T arg) noexcept {
        auto &typed_actor = base_t::typed_actor;
        auto &sup = static_cast<supervisor_asio_t &>(typed_actor->get_supervisor());
        auto &strand = get_strand(sup);
        if (ec) {
            asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::err_handler), ec = ec]() {
                ((*actor).*handler)(ec);
                actor->get_supervisor().do_process();
            });
        } else {
            asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::handler),
                                 arg = std::move(arg)]() mutable {
                ((*actor).*handler)(std::move(arg));
                actor->get_supervisor().do_process();
            });
        }
    }
};
 
template <typename Actor, typename Handler>
struct forwarder_t<Actor, Handler, details::count::_0, void> : forwarder_base_t<Actor, Handler, void> {
    using base_t = forwarder_base_t<Actor, Handler, void>;
    using base_t::base_t;
 
    template <typename T = void> inline void operator()() noexcept {
        auto &typed_actor = base_t::typed_actor;
        auto &sup = static_cast<supervisor_asio_t &>(typed_actor->get_supervisor());
        auto &strand = get_strand(sup);
        asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::handler)]() {
            ((*actor).*handler)();
            actor->get_supervisor().do_process();
        });
    }
};
 
template <typename Actor, typename Handler>
struct forwarder_t<Actor, Handler, details::count::_1, void> : forwarder_base_t<Actor, Handler, void> {
    using base_t = forwarder_base_t<Actor, Handler, void>;
    using base_t::base_t;
 
    template <typename T> inline void operator()(T arg) noexcept {
        auto &typed_actor = base_t::typed_actor;
        auto &sup = static_cast<supervisor_asio_t &>(typed_actor->get_supervisor());
        auto &strand = get_strand(sup);
        asio::defer(strand, [actor = base_t::typed_actor, handler = std::move(base_t::handler),
                             arg = std::move(arg)]() mutable {
            ((*actor).*handler)(std::move(arg));
            actor->get_supervisor().do_process();
        });
    }
};
 
template <typename Actor, typename Handler>
forwarder_t(Actor &, Handler &&)
    -> forwarder_t<Actor, Handler, typename details::callback_traits<Handler>::args_count, void>;
 
template <typename Actor, typename Handler, typename ErrHandler>
forwarder_t(Actor &, Handler &&, ErrHandler &&)
    -> forwarder_t<Actor, Handler, typename details::callback_traits<Handler>::args_count, ErrHandler>;
 
} // namespace asio
 
} // namespace rotor