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  <ifw/fnd/defs/dataType.hpp>
 
#include <ifw/core/utils/base/base.hpp>
#include <ifw/core/utils/conversion/conversion.hpp>
 
 
namespace ifw::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(ifw::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,
                          const ifw::fnd::datatype::DataType data_type =
                            ifw::fnd::datatype::DataType::UNSPECIFIED);

      Parameter& SetValue(const char* value,
                          const ifw::fnd::datatype::DataType data_type =
                            ifw::fnd::datatype::DataType::UNSPECIFIED);

      template <class TYPE>
      Parameter& SetValue(TYPE value) {
        LOG4CPLUS_TRACE_METHOD(ifw::core::utils::base::Logger(), __PRETTY_FUNCTION__);
        m_value = ifw::core::utils::conversion::NbToStr(value);
        return *this;
      }

      const std::string& GetValue() const;

      ifw::fnd::datatype::DataType GetDataType() const;

      bool NoValue() const;

      template <class TYPE>
      void GetValue(TYPE& value) const {
        LOG4CPLUS_TRACE_METHOD(ifw::core::utils::base::Logger(), __PRETTY_FUNCTION__);
         ifw::core::utils::conversion::Convert(m_value, value);
        //value = boost::l_exical_cast<TYPE>(m_value);
      }

      template <class TYPE>
      TYPE GetValue() const {
        LOG4CPLUS_TRACE_METHOD(ifw::core::utils::base::Logger(), __PRETTY_FUNCTION__);
        TYPE tmp_value;
         ifw::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;
 
      ifw::fnd::datatype::DataType m_data_type{ifw::fnd::datatype::DataType::UNSPECIFIED};
 
    private:
      void _Copy(const Parameter& source);
    };
 
}
 
#endif // !IFW_CORE_UTILS_PARAMETER_HPP_