actor_base.h

#pragma once
 
//
// Copyright (c) 2019-2025 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "forward.hpp"
#include "address.hpp"
#include "actor_config.h"
#include "messages.hpp"
#include "state.h"
#include "handler.h"
#include "extended_error.h"
#include "timer_handler.hpp"
#include <set>
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor {

struct ROTOR_API actor_base_t : public arc_base_t<actor_base_t> {
    using config_t = actor_config_t;

    template <typename Actor> using config_builder_t = actor_config_builder_t<Actor>;

    template <typename Handler>
    using is_handler =
        std::enable_if_t<std::is_member_function_pointer_v<Handler> || std::is_base_of_v<handler_base_t, Handler>>;
 
    // clang-format off
    using plugins_list_t = std::tuple<
        plugin::address_maker_plugin_t,
        plugin::lifetime_plugin_t,
        plugin::init_shutdown_plugin_t,
        plugin::link_server_plugin_t,
        plugin::link_client_plugin_t,
        plugin::registry_plugin_t,
        plugin::resources_plugin_t,
        plugin::starter_plugin_t>;
    // clang-format on

    actor_base_t(config_t &cfg);
    virtual ~actor_base_t();

    virtual void do_initialize(system_context_t *ctx) noexcept;

    virtual void do_shutdown(const extended_error_ptr_t &reason = {}) noexcept;

    virtual void on_start() noexcept;

    template <typename M, typename... Args> void send(const address_ptr_t &addr, Args &&...args);

    template <typename M, typename... Args>
    void route(const address_ptr_t &addr, const address_ptr_t &next_addr, Args &&...args);

    void redirect(message_ptr_t message, const address_ptr_t &addr, const address_ptr_t &next_addr = {}) noexcept;

    template <typename R, typename... Args>
    request_builder_t<typename request_wrapper_t<R>::request_t> request(const address_ptr_t &dest_addr, Args &&...args);

    template <typename R, typename... Args>
    request_builder_t<typename request_wrapper_t<R>::request_t>
    request_via(const address_ptr_t &dest_addr, const address_ptr_t &reply_addr, Args &&...args);

    template <typename Request, typename... Args> void reply_to(Request &message, Args &&...args);

    template <typename Request> void reply_with_error(Request &message, const extended_error_ptr_t &ec);

    template <typename Request, typename... Args> auto make_response(Request &message, Args &&...args);

    template <typename Request> auto make_response(Request &message, const extended_error_ptr_t &ec);

    template <typename Handler> subscription_info_ptr_t subscribe(Handler &&h, const address_ptr_t &addr) noexcept;

    template <typename Handler> subscription_info_ptr_t subscribe(Handler &&h) noexcept;

    template <typename Handler, typename = is_handler<Handler>>
    void unsubscribe(Handler &&h, address_ptr_t &addr) noexcept;

    template <typename Handler, typename = is_handler<Handler>> void unsubscribe(Handler &&h) noexcept;
 
    /* \brief initiates handler unsubscription from the address
     *
     * If the address is local, then unsubscription confirmation is sent immediately,
     * otherwise {@link payload::external_subscription_t} request is sent to the external
     * supervisor, which owns the address.
     *
     * The optional call can be provided to be called upon message destruction.
     *
     */

    inline void unsubscribe(const handler_ptr_t &h) noexcept { lifetime->unsubscribe(h, address); }

    void activate_plugins() noexcept;

    void commit_plugin_activation(plugin::plugin_base_t &plugin, bool success) noexcept;

    void deactivate_plugins() noexcept;

    void commit_plugin_deactivation(plugin::plugin_base_t &plugin) noexcept;

    void on_subscription(message::subscription_t &message) noexcept;

    void on_unsubscription(message::unsubscription_t &message) noexcept;

    void on_unsubscription_external(message::unsubscription_external_t &message) noexcept;

    address_ptr_t create_address() noexcept;

    virtual void shutdown_start() noexcept;

    void shutdown_continue() noexcept;

    virtual void shutdown_finish() noexcept;

    virtual void init_start() noexcept;

    void init_continue() noexcept;

    virtual void init_finish() noexcept;

    virtual void configure(plugin::plugin_base_t &plugin) noexcept;

    template <typename T> auto &access() noexcept;

    template <typename T, typename... Args> auto access(Args... args) noexcept;

    template <typename T> auto &access() const noexcept;

    template <typename T, typename... Args> auto access(Args... args) const noexcept;

    inline const address_ptr_t &get_address() const noexcept { return address; }

    inline supervisor_t &get_supervisor() const noexcept { return *supervisor; }

    template <typename Delegate, typename Method,
              typename = std::enable_if_t<std::is_invocable_v<Method, Delegate *, request_id_t, bool>>>
    request_id_t start_timer(const pt::time_duration &interval, Delegate &delegate, Method method) noexcept;

    void cancel_timer(request_id_t request_id) noexcept;

    inline const extended_error_ptr_t &get_shutdown_reason() const noexcept { return shutdown_reason; }

    inline const std::string &get_identity() const noexcept { return identity; }

    static const constexpr std::uint32_t PROGRESS_INIT = 1 << 0;

    static const constexpr std::uint32_t PROGRESS_SHUTDOWN = 1 << 1;

    static const constexpr std::uint32_t ESCALATE_FALIURE = 1 << 2;

    static const constexpr std::uint32_t AUTOSHUTDOWN_SUPERVISOR = 1 << 3;

    virtual bool should_restart() const noexcept;
 
  protected:
    using timers_map_t = std::unordered_map<request_id_t, timer_handler_ptr_t>;

    using requests_t = std::unordered_set<request_id_t>;

    void on_timer_trigger(request_id_t request_id, bool cancelled) noexcept;

    template <typename Delegate, typename Method>
    void start_timer(request_id_t request_id, const pt::time_duration &interval, Delegate &delegate,
                     Method method) noexcept;

    void assign_shutdown_reason(extended_error_ptr_t reason) noexcept;

    extended_error_ptr_t make_error(const std::error_code &ec, const extended_error_ptr_t &next = {},
                                    const message_ptr_t &request = {}) const noexcept;

    virtual bool on_unlink(const address_ptr_t &server_addr) noexcept;

    intrusive_ptr_t<message::init_request_t> init_request;

    intrusive_ptr_t<message::shutdown_request_t> shutdown_request;

    address_ptr_t address;

    address_ptr_t spawner_address;

    std::string identity;

    supervisor_t *supervisor;

    plugin_storage_ptr_t plugins_storage;

    plugins_t plugins;

    pt::time_duration init_timeout;

    pt::time_duration shutdown_timeout;

    state_t state;

    plugin::address_maker_plugin_t *address_maker = nullptr;

    plugin::lifetime_plugin_t *lifetime = nullptr;

    plugin::link_server_plugin_t *link_server = nullptr;

    plugin::resources_plugin_t *resources = nullptr;

    plugin::plugin_base_t *get_plugin(const std::type_index &) const noexcept;

    std::set<const std::type_index *> activating_plugins;

    std::set<const std::type_index *> deactivating_plugins;

    timers_map_t timers_map;

    requests_t active_requests;

    std::uint32_t continuation_mask = 0;

    extended_error_ptr_t shutdown_reason;
 
    friend struct plugin::plugin_base_t;
    friend struct plugin::lifetime_plugin_t;
    friend struct supervisor_t;
    template <typename T> friend struct request_builder_t;
    template <typename T, typename M> friend struct accessor_t;
};
 
} // namespace rotor
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif