conversion.hpp

Go to the documentation of this file.

#ifndef IFW_CTD_CONVERSION_HPP_
#define IFW_CTD_CONVERSION_HPP_

#include <typeinfo>
#include <iomanip>
#include <variant>

#include "ctd/defines/defines.hpp"
#include "ctd/string/string.hpp"


namespace ctd {
  namespace conversion {

    // 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 = "") {
      RAD_LOG_TRACE();

      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))) {
          char tmp_buf[64];
          char tmp_format[64];
          if (format != "") {
              strncpy(tmp_format, format.c_str(), sizeof(tmp_format));
            } else {
              strncpy(tmp_format, "%%.%df", sizeof(tmp_format));
            }
          double tmp_dbl = static_cast<double>(number);
          snprintf(tmp_buf, sizeof(tmp_buf), tmp_format, tmp_dbl);
          nb_str << tmp_buf;
        } else {
          nb_str << number;
        }
      return nb_str.str();
    }

    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);

    template <typename TYPE>
    void Convert(const std::string& value,
                 ctd::defines::DataType data_type,
                 std::variant<TYPE>& native_value) {
      RAD_LOG_TRACE();

      switch (data_type) {
        case ctd::defines::DataType::DATA_TYPE_BOOLEAN:
          native_value = Boolean(value);
          break;
        case ctd::defines::DataType::DATA_TYPE_INT8:
          native_value = static_cast<int8_t>(std::stoi(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_UINT8:
          native_value = static_cast<uint8_t>(std::stoi(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_INT16:
          native_value = static_cast<int16_t>(std::stoi(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_UINT16:
          native_value = static_cast<uint16_t>(std::stoi(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_INT32:
          native_value = static_cast<int32_t>(std::stoi(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_UINT32:
          native_value = static_cast<uint32_t>(std::stol(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_INT64:
          native_value = static_cast<int64_t>(std::stoll(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_UINT64:
          native_value = static_cast<uint64_t>(std::stoll(value));
          break;
        case ctd::defines::DataType::DATA_TYPE_FLOAT:
          native_value = static_cast<float>(std::atof(value.c_str()));
          break;
        case ctd::defines::DataType::DATA_TYPE_DOUBLE:
          native_value = static_cast<double>(std::strtod(value.c_str(), nullptr));
          break;

          // @todo: Handle:
          // ctd::defines::DataType::DATA_TYPE_NON_BASIC
          // ctd::defines::DataType::DATA_TYPE_TIME_DATE
          // ctd::defines::DataType::DATA_TYPE_TIMESTAMP
          // ctd::defines::DataType::DATA_TYPE_BLOB

        default:
          throw rad::Exception("Illegal data type encountered");
        }
    }

    void Convert(const std::string& str_value,
                 std::string& native_value);

    template <typename TYPE>
    void Convert(const std::string& str_value,
                 TYPE& native_value) {
      RAD_LOG_TRACE();

      const auto type_it = ctd::defines::TYPE_ID_2_DATA_TYPE_MAP.find(typeid(native_value).name());
      if (type_it == ctd::defines::TYPE_ID_2_DATA_TYPE_MAP.end()) {
          throw rad::Exception("Unknown datatype encountered");
        }
      ctd::defines::DataType data_type = type_it->second;
      std::variant<TYPE> tmp_native_value;
      Convert(str_value, data_type, tmp_native_value);
      native_value = std::get<TYPE>(tmp_native_value);
    }

  }
}

#endif // IFW_CTD_CONVERSION_HPP_