dbInterface.hpp

Go to the documentation of this file.

 
#ifndef CORE_UTILS_BAT_DB_INTERFACE_HPP_
#define CORE_UTILS_BAT_DB_INTERFACE_HPP_
 
#include <string>
#include <any>
#include <fmt/format.h>
#include <boost/lockfree/spsc_queue.hpp>
#include <boost/atomic.hpp>
 
#include <ifw/core/utils/bat/logger.hpp>
#include <ifw/core/utils/bat/taskOldb.hpp>
#include <rad/cii/oldbAdapter.hpp>
#include <rad/cii/oldbTypes.hpp>
 
 
namespace ifw::core::utils::bat {
 
  using DbPair = std::pair<std::string, std::any>;
  using DbVector = std::vector<DbPair>;
 
  class DbInterface {
  public:
    DbInterface(const std::string& prefix,
                std::chrono::seconds db_timeout,
                std::chrono::milliseconds db_task_period,
                bool with_worker_thread = true);
 
    virtual ~DbInterface();
 
    inline bool IsConnected() { return m_connected; }
    inline std::string GetPrefix() { return m_prefix; }
 
    void SetStates(const std::string& prefix,
                     const std::string& state,
                     const std::string& substate);
 
 
    template<typename T>
    void Get(const std::string& key, T& value);
 
    template<typename T>
    void Set(const std::string& key,
             const T& value);
 
 
    template<typename T>
    void SetAsync(const std::string& key,
               const T& value);
 
    void BatchSetAsync(const DbVector& vec);
 
 
 
    DbInterface(const DbInterface&) = delete;       
    DbInterface& operator=(const DbInterface&) = delete;  
 
 
 
  private:
    std::string               m_prefix;     
    bool m_connected{false};
 
 
    rad::DoubleMap<rad::cii::OldbType> m_oldb_map;
 
    rad::cii::OldbAdapter m_oldb_adapter;
 
    TaskOldb m_task_oldb;
 
    bool m_with_worker_thread {true};
    log4cplus::Logger         m_logger;
 
  };
 
 
  template<typename T>
   void DbInterface::Get(const std::string& key, T& value) {
       LOG4CPLUS_DEBUG(m_logger, fmt::format("Reading attribute <{}> with value: {}", key, value));
       m_oldb_adapter.Get<T>(m_prefix + key, value);
       LOG4CPLUS_DEBUG(m_logger, fmt::format("Reading attribute <{}> finished !", key));
   }
 
  template<typename T>
   void DbInterface::Set(const std::string& key, const T& value) {
       LOG4CPLUS_DEBUG(m_logger, fmt::format("Writing attribute <{}>", key));
       m_oldb_adapter.Set<T>(m_prefix + key, value);
       LOG4CPLUS_DEBUG(m_logger, fmt::format("Writing attribute <{}> finished !", key));
   }
 
  template<typename T>
  void DbInterface::SetAsync(const std::string& key, const T& value) {
      //LOG4CPLUS_DEBUG(m_logger, fmt::format("Async attribute for write <{}> with value: {}",
      //                                          m_prefix + key, value));
      m_oldb_map.Set(m_prefix + key, value);
      //LOG4CPLUS_DEBUG(m_logger, fmt::format("Async attribute for write <{}> finished !",
      //                                          m_prefix +key));
  }
 
}  // namespace
 
#endif  // CORE_UTILS_BAT_DB_INTERFACE_HPP_