StringConvertUtil.h

Go to the documentation of this file.

#ifndef ZSERIO_STRING_CONVERT_UTIL_H_INC
#define ZSERIO_STRING_CONVERT_UTIL_H_INC
 
#include <array>
#include <limits>
#include <sstream>
 
#include "zserio/RebindAlloc.h"
#include "zserio/String.h"
 
namespace zserio
{
 
namespace detail
{
 
template <typename T,
        typename std::enable_if<std::is_unsigned<T>::value && !std::is_same<T, bool>::value, int>::type = 0>
const char* convertIntToString(std::array<char, 24>& buffer, T value, bool isNegative)
{
    static const std::array<char, 201> DIGITS = {
            "0001020304050607080910111213141516171819"
            "2021222324252627282930313233343536373839"
            "4041424344454647484950515253545556575859"
            "6061626364656667686970717273747576777879"
            "8081828384858687888990919293949596979899"};
 
    auto bufferEnd = buffer.end();
    *(--bufferEnd) = 0; // always terminate with '\0'
 
    while (value >= 100)
    {
        const unsigned int index = static_cast<unsigned int>((value % 100) * 2);
        value /= 100;
        *(--bufferEnd) = DIGITS[index + 1];
        *(--bufferEnd) = DIGITS[index];
    }
 
    if (value < 10)
    {
        *(--bufferEnd) = static_cast<char>('0' + value);
    }
    else
    {
        const unsigned int index = static_cast<unsigned int>(value * 2);
        *(--bufferEnd) = DIGITS[index + 1];
        *(--bufferEnd) = DIGITS[index];
    }
 
    if (isNegative)
    {
        *(--bufferEnd) = '-';
    }
 
    return &(*bufferEnd);
}
 
} // namespace detail
 
template <typename T, typename std::enable_if<std::is_unsigned<T>::value, int>::type = 0>
const char* convertIntToString(std::array<char, 24>& buffer, T value)
{
    return detail::convertIntToString(buffer, value, false);
}
 
template <typename T, typename std::enable_if<std::is_signed<T>::value, int>::type = 0>
const char* convertIntToString(std::array<char, 24>& buffer, T value)
{
    using unsigned_type = typename std::make_unsigned<T>::type;
    unsigned_type absValue = static_cast<unsigned_type>(value);
    const bool isNegative = value < 0;
    if (isNegative)
    {
        absValue = static_cast<unsigned_type>(0 - absValue);
    }
 
    return detail::convertIntToString(buffer, absValue, isNegative);
}
 
inline void convertFloatToString(std::array<char, 24>& integerPartBuffer,
        std::array<char, 24>& floatingPartBuffer, float value, const char*& integerPartString,
        const char*& floatingPartString)
{
    if (value >= static_cast<float>(std::numeric_limits<int64_t>::max()))
    {
        integerPartString = "+Inf";
        floatingPartString = nullptr;
    }
    else if (value <= static_cast<float>(std::numeric_limits<int64_t>::min()))
    {
        integerPartString = "-Inf";
        floatingPartString = nullptr;
    }
    else
    {
        const int64_t integerPart = static_cast<int64_t>(value);
        const int64_t floatingPart =
                static_cast<int64_t>((value - static_cast<float>(integerPart)) * 1e3F); // 3 digits
        const int64_t floatingPartAbs = (floatingPart < 0) ? 0 - floatingPart : floatingPart;
        integerPartString = convertIntToString(integerPartBuffer, integerPart);
        floatingPartString = convertIntToString(floatingPartBuffer, floatingPartAbs);
    }
}
 
inline const char* convertBoolToString(bool value)
{
    return value ? "true" : "false";
}
 
template <typename ALLOC, typename T>
string<ALLOC> toString(T value, const ALLOC& allocator = ALLOC())
{
    std::array<char, 24> buffer = {};
    return string<ALLOC>(convertIntToString(buffer, value), allocator);
}
 
template <typename ALLOC>
string<ALLOC> toString(bool value, const ALLOC& allocator = ALLOC())
{
    return string<ALLOC>(convertBoolToString(value), allocator);
}
 
template <typename T>
string<std::allocator<char>> toString(T value)
{
    return toString<std::allocator<char>>(value);
}
 
} // namespace zserio
 
#endif // ifndef ZSERIO_STRING_CONVERT_UTIL_H_INC