configBase.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_CONFIG_BASE_HPP_H_
#define CCF_COMMON_CONFIG_BASE_HPP_H_
 
#include <yaml-cpp/yaml.h>
 
#include <dit/did/Did.hpp>
 
#include <ccf/common/base.hpp>
 
namespace ccf::common {
 
  const std::string CFG_DEF_LOGLEVEL            = "INFO";
 
  const std::string CFG_PRIM_DID                = "dit/stddid/primary.did";
 
  // @{
  const std::string CFG_SYS_NAME                = "sys.name";
  const std::string CFG_SYS_DID                 = "sys.did%d";
  const std::string CFG_SYS_REQ_ENDPOINT        = "sys.req.endpoint";
  const std::string CFG_SYS_DB_ENDPOINT         = "sys.db.endpoint";
  const std::string CFG_SYS_DB_TIMEOUT_SEC      = "sys.db.timeout.sec";
  const std::string CFG_SYS_DB_PREFIX           = "sys.db.prefix";
  const std::string CFG_SYS_SM_SCXML            = "sys.sm.scxml";
  const std::string CFG_SYS_LOG_LEVEL           = "sys.log.level";
  const std::string CFG_SYS_LOG_PROPERTIES      = "sys.log.properties";
  const std::string CFG_SYS_PUB_SUB_ENDPOINT    = "sys.pub_sub.endpoint";
 
  const std::string CFG_SYS_REQ_HIST_SIZE       = "sys.req.hist.size";       // Number lf elements in recoding history.
  const std::string CFG_SYS_REQ_HIST_EXP        = "sys.req.hist.expiration"; // Expiration time in seconds of elements in the rec hist.
 
  const std::string CFG_SYS_SIMULATION          = "sys.simulation";
  // @}
 
  // @{
  const std::string CFG_MON_PERIOD              = "mon.period";
  const std::string CFG_MON_NB_OF_SAMPLES       = "mon.nb_of_samples";
  // @}
 
  // @{
  const std::string CFG_CAM_NAME                = "cam.name";
  const std::string CFG_CAM_ID                  = "cam.id";
  const std::string CFG_CAM_MODEL               = "cam.model";
  const std::string CFG_CAM_CHIP_MODEL          = "cam.chip.model";
  const std::string CFG_CAM_TYPE                = "cam.type";
  const std::string CFG_CAM_MANUFACTURER        = "cam.manufacturer";
  const std::string CFG_CAM_ADAPTER_PROTOCOL    = "cam.adapter.protocol";
  const std::string CFG_CAM_ADAPTER_MAPPING     = "cam.adapter.mapping";
  const std::string CFG_CAM_ADAPTER_API         = "cam.adapter.api";
  const std::string CFG_CAM_ADAPTER_ADDRESS     = "cam.adapter.address";
  const std::string CFG_CAM_ADAPTER_SIM_ADDRESS = "cam.adapter.sim_address";
  const std::string CFG_CAM_ADAPTER_PROPERTY    = "cam.adapter.property%d";
  const std::string CFG_CAM_CHIP_WIDTH          = "cam.chip.width";
  const std::string CFG_CAM_CHIP_HEIGHT         = "cam.chip.height";
  const std::string CFG_CAM_CHIP_MAX_RES        = "cam.chip.max_resolution";
  const std::string CFG_CAM_CHIP_RESOLUTION     = "cam.chip.resolution";
  // @}
 
  // @{
  const std::string CFG_ACQ_LOST_FRAMES          = "acq.allow_lost_frames";
  const std::string CFG_ACQ_FRAME_SKIPPING       = "acq.allow_frame_skipping";
  const std::string CFG_ACQ_PRIORITY             = "acq.priority";
  // @}
 
  const std::string CFG_PROC_SKIP_FRAMES         = "proc%d.allow_frame_skipping";
 
  const std::string CFG_PROC_PRIORITY            = "proc%d.priority";
 
  const std::string CFG_PUB_PRIORITY             = "proc%d.pub%d.priority";
 
  class ConfigBase: public Base {
  public:
 
    // Singleton instance.
    static ConfigBase* s_instance;
 
    static ConfigBase& Instance();
 
    ~ConfigBase();
 
    void Load(const std::string& filename);
 
    const std::string& GetFilename() const;
  
    template <class TYPE> bool HasPar(const std::string& name,
                                      TYPE& value) const {
        CCFTRACE;
        return m_config.HasPar(name, value);
      }
 
    template <class TYPE> TYPE GetValue(const std::string& name) const {
        CCFTRACE;
        TYPE tmp_value;
        m_config.GetValue(name, tmp_value, true);
        return tmp_value;
    }
 
    const dit::did::Did& GetDictionary() const;
 
    uint32_t GetMaxFrameSize();
 
    virtual uint32_t GetMaxFrameSizeUser();
 
    template <class TYPE>
    bool HasAdapterProperty(const std::string& property,
                            TYPE& value) {
      CCFTRACE;
      std::string tmp_value;
      if (_HasAdapterProperty(property, tmp_value)) {
        ctd::conversion::Convert(tmp_value, value);
        return true;
      } else {
        return false;
      }
    }
 
  protected:
    bool _HasAdapterProperty(const std::string& property,
                             std::string& value);
 
  private:
    ConfigBase();
    ctd::file::Yaml  m_config;
    std::string      m_config_filename;
    dit::did::Did    m_dictionary;
  };
 
  inline ConfigBase& GetCfg() {
    return ConfigBase::Instance();
  }
 
}
 
#endif // CCF_COMMON_CONFIG_BASE_HPP_H_