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
 
template<typename T>
inline std::string float_to_string(T value, float_format format)
{
    std::ostringstream oStream;
    oStream.imbue(std::locale::classic());
 
    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(std::locale::classic());
    oStream >> result;
    if (oStream.fail())
    {
        throw std::invalid_argument("not a number");
    }
    return result;
}
 
#endif
 
inline std::pair<int, size_t> get_base(std::string_view value)
{
    const size_t nSignLength = (!value.empty() && (value.front() == '-' || value.front() == '+')) ? 1 : 0;
    const std::string_view strDigits = value.substr(nSignLength);
 
    if (strDigits.size() > 1 && strDigits[0] == '0')
    {
        if (strDigits[1] == 'x' || strDigits[1] == 'X')
        {
            // hexadecimal detected
            return {16, nSignLength + 2};
        }
        if (strDigits[1] == 'b' || strDigits[1] == 'B')
        {
            // binary detected
            return {2, nSignLength + 2};
        }
        if (strDigits[1] >= '0' && strDigits[1] <= '7')
        {
            // octal detected
            return {8, nSignLength + 1};
        }
    }
 
    return {10, nSignLength};
}
 
} // namespace detail
 
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);
}

template<typename T>
inline T to_number(std::string_view value, int base = 0)
{
    T result = 0;
 
    bool negative = false;
    if (base == 0)
    {
        const auto base_helper = detail::get_base(value);
        base = base_helper.first;
 
        // std::from_chars() cannot parse a "0x"/"0b" prefix (sto* does not support 0b), so
        // get_base() reports the prefix length (including a leading sign) to strip. Because a sign
        // that is stripped together with the prefix can no longer be parsed by std::from_chars(),
        // it is remembered here and re-applied afterwards. Octal and decimal values are reported
        // with a zero-length prefix, so their sign is parsed directly by std::from_chars().
        if (base_helper.second > 0)
        {
            negative = !value.empty() && value.front() == '-';
            value = value.substr(base_helper.second);
        }
    }
 
#ifdef STRING_CONV_HAVE_CHAR_CONV
    const auto fnConvert = [&](std::string_view value, auto& result, int base)
    {
        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::out_of_range(strMessage);
            }
 
            throw std::runtime_error(strMessage);
        }
    };
#else
    const auto fnConvert = [&](std::string_view value, auto& result, int base)
    {
        using U = std::decay_t<decltype(result)>;
        try
        {
            if constexpr (std::is_signed_v<U>)
            {
                const auto helper = std::stoll(std::string(value), 0, base);
                if (helper > (std::numeric_limits<U>::max)() || helper < std::numeric_limits<U>::lowest())
                {
                    throw std::out_of_range("out of range");
                }
                result = static_cast<U>(helper);
            }
            else
            {
                const auto helper = std::stoull(std::string(value), 0, base);
                if (helper > (std::numeric_limits<U>::max)())
                {
                    throw std::out_of_range("out of range");
                }
                result = static_cast<U>(helper);
            }
        }
        catch (const std::out_of_range& oError)
        {
            const auto strMessage = "cannot convert string '" + std::string(value) + "' to number: " + oError.what();
            throw std::out_of_range(strMessage);
        }
    };
#endif
 
    if (negative)
    {
        if constexpr (std::is_signed_v<T>)
        {
            // The sign was stripped together with the base prefix, so the bare
            // magnitude is parsed into the unsigned counterpart first. This also
            // allows the most negative value (e.g. "-0x80" -> -128), whose
            // magnitude does not fit into the positive range of the signed type.
            using unsigned_t = std::make_unsigned_t<T>;
            unsigned_t magnitude = 0;
            fnConvert(value, magnitude, base);
 
            const unsigned_t max_magnitude = static_cast<unsigned_t>((std::numeric_limits<T>::max)()) + 1;
            if (magnitude > max_magnitude)
            {
                throw std::out_of_range("cannot convert string '" + std::string(value) + "' to number: " +
                                        std::make_error_code(std::errc::result_out_of_range).message());
            }
 
            result = static_cast<T>(0 - magnitude);
        }
        else
        {
            throw std::runtime_error("cannot convert string '" + std::string(value) +
                                     "' to number: negative value is not representable as an unsigned type");
        }
    }
    else
    {
        fnConvert(value, result, base);
    }
 
    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);
}
 
} // namespace adtf::base::string_conversion