stdCmdsImpl.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_STDCMDSIMPL_HPP
#define RTCTK_COMPONENTFRAMEWORK_STDCMDSIMPL_HPP
 
#include <Stdif.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 StdCmdsImpl : public stdif::AsyncStdCmds {
public:
    static void Register(CommandReplier& replier, StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service = std::make_shared<StdCmdsImpl>(engine);
        replier.RegisterService<stdif::AsyncStdCmds>("StdCmds", rr_service);
    }
 
    explicit StdCmdsImpl(StateMachineEngine& engine)
        : m_logger(GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> Init() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Init'");
        return InjectReqRepEvent<events::Init>(m_engine);
    }
 
    ::elt::mal::future<std::string> Stop() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Stop'");
        return InjectReqRepEvent<events::Stop>(m_engine);
    }
 
    ::elt::mal::future<std::string> Reset() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Reset'");
        return InjectReqRepEvent<events::Reset>(m_engine);
    }
 
    ::elt::mal::future<std::string> Enable() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Enable'");
        return InjectReqRepEvent<events::Enable>(m_engine);
    }
 
    ::elt::mal::future<std::string> Disable() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Disable'");
        return InjectReqRepEvent<events::Disable>(m_engine);
    }
 
    ::elt::mal::future<std::string> GetState() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetState'");
        return InjectReqRepEvent<events::GetState>(m_engine);
    }
 
    ::elt::mal::future<std::string> GetStatus() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetStatus'");
        return InjectReqRepEvent<events::GetStatus>(m_engine);
    }
 
    ::elt::mal::future<std::string> GetVersion() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetVersion'");
        return InjectReqRepEvent<events::GetVersion>(m_engine);
    }
 
    ::elt::mal::future<std::string> Exit() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Exit'");
        return InjectReqRepEvent<events::Exit>(m_engine);
    }
 
    ::elt::mal::future<std::string>
    SetLogLevel(std::shared_ptr<stdif::LogInfo> const& info) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'SetLogLevel' with logger '" + info->getLogger() +
                            "' and level '" + info->getLevel() + "'");
        auto ev = std::make_shared<events::SetLogLevel>(info->clone());
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_STDCMDSIMPL_HPP