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);
            RecoverCmdsImpl::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:
        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::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");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif