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.GetMal());
        replier.RegisterService<stdif::AsyncStdCmds>("StdCmds", rr_service);
    }
 
    explicit StdCmdsImpl(StateMachineEngine& engine, std::shared_ptr<elt::mal::Mal> mal)
        : m_logger(GetLogger("rtctk")), m_engine(engine), m_mal(std::move(mal)) {
    }
 
    ::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(const std::shared_ptr<stdif::LogInfo>& 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;
    }
 
    ::elt::mal::future<std::vector<std::shared_ptr<stdif::LogInfo>>>
    GetLogLevel(const std::string& req_loggers) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'GetLogLevel' for logger '" + req_loggers + "'");
        boost::promise<std::vector<std::shared_ptr<stdif::LogInfo>>> promise;
 
        std::vector<std::shared_ptr<stdif::LogInfo>> loggers{};
 
        for (const log4cplus::Logger& logger : log4cplus::Logger::getCurrentLoggers()) {
            std::shared_ptr<stdif::LogInfo> log = m_mal->createDataEntity<stdif::LogInfo>();
            log->setLogger(logger.getName());
            log->setLevel(log4cplus::getLogLevelManager().toString(logger.getLogLevel()));
            if (req_loggers.empty()) {
                // If  the parameters is an empty string we return all  loggers
                loggers.push_back(std::move(log));
            } else if (logger.getName() == req_loggers) {
                // Otherwise, we only return the logger that matches
                loggers.push_back(std::move(log));
                break;
            }
        }  // for
 
        std::string log_msg = "[";
        bool is_first = true;
        for (const std::shared_ptr<stdif::LogInfo>& l : loggers) {
            if (!is_first) {
                log_msg += ", ";
            }
            log_msg += "logger: ";
            log_msg += l->getLogger();
            log_msg += " level: ";
            log_msg += l->getLevel();
            is_first = false;
        }
        log_msg += "]";
 
        LOG4CPLUS_DEBUG(m_logger, "Loggers: " + log_msg);
 
        return boost::make_ready_future<std::vector<std::shared_ptr<stdif::LogInfo>>>(loggers);
    }  // GetLogLevel
 
private:
    log4cplus::Logger& m_logger;
    StateMachineEngine& m_engine;
    std::shared_ptr<elt::mal::Mal> m_mal;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_STDCMDSIMPL_HPP