charconv

Go to the documentation of this file.

// -*- C++ -*-
// SPDX-FileCopyrightText: 2006-2026, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2026, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef SEQAN_STD_CHARCONV_SHIM // to avoid multiple definitions if other seqan modules also implement this
#define SEQAN_STD_CHARCONV_SHIM
 
#include <version> // From C++20 onwards, all feature macros should be defined here.
 
// Workaround for llvm marking float charconv as unavailable
#if defined(__APPLE__) && defined(_LIBCPP_VERSION)
#    ifdef _LIBCPP___CHARCONV_FROM_CHARS_FLOATING_POINT_H
#        warning This file needs to be included before any <charconv> include.
#    endif
#    if __has_include(<__configuration/availability.h>)
#        include <__configuration/availability.h>
#        undef _LIBCPP_AVAILABILITY_FROM_CHARS_FLOATING_POINT
#        define _LIBCPP_AVAILABILITY_FROM_CHARS_FLOATING_POINT /* nothing */
#        undef _LIBCPP_AVAILABILITY_HAS_FROM_CHARS_FLOATING_POINT
#        define _LIBCPP_AVAILABILITY_HAS_FROM_CHARS_FLOATING_POINT /* nothing */
#    endif
#endif
 
#include <charconv>
#include <utility> // __cpp_lib_to_chars may be defined here as currently documented.
 
// =========================================================================
// If float implementation is missing, add our own shim-implementation
// =========================================================================
 
#if __cpp_lib_to_chars < 201611
#    include <algorithm>
#    include <cassert>
#    include <cctype>
#    include <cerrno>
#    include <cstdlib>
#    include <sstream>
#    include <string>
#    include <type_traits>
 
namespace sharg::contrib::charconv_float
{
using ::std::chars_format;
using ::std::from_chars_result;
using ::std::to_chars_result;
 
template <typename value_type>
    requires std::is_floating_point_v<value_type>
inline to_chars_result to_chars_floating_point(char * first, char * last, value_type value) noexcept
{
    assert(first != nullptr);
    assert(last != nullptr);
 
    std::ostringstream ss;
    ss << value;
    auto str = ss.str();
 
    if (last - first < static_cast<std::ptrdiff_t>(str.size()))
        return {last, std::errc::value_too_large};
 
    std::copy(str.begin(), str.end(), first);
 
    return {first + str.size(), std::errc{}};
}
 
template <typename value_type>
    requires std::is_floating_point_v<value_type>
inline from_chars_result from_chars_floating_point(char const * first,
                                                   char const * last,
                                                   value_type & value,
                                                   chars_format fmt = chars_format::general) noexcept
{
    // The locale issue:
    // std::from_chars is documented to be locale independent. The accepted patterns
    // are identical to the one used by strtod in the defailt ("C") locale.
    //
    // The functions strto[d/f/ld] used here are locale dependent but
    // setting the locale manually by std::setlocale is not thread safe.
    // So for the time being this workaround is locale dependent.
    // strto[d/f/ld] skip leading whitespace and accept a leading +, from_chars does neither.
    if (first >= last || *first == '+' || std::isspace(static_cast<unsigned char>(*first)))
        return {first, std::errc::invalid_argument};
 
    auto is_exponent = [](char const c)
    {
        return c == 'e' || c == 'E';
    };
 
    bool const is_negative = *first == '-';
    char const * const digits = first + is_negative;
    bool const is_inf_or_nan = digits != last && (*digits == 'i' || *digits == 'I' || *digits == 'n' || *digits == 'N');
 
    // strto[d/f/ld] parse hexadecimal floats if the sequence has a 0x prefix, from_chars never accepts the prefix:
    // "0x123" is parsed as the value "0" with unparsed remainder "x123". Hence, only the "0" is handed to strto[d/f/ld].
    bool const has_hex_prefix = last - digits >= 2 && digits[0] == '0' && (digits[1] == 'x' || digits[1] == 'X');
    char const * parse_last = has_hex_prefix ? digits + 1 : last;
 
    // If fmt is fixed, the exponent is not part of the pattern and parsing stops before it.
    if (fmt == chars_format::fixed && !is_inf_or_nan)
        parse_last = std::find_if(first, parse_last, is_exponent);
 
    // If fmt is hex, strto[d/f/ld] need the 0x prefix (after the sign) to parse the digits as hexadecimal.
    // The prefix is subtracted from the number of parsed characters afterwards.
    ptrdiff_t const prefix_size = (fmt == chars_format::hex && !is_inf_or_nan) ? 2 : 0;
 
    // In contrast to std::from_chars, std::strto[f/d/ld] does not treat the second
    // parameter (str_end) as "end of the sequence to parse" but merely as an out
    // parameter to indicate where the parsing ended. Therefore, a null-terminated
    // copy of the sequence is needed to ensure correct from_chars functionality.
    // Sequences that do not fit into the stack buffer are copied to the heap.
    constexpr ptrdiff_t stack_buffer_size = 100;
    char stack_buffer[stack_buffer_size];
    std::string heap_buffer;
    ptrdiff_t const buffer_size = (parse_last - first) + prefix_size + 1;
    char * const buffer = [&]()
    {
        if (buffer_size <= stack_buffer_size)
            return &stack_buffer[0];
 
        heap_buffer.resize(buffer_size);
        return heap_buffer.data();
    }();
 
    char * buffer_end = std::copy(first, digits, buffer);
    if (prefix_size)
    {
        *buffer_end++ = '0';
        *buffer_end++ = 'x';
    }
    buffer_end = std::copy(digits, parse_last, buffer_end);
    *buffer_end = '\0';
 
    value_type tmp{};
    char * end;
    int const previous_errno = errno;
    errno = 0;
 
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, float>)
    {
        tmp = strtof(buffer, &end);
    }
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, double>)
    {
        tmp = strtod(buffer, &end);
    }
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, long double>)
    {
        tmp = strtold(buffer, &end);
    }
 
    bool const is_out_of_range = errno == ERANGE;
    errno = previous_errno;
 
    // If only the prepended prefix (or rather its "0") has been parsed, nothing of the original sequence matched.
    char const * const ptr = first + std::max<ptrdiff_t>(0, (end - buffer) - prefix_size);
 
    if (ptr == first)
        return {first, std::errc::invalid_argument};
 
    // If fmt is scientific, the exponent is required.
    if (fmt == chars_format::scientific && !is_inf_or_nan && std::find_if(first, ptr, is_exponent) == ptr)
        return {first, std::errc::invalid_argument};
 
    if (is_out_of_range)
        return {ptr, std::errc::result_out_of_range};
 
    // Success.
    value = tmp;
    return {ptr, {}};
}
 
} // namespace sharg::contrib::charconv_float
 
namespace sharg::contrib::charconv_float
{
// -----------------------------------------------------------------------------
// to_chars for floating point types
// -----------------------------------------------------------------------------
 
template <typename floating_point_type>
    requires std::is_floating_point_v<floating_point_type>
inline to_chars_result to_chars(char * first, char * last, floating_point_type value) noexcept
{
    return to_chars_floating_point(first, last, value);
}
 
// -----------------------------------------------------------------------------
// from_chars for floating point types
// -----------------------------------------------------------------------------
 
template <typename floating_point_type>
    requires std::is_floating_point_v<floating_point_type>
inline from_chars_result from_chars(char const * first,
                                    char const * last,
                                    floating_point_type & value,
                                    chars_format fmt = chars_format::general) noexcept
{
    return from_chars_floating_point(first, last, value, fmt);
}
} // namespace sharg::contrib::charconv_float
 
namespace std
{
// gcc-11 also defines float versions, but they don't clash with ours, because they use explicit overloads for each
// float type. That means the stdlib has a higher priority in overload resolution then our shim implementation.
using ::sharg::contrib::charconv_float::from_chars; // import our shim-float version
using ::sharg::contrib::charconv_float::to_chars;   // import our shim-float version
} // namespace std
 
#endif // __cpp_lib_to_chars < 201611
 
#endif // SEQAN_STD_CHARCONV_SHIM