runnable.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RUNABLE_HPP
#define RTCTK_COMPONENTFRAMEWORK_RUNABLE_HPP
 
#include <Rtctkif.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
 
template <typename Super>
struct Loopaware;
 
template <typename Super>
struct Runnable : Super {
    static_assert(std::is_base_of_v<RtcComponent, Super>, "'Runnable' requires 'RtcComponent'");
    static_assert(not is_base_of_template_v<Loopaware, Super>, "'Runnable' excludes 'Loopaware'");
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivityGoingRunning(StopToken st) {};
        virtual void ActivityGoingIdle(StopToken st) {};
        virtual void ActivityRunning(StopToken st) {};
        virtual void ActivityRecovering(StopToken st) {};
    };
 
    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            FuncCmdsImpl::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::Run, RequestRejected>();
            engine.RegisterRejectHandler<events::Idle, RequestRejected>();
            engine.RegisterRejectHandler<events::Recover, RequestRejected>();
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.push_back("On:Operational:Error");
            this->m_no_disable_in_states.push_back("On:Operational:Recovering");
            this->m_no_disable_in_states.push_back("On:Operational:GoingRunning");
            this->m_no_disable_in_states.push_back("On:Operational:GoingIdle");
            this->m_no_disable_in_states.push_back("On:Operational:Running");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.push_back("On:Operational:GoingRunning");
            this->m_no_update_in_states.push_back("On:Operational:GoingIdle");
            this->m_no_update_in_states.push_back("On:Operational:Error");
            this->m_no_update_in_states.push_back("On:Operational:Recovering");
 
            // Run #####################################################################
 
            engine.RegisterAction("ActionGoingRunningEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Run>(c);
            });
 
            engine.RegisterAction("ActionGoingRunningDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            // Idle #####################################################################
 
            engine.RegisterAction("ActionGoingIdleEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Idle>(c);
            });
 
            engine.RegisterAction("ActionGoingIdleDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            // Error #####################################################################
 
            engine.RegisterAction("ActionErrorEntry", [this](auto c) {
                if(auto eptr = GetPayloadNothrow<events::Error>(c); eptr) {
                    if (this->m_tmp_request) {
                        this->m_tmp_request->SetException(
                            RequestFailed(NestedExceptionPrinter(*eptr).Str()));
                        this->m_tmp_request = nullptr;
                    }
                }
            });
 
            // Recover #####################################################################
 
            engine.RegisterAction("ActionRecoveringEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Recover>(c);
            });
 
            engine.RegisterAction("ActionRecoveringDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            // Activities #####################################################################
 
            engine.RegisterActivity("ActivityGoingRunning",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityGoingRunning(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityGoingIdle",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityGoingIdle(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityRunning",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityRunning(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityRecovering",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityRecovering(stop_token);
                }, this->m_success_handler, this->m_error_handler);
        }
    };
 
    struct ModelBuilder : public Super::ModelBuilder {
    public:
        ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            this->RegisterLayer({"Runnable", {}});
 
            const std::string parent_region = "On:Operational:RegionMain";
 
            this->mm.AddState(Composite, parent_region,  "On:Operational");
 
            this->mm.AddState(Initial,   "On:Operational:Initial",       parent_region);
            this->mm.AddState(Simple,    "On:Operational:Idle",          parent_region);
            this->mm.AddState(Simple,    "On:Operational:Error",         parent_region          ,""                                ,"ActionErrorEntry");
            this->mm.AddState(Simple,    "On:Operational:Running",       parent_region          ,"ActivityRunning");
            this->mm.AddState(Simple,    "On:Operational:Recovering",    parent_region          ,"ActivityRecovering"              ,"ActionRecoveringEntry");
            this->mm.AddState(Simple,    "On:Operational:GoingRunning",  parent_region          ,"ActivityGoingRunning"            ,"ActionGoingRunningEntry");
            this->mm.AddState(Simple,    "On:Operational:GoingIdle",     parent_region          ,"ActivityGoingIdle"               ,"ActionGoingIdleEntry");
 
            this->mm.AddTrans("On:Operational:Initial"       , "On:Operational:Idle"       );
            this->mm.AddTrans(parent_region                  , "On:Operational:Error"           , "events.Error");
 
            this->mm.AddTrans("On:Operational:Error"         , "On:Operational:Recovering"      , "events.Recover");
            this->mm.AddTrans("On:Operational:Recovering"    , "On:Operational:Idle"            , "events.Done",   ""               ,"ActionRecoveringDone");
 
            this->mm.AddTrans("On:Operational:Idle"          , "On:Operational:GoingRunning"    , "events.Run");
            this->mm.AddTrans("On:Operational:GoingRunning"  , "On:Operational:Running"         , "events.Done",   ""               ,"ActionGoingRunningDone");
 
            this->mm.AddTrans("On:Operational:Running"       , "On:Operational:GoingIdle"       , "events.Idle");
            this->mm.AddTrans("On:Operational:GoingIdle"     , "On:Operational:Idle"            , "events.Done",   ""               ,"ActionGoingIdleDone");
 
            this->mm.AddTrans("On:Operational:Running"       , "On:Operational:GoingIdle"       , "events.Done");
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RUNABLE_HPP