strings_conversion.h

Go to the documentation of this file.

 
#pragma once
#include <array>
#include <iomanip>
#include <limits>
#include <locale>
#include <sstream>
#include <string>
#include <string_view>
 
#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 a_util::strings::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::array<char, std::numeric_limits<T>::max_exponent10 + 2> buffer{};
    std::to_chars_result conversion_result;
    switch (format) {
    case float_format::general: {
        conversion_result = std::to_chars(
            buffer.data(), buffer.data() + buffer.size(), value, std::chars_format::general, 100);
        break;
    }
    case float_format::fixed: {
        conversion_result = std::to_chars(
            buffer.data(), buffer.data() + buffer.size(), value, std::chars_format::fixed);
        break;
    }
    case float_format::scientific: {
        conversion_result = std::to_chars(
            buffer.data(), buffer.data() + buffer.size(), value, std::chars_format::scientific);
        break;
    }
    case float_format::hex: {
        conversion_result = std::to_chars(
            buffer.data(), buffer.data() + buffer.size(), value, std::chars_format::hex);
        break;
    }
    default: {
        throw std::invalid_argument("unknown float 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());
    }
    else if (conversion_result.ptr != value.data() + value.size()) {
        throw std::runtime_error("cannot convert string '" + std::string(value) +
                                 "' to number: trailing chars found");
    }
    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 stream_used;
    stream_used.imbue(get_c_locale());
 
    switch (format) {
    case float_format::general:
        stream_used << std::setprecision(100);
        break;
    case float_format::fixed:
        stream_used << std::fixed;
        break;
    case float_format::scientific:
        stream_used << std::scientific;
        break;
    case float_format::hex:
        stream_used << std::hexfloat;
        break;
    }
 
    stream_used << value;
 
    return stream_used.str();
}
 
template <typename T>
inline T string_to_float(std::string_view value)
{
    T result = {};
    std::istringstream stream_used{std::string(value)};
    stream_used.imbue(get_c_locale());
    stream_used >> result;
    if (stream_used.fail() || !stream_used.eof()) {
        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 a_util::strings::conversion