conversion.hpp

Go to the documentation of this file.

#ifndef IFW_CTD_CONVERSION_HPP_
#define IFW_CTD_CONVERSION_HPP_

#include <typeinfo>
#include <iomanip>

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


namespace ctd {
namespace conversion {

template <class 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 = true);

template <class TYPE> std::string TypeName(TYPE instance) {
    RAD_LOG_TRACE();

    return typeid(instance).name();
}

class Value {
public:
    explicit Value(const std::string& name = "") {
        RAD_LOG_TRACE();

        m_value = NULL;
        m_name = name;
    }

    ~Value() {
        RAD_LOG_TRACE();

        if (m_value != NULL) {
            free(m_value);
        }
    }

    template <class TYPE> void SetValue(const TYPE& value) {
        RAD_LOG_TRACE();

        if (!ctd::defines::SupportedType(value)) {
            if (m_name != "") {
                throw rad::Exception(ifw::Print("Illegal data type encountered %s. Variable: %s",
                                                typeid(value).name()), m_name.c_str());
            } else {
                throw rad::Exception(ifw::Print("Illegal data type encountered %s",
                                                typeid(value).name()));
            }
        }
        if (typeid(value) == typeid(static_cast<std::string>(""))) {
            std::stringstream tmp_str;
            tmp_str << value;
            m_string_value = tmp_str.str();
        } else {
            m_value = malloc(sizeof(TYPE));
            memcpy(m_value, &value, sizeof(TYPE));
        }
        m_type = ctd::defines::TypeId2DataTypeMap().at(typeid(value).name());
    }

    void* GetValue() {
        RAD_LOG_TRACE();

        if (m_type == ctd::defines::DATA_TYPE_STRING) {
            return &m_string_value;
        }
        return m_value;
    }

private:
    std::string m_name;
    ctd::defines::DataType m_type;
    void* m_value;
    std::string m_string_value;
};

void Convert(const std::string& value,
             ctd::defines::DataType data_type,
             Value& native_value);

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

    std::map<std::string, ctd::defines::DataType>::const_iterator type_it =
            ctd::defines::TypeId2DataTypeMap().find(typeid(native_value).name());
    if (type_it == ctd::defines::TypeId2DataTypeMap().end()) {
        throw rad::Exception("Unknown datatype encountered");
    }
    ctd::defines::DataType data_type = type_it->second;
    Value tmp_native_value;
    Convert(str_value, data_type, tmp_native_value);
    native_value = *(static_cast<TYPE*>(tmp_native_value.GetValue()));
}

} // namespace conversion
} // namespace ctd


#endif // IFW_CTD_CONVERSION_HPP_