ddtForwarder.hpp

Go to the documentation of this file.

 
#ifndef DDT_FORWARDER_HPP
#define DDT_FORWARDER_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
 
#include <fmt/format.h>
 
#include <atomic>
#include <functional>
#include <list>
#include <memory>
#include <set>
#include <string>
 
namespace rtctk::ddtServer {
 
class DdtForwarder;
 
using DdtForwarderListType = std::list<std::unique_ptr<DdtForwarder>>;
using DdtForwarderFactoryType = std::function<DdtForwarderListType(
    const std::string&, rtctk::componentFramework::ServiceContainer&)>;
 
template <class T, class... Args>
void AddDdtForwarder(DdtForwarderListType& units, Args&&... args) {
    units.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
}
 
class DdtForwarder {
public:
    using ServiceContainer = rtctk::componentFramework::ServiceContainer;
    using OldbIf = rtctk::componentFramework::OldbIf;
 
    enum class State : uint8_t { STOPPED, STARTING, IDLE, RUNNING, ERROR };
 
    DdtForwarder(const std::string& comp_id,
                 const std::string& fwd_type,
                 const std::string& fwd_id,
                 ServiceContainer& services)
        : m_logger(componentFramework::GetLogger("rtctk"))
        , m_oldb(services.Get<OldbIf>())
        , m_comp_id(comp_id)
        , m_fwd_id(fwd_id)
        , m_state(State::STOPPED)
        , m_oldb_prefix(fmt::format("/{}/forwarders/{}", comp_id, fwd_id)) {
        using namespace rtctk::componentFramework;
 
        LOG4CPLUS_INFO(m_logger, fmt::format("Creating {} '{}'", fwd_type, fwd_id));
 
        auto state_dp_path = DataPointPath(m_oldb_prefix + "/state");
        m_oldb.CreateDataPoint<std::string>(state_dp_path);
        m_oldb.SetDataPoint(state_dp_path, m_state_text.at(m_state));
 
        auto type_dp_path = DataPointPath(m_oldb_prefix + "/type");
        m_oldb.CreateDataPoint<std::string>(type_dp_path);
        m_oldb.SetDataPoint(type_dp_path, fwd_type);
    }
 
    virtual ~DdtForwarder() = default;
 
    std::string GetId() {
        return m_fwd_id;
    }
 
    State GetState() {
        return m_state;
    }
 
    virtual void Start() = 0;
 
    virtual void Run() = 0;
 
    virtual void Idle() = 0;
 
    virtual void Stop() = 0;
 
    virtual void Recover() = 0;
 
    virtual void Update() = 0;
 
    virtual void CheckErrors() = 0;
 
protected:
    virtual void SetState(State state) {
        using namespace rtctk::componentFramework;
 
        m_state = state;
 
        try {
            auto state_dp_path = DataPointPath(m_oldb_prefix + "/state");
            m_oldb.SetDataPoint<std::string>(state_dp_path, m_state_text.at(state));
        } catch (...) {
            LOG4CPLUS_ERROR(m_logger, "DdtForwarder: Failed to publish state to OLDB.");
        }
    }
 
    void AssertState(const std::set<State>& states) {
        using namespace rtctk::componentFramework;
 
        if (states.find(m_state) == states.end()) {
            std::string state_texts;
            for (auto s : states) {
                state_texts += m_state_text.at(s) + " ";
            }
            CII_THROW(RtctkException,
                      fmt::format("State '{}' does not fulfill precondition '{}'.",
                                  m_state_text.at(m_state),
                                  state_texts));
        }
    }
 
    const std::map<State, std::string> m_state_text = {
        {State::STOPPED, "Stopped"},
        {State::STARTING, "Starting"},
        {State::IDLE, "Idle"},
        {State::RUNNING, "Running"},
        {State::ERROR, "Error"},
    };  //< States names
 
    log4cplus::Logger& m_logger;
 
private:
    OldbIf& m_oldb;
 
    std::string m_comp_id;
    std::string m_fwd_id;
    std::atomic<State> m_state;
 
    std::string m_oldb_prefix;
};
 
}  // namespace rtctk::ddtServer
 
#endif  // DDT_FORWARDER