string_conversion.h

Go to the documentation of this file.

 
#pragma once
#include <string>
#include <string_view>
#include <sstream>
#include <locale>
#include <array>
#include <limits>
 
#ifdef _WIN32
    #define STRING_CONV_HAVE_CHAR_CONV
    #include <charconv>
#else
    #if defined __has_include
        #if __has_include (<charconv>)
            #include <charconv>
            #ifdef __cpp_lib_to_chars
                #define STRING_CONV_HAVE_CHAR_CONV
            #endif
        #endif
    #endif
#endif
 
namespace adtf::base::string_conversion
{
 
enum class float_format
{
    general = 0,
    scientific = 1,
    fixed = 2,
    hex = 3
};
 
namespace detail
{
 
#ifdef STRING_CONV_HAVE_CHAR_CONV
 
template <typename T>
inline std::string float_to_string(T value, float_format format)
{
    std::chars_format target_format = std::chars_format::fixed;
    switch (format)
    {
        case float_format::general: target_format = std::chars_format::general; break;
        case float_format::fixed: target_format = std::chars_format::fixed; break;
        case float_format::scientific: target_format = std::chars_format::scientific; break;
        case float_format::hex: target_format = std::chars_format::hex; break;
    }
 
    std::array<char, std::numeric_limits<T>::max_exponent10 + 2> buffer {};
    const auto conversion_result = std::to_chars(buffer.data(), buffer.data() + buffer.size(), value, target_format);
    if (conversion_result.ec != std::errc())
    {
        throw std::runtime_error("cannot convert number to string: " + std::make_error_code(conversion_result.ec).message());
    }
    else
    {
        return std::string(buffer.data(), conversion_result.ptr);
    }
}
 
template <typename T>
inline T string_to_float(std::string_view value)
{
    T result = 0;
    const auto conversion_result = std::from_chars(value.data(), value.data() + value.size(), result);
    if (conversion_result.ec != std::errc())
    {
        throw std::runtime_error("cannot convert string '" + std::string(value) + "' to number: " +
                                 std::make_error_code(conversion_result.ec).message());
    }
    return result;
}
 
#else
 
const std::locale& get_c_locale();
 
template <typename T>
inline std::string float_to_string(T value, float_format format)
{
    std::ostringstream oStream;
    oStream.imbue(get_c_locale());
 
    switch (format)
    {
        case float_format::general: break;
        case float_format::fixed: oStream << std::fixed ; break;
        case float_format::scientific: oStream << std::scientific; break;
        case float_format::hex: oStream << std::hexfloat; break;
    }
 
    oStream << value;
 
    return oStream.str();
}
 
template <typename T>
inline T string_to_float(std::string_view value)
{
    T result = {};
    std::istringstream oStream {std::string(value)};
    oStream.imbue(get_c_locale());
    oStream >> result;
    if (oStream.fail())
    {
        throw std::invalid_argument("not a number");
    }
    return result;
}
 
#endif
 
}
 
template <typename T>
inline std::string to_string(T value, float_format /* format */ = float_format::fixed)
{
    return std::to_string(value);
}
 
template <>
inline std::string to_string(float value, float_format format)
{
    return detail::float_to_string(value, format);
}
 
template <>
inline std::string to_string(double value, float_format format)
{
    return detail::float_to_string(value, format);
}
 
std::pair<int, size_t> get_base(std::string_view value);
 
template <typename T>
inline T to_number(std::string_view value, int base = 0)
{
    T result = 0;
 
#ifdef STRING_CONV_HAVE_CHAR_CONV
    if (base == 0)
    {
        const auto base_helper = get_base(value);
        value = value.substr(base_helper.second);
        base = base_helper.first;
    }
    const auto conversion_result = std::from_chars(value.data(), value.data() + value.size(), result, base);
 
    if (conversion_result.ec != std::errc())
    {
        const auto strMessage = "cannot convert string '" + std::string(value) + "' to number: " +
                                std::make_error_code(conversion_result.ec).message();
 
        if (conversion_result.ec == std::errc::result_out_of_range)
        {
            throw std::overflow_error(strMessage);
        }
 
        throw std::runtime_error(strMessage);
    }
#else
    try
    {
        if constexpr(std::is_signed_v<T>)
        {
            const auto helper = std::stoll(std::string(value), 0, base);
            if (helper > std::numeric_limits<T>::max() ||
                helper < std::numeric_limits<T>::lowest())
            {
                throw std::out_of_range("out of range");
            }
            result = static_cast<T>(helper);
        }
        else
        {
            const auto helper = std::stoull(std::string(value), 0, base);
            if (helper > std::numeric_limits<T>::max())
            {
                throw std::out_of_range("out of range");
            }
            result = static_cast<T>(helper);
        }
    }
    catch (const std::out_of_range& oError)
    {
        const auto strMessage = "cannot convert string '" + std::string(value) + "' to number: " + oError.what();
        throw std::overflow_error(strMessage);
    }
#endif
 
    return result;
}
 
template <>
inline float to_number(std::string_view value, int /*base = 10*/)
{
    return detail::string_to_float<float>(value);
}
 
template <>
inline double to_number(std::string_view value, int /*base = 10*/)
{
    return detail::string_to_float<double>(value);
}
 
}