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);
            RecoverCmdsImpl::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:
        explicit ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            // clang-format off
            this->mm.ModStateType("On::Operational", Parallel);
 
            const std::string parent_region = "On::Operational:";
 
            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");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RUNABLE_HPP