parameterSet.hpp

Go to the documentation of this file.

 
#ifndef IFW_CORE_UTILS_PARAMETER_SET_HPP_
#define IFW_CORE_UTILS_PARAMETER_SET_HPP_
 
#include <core/utils/base/base.hpp>
#include <core/utils/param/parameter.hpp>
 
 
 
namespace core::utils::param {
 
    class ParameterSet {
    public:
 
      ParameterSet();
 
      ParameterSet(const ParameterSet& source);
 
      ~ParameterSet();
 
      static std::string ToString(std::vector<core::utils::param::Parameter>& par_list);
 
      ParameterSet& Clear();
 
      void Store(const std::string& par_name,
                 const std::string& value,
                 const std::string& comment = "");
 
      std::string GetValue(const std::string& par_name,
                           const bool exception = false) const;
 
      template <class TYPE>
      bool GetValue(const std::string& name,
                    TYPE& value,
                    const bool exception = false) const {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
 
        core::utils::param::Parameter tmpPar;
        if (HasPar(name, tmpPar)) {
            tmpPar.GetValue(value);
        } else {
            if (exception) {
                throw std::runtime_error("Undefined parameter name: " + name);
            } else {
                return false;
            }
        }
        return true;
      }
 
      const core::utils::param::Parameter& GetPar(const std::string& par_name) const;
 
      bool HasPar(const std::string& par_name) const;
 
      bool HasPar(const std::string& par_name,
                  core::utils::param::Parameter& parameter) const;
 
      bool HasPar(const std::string& par_name,
                  std::string& value) const;
 
      template <class TYPE>
      bool HasPar(const std::string& par_name,
                  TYPE& value) const {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
 
        core::utils::param::Parameter tmpPar;
        if (HasPar(par_name, tmpPar)) {
            tmpPar.GetValue(value);
        } else {
            return false;
        }
        return true;
      }
 
      uint32_t Scan(const std::string& filter_reg_exp,
                    std::vector<core::utils::param::Parameter>& matches) const;
 
      std::string ToString(const std::string& filter_reg_exp = "") const;
 
      std::vector<std::string> ParNames() const;
 
      const std::map<std::string, core::utils::param::Parameter>& GetParameterMap() const;
 
      void Merge(const ParameterSet& source_set);
 
      ParameterSet& operator = (const ParameterSet& source);
 
    protected:
      // Mapping keywords into the associated values.
      std::map<std::string, core::utils::param::Parameter> m_par_map;
 
      void _Copy(const ParameterSet& source);
 
    private:
 
    };
 
}
 
#endif // !IFW_CORE_UTILS_PARAMETER_SET_HPP_