rtcComponent.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
 
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/componentFramework/rtcCmdsImpl.hpp>
#include <rtctk/componentFramework/stdComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
 
// High level exception types returned via MAL
 
class RequestAborted : public rtctkif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 11;
    RequestAborted() : rtctkif::ExceptionErr("Request aborted.", ERROR_CODE) {
    }
};
 
class RequestRejected : public rtctkif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 10;
    RequestRejected(std::string const& request_id, std::string const& state_id)
        : rtctkif::ExceptionErr("Request " + request_id + " rejected in state " + state_id,
                                ERROR_CODE) {
    }
};
 
class RequestFailed : public rtctkif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 501;
    explicit RequestFailed(std::string const& message)
        : rtctkif::ExceptionErr(message, ERROR_CODE) {
    }
};
 
 
using RtcComponentSuper = StdComponent;
 
struct RtcComponent : RtcComponentSuper {
    using Super = RtcComponentSuper;
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
        virtual void ActivityUpdating(StopToken st, JsonPayload const& args) {
        }
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
        virtual bool GuardUpdatingAllowed(JsonPayload const& args) {
            return true;
        }
    };
 
    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            UpdateCmdsImpl::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::Update, RequestRejected>();
 
            m_update_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::UpdateDone>());
            };
 
            m_update_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::UpdateError>(std::move(eptr)));
            };
 
            // No Disable in states ###############################################################
 
            m_no_disable_in_states.push_back("On:Update:Busy");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.push_back("On::NotOperational::Starting");
            this->m_no_update_in_states.push_back("On::NotOperational::NotReady");
            this->m_no_update_in_states.push_back("On::NotOperational::Initialising");
            this->m_no_update_in_states.push_back("On::NotOperational::Enabling");
            this->m_no_update_in_states.push_back("On::NotOperational::Disabling");
 
            // Actions ############################################################################
 
            engine.RegisterAction("ActionUpdatingEntry", [this](auto c) {
                m_tmp_update_request = GetPayloadNothrow<events::Update>(c);
            });
 
            engine.RegisterAction("ActionUpdatingDone", [this](auto c) {
                if (m_tmp_update_request) {
                    m_tmp_update_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_update_request = nullptr;
                }
            });
 
            engine.RegisterAction("ActionUpdatingFailed", [this](auto c) {
                if (auto eptr = GetPayloadNothrow<events::UpdateError>(c); eptr) {
                    if (m_tmp_update_request) {
                        m_tmp_update_request->SetException(
                            RequestFailed{NestedExceptionPrinter{*eptr}.Str()});
                        m_tmp_update_request = nullptr;
                    }
                }
            });
 
            // Guards ############################################################################
 
            engine.RegisterGuard("GuardUpdatingAllowed", [this](auto c) {
                auto req = GetPayloadNothrow<events::Update>(c);
                if (req == nullptr) {
                    // no event or request
                    return false;
                }
 
                auto act_state = this->m_engine.GetState();
                for (auto& s : m_no_update_in_states) {
                    if (act_state.find(s) != std::string::npos) {
                        return false;
                    }
                }
 
                std::string string_arg = req->GetRequestPayload();
                JsonPayload json_arg = JsonPayload::parse(string_arg);
                return static_cast<BizLogicIf&>(this->m_logic).GuardUpdatingAllowed(json_arg);
            });
 
            engine.RegisterGuard("GuardDisablingAllowed", [this](auto c) {
                auto act_state = this->m_engine.GetState();
                for (auto& s : m_no_disable_in_states) {
                    if (act_state.find(s) != std::string::npos) {
                        return false;
                    }
                }
                return true;
            });
 
            // Activities #####################################################################
 
            engine.RegisterActivity(
                "ActivityUpdating",
                [this](StopToken stop_token) {
                    std::string string_arg = m_tmp_update_request->GetRequestPayload();
                    JsonPayload json_arg = JsonPayload::parse(string_arg);
                    static_cast<BizLogicIf&>(this->m_logic).ActivityUpdating(stop_token, json_arg);
                },
                m_update_success_handler,
                m_update_error_handler);
        }
 
    protected:
        std::shared_ptr<rad::cii::Request<std::string, std::string>> m_tmp_update_request;
        std::function<void()> m_update_success_handler;
        std::function<void(std::exception_ptr)> m_update_error_handler;
        std::list<std::string> m_no_update_in_states;
        std::list<std::string> m_no_disable_in_states;
    };
 
    class ModelBuilder : public Super::ModelBuilder {
    public:
        ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            // clang-format off
            const std::string update_region = "On:Update";
            this->mm.AddState(Composite, update_region,  "On");
            this->mm.AddState(Initial,   "On:Update:Initial", update_region);
            this->mm.AddState(Simple,    "On:Update:Idle",    update_region);
            this->mm.AddState(Simple,    "On:Update:Busy",    update_region  ,   "ActivityUpdating"                ,"ActionUpdatingEntry");
 
            this->mm.AddTrans("On:Update:Initial"    , "On:Update:Idle" );
            this->mm.AddTrans("On:Update:Idle"       , "On:Update:Busy"  , "events.Update",       "GuardUpdatingAllowed");
            this->mm.AddTrans("On:Update:Busy"       , "On:Update:Idle"  , "events.UpdateDone",   ""                  ,"ActionUpdatingDone"  );
            this->mm.AddTrans("On:Update:Busy"       , "On:Update:Idle"  , "events.UpdateError",  ""                  ,"ActionUpdatingFailed"  );
 
            this->mm.ModTransGuard("On::Operational", "On::NotOperational::Disabling", "events.Disable", "", "GuardDisablingAllowed");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP