dataContext.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DATA_CONTEXT_HPP_
#define FCF_DEVMGR_COMMON_DATA_CONTEXT_HPP_
 
// System headers
#include <unordered_map>
 
// Local headers
//#include <rad/topicPub.hpp>
#include <mal/Cii.hpp>
#include <mal/utility/LoadMal.hpp>
#include <rad/topicPub.hpp>
#include <rad/mal/publisher.hpp>
#include <boost/asio.hpp>
#include <Stdif.hpp>
#include <fcf/devmgr/common/config.hpp>
#include <utils/bat/dbInterface.hpp>
 
namespace fcf::devmgr::common {
 
  // Constants for state values
  const short SRV_STATE_NOT_OPERATIONAL       =  1;
  const short SRV_STATE_OPERATIONAL           =  2;
 
  // Constants for substate values
  const short SRV_SUBSTATE_NOTREADY           =  1;
  const short SRV_SUBSTATE_READY              =  2;
  const short SRV_SUBSTATE_IDLE               =  3;
  const short SRV_SUBSTATE_INITIALISING       =  4;
  const short SRV_SUBSTATE_ENABLING           =  5;
  const short SRV_SUBSTATE_SETTING_UP         =  6;
  const short SRV_SUBSTATE_ERROR              =  10;
 
 
  const std::string SRV_STATE_NOT_OPERATIONAL_STR  =  "NotOperational";
  const std::string SRV_STATE_OPERATIONAL_STR      =  "Operational";
  const std::string SRV_STATE_UNAVAILABLE_STR      =  "Unavailable";
 
  const std::string SRV_SUBSTATE_NOTREADY_STR      =  "NotReady";
  const std::string SRV_SUBSTATE_READY_STR         =  "Ready";
  const std::string SRV_SUBSTATE_IDLE_STR          =  "Idle";
  const std::string SRV_SUBSTATE_INITIALISING_STR  =  "Initialising";
  const std::string SRV_SUBSTATE_ENABLING_STR      =  "Enabling";
  const std::string SRV_SUBSTATE_ERROR_STR         =  "Error";
  const std::string SRV_SUBSTATE_SETTING_UP_STR    =  "SettingUp";
 
 
 
  const std::unordered_map<short, std::string>  SrvStateMap = {
    {SRV_STATE_NOT_OPERATIONAL,           SRV_STATE_NOT_OPERATIONAL_STR},
    {SRV_STATE_OPERATIONAL,       SRV_STATE_OPERATIONAL_STR},
  };
 
  const std::unordered_map<std::string, short>  SrvStateStrMap = {
    {SRV_STATE_NOT_OPERATIONAL_STR,       SRV_STATE_NOT_OPERATIONAL},
    {SRV_STATE_OPERATIONAL_STR,   SRV_STATE_OPERATIONAL},
  };
 
  const std::unordered_map<short, std::string>  SrvSubstateMap = {
    {SRV_SUBSTATE_NOTREADY,       SRV_SUBSTATE_NOTREADY_STR},
    {SRV_SUBSTATE_READY,          SRV_SUBSTATE_READY_STR},
    {SRV_SUBSTATE_IDLE,           SRV_SUBSTATE_IDLE_STR},
    {SRV_SUBSTATE_INITIALISING,   SRV_SUBSTATE_INITIALISING_STR},
    {SRV_SUBSTATE_ENABLING,       SRV_SUBSTATE_ENABLING_STR},
    {SRV_SUBSTATE_ERROR,          SRV_SUBSTATE_ERROR_STR},
    {SRV_SUBSTATE_SETTING_UP,     SRV_SUBSTATE_SETTING_UP_STR},
  };
 
  const std::unordered_map<std::string, short>  SrvSubstateStrMap = {
    {SRV_SUBSTATE_NOTREADY_STR,   SRV_SUBSTATE_NOTREADY},
    {SRV_SUBSTATE_READY_STR,      SRV_SUBSTATE_READY},
    {SRV_SUBSTATE_IDLE_STR,       SRV_SUBSTATE_IDLE},
    {SRV_SUBSTATE_INITIALISING_STR,   SRV_SUBSTATE_INITIALISING},
    {SRV_SUBSTATE_ENABLING_STR,   SRV_SUBSTATE_ENABLING},
    {SRV_SUBSTATE_ERROR_STR,      SRV_SUBSTATE_ERROR},
    {SRV_SUBSTATE_SETTING_UP_STR, SRV_SUBSTATE_SETTING_UP},
  };
 
  class DataContext {
  public:
    DataContext(Config& config,
                boost::asio::io_service& ios,
                bool with_publisher = true,
                bool with_oldb = true);
 
    virtual ~DataContext();
 
    void ReloadConfig();
 
    void UpdateDb();
    void UpdateDb(utils::bat::DbVector& vec);
 
 
    Config& GetConfig();
 
    short GetState();
    std::string GetStateStr();
    void  SetState(const short state);
    void  SetState(const std::string state);
    short GetSubstate();
    std::string GetSubstateStr();
    void  SetSubstate(const short state);
    void  SetSubstate(const std::string state);
    void  SetSettingState(bool new_state);
    bool  GetSettingState();
 
    void  PublishStates();
 
    /*
    template<typename T>
    void Set(const std::string& key,
             const T& value);
             */
 
    template<typename T>
    void SetAsync(const std::string& key,
             const T& value);
 
 
    DataContext(const DataContext&) = delete;       
    DataContext& operator=(const DataContext&) = delete;  
 
  private:
    Config&                        m_config;        
    std::unique_ptr<utils::bat::DbInterface>   m_db_interface; 
 
    boost::asio::io_service&       m_ios;
    std::unique_ptr<rad::cii::Publisher<stdif::Status>> m_publisher;
 
    short m_state;
    short m_substate;
    std::string m_state_str;
    std::string m_substate_str;
 
    bool m_setting_state {false};
    log4cplus::Logger m_logger;
  };
 
  /*
  template<typename T>
  void DataContext::Set(const std::string& key, const T& value) {
    if (m_db_interface) {
        m_db_interface->Set<T>(key, value);
      }
  }
  */
 
  template<typename T>
  void DataContext::SetAsync(const std::string& key, const T& value) {
    if (m_db_interface) {
        m_db_interface->SetAsync<T>(key, value);
      }
  }
 
}  // namespace devmgr
 
#endif  // DEVMGR_COMMON_DATA_CONTEXT_HPP_