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 <cassert>
#    include <sstream>
#    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.
    if (*first == '+') // + is permitted in function strto[d/f/ld] but not in from_chars
        return {last, std::errc::invalid_argument};
 
    value_type tmp{};
    constexpr ptrdiff_t buffer_size = 100;
    char buffer[buffer_size];
 
    if (fmt != chars_format::general)
    {
        bool exponent_is_present{false};
        for (auto it = first; it != last; ++it)
        {
            if (*it == 'e' || *it == 'E')
            {
                exponent_is_present = true;
                break;
            }
        }
 
        if (fmt == chars_format::scientific && !exponent_is_present)
            return {last, std::errc::invalid_argument};
 
        if (fmt == chars_format::fixed && exponent_is_present)
            return {last, std::errc::invalid_argument};
    }
 
    // 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, if [last] does
    // not point to the end of a null-terminated string, a buffer is needed to
    // represent the truncated sequence and ensure correct from_chars functionality.
    char * start;
 
    if ((*last != '\0') || fmt == chars_format::hex)
    {
        // If hex format is explicitly expected, the 0x prefix is not allowed in the
        // the original sequence according to the std::from_chars cppreference
        // documentation.
        // In order to use strto[f/d/ld], the prefix must be prepended to achieve
        // correct parsing. This will also automatically lead to an error if the
        // original sequence did contain a 0x prefix and thus reflect the correct
        // requirements of std::from_chars.
        ptrdiff_t offset{0};
        if (fmt == chars_format::hex)
        {
            buffer[0] = '0';
            buffer[1] = 'x';
            offset = 2;
        }
 
        std::copy(first, last, &buffer[offset]);
        buffer[std::min<ptrdiff_t>(buffer_size - offset, last - first)] = '\0';
 
        start = &buffer[0];
    }
    else
    {
        start = const_cast<char *>(first);
    }
 
    char * end;
 
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, float>)
    {
        tmp = strtof(start, &end);
    }
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, double>)
    {
        tmp = strtod(start, &end);
    }
    if constexpr (std::is_same_v<std::remove_reference_t<value_type>, long double>)
    {
        tmp = strtold(start, &end);
    }
 
    last = first + (end - start);
 
    if (errno == ERANGE)
    {
        return {last, std::errc::result_out_of_range};
    }
    else if (tmp == 0 && end == start)
    {
        return {last, std::errc::invalid_argument};
    }
 
    // Success.
    value = tmp;
    return {last, {}};
}
 
} // 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