plugin_base.h

#pragma once
 
//
// Copyright (c) 2019-2024 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "../subscription.h"
#include "rotor/messages.hpp"
#include <typeinfo>
#include <cstdint>
 
namespace rotor::plugin {
 
enum class config_phase_t { PREINIT = 0b01, INITIALIZING = 0b10 };
 
struct ROTOR_API plugin_base_t {
 
    // clang-format off
    enum reaction_t: unsigned {
        INIT         = 0b00000001,
        SHUTDOWN     = 0b00000010,
        SUBSCRIPTION = 0b00000100,
        START        = 0b00001000,
    };
    // clang-format on
    using reaction_underlying_t = std::underlying_type_t<reaction_t>;
 
    static constexpr reaction_underlying_t REACTION_MASK = 0b00001111;
 
    plugin_base_t() = default;
 
    plugin_base_t(const plugin_base_t &) = delete;
    virtual ~plugin_base_t() = default;
 
    virtual const std::type_index &identity() const noexcept = 0;
 
    virtual void activate(actor_base_t *actor) noexcept;
 
    virtual void deactivate() noexcept;
 
    virtual bool handle_init(message::init_request_t *message) noexcept;
 
    virtual bool handle_shutdown(message::shutdown_request_t *message) noexcept;
 
    virtual void handle_start(message::start_trigger_t *message) noexcept;
 
    virtual bool handle_subscription(message::subscription_t &message) noexcept;
 
    virtual bool handle_unsubscription(const subscription_point_t &point, bool external) noexcept;
 
    virtual bool forget_subscription(const subscription_point_t &point) noexcept;
 
    virtual void forget_subscription(const subscription_info_ptr_t &info) noexcept;
 
    template <typename Plugin, typename Fn>
    void with_casted(Fn &&fn, config_phase_t desired_phase = config_phase_t::INITIALIZING) noexcept {
        int phase_match = static_cast<int>(phase) & static_cast<int>(desired_phase);
        if (phase_match && identity() == Plugin::class_identity) {
            auto &final = static_cast<Plugin &>(*this);
            fn(final);
        }
    }
 
    reaction_underlying_t get_reaction() const noexcept { return reaction; }
 
    void reaction_on(reaction_t value) noexcept { reaction = reaction | value; }
 
    void reaction_off(reaction_t value) noexcept { reaction = reaction & (REACTION_MASK ^ value); }
    template <typename T> auto &access() noexcept;
 
  protected:
    template <typename Handler>
    subscription_info_ptr_t subscribe(Handler &&handler, const address_ptr_t &address) noexcept;
 
    template <typename Handler> subscription_info_ptr_t subscribe(Handler &&handler) noexcept;
 
    actor_base_t *actor;
 
    extended_error_ptr_t make_error(const std::error_code &ec, const extended_error_ptr_t &next = {},
                                    const message_ptr_t &request = {}) noexcept;
 
  private:
    subscription_container_t own_subscriptions;
    reaction_underlying_t reaction = 0;
    config_phase_t phase = config_phase_t::PREINIT;
};
 
} // namespace rotor::plugin