utoa: unsigned to chars

Functions
template<class T>
size_t	c4::utoa (substr buf, T v) noexcept
	convert an integral unsigned decimal to a string.
template<class T>
size_t	c4::utoa (substr buf, T v, T radix) noexcept
	convert an integral unsigned integer to a string, using a specific radix.
template<class T>
size_t	c4::utoa (substr buf, T v, T radix, size_t num_digits) noexcept
	same as c4::utoa(), but pad with zeroes on the left such that the resulting string is num_digits wide.

Detailed Description

Function Documentation

utoa() [1/3]

template<class T>

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

inlinenoexcept

convert an integral unsigned 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 1315 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
    // write_dec() does the buffer length check, so no need to check here
    return write_dec(buf, v);
}

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

utoa() [2/3]

template<class T>

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

inlinenoexcept

convert an integral unsigned 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 1330 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
    unsigned digits = 0;
    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
    {
    case T(10):
        digits = digits_dec(v);
        if C4_LIKELY(buf.len >= digits)
            write_dec_unchecked(buf, v, digits);
        break;
    case T(16):
        digits = digits_hex(v);
        if C4_LIKELY(buf.len >= digits+2u)
        {
            buf.str[0] = '0';
            buf.str[1] = 'x';
            write_hex_unchecked(buf.sub(2), v, digits);
        }
        digits += 2u;
        break;
    case T(2):
        digits = digits_bin(v);
        if C4_LIKELY(buf.len >= digits+2u)
        {
            buf.str[0] = '0';
            buf.str[1] = 'b';
            write_bin_unchecked(buf.sub(2), v, digits);
        }
        digits += 2u;
        break;
    case T(8):
        digits = digits_oct(v);
        if C4_LIKELY(buf.len >= digits+2u)
        {
            buf.str[0] = '0';
            buf.str[1] = 'o';
            write_oct_unchecked(buf.sub(2), v, digits);
        }
        digits += 2u;
        break;
    }
    return digits;
}

utoa() [3/3]

template<class T>

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

inlinenoexcept

same as c4::utoa(), but pad with zeroes on the left such that the resulting string is num_digits wide.

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 1385 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
    unsigned total_digits = 0;
    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
    {
    case T(10):
        total_digits = digits_dec(v);
        total_digits = (unsigned)(num_digits > total_digits ? num_digits : total_digits);
        if C4_LIKELY(buf.len >= total_digits)
            write_dec(buf, v, num_digits);
        break;
    case T(16):
        total_digits = digits_hex(v);
        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
        if C4_LIKELY(buf.len >= total_digits)
        {
            buf.str[0] = '0';
            buf.str[1] = 'x';
            write_hex(buf.sub(2), v, num_digits);
        }
        break;
    case T(2):
        total_digits = digits_bin(v);
        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
        if C4_LIKELY(buf.len >= total_digits)
        {
            buf.str[0] = '0';
            buf.str[1] = 'b';
            write_bin(buf.sub(2), v, num_digits);
        }
        break;
    case T(8):
        total_digits = digits_oct(v);
        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
        if C4_LIKELY(buf.len >= total_digits)
        {
            buf.str[0] = '0';
            buf.str[1] = 'o';
            write_oct(buf.sub(2), v, num_digits);
        }
        break;
    }
    return total_digits;
}