customLifeCycle.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLECUSTOM_CUSTOMLIFECYCLE_HPP
#define RTCTK_EXAMPLECUSTOM_CUSTOMLIFECYCLE_HPP
 
#include "customCmdsImpl.hpp"
#include "rtctk/componentFramework/jsonPayload.hpp"
#include "rtctk/componentFramework/rtcComponent.hpp"
#include "rtctk/componentFramework/exceptions.hpp"
#include "rtctk/componentFramework/stopToken.hpp"
 
namespace rtctk::exampleCustom {
 
namespace cfw = componentFramework;
 
template <typename Super>
struct CustomLifeCycle : Super {
    static_assert(std::is_base_of_v<cfw::RtcComponent, Super>,
                  "'CustomLifeCycle' requires 'RtcComponent'");
 
    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual void ActivityFoo(cfw::StopToken st) {
        }
        virtual void ActivityBar(cfw::StopToken st, cfw::JsonPayload const& args) {
        }
    };
 
    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            CustomCmdsImpl::Register(this->m_replier, this->m_engine);
        }
    };
 
    class OutputStage : public Super::OutputStage {
    public:
        OutputStage(cfw::StateMachineEngine& engine, BizLogicIf& bl)
            : Super::OutputStage(engine, bl) {
            using namespace cfw;
 
            // Handlers ###################################################################
 
            engine.RegisterRejectHandler<events::Foo, RequestRejected>();
            engine.RegisterRejectHandler<events::Bar, RequestRejected>();
 
            m_custom_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::CustomDone>());
            };
 
            m_custom_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::CustomError>(eptr));
            };
 
            // Actions #####################################################################
 
            engine.RegisterActionStatic<events::Foo>("ActionFooEntry",
                [this](auto const& ev) {
                    assert(not m_tmp_foo_request);
                    m_tmp_foo_request = ev.GetPayload();
                });
 
            engine.RegisterActionStatic<events::CustomDone>("ActionFooDone",
                [this](auto const&) {
                    assert(m_tmp_foo_request);
                    m_tmp_foo_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_foo_request.reset();
                });
 
            engine.RegisterActionStatic<events::CustomError>("ActionFooFailed",
                [this](auto const& ev) {
                    auto const& eptr = ev.GetPayload();
                    assert(m_tmp_foo_request);
                    m_tmp_foo_request->SetException(
                        RequestFailed(NestedExceptionPrinter(eptr).Str()));
                    m_tmp_foo_request.reset();
                });
 
            engine.RegisterActionStatic<events::Bar>("ActionBarEntry",
                [this](auto const& ev) {
                    assert(not m_tmp_bar_request);
                    m_tmp_bar_request = ev.GetPayload();
                });
 
            engine.RegisterActionStatic<events::CustomDone>("ActionBarDone",
                [this](auto const&) {
                    assert(m_tmp_bar_request);
                    m_tmp_bar_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_bar_request.reset();
                });
 
            engine.RegisterActionStatic<events::CustomError>("ActionBarFailed",
                [this](auto const& ev) {
                    auto const& eptr = ev.GetPayload();
                    assert(m_tmp_bar_request);
                    m_tmp_bar_request->SetException(
                        RequestFailed(NestedExceptionPrinter(eptr).Str()));
                    m_tmp_bar_request.reset();
                });
 
            // Activities #####################################################################
 
            engine.RegisterActivity("ActivityFoo",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityFoo(stop_token);
                }, m_custom_success_handler, m_custom_error_handler);
 
            engine.RegisterActivity("ActivityBar",
                [this](StopToken stop_token) {
                    std::string args = m_tmp_bar_request->GetRequestPayload();
                    JsonPayload arg = JsonPayload::parse(args);
                    static_cast<BizLogicIf&>(this->m_logic).ActivityBar(stop_token, arg);
                }, m_custom_success_handler, m_custom_error_handler);
        }
 
    protected:
        std::optional<rad::cii::Request<std::string>> m_tmp_foo_request;
        std::optional<rad::cii::Request<std::string, std::string>> m_tmp_bar_request;
        std::function<void()> m_custom_success_handler;
        std::function<void(std::exception_ptr)> m_custom_error_handler;
    };
 
    class ModelBuilder : public Super::ModelBuilder {
    public:
        ModelBuilder(cfw::StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            using namespace cfw;
 
            this->RegisterLayer({"CustomLifeCycle", {}});
 
            this->mm.AddState(Composite, "On:Operational:RegionCustom",  "On:Operational");
            this->mm.AddState(Initial,   "On:Operational:CustomInitial", "On:Operational:RegionCustom");
            this->mm.AddState(Simple,    "On:Operational:CustomIdle",    "On:Operational:RegionCustom");
            this->mm.AddState(Simple,    "On:Operational:CustomFoo",     "On:Operational:RegionCustom",   "ActivityFoo" ,"ActionFooEntry");
            this->mm.AddState(Simple,    "On:Operational:CustomBar",     "On:Operational:RegionCustom",   "ActivityBar" ,"ActionBarEntry");
 
            this->mm.AddTrans("On:Operational:CustomInitial"   , "On:Operational:CustomIdle");
            this->mm.AddTrans("On:Operational:CustomIdle"      , "On:Operational:CustomFoo"   , "events.Foo"      ,"");
            this->mm.AddTrans("On:Operational:CustomFoo"       , "On:Operational:CustomIdle"  , "events.CustomDone"  ,""      ,"ActionFooDone"  );
            this->mm.AddTrans("On:Operational:CustomFoo"       , "On:Operational:CustomIdle"  , "events.CustomError" ,""      ,"ActionFooFailed"  );
            this->mm.AddTrans("On:Operational:CustomIdle"      , "On:Operational:CustomBar"   , "events.Bar"      ,"");
            this->mm.AddTrans("On:Operational:CustomBar"       , "On:Operational:CustomIdle"  , "events.CustomDone"  ,""      ,"ActionBarDone"  );
            this->mm.AddTrans("On:Operational:CustomBar"       , "On:Operational:CustomIdle"  , "events.CustomError" ,""      ,"ActionBarFailed"  );
        }
    };
};
 
}  // namespace rtctk::exampleCustom
 
#endif