suspendable.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_SUSPENDABLE_HPP
#define RTCTK_COMPONENTFRAMEWORK_SUSPENDABLE_HPP
 
#include <rtctk/componentFramework/loopaware.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
#include <rtctk/componentFramework/suspCmdsImpl.hpp>
 
namespace rtctk::componentFramework {
 
template <typename Super>
struct Suspendable : Super {
    static_assert(is_base_of_template_v<Loopaware, Super>, "'Suspendable' requires 'Loopaware'");
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivitySuspending(StopToken st) {};
        virtual void ActivityResuming(StopToken st) {};
        virtual void ActivitySuspended(StopToken st) {};
    };
 
    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            SuspCmdsImpl::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::Suspend, RequestRejected>();
            engine.RegisterRejectHandler<events::Resume, RequestRejected>();
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.push_back("On.Operational.Suspending");
            this->m_no_disable_in_states.push_back("On.Operational.Resuming");
            this->m_no_disable_in_states.push_back("On.Operational.Suspended");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.push_back("On.Operational.Suspending");
            this->m_no_update_in_states.push_back("On.Operational.Resuming");
 
            // Actions ############################################################################
 
            engine.RegisterAction("ActionSuspendingEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Suspend>(c);
            });
 
            engine.RegisterAction("ActionSuspendingDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            engine.RegisterAction("ActionResumingEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Resume>(c);
            });
 
            engine.RegisterAction("ActionResumingDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            // Activities #########################################################################
 
            engine.RegisterActivity("ActivitySuspending",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivitySuspending(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivityResuming",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityResuming(stop_token);
                }, this->m_success_handler, this->m_error_handler);
 
            engine.RegisterActivity("ActivitySuspended",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivitySuspended(stop_token);
                }, {}, this->m_error_handler);
        }
    };
 
    class ModelBuilder : public Super::ModelBuilder {
    public:
        ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            this->RegisterLayer({"Suspendable", {}});
 
            std::string parent_region = this->mm.GetParentId("On.Operational.Closed");
 
            this->mm.AddState(Simple, "On.Operational.Suspended"    ,parent_region   ,"ActivitySuspended");
            this->mm.AddState(Simple, "On.Operational.Suspending"   ,parent_region   ,"ActivitySuspending" , "ActionSuspendingEntry");
            this->mm.AddState(Simple, "On.Operational.Resuming"     ,parent_region   ,"ActivityResuming"   , "ActionResumingEntry" );
 
            this->mm.AddTrans("On.Operational.Closed"       , "On.Operational.Suspending"      , "events.Suspend");
            this->mm.AddTrans("On.Operational.Suspending"   , "On.Operational.Suspended"       , "events.Done", ""  ,"ActionSuspendingDone");
            this->mm.AddTrans("On.Operational.Suspended"    , "On.Operational.Resuming"        , "events.Resume");
            this->mm.AddTrans("On.Operational.Resuming"     , "On.Operational.Closed"          , "events.Done", ""  ,"ActionResumingDone");
            this->mm.AddTrans("On.Operational.Suspended"    , "On.Operational.Opening"         , "events.Open");
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_SUSPENDABLE_HPP