rtcComponent.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
 
#include <rtctk/componentFramework/payload.hpp>
#include <rtctk/componentFramework/rtcCmdsImpl.hpp>
#include <rtctk/componentFramework/stdComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
 
// High level excepiton types returned via MAL
 
// somebody send a stop or abort command
class RequestAborted : public rtctkif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 11;
    RequestAborted()
        : rtctkif::ExceptionErr("Request aborted.", ERROR_CODE) {
    }
};
 
// command is not allowed in current state or guard
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) {
    }
};
 
// the command was accepted but the task to do failed
class RequestFailed : public rtctkif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 501;
    RequestFailed(std::string const& message)
        : rtctkif::ExceptionErr(message, ERROR_CODE) {
    }
};
 
 
using RtcComponentSuper = StdComponent<UseStarting<Enabled>,
                                       UseInitialising<Enabled>,
                                       UseEnabling<Enabled>,
                                       UseDisabling<Enabled>>;
 
struct RtcComponent : RtcComponentSuper {
    using Super = RtcComponentSuper;
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivityUpdating(StopToken st, Payload args) {
        }
        virtual bool GuardUpdatingAllowed(Payload 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>(eptr));
            };
 
            // No Disable in states ###############################################################
 
            m_no_disable_in_states.push_back("On:Operational:UpdateBusy");
 
            // 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;
                }
                std::string args = req->GetRequestPayload();
                // TODO: parse the args and present them nicely to the BL
 
                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;
                    }
                }
                return static_cast<BizLogicIf&>(this->m_logic).GuardUpdatingAllowed(args);
            });
 
            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 args = m_tmp_update_request->GetRequestPayload();
                    // TODO: parse the args and present them nicely to the BL
                    static_cast<BizLogicIf&>(this->m_logic).ActivityUpdating(stop_token, args);
                }, 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) {
            this->RegisterLayer({"RtcComponent", {}});
 
            const std::string parent_region = "On:Operational:RegionUpdate";
 
            this->mm.ModStateType("On:Operational", Parallel);
            this->mm.AddState(Composite, parent_region,  "On:Operational");
 
            this->mm.AddState(Initial,   "On:Operational:UpdateInitial", parent_region);
            this->mm.AddState(Simple,    "On:Operational:UpdateIdle",    parent_region);
            this->mm.AddState(Simple,    "On:Operational:UpdateBusy",    parent_region  ,   "ActivityUpdating"                ,"ActionUpdatingEntry");
 
            this->mm.AddTrans("On:Operational:UpdateInitial"    , "On:Operational:UpdateIdle" );
            this->mm.AddTrans("On:Operational:UpdateIdle"       , "On:Operational:UpdateBusy"  , "events.Update",     "GuardUpdatingAllowed");
            this->mm.AddTrans("On:Operational:UpdateBusy"       , "On:Operational:UpdateIdle"  , "events.UpdateDone",  ""                   ,"ActionUpdatingDone"  );
            this->mm.AddTrans("On:Operational:UpdateBusy"       , "On:Operational:UpdateIdle"  , "events.UpdateError",  ""                  ,"ActionUpdatingFailed"  );
 
            this->mm.ModTransGuard("On:Operational", "On:NotOperational:Disabling", "events.Disable", "", "GuardDisablingAllowed");
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP