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 <Sawyer/Parse.h>

#include <vector>

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) {
    return Sawyer::parse<IntegralType>(s);
}

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