optimisable.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_OPTIMISABLE_HPP
#define RTCTK_COMPONENTFRAMEWORK_OPTIMISABLE_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/optCmdsImpl.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
namespace detail {
class OptimiseContext {
public:
    explicit OptimiseContext(const rad::cii::Request<std::string, std::string>& request)
        : m_logger(GetLogger("rtctk")), m_request(request), m_arg() {
        m_arg = JsonPayload::parse(m_request.GetRequestPayload());
    }
    OptimiseContext(OptimiseContext&&) noexcept = default;

    const JsonPayload& GetArg() const noexcept {
        return m_arg;
    }

    void SendReply() noexcept {
        try {
            m_request.SetReplyValue(STD_OK_REPLY);
        } catch (const std::exception& exception) {
            LOG4CPLUS_ERROR(
                m_logger, "OptimiseContext::SendReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "OptimiseContext::SendReply: Failed to send reply with unknown exception.");
        }
    }

    void SendErrorReply(std::exception_ptr eptr) noexcept {
        try {
            m_request.SetException(RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
        } catch (...) {
        }
    }
 
private:
    log4cplus::Logger& m_logger;

    rad::cii::Request<std::string, std::string> m_request;
    JsonPayload m_arg;
};
}  // namespace detail

template <typename Super>
struct Optimisable : Super {
    static_assert(std::is_base_of_v<RtcComponent, Super>, "'Optimisable' requires 'RtcComponent'");

    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivityOptimising(StopToken st, const JsonPayload& arg) {
        }

        virtual bool GuardOptimisingAllowed(const JsonPayload& arg) {
            return true;
        }
    };

    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            OptCmdsImpl::Register(this->m_replier, this->m_engine);
        }
    };

    class OutputStage : public Super::OutputStage {
    public:
        OutputStage(StateMachineEngine& engine, BizLogicIf& bl) : Super::OutputStage(engine, bl) {
            // Handlers ###################################################################
 
            engine.RegisterRejectHandler<events::Optimise, RequestRejected>();
 
            m_optimise_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::OptimiseDone>());
            };
 
            m_optimise_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::OptimiseError>(std::move(eptr)));
            };
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.emplace_back("On::Operational:Optimise:Busy");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.emplace_back("On::Operational:Optimise:Busy");
 
            // No Optimise in states ##############################################################
 
            this->m_no_optimise_in_states.emplace_back("On:Update:Busy");
 
            // Guards #####################################################################
 
            engine.RegisterGuardStatic<events::Optimise>(
                "GuardOptimisingAllowed", [this](const events::Optimise& ev) -> bool {
                    auto act_state = this->m_engine.GetState();
                    for (auto& s : m_no_optimise_in_states) {
                        if (act_state.find(s) != std::string::npos) {
                            return false;
                        }
                    }
                    detail::OptimiseContext ctx(ev.GetPayload());
                    if (static_cast<BizLogicIf&>(this->m_logic)
                            .GuardOptimisingAllowed(ctx.GetArg())) {
                        // Optimise is allowed so context is stored.
                        // If there's an active context (and correspondingly an active
                        // request being processed something have gone terribly wrong)
                        assert(!m_optimise_ctx);
                        m_optimise_ctx.emplace(std::move(ctx));
                        return true;
                    }
                    return false;
                });
 
            // Activities #####################################################################
 
            engine.RegisterActivity(
                "ActivityOptimising",
                [this](StopToken stop_token) {
                    assert(m_optimise_ctx);
                    static_cast<BizLogicIf&>(this->m_logic)
                        .ActivityOptimising(stop_token, m_optimise_ctx->GetArg());
                },
                m_optimise_success_handler,
                m_optimise_error_handler);
 
            // Actions #####################################################################
            engine.RegisterActionStatic<events::OptimiseDone>("ActionOptimisingDone",
                                                              [this](const events::OptimiseDone&) {
                                                                  assert(m_optimise_ctx);
                                                                  m_optimise_ctx->SendReply();
                                                                  m_optimise_ctx.reset();
                                                              });
 
            engine.RegisterActionStatic<events::OptimiseError>(
                "ActionOptimisingFailed", [this](const events::OptimiseError& ev) {
                    m_optimise_ctx->SendErrorReply(ev.GetPayload());
                    m_optimise_ctx.reset();
                });
        }
 
    protected:
        std::optional<detail::OptimiseContext> m_optimise_ctx;
        std::function<void()> m_optimise_success_handler;
        std::function<void(std::exception_ptr)> m_optimise_error_handler;
        std::list<std::string> m_no_optimise_in_states;
    };

    class ModelBuilder : public Super::ModelBuilder {
    public:
        explicit ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            // clang-format off
            this->mm.ModStateType("On::Operational", Parallel);
 
            this->mm.AddState(Composite, "On::Operational:Optimise:",        "On::Operational");
            this->mm.AddState(Initial,   "On::Operational:Optimise:Initial", "On::Operational:Optimise:");
            this->mm.AddState(Simple,    "On::Operational:Optimise:Idle",    "On::Operational:Optimise:");
            this->mm.AddState(Simple,    "On::Operational:Optimise:Busy",    "On::Operational:Optimise:",   "ActivityOptimising");
 
            this->mm.AddTrans("On::Operational:Optimise:Initial" , "On::Operational:Optimise:Idle" );
            this->mm.AddTrans("On::Operational:Optimise:Idle"    , "On::Operational:Optimise:Busy", events::Optimise::ID,      "GuardOptimisingAllowed");
            this->mm.AddTrans("On::Operational:Optimise:Busy"    , "On::Operational:Optimise:Idle", events::OptimiseDone::ID,  "",  "ActionOptimisingDone");
            this->mm.AddTrans("On::Operational:Optimise:Busy"    , "On::Operational:Optimise:Idle", events::OptimiseError::ID, "",  "ActionOptimisingFailed");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif