supervisoryCmdsImpl.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_RTCSUPERVISOR_SUPERVISORYCMDSIMPL_HPP
#define RTCTK_RTCSUPERVISOR_SUPERVISORYCMDSIMPL_HPP
 
#include <Rtctkif.hpp>
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/malEventInjector.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
 
#include <rtctk/rtcSupervisor/supervisoryEvents.rad.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::rtcSupervisor {
 
using namespace rtctk::componentFramework;
 
class ModeCmdsImpl : public rtctkif::AsyncModeCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service = std::make_shared<ModeCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncModeCmds>("ModeCmds", rr_service);
    }
 
    explicit ModeCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> SetModes(const std::string& args) override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'SetModes' with payload '" + args + "'");
        return InjectReqRepEvent<events::SetModes>(this->m_engine, args);
    }
 
    ::elt::mal::future<std::string> SetDeferredModes(const std::string& args) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'SetDeferredModes' with payload '" + args + "'");
        return InjectReqRepEvent<events::SetDeferredModes>(this->m_engine, args);
    }
 
    ::elt::mal::future<std::string> GetDeferredModes() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetDeferredModes'");
        return InjectReqRepEvent<events::GetDeferredModes>(this->m_engine);
    }
 
    ::elt::mal::future<std::string> GetAvailableModes() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetAvailableModes'");
        return InjectReqRepEvent<events::GetAvailableModes>(this->m_engine);
    }
 
    ::elt::mal::future<std::string> GetActiveModes() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetActiveModes'");
        return InjectReqRepEvent<events::GetActiveModes>(this->m_engine);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};
 
class WriteBackCmdsImpl : public rtctkif::AsyncWriteBackCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service =
            std::make_shared<WriteBackCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncWriteBackCmds>("WriteBackCmds", rr_service);
    }
 
    explicit WriteBackCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> WriteBack(const std::string& args) override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'WriteBack' with payload '" + args + "'");
        return InjectReqRepEvent<events::WriteBack>(this->m_engine, args);
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};
 
}  // namespace rtctk::rtcSupervisor
 
#endif