rtcCmdsImpl.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCMDSIMPL_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCMDSIMPL_HPP
 
#include <Rtctkif.hpp>
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/events.rad.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/malEventInjector.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::componentFramework {

class FuncCmdsImpl : public rtctkif::AsyncFuncCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service = std::make_shared<FuncCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncFuncCmds>("FuncCmds", rr_service);
    }
 
    explicit FuncCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> Run() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Run'");
        return InjectReqRepEvent<events::Run>(m_engine);
    }
 
    ::elt::mal::future<std::string> Idle() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Idle'");
        return InjectReqRepEvent<events::Idle>(m_engine);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};

class RecoverCmdsImpl : public rtctkif::AsyncRecoverCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service =
            std::make_shared<RecoverCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncRecoverCmds>("RecoverCmds", rr_service);
    }
 
    explicit RecoverCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> Recover() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Recover'");
        return InjectReqRepEvent<events::Recover>(m_engine);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};

class AlertCmdsImpl : public rtctkif::AsyncAlertCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service =
            std::make_shared<AlertCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncAlertCmds>("AlertCmds", rr_service);
    }
 
    explicit AlertCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> ClearAlerts() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'ClearAlerts'");
        return InjectReqRepEvent<events::ClearAlerts>(m_engine);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};

class UpdateCmdsImpl : public rtctkif::AsyncUpdateCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service =
            std::make_shared<UpdateCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncUpdateCmds>("UpdateCmds", rr_service);
    }
 
    explicit UpdateCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> Update(const std::string& args) override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Update' with payload '" + args + "'");
        return InjectReqRepEvent<events::Update>(m_engine, args);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};
 
}  // namespace rtctk::componentFramework
 
#endif