itoa: signed to chars

Functions
template<class T>
size_t	c4::itoa (substr buf, T v) noexcept
	convert an integral signed decimal to a string.
template<class T>
size_t	c4::itoa (substr buf, T v, T radix) noexcept
	convert an integral signed integer to a string, using a specific radix.
template<class T>
size_t	c4::itoa (substr buf, T v, T radix, size_t num_digits) noexcept
	same as c4::itoa(), but pad with zeroes on the left such that the resulting string is num_digits wide, not accounting for radix prefix (0x,0o,0b).

Detailed Description

Function Documentation

itoa() [1/3]

template<class T>

size_t c4::itoa ( substr buf, T v )

inlinenoexcept

convert an integral signed decimal to a string.

Note

the resulting string is NOT zero-terminated.

it is ok to call this with an empty or too-small buffer; no writes will occur, and the needed size will be returned

Returns

the number of characters required for the buffer.

Definition at line 1120 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_signed<T>::value);
    if(v >= T(0))
    {
        // write_dec() checks the buffer size, so no need to check here
        return write_dec(buf, v);
    }
    // when T is the min value (eg i8: -128), negating it
    // will overflow, so treat the min as a special case
    if C4_LIKELY(v != std::numeric_limits<T>::min())
    {
        v = (T)-v;
        unsigned digits = digits_dec(v);
        if C4_LIKELY(buf.len >= digits + 1u)
        {
            buf.str[0] = '-';
            write_dec_unchecked(buf.sub(1), v, digits);
        }
        return digits + 1u;
    }
    return detail::_itoadec2buf<T>(buf);
}

Referenced by to_chars(), to_chars(), to_chars(), to_chars(), to_chars(), to_chars(), to_chars(), to_chars(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), xtoa(), and xtoa().

itoa() [2/3]

template<class T>

size_t c4::itoa ( substr buf, T v, T radix )

inlinenoexcept

convert an integral signed integer to a string, using a specific radix.

The radix must be 2, 8, 10 or 16.

Note

the resulting string is NOT zero-terminated.

it is ok to call this with an empty or too-small buffer; no writes will occur, and the needed size will be returned

Returns

the number of characters required for the buffer.

Definition at line 1152 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_signed<T>::value);
    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
    C4_SUPPRESS_WARNING_GCC_PUSH
    #if (defined(__GNUC__) && (__GNUC__ >= 7))
        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc has a false positive here
    #endif
    // when T is the min value (eg i8: -128), negating it
    // will overflow, so treat the min as a special case
    if C4_LIKELY(v != std::numeric_limits<T>::min())
    {
        unsigned pos = 0;
        if(v < 0)
        {
            v = (T)-v;
            if C4_LIKELY(buf.len > 0)
                buf.str[pos] = '-';
            ++pos;
        }
        unsigned digits = 0;
        switch(radix) // NOLINT(hicpp-multiway-paths-covered)
        {
        case T(10):
            digits = digits_dec(v);
            if C4_LIKELY(buf.len >= pos + digits)
                write_dec_unchecked(buf.sub(pos), v, digits);
            break;
        case T(16):
            digits = digits_hex(v);
            if C4_LIKELY(buf.len >= pos + 2u + digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'x';
                write_hex_unchecked(buf.sub(pos + 2), v, digits);
            }
            digits += 2u;
            break;
        case T(2):
            digits = digits_bin(v);
            if C4_LIKELY(buf.len >= pos + 2u + digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'b';
                write_bin_unchecked(buf.sub(pos + 2), v, digits);
            }
            digits += 2u;
            break;
        case T(8):
            digits = digits_oct(v);
            if C4_LIKELY(buf.len >= pos + 2u + digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'o';
                write_oct_unchecked(buf.sub(pos + 2), v, digits);
            }
            digits += 2u;
            break;
        }
        return pos + digits;
    }
    C4_SUPPRESS_WARNING_GCC_POP
    // when T is the min value (eg i8: -128), negating it
    // will overflow
    return detail::_itoa2buf<T>(buf, radix);
}

itoa() [3/3]

template<class T>

size_t c4::itoa ( substr buf, T v, T radix, size_t num_digits )

inlinenoexcept

same as c4::itoa(), but pad with zeroes on the left such that the resulting string is num_digits wide, not accounting for radix prefix (0x,0o,0b).

The radix must be 2, 8, 10 or 16.

Note

the resulting string is NOT zero-terminated.

it is ok to call this with an empty or too-small buffer; no writes will occur, and the needed size will be returned

Returns

the number of characters required for the buffer.

Definition at line 1229 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_signed<T>::value);
    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
    C4_SUPPRESS_WARNING_GCC_PUSH
    #if (defined(__GNUC__) && (__GNUC__ >= 7))
        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc has a false positive here
    #endif
    // when T is the min value (eg i8: -128), negating it
    // will overflow, so treat the min as a special case
    if C4_LIKELY(v != std::numeric_limits<T>::min())
    {
        unsigned pos = 0;
        if(v < 0)
        {
            v = (T)-v;
            if C4_LIKELY(buf.len > 0)
                buf.str[pos] = '-';
            ++pos;
        }
        unsigned total_digits = 0;
        switch(radix) // NOLINT(hicpp-multiway-paths-covered)
        {
        case T(10):
            total_digits = digits_dec(v);
            total_digits = pos + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
            if C4_LIKELY(buf.len >= total_digits)
                write_dec(buf.sub(pos), v, num_digits);
            break;
        case T(16):
            total_digits = digits_hex(v);
            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
            if C4_LIKELY(buf.len >= total_digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'x';
                write_hex(buf.sub(pos + 2), v, num_digits);
            }
            break;
        case T(2):
            total_digits = digits_bin(v);
            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
            if C4_LIKELY(buf.len >= total_digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'b';
                write_bin(buf.sub(pos + 2), v, num_digits);
            }
            break;
        case T(8):
            total_digits = digits_oct(v);
            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
            if C4_LIKELY(buf.len >= total_digits)
            {
                buf.str[pos + 0] = '0';
                buf.str[pos + 1] = 'o';
                write_oct(buf.sub(pos + 2), v, num_digits);
            }
            break;
        }
        return total_digits;
    }
    C4_SUPPRESS_WARNING_GCC_POP
    // when T is the min value (eg i8: -128), negating it
    // will overflow
    return detail::_itoa2buf<T>(buf, radix, num_digits);
}