config.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_CONFIG_BASE_HPP_H_
#define CCF_COMMON_CONFIG_BASE_HPP_H_
 
#include <sstream>
 
#include <boost/program_options.hpp>
 
#include <ifw/core/utils/bat/config.hpp>
 
#include <ifw/ccf/common/base.hpp>
 
 
namespace bpo = boost::program_options;
 
namespace ifw::ccf::common {
 
    // Note, no getter's and setter's + members public -- may be OK:
    // https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c131-avoid-trivial-getters-and-setters
    struct DeviceProperty {
        std::string  ToString() const;
 
        std::string  m_name;
        std::string  m_value;
        bool         m_write_on_init;
    };
 
    struct DeviceInfo {
        std::string  ToString() const;
 
        std::string  m_name;
        std::string  m_id;
        std::string  m_type;
        std::string  m_model;
        std::string  m_manufacturer;
        int16_t      m_width;
        int16_t      m_height;
        int8_t       m_max_resolution;
        int8_t       m_resolution;
        std::string  m_data_type;  // Optional: explicit data type (e.g., "Uint16", "Byte")
        std::string  m_protocol;
        std::string  m_mapping;
        std::string  m_sdk;
        std::string  m_address;
        std::string  m_sim_address;
        std::map<std::string, DeviceProperty> m_device_properties;
    };
 
    class Config : public Base {
    public:
        // Singleton instance.
        static Config* s_instance;
 
        static ifw::core::utils::bat::Config s_bat_cfg;
 
        // Contains the devices defined.
        static std::vector<std::string> s_devices;
 
        // Maps "device" name into the associated properties.
        static std::map<std::string, DeviceInfo> s_device_info;

        static Config& Instance();

        static ifw::core::utils::bat::Config& BatCfg();

        const static elt::configng::CiiConfigInstanceNamespace& CiiCfg();
 
        Config();
 
        ~Config();

        bool ParseOptions(int argc, char* argv[]);

        void SetLogProperties(const std::string& filename);

        void LoadConfig(const std::string& filename = "", bool reset = false);

        void GetPars(std::map<std::string, std::string>& pars,
                     const std::string& pattern = "*");

        elt::configng::CiiConfigInstanceNode& GetNode(const std::vector<std::string>& names);

        bool HasNode(const std::vector<std::string>& names, elt::configng::CiiConfigInstanceNode& node);

        template <class TYPE>
        bool HasPar(const std::vector<std::string>& names, TYPE& value) {
            LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
            elt::configng::CiiConfigInstanceNode node;
            try {
                node = GetNode(names);
            } catch (...) {
                return false;
            }
            value = node.As<TYPE>();
            return true;
        }

        bool HasPar(const std::vector<std::string>& names);

        template <class TYPE>
        TYPE Get(const std::vector<std::string>& names) {
            LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
            TYPE value;
            if (!HasPar(names, value)) {
                CCFTHROW("Parameter requested is not defined: " + BuildKey(names));
            }
            return value;
        }

        template <class TYPE>
        void Set(const std::vector<std::string>& names, TYPE& value) {
            LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
            auto node = GetNode(names);
            node = value;
        }

        uint32_t GetMaxFrameSize(const std::string& device = "");

        virtual uint32_t GetMaxFrameSizeUser(const std::string& device = "");

        const DeviceInfo& GetDeviceInfo(const std::string& device = "") const;

        void GetDeviceProperties(std::map<std::string, DeviceProperty>& device_properties,
                                const std::string& device = "") const;

        template <class TYPE>
        bool
        HasDeviceProperty(const std::string& name, TYPE& value, const std::string& device = "") {
            LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
            DeviceProperty prop;
            if (HasDeviceProperty(name, prop, device)) {
                ifw::core::utils::conversion::Convert(prop.m_value, value);
                return true;
            } else {
                return false;
            }
        }

        const bpo::variables_map& GetOptions() const;

        // is returned (see server.devices in the configuration).
        std::string GetDeviceName(const std::string& device = "") const;

        bool HasDeviceProperty(const std::string& name,
                               DeviceProperty& property,
                               const std::string& device="");
 
    template <class TYPE>
    void SetDeviceProperty(const std::string& property, TYPE value, const std::string& device ="") {
        TYPE cur_value;
            if (HasDeviceProperty(property, cur_value, device)) {
        std::stringstream svalue;
        svalue << value;
                auto tmp_device = GetDeviceName(device);
                auto it = s_device_info[tmp_device].m_device_properties.find(property);
        it->second.m_value= svalue.str(); 
            } 
        else {
                CCFTHROW("Trying to set non existing property");
        }
    }
 
 
    protected:
 
    private:
        bpo::variables_map m_options_map;
    };

    inline ifw::ccf::common::Config& GetCfg() {
        return ifw::ccf::common::Config::Instance();
    }
 
}  // namespace ifw::ccf::common
 
#endif  // CCF_COMMON_CONFIG_BASE_HPP_H_