conversion.hpp

Go to the documentation of this file.

 
#ifndef IFW_CORE_UTILS_CONVERSION_HPP_
#define IFW_CORE_UTILS_CONVERSION_HPP_
 
#include <typeinfo>
#include <iomanip>
#include <variant>
#include <iostream>
 
#include <boost/lexical_cast.hpp>
#include <boost/exception/diagnostic_information.hpp>
 
#include <core/utils/base/base.hpp>
#include <core/utils/string/string.hpp>
 
 
namespace core::utils::conversion {
 
    std::string DblToString(const double dbl_val,
                            const std::string& prec_or_format = "3");
 
    std::string BoolToString(const bool bool_val,
                             const bool long_format = true);
 
    bool Boolean(const std::string& value,
                 const bool permissive = false);
 
    // TODO: Check if this function can be replaced with some C++/Boost/fmtlib.net function.
    template <typename TYPE>
    std::string NbToStr(const TYPE number,
                        const std::string& format = "") {
      LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
 
      std::stringstream nb_str;
      if ((typeid(number) == typeid(uint8_t)) || (typeid(number) == typeid(int8_t))) {
          nb_str << int(number);
      } else if ((typeid(number) == typeid(float)) || (typeid(number) == typeid(double))) {
          std::string dbl_str;
          try {
            dbl_str = DblToString(static_cast<double>(number), format);
          } catch (...) {
            dbl_str = DblToString(static_cast<double>(number), "6");
          }
          nb_str << dbl_str;
      } else {
          nb_str << number;
      }
      return nb_str.str();
    }
 
 
    // This function is needed to avoid a compilation warning.
    void Convert(const std::string& str_value,
                  std::string& native_value);
 
    template <typename TYPE>
    void Convert_(const std::string& str_value,
                  std::variant<TYPE>& native_value) {
      LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
      // Special handling for the types: int8_t, uint8_t, bool.
      //      if (std::type_index(typeid(TYPE)) == std::type_index(typeid(int8_t))) {
      if (typeid(TYPE) == typeid(int8_t)) {
        native_value = static_cast<TYPE>(std::stoi(str_value));
      } else if (typeid(TYPE) == typeid(uint8_t)) {
        native_value = static_cast<TYPE>(std::stoi(str_value));
      } else if (typeid(TYPE) == typeid(bool)) {
        native_value = static_cast<TYPE>(Boolean(str_value));
      } else {
         native_value = boost::lexical_cast<TYPE>(str_value);
      }
    }
 
    template <typename TYPE>
    void Convert(const std::string& str_value,
                 TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(core::utils::base::Logger(), __PRETTY_FUNCTION__);
      try {
        std::variant<TYPE> tmp_native_value;
        Convert_(str_value, tmp_native_value);
        value = std::get<TYPE>(tmp_native_value);
      } catch (...) {
        std::string err = ("Error converting value: |" + str_value + "| from string to native type (typeid()): |" + typeid(TYPE).name() 
          + "|. Error: " + boost::current_exception_diagnostic_information());
        throw std::runtime_error(err);
      }
    }
 
}
 
#endif // IFW_CORE_UTILS_CONVERSION_HPP_