loopaware.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_LOOPAWARE_HPP
#define RTCTK_COMPONENTFRAMEWORK_LOOPAWARE_HPP
 
#include <rtctk/componentFramework/loopCmdsImpl.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
 
template <typename Super>
struct Runnable;
 
template <typename Super>
struct Loopaware : Super {
    static_assert(std::is_base_of_v<RtcComponent, Super>, "'Loopaware' requires 'RtcComponent'");
    static_assert(not is_base_of_template_v<Runnable, Super>, "'Loopaware' excludes 'Runnable'");
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivityGoingRunning(StopToken st) {};
        virtual void ActivityGoingIdle(StopToken st) {};
        virtual void ActivityRecovering(StopToken st) {};
        virtual void ActivityOpening(StopToken st) {};
        virtual void ActivityClosing(StopToken st) {};
        virtual void ActivityOpened(StopToken st) {};
        virtual void ActivityClosed(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);
            LoopCmdsImpl::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::Open, RequestRejected>();
            engine.RegisterRejectHandler<events::Close, 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.Opened");
            this->m_no_disable_in_states.push_back("On.Operational.Closed");
            this->m_no_disable_in_states.push_back("On.Operational.Opening");
            this->m_no_disable_in_states.push_back("On.Operational.Closing");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.push_back("On.Operational.Error");
            this->m_no_update_in_states.push_back("On.Operational.Recovering");
            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.Opening");
            this->m_no_update_in_states.push_back("On.Operational.Closing");
 
            // Actions ############################################################################
 
            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;
                }
            });
 
            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;
                }
            });
 
            engine.RegisterAction("ActionOpeningEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Open>(c);
            });
 
            engine.RegisterAction("ActionOpeningDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            engine.RegisterAction("ActionClosingEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Close>(c);
            });
 
            engine.RegisterAction("ActionClosingDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            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;
                    }
                }
            });
 
            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("ActivityOpening",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityOpening(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityClosing",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityClosing(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityOpened",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityOpened(stop_token);
                }, {}, this->m_error_handler);
 
            engine.RegisterActivity("ActivityClosed",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityClosed(stop_token);
                }, {}, 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);
        }
    };
 
    class ModelBuilder : public Super::ModelBuilder {
    public:
        ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            this->RegisterLayer({"Loopaware", {}});
 
            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.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.AddState(Simple, "On.Operational.Opened",        parent_region,   "ActivityOpened");
            this->mm.AddState(Simple, "On.Operational.Closed",        parent_region,   "ActivityClosed");
            this->mm.AddState(Simple, "On.Operational.Opening",       parent_region,   "ActivityOpening"       , "ActionOpeningEntry");
            this->mm.AddState(Simple, "On.Operational.Closing",       parent_region,   "ActivityClosing"       , "ActionClosingEntry");
 
            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.Opened"      , "events.Done",   ""  , "ActionGoingRunningDone");
 
            this->mm.AddTrans("On.Operational.Opened"        , "On.Operational.GoingIdle"   , "events.Idle");
            this->mm.AddTrans("On.Operational.GoingIdle"     , "On.Operational.Idle"        , "events.Done",   ""  , "ActionGoingIdleDone");
 
            this->mm.AddTrans("On.Operational.Opened"        , "On.Operational.Closing"     , "events.Close");
            this->mm.AddTrans("On.Operational.Closing"       , "On.Operational.Closed"      , "events.Done",   ""  , "ActionClosingDone");
            this->mm.AddTrans("On.Operational.Closed"        , "On.Operational.Opening"     , "events.Open");
            this->mm.AddTrans("On.Operational.Opening"       , "On.Operational.Opened"      , "events.Done",   ""  , "ActionOpeningDone");
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif