deviceConfig.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_
#define FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_
 
// System headers
#include <string>
#include <unordered_map>
 
// Third party headers
#include <yaml-cpp/yaml.h>
 
#include <fcf/common/iComm.hpp>
#include <fcf/devmgr/common/iDeviceConfig.hpp>
#include <fcf/devmgr/common/configSet.hpp>
 
namespace fcf {
  namespace devmgr {
    namespace common {
 
      // Constants for common configuration
      constexpr auto CI_IDENTIFIER             = "identifier";
      constexpr auto CI_SIMULATED              = "simulated";
      constexpr auto CI_IGNORED                = "ignored";
      constexpr auto CI_ADDRESS                = "address";
      constexpr auto CI_SIM_ADDRESS            = "simaddr";
      constexpr auto CI_TYPE                   = "type";
      constexpr auto CI_PREFIX                 = "prefix";
      constexpr auto CI_NAMESPACE              = "namespace";
      constexpr auto CI_MAP_FILE               = "mapfile";
      constexpr auto CI_FITS_PREFIX            = "fits_prefix";
      constexpr auto CI_ALIAS                  = "alias";
      constexpr auto CI_CFG_FILE               = "cfgfile";
      constexpr auto CI_CTRL_CONFIG            = "ctrl_config";
 
      // Constants for common RPC calls
      constexpr auto RPC_INIT                  = "rpcInit";
      constexpr auto RPC_ENABLE                = "rpcEnable";
      constexpr auto RPC_DISABLE               = "rpcDisable";
      constexpr auto RPC_STOP                  = "rpcStop";
      constexpr auto RPC_RESET                 = "rpcReset";
 
      // Constants for common status attributes
      constexpr auto CI_STAT_SUBSTATE          = "substate";
      constexpr auto CI_STAT_STATE             = "state";
      constexpr auto CI_STAT_STATU             = "status";
      constexpr auto CI_STAT_LOCAL             = "local";
      constexpr auto CI_STAT_ERROR_CODE        = "error_code";
      constexpr auto CI_STAT_ERROR_STR         = "error_str";
      constexpr auto DB_CONTROLLER_PREFIX      = "lcs";
 
      // Constants for address categories
      constexpr auto CAT_STAT                  = "stat";
      constexpr auto CAT_CFG                   = "cfg";
      constexpr auto CAT_RPC                   = "rpc";
 
      // Constants for state values
      constexpr int STATE_NOT_OPERATIONAL      =  1;
      constexpr int STATE_OPERATIONAL          =  2;
 
      constexpr auto STATE_NOT_OPERATIONAL_STR =  "NotOperational";
      constexpr auto STATE_OPERATIONAL_STR     =  "Operational";
      constexpr auto STATE_UNAVAILABLE_STR     =  "Unavailable";
 
      const std::unordered_map<short, std::string>  StateMap = {
        {STATE_NOT_OPERATIONAL,       STATE_NOT_OPERATIONAL_STR},
        {STATE_OPERATIONAL,   STATE_OPERATIONAL_STR},
      };
 
      const std::unordered_map<std::string, short>  StateStrMap = {
        {STATE_NOT_OPERATIONAL_STR,       STATE_NOT_OPERATIONAL},
        {STATE_OPERATIONAL_STR,   STATE_OPERATIONAL},
      };
 
      // Constants for substate values
      constexpr int SUBSTATE_NOTREADY        =  100;
      constexpr int SUBSTATE_READY           =  101;
      constexpr int SUBSTATE_INITIALISING    =  102;
      constexpr int SUBSTATE_ERROR           =  199;
 
      constexpr auto SUBSTATE_NOTREADY_STR     =  "NotReady";
      constexpr auto SUBSTATE_INITIALISING_STR =  "Initialising";
      constexpr auto SUBSTATE_READY_STR        =  "Ready";
      constexpr auto SUBSTATE_ERROR_STR        =  "Error";
 
      constexpr int SUBSTATE_OP_DISABLING      =  205;
      constexpr int SUBSTATE_OP_ERROR          =  299;
 
      constexpr auto SUBSTATE_OP_DISABLING_STR =  "Disabling";
      constexpr auto SUBSTATE_OP_ERROR_STR     =  "OpError";
 
      constexpr auto FITS_PARAM_ID             = "ID";
      constexpr auto FITS_PARAM_NAME           = "NAME";
      constexpr auto FITS_PARAM_STAT           = "STAT";
      constexpr auto FITS_PARAM_DEVSIM         = "DEVSIM";
      constexpr auto FITS_PARAM_DEVIGN         = "DEVIGN";
 
      // Type definitions
      using CfgBool    = fcf::devmgr::common::ConfigSet<bool>;
      using CfgShort   = fcf::devmgr::common::ConfigSet<short>;
      using CfgInt     = fcf::devmgr::common::ConfigSet<int>;
      using CfgUInt    = fcf::devmgr::common::ConfigSet<unsigned int>;
      using CfgDouble  = fcf::devmgr::common::ConfigSet<double>;
 
 
      using MapCfgBool   = std::map<int, CfgBool>;
      using MapCfgShort  = std::map<int, CfgShort>;
      using MapCfgInt    = std::map<int, CfgInt>;
      using MapCfgUInt   = std::map<int, CfgUInt>;
      using MapCfgDouble = std::map<int, CfgDouble>;
 
      class DeviceConfig : public IDeviceConfig {
 
      public:
        DeviceConfig(const std::string& filename, const std::string& name);
 
        DeviceConfig(const std::string& name);
 
        virtual ~DeviceConfig();
 
        bool Init();
 
        void InitFromString(std::string config);
 
        void InitFromFile(const std::string& filename);
 
        void CheckConfig();
 
        virtual void ReadConfig();
 
        virtual void GetConfig(fcf::common::VectorVariant& params);
 
        std::string  GetIdentifier();
 
        std::string  GetPrefix();
 
        std::string  GetAddress();
 
        std::string  GetSimAddress();
 
        std::string  GetFitsPrefix();
 
 
        std::string  GetType();
 
        int          GetNamespace();
 
        std::string  GetAlias();
 
        std::string  GetName();
 
        std::string  GetNodeId(const std::string& attrib);
 
        std::string  GetProcId(const std::string& attrib);
 
        std::string  GetObjId();
 
        virtual void GetConfigList(std::vector<std::string>& cfg_list, std::string prefix);
 
        std::string GetCfgFile();
 
        std::string GetCfgAsString();
 
 
        virtual void SetSimulateFlag(bool flag);
 
        virtual void SetIgnoreFlag(bool flag);
 
        virtual bool GetIgnored();
 
        virtual bool GetSimulated();
 
      virtual std::string GetMapFile();
 
      protected:
        // All configuration parameters related to the LCS are stored in
        // dedicated STL maps to make them easilly accessible when downloading
        // the configuration to the LCS.
        MapCfgBool   m_map_cfg_bool;
        MapCfgShort  m_map_cfg_short;
        MapCfgInt    m_map_cfg_int;
        MapCfgUInt   m_map_cfg_uint;
        MapCfgDouble m_map_cfg_double;
 
        std::string         m_filename;    
        std::string         m_name;        
        YAML::Node          m_config_node;  
        std::string         m_identifier;  
        std::string         m_type;        
        std::string         m_fits_prefix;
        bool                m_simulated;
        bool                m_ignored;
        std::string         m_lcs_prefix;
        std::string         m_address;
        std::string         m_sim_address;
        std::string         m_map_file;
        std::string         m_alias;
        int                 m_lcs_namespace;
      };
 
    }
  }
}
 
 
#endif //FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_