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/optCmdsImpl.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
namespace detail {
class OptimiseContext {
public:
    OptimiseContext(rad::cii::Request<std::string, std::string> const& request)
        : m_request(request), m_arg() {
        m_arg = JsonPayload::parse(m_request.GetRequestPayload());
    }
    OptimiseContext(OptimiseContext&&) noexcept = default;
 
    JsonPayload const& GetArg() const noexcept {
        return m_arg;
    }
 
    void SendReply() noexcept {
        try {
            m_request.SetReplyValue(STD_OK_REPLY);
        } catch (std::exception const& exception) {
            LOG4CPLUS_ERROR(
                GetLogger(),
                "OptimiseContext::SendReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                GetLogger(),
                "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:
    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, JsonPayload const& arg) {
        }
        virtual bool GuardOptimisingAllowed(JsonPayload const& 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>(eptr));
            };
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.push_back("On:Operational:OptimiseBusy");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.push_back("On:Operational:OptimiseBusy");
 
            // No Optimise in states ##############################################################
 
            this->m_no_optimise_in_states.push_back("On:Operational:UpdateBusy");
 
            // Guards #####################################################################
 
            engine.RegisterGuardStatic<events::Optimise>(
                "GuardOptimisingAllowed",
                [this](events::Optimise const& 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](events::OptimiseDone const&) {
                    assert(m_optimise_ctx);
                    m_optimise_ctx->SendReply();
                    m_optimise_ctx.reset();
                });
 
            engine.RegisterActionStatic<events::OptimiseError>(
                "ActionOptimisingFailed",
                [this](events::OptimiseError const& 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:
        ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            this->RegisterLayer({"Optimisable", {}});
 
            this->mm.AddState(Composite, "On:Operational:RegionOptimise",  "On:Operational");
            this->mm.AddState(Initial,   "On:Operational:OptimiseInitial", "On:Operational:RegionOptimise");
            this->mm.AddState(Simple,    "On:Operational:OptimiseIdle",    "On:Operational:RegionOptimise");
            this->mm.AddState(Simple,    "On:Operational:OptimiseBusy",    "On:Operational:RegionOptimise",   "ActivityOptimising");
 
            this->mm.AddTrans("On:Operational:OptimiseInitial"   , "On:Operational:OptimiseIdle" );
            this->mm.AddTrans("On:Operational:OptimiseIdle",
                              "On:Operational:OptimiseBusy",
                              events::Optimise::ID,
                              "GuardOptimisingAllowed");
            this->mm.AddTrans("On:Operational:OptimiseBusy",
                              "On:Operational:OptimiseIdle",
                              events::OptimiseDone::ID,
                              "",
                              "ActionOptimisingDone");
            this->mm.AddTrans("On:Operational:OptimiseBusy",
                              "On:Operational:OptimiseIdle",
                              events::OptimiseError::ID,
                              "",
                              "ActionOptimisingFailed");
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif