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/exceptions.hpp"
#include "rtctk/componentFramework/jsonPayload.hpp"
#include "rtctk/componentFramework/rtcComponent.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, const cfw::JsonPayload& 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>(std::move(eptr)));
            };
 
            // Actions #####################################################################
 
            engine.RegisterActionStatic<events::Foo>("ActionFooEntry", [this](const auto& ev) {
                assert(not m_tmp_foo_request);
                m_tmp_foo_request = ev.GetPayload();
            });
 
            engine.RegisterActionStatic<events::CustomDone>("ActionFooDone", [this](const auto&) {
                assert(m_tmp_foo_request);
                m_tmp_foo_request->SetReplyValue(STD_OK_REPLY);
                m_tmp_foo_request.reset();
            });
 
            engine.RegisterActionStatic<events::CustomError>(
                "ActionFooFailed", [this](const auto& ev) {
                    const auto& 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](const auto& ev) {
                assert(not m_tmp_bar_request);
                m_tmp_bar_request = ev.GetPayload();
            });
 
            engine.RegisterActionStatic<events::CustomDone>("ActionBarDone", [this](const auto&) {
                assert(m_tmp_bar_request);
                m_tmp_bar_request->SetReplyValue(STD_OK_REPLY);
                m_tmp_bar_request.reset();
            });
 
            engine.RegisterActionStatic<events::CustomError>(
                "ActionBarFailed", [this](const auto& ev) {
                    const auto& 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:
        explicit ModelBuilder(cfw::StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            using namespace cfw;
 
            // clang-format off
            this->mm.ModStateType("On::Operational", Parallel);
 
            this->mm.AddState(Composite, "On::Operational:Custom",         "On::Operational");
            this->mm.AddState(Initial,   "On::Operational:Custom:Initial", "On::Operational:Custom");
            this->mm.AddState(Simple,    "On::Operational:Custom:Idle",    "On::Operational:Custom");
            this->mm.AddState(Simple,    "On::Operational:Custom:Foo",     "On::Operational:Custom",   "ActivityFoo" ,"ActionFooEntry");
            this->mm.AddState(Simple,    "On::Operational:Custom:Bar",     "On::Operational:Custom",   "ActivityBar" ,"ActionBarEntry");
 
            this->mm.AddTrans("On::Operational:Custom:Initial"   , "On::Operational:Custom:Idle");
            this->mm.AddTrans("On::Operational:Custom:Idle"      , "On::Operational:Custom:Foo"   , "events.Foo"      ,"");
            this->mm.AddTrans("On::Operational:Custom:Foo"       , "On::Operational:Custom:Idle"  , "events.CustomDone"  ,""      ,"ActionFooDone"  );
            this->mm.AddTrans("On::Operational:Custom:Foo"       , "On::Operational:Custom:Idle"  , "events.CustomError" ,""      ,"ActionFooFailed"  );
            this->mm.AddTrans("On::Operational:Custom:Idle"      , "On::Operational:Custom:Bar"   , "events.Bar"      ,"");
            this->mm.AddTrans("On::Operational:Custom:Bar"       , "On::Operational:Custom:Idle"  , "events.CustomDone"  ,""      ,"ActionBarDone"  );
            this->mm.AddTrans("On::Operational:Custom:Bar"       , "On::Operational:Custom:Idle"  , "events.CustomError" ,""      ,"ActionBarFailed"  );
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::exampleCustom
 
#endif