StringToNumber.h

#ifndef ROSE_StringUtility_StringToNumber_H
#define ROSE_StringUtility_StringToNumber_H
 
#include <Rose/StringUtility/NumberToString.h>
 
#include <Rose/StringUtility/Diagnostics.h>
#include <Rose/Exception.h>
#include <rosedll.h>
 
#include <limits>
#include <string>
#include <type_traits>
#include <vector>
#include <Sawyer/Optional.h>
#include <Sawyer/Result.h>
 
namespace Rose {
namespace StringUtility {
 
//                                      Number parsing
 
ROSE_UTIL_API unsigned hexadecimalToInt(char);
 
template<class Container, class Stringifier>
std::vector<std::string> toStrings(const Container &numbers, const Stringifier &stringifier=numberToString) {
    return toStrings_range(numbers.begin(), numbers.end(), stringifier);
}
template<class Iterator, class Stringifier>
std::vector<std::string> toStrings_range(Iterator begin, Iterator end, const Stringifier &stringifier=numberToString) {
    std::vector<std::string> retval;
    for (/*void*/; begin!=end; ++begin)
        retval.push_back(stringifier(*begin));
    return retval;
}
template<class IntegralType>
Sawyer::Optional<typename std::enable_if<std::is_integral<IntegralType>::value, IntegralType>::type>
toDigit(char ch, IntegralType radix = 10) {
    assert(radix <= 16);
    assert(!std::numeric_limits<IntegralType>::is_signed || radix >= 0); // trait test is to avoid compiler warning
    IntegralType digit;
    if (ch >= '0' && ch <= '9') {
        digit = ch - '0';
    } else if (ch >= 'a' && ch <= 'f') {
        digit = ch - 'a' + 10;
    } else if (ch >= 'A' && ch <= 'F') {
        digit = ch - 'A' + 10;
    } else {
        return Sawyer::Nothing();
    }
 
    if (digit < radix)
        return digit;
    return Sawyer::Nothing();
}
 
template<class IntegralType>
typename std::enable_if<std::is_integral<IntegralType>::value, Sawyer::Result<IntegralType, std::string>>::type
toNumber(const std::string &s) {
    using UnsignedType = typename std::make_unsigned<IntegralType>::type;
 
    // No template parameter deduction in constructors before C++17, so make aliases
    using Error = Sawyer::Error<std::string>;
    using Ok = Sawyer::Ok<IntegralType>;
 
    const char *sptr = s.c_str();
 
    // Optional plus or minus sign when parsing signed values
    if ('-' == *sptr || '+' == *sptr) {
        if (std::numeric_limits<IntegralType>::is_signed) {
            ++sptr;
        } else {
            return Error("syntax error: sign not allowed for unsigned types");
        }
    }
    if ('_' == *sptr)
        return Error("syntax error: separator not allowed before first digit");
 
    // Radix specification
    UnsignedType radix = 10;
    if (strncmp("0x", sptr, 2) == 0 || strncmp("0X", sptr, 2) == 0) {
        radix = 16;
        sptr += 2;
    } else if (strncmp("0b", sptr, 2) == 0) {
        radix = 2;
        sptr += 2;
    }
 
    // Number may have a leading digit separator if it has a radix specifier
    if (radix != 10 && '_' == *sptr)
        ++sptr;
 
    // Parse the value as unsigned, but be careful of overflows.
    UnsignedType n = 0;
    size_t nDigits = 0;
    for (size_t i = 0; sptr[i]; ++i) {
        if ('_' == sptr[i]) {
            if (0 == i || '_' == sptr[i-1] || !sptr[i+1])
                return Error("syntax error: invalid use of digit separator");
 
        } else if (Sawyer::Optional<UnsignedType> digit = toDigit(sptr[i], radix)) {
            ++nDigits;
 
            // Check for overflow
            const UnsignedType shifted = n * radix;
            if ((n != 0 && shifted / n != radix) || *digit > std::numeric_limits<UnsignedType>::max() - shifted) {
                if ('-' == s[0]) {
                    return Error("overflow error: less than minimum value for type");
                } else {
                    return Error("overflow error: greater than maximum value for type");
                }
            }
 
            n = shifted + *digit;
        } else {
            return Error("syntax error: invalid digit after parsing " + plural(nDigits, "digits"));
        }
    }
    if (0 == nDigits)
        return Error("syntax error: digits expected");
 
    // Convert the unsigned (positive) value to a signed negative if necessary, checking overflow.
    if (std::numeric_limits<IntegralType>::is_signed) {
        const UnsignedType signBit = (UnsignedType)1 << (8*sizeof(IntegralType) - 1);
        if ('-' == s[0]) {
            if (n & signBit && n != signBit)
                return Error("overflow error: less than minimum value for type");
            return Ok((IntegralType)(~n + 1));
        } else if (n & signBit) {
            return Error("overflow error: greater than maximum value for type");
        } else {
            return Ok((IntegralType)n);
        }
    } else {
        return Ok((IntegralType)n);
    }
}
 
template<class IntegralType>
typename std::enable_if<std::is_integral<IntegralType>::value, IntegralType>::type
toNumberOrThrow(const std::string &s) {
    return toNumber<IntegralType>(s).template orThrow<Exception>();
}
 
} // namespace
} // namespace
 
#endif