parameter.hpp

Go to the documentation of this file.

 
#ifndef IFW_CORE_UTILS_PARAMETER_HPP_
#define IFW_CORE_UTILS_PARAMETER_HPP_
 
#include <string>
 
#include <boost/lexical_cast.hpp>
 
#include <core/utils/base/base.hpp>
#include <core/utils/conversion/conversion.hpp>
 
 
namespace core::utils::param {
 
    const std::string NO_VALUE = "__NO__VALUE__";
 
    class Parameter {
    public:
 
      Parameter();
 
      Parameter(const std::string name,
                const std::string value,
                const std::string comment = "");
 
      template <class TYPE>
      Parameter(const std::string name,
                const TYPE& value,
                const std::string comment = "") {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
        SetName(name);
        SetValue(value);
        SetComment(comment);
      }
 
      Parameter(const Parameter& source);
 
      ~Parameter();
 
      Parameter& Clear();
 
      Parameter& SetName(const std::string name);
 
      Parameter& SetLowLevelName(const std::string name);
 
      Parameter& SetMetaName(const std::string name);
 
      bool NameDefined(const std::string& name, const bool tolerant = false) const;
 
      bool MatchName(const std::string& name_regex) const;
 
      const std::string& GetName() const;
 
      const std::string& GetLowLevelName() const;
 
      const std::string& GetMetaName() const;
 
      std::string GetNames() const;
 
      Parameter& SetValue(const std::string& value);
 
      Parameter& SetValue(const char* value);
 
      template <class TYPE>
      Parameter& SetValue(TYPE value) {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
        m_value = core::utils::conversion::NbToStr(value);
        return *this;
      }
 
      const std::string& GetValue() const;
 
      bool NoValue() const;
 
      template <class TYPE>
      void GetValue(TYPE& value) const {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
        core::utils::conversion::Convert(m_value, value);
        //value = boost::l_exical_cast<TYPE>(m_value);
      }
 
      template <class TYPE>
      TYPE GetValue() const {
        LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
        TYPE tmp_value;
        core::utils::conversion::Convert(m_value, tmp_value);
        return tmp_value;
        //return boost::l_exical_cast<TYPE>(m_value);
      }
 
      bool GetValueAsBool() const;
 
      int64_t GetValueAsInt() const;
 
      int64_t GetValueAsInt64() const;
 
      double GetValueAsDouble() const;
 
      Parameter& SetComment(const std::string& comment);
 
      const std::string& GetComment() const;
 
      std::string ToString() const;
 
      Parameter& operator = (const Parameter& source);
 
    protected:
      std::string m_name;
      std::string m_low_level_name;
      std::string m_meta_name;
      std::string m_value;
      std::string m_comment;
      std::string m_no_value;
 
    private:
      void _Copy(const Parameter& source);
    };
 
}
 
#endif // !IFW_CORE_UTILS_PARAMETER_HPP_