diff options
Diffstat (limited to 'shared/string_tools.h')
| -rw-r--r-- | shared/string_tools.h | 577 |
1 files changed, 411 insertions, 166 deletions
diff --git a/shared/string_tools.h b/shared/string_tools.h index 53365f71..d2e2c597 100644 --- a/shared/string_tools.h +++ b/shared/string_tools.h @@ -1,54 +1,80 @@ // ************************************************************************** -// * This file is part of the FreeFileSync project. It is distributed under * -// * GNU General Public License: http://www.gnu.org/licenses/gpl.html * -// * Copyright (C) 2008-2011 ZenJu (zhnmju123 AT gmx.de) * +// * This file is part of the zenXML project. It is distributed under the * +// * Boost Software License, Version 1.0. See accompanying file * +// * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt. * +// * Copyright (C) 2011 ZenJu (zhnmju123 AT gmx.de) * // ************************************************************************** -// + #ifndef STRING_TOOLS_HEADER_213458973046 #define STRING_TOOLS_HEADER_213458973046 #include <cstddef> //size_t #include <cctype> //isspace #include <cwctype> //iswspace +#include <cwchar> //swprintf +#include <cstdio> //sprintf #include <algorithm> #include <cassert> #include <sstream> #include <functional> #include <vector> +#include "loki/TypeManip.h" +#include "loki/EmptyType.h" #include "loki/TypeTraits.h" +#include "assert_static.h" +#ifdef _MSC_VER +template <> struct Loki::IsCustomUnsignedInt<unsigned __int64> { enum { value = 1 }; }; +template <> struct Loki::IsCustomSignedInt <signed __int64> { enum { value = 1 }; }; +#endif //enhance arbitray string class with useful non-member functions: namespace zen { -template <class C> size_t cStringLength(const C* input); //strlen() -template <class C> bool cStringIsWhiteSpace(C ch); -template <class C> bool cStringIsDigit(C ch); - -template <class S> bool startsWith(const S& str, typename S::value_type prefix); -template <class S> bool startsWith(const S& str, const typename S::value_type* prefix); -template <class S, class T> bool startsWith(const S& str, const T& prefix, typename T::value_type dummy = 0); //SFINAE: T must be a "string" -template <class S> bool endsWith(const S& str, typename S::value_type postfix); -template <class S> bool endsWith(const S& str, const typename S::value_type* postfix); -template <class S, class T> bool endsWith(const S& str, const T& postfix, typename T::value_type dummy = 0); //SFINAE: T must be a "string" - -template <class S> S afterLast (const S& str, typename S::value_type ch); //returns the whole string if ch not found -template <class S> S beforeLast (const S& str, typename S::value_type ch); //returns empty string if ch not found -template <class S> S afterFirst (const S& str, typename S::value_type ch); //returns empty string if ch not found -template <class S> S beforeFirst(const S& str, typename S::value_type ch); //returns the whole string if ch not found +template <class C> size_t cStringLength(const C* str); //strlen() +template <class C> bool cStringIsWhiteSpace(C ch); +template <class C> bool cStringIsDigit(C ch); + +//uniform access to string-like types: classes and character arrays +/* +strBegin(): + std::wstring str(L"dummy"); + char array[] = "dummy"; + const wchar_t* iter = strBegin(str); //returns str.c_str() + const char* iter2 = strBegin(array); //returns array + +strLength(): + strLength(str); //equals str.size() + strLength(array); //equals cStringLength(array) + +StringTraits<>: + StringTraits<std::wstring>::CharType //equals wchar_t + StringTraits<wchar_t[5]> ::CharType //equals wchar_t + StringTraits<const wchar_t*>::isStringLike; //equals "true" + StringTraits<const int*> ::isStringLike; //equals "false" + StringTraits<std::wstring>::isStringClass //equals "true" + StringTraits<wchar_t[5]> ::isStringClass //equals "false" +*/ + +template <class S, class T> bool startsWith(const S& str, const T& prefix); //both S and T can be strings or char/wchar_t arrays or simple char/wchar_t +template <class S, class T> bool endsWith (const S& str, const T& postfix); // + +template <class S, class T> S afterLast (const S& str, const T& ch); //returns the whole string if ch not found +template <class S, class T> S beforeLast (const S& str, const T& ch); //returns empty string if ch not found +template <class S, class T> S afterFirst (const S& str, const T& ch); //returns empty string if ch not found +template <class S, class T> S beforeFirst(const S& str, const T& ch); //returns the whole string if ch not found template <class S, class T> std::vector<S> split(const S& str, const T& delimiter); template <class S> void truncate(S& str, size_t newLen); -template <class S> void replace(S& str, const typename S::value_type* old, const typename S::value_type* replacement, bool replaceAll); +template <class S, class T, class U> void replace(S& str, const T& old, const U& replacement, bool replaceAll = true); template <class S> void trim(S& str, bool fromLeft = true, bool fromRight = true); -//formatted number conversion the C++ way +//high-performance conversion from numbers to strings template <class S, class Num> S toString(const Num& number); template <class Num, class S> Num toNumber(const S& str); - - - +//string to string conversion: converst string-like type into compatible target string class +template <class T, class S> T cvrtString(const S& str); @@ -87,36 +113,31 @@ template <class Num, class S> Num toNumber(const S& str); //---------------------- implementation ---------------------- -template <class C> -inline -size_t cStringLength(const C* input) //strlen() +template <class C> inline +size_t cStringLength(const C* str) //strlen() { - const C* iter = input; - while (*iter != 0) - ++iter; - return iter - input; + assert_static((Loki::IsSameType<C, char>::value || Loki::IsSameType<C, wchar_t>::value)); + size_t len = 0; + while (*str++ != 0) + ++len; + return len; } -template <> -inline +template <> inline bool cStringIsWhiteSpace(char ch) { - const unsigned char usc = ch; //caveat 1: std::isspace() takes an int, but expects an unsigned char - return usc < 128 && //caveat 2: some parts of UTF-8 chars are erroneously seen as whitespace, e.g. the a0 from "\xec\x8b\xa0" (MSVC) - std::isspace(usc) != 0; -} - -template <> -inline -bool cStringIsWhiteSpace(wchar_t ch) -{ - return std::iswspace(ch) != 0; //some compilers (e.g. VC++ 6.0) return true for a call to isspace('\xEA'); but no issue with newer versions of MSVC + //caveat 1: std::isspace() takes an int, but expects an unsigned char + //caveat 2: some parts of UTF-8 chars are erroneously seen as whitespace, e.g. the a0 from "\xec\x8b\xa0" (MSVC) + return static_cast<unsigned char>(ch) < 128 && + std::isspace(static_cast<unsigned char>(ch)) != 0; } +template <> inline bool cStringIsWhiteSpace(unsigned char ch) { return cStringIsWhiteSpace<char>(ch); } +template <> inline bool cStringIsWhiteSpace(signed char ch) { return cStringIsWhiteSpace<char>(ch); } +template <> inline bool cStringIsWhiteSpace(wchar_t ch) { return std::iswspace(ch) != 0; } -template <> -inline +template <> inline bool cStringIsDigit(char ch) { return std::isdigit(static_cast<unsigned char>(ch)) != 0; //caveat: takes an int, but expects an unsigned char @@ -130,85 +151,179 @@ bool cStringIsDigit(wchar_t ch) return std::iswdigit(ch) != 0; } - -template <class S> -inline -bool startsWith(const S& str, typename S::value_type prefix) +namespace implementation { - return str.length() != 0 && str.operator[](0) == prefix; -} +template <class T> +struct UnArray { typedef T NonArrayType; }; +template <class T, int N> +struct UnArray<T[N]> { typedef T NonArrayType; }; -template <class S> -inline -bool startsWith(const S& str, const typename S::value_type* prefix) +template <class T> +struct UnPointer { typedef T NonPtrType; }; + +template <class T> +struct UnPointer<T*> { typedef T NonPtrType; }; + +template <class T> +struct UnReference { typedef T NonRefType; }; + +template <class T> +struct UnReference<T&> { typedef T NonRefType; }; + + +template<typename T> +class HasValueType { - const size_t pfLength = cStringLength(prefix); - if (str.length() < pfLength) - return false; + typedef char Yes[1]; + typedef char No [2]; - return std::equal(str.c_str(), str.c_str() + pfLength, - prefix); -} + template <typename U> class HelperTp {}; + //detect presence of a member type called value_type + template <class U> static Yes& hasMemberValueType(HelperTp<typename U::value_type>*); + template <class U> static No& hasMemberValueType(...); -template <class S, class T> -inline -bool startsWith(const S& str, const T& prefix, typename T::value_type) +public: + enum { Result = sizeof(hasMemberValueType<T>(NULL)) == sizeof(Yes) + }; +}; + + +template<typename T, bool isClassType> +class HasStringMembers { - if (str.length() < prefix.length()) - return false; +public: + enum { Result = false }; +}; - return std::equal(str.c_str(), str.c_str() + prefix.length(), - prefix.c_str()); -} +template<typename T> +class HasStringMembers<T, true> +{ + typedef char Yes[1]; + typedef char No [2]; + + //detect presence of member functions (without specific restriction on return type, within T or one of it's base classes) + template <typename U, U t> class HelperFn {}; + + struct Fallback + { + int c_str; + int length; + }; + + template <class U> + struct Helper2 : public U, public Fallback {}; //U must be a class-type! + + //we don't know the exact declaration of the member attribute (may be in base class), but we know what NOT to expect: + template <class U> static No& hasMemberCstr(HelperFn<int Fallback::*, &Helper2<U>::c_str>*); + template <class U> static Yes& hasMemberCstr(...); + + template <class U> static No& hasMemberLength(HelperFn<int Fallback::*, &Helper2<U>::length>*); + template <class U> static Yes& hasMemberLength(...); +public: + enum { Result = sizeof(hasMemberCstr <T>(NULL)) == sizeof(Yes) && + sizeof(hasMemberLength<T>(NULL)) == sizeof(Yes) + }; +}; + +template <class S, bool isStringClass> struct StringTraits2 { typedef Loki::EmptyType Result; }; //"StringTraits2": fix some VS bug with namespace and partial template specialization +template <class S> struct StringTraits2<S, true> { typedef typename S::value_type Result; }; +template <> struct StringTraits2<char, false> { typedef char Result; }; +template <> struct StringTraits2<wchar_t, false> { typedef wchar_t Result; }; +} template <class S> -inline -bool endsWith(const S& str, typename S::value_type postfix) +struct StringTraits { - const size_t len = str.length(); - return len != 0 && str.operator[](len - 1) == postfix; -} +private: + typedef typename implementation::UnReference<S>::NonRefType NonRefType; + typedef typename Loki::TypeTraits<NonRefType>::NonConstType UndecoratedType; + + typedef typename implementation::UnArray<UndecoratedType>::NonArrayType NonArrayType; + typedef typename implementation::UnPointer<NonArrayType>::NonPtrType NonPtrType; + typedef typename Loki::TypeTraits<NonPtrType>::NonConstType NonConstValType; //handle "const char* const" +public: + enum + { + isStringClass = implementation::HasStringMembers<UndecoratedType, implementation::HasValueType<UndecoratedType>::Result>::Result + }; + typedef typename implementation::StringTraits2<NonConstValType, isStringClass>::Result CharType; -template <class S> -inline -bool endsWith(const S& str, const typename S::value_type* postfix) + enum + { + isStringLike = Loki::IsSameType<CharType, char>::value || Loki::IsSameType<CharType, wchar_t>::value + }; +}; + + +template <class S> inline +const typename StringTraits<S>::CharType* strBegin(const S& str, typename S::value_type dummy = 0) { return str.c_str(); } //SFINAE: T must be a "string" + +template <class Char> +inline const typename StringTraits<Char>::CharType* strBegin(const Char* str) { return str; } +inline const char* strBegin(const char& ch) { return &ch; } +inline const wchar_t* strBegin(const wchar_t& ch) { return &ch; } + + +template <class S> inline +size_t strLength(const S& str, typename S::value_type dummy = 0) { return str.length(); } //SFINAE: T must be a "string" + +template <class Char> +inline size_t strLength(const Char* str) { return cStringLength(str); } +inline size_t strLength(char) { return 1; } +inline size_t strLength(wchar_t) { return 1; } + + +template <class S, class T> inline +bool startsWith(const S& str, const T& prefix) { - const size_t pfLength = cStringLength(postfix); - if (str.length() < pfLength) + assert_static(StringTraits<S>::isStringLike); + assert_static(StringTraits<T>::isStringLike); + + const size_t pfLength = strLength(prefix); + if (strLength(str) < pfLength) return false; - const typename S::value_type* cmpBegin = str.c_str() + str.length() - pfLength; - return std::equal(cmpBegin, cmpBegin + pfLength, - postfix); + return std::equal(strBegin(str), strBegin(str) + pfLength, + strBegin(prefix)); } -template <class S, class T> -inline -bool endsWith(const S& str, const T& postfix, typename T::value_type) +template <class S, class T> inline +bool endsWith(const S& str, const T& postfix) { - if (str.length() < postfix.length()) + assert_static(StringTraits<S>::isStringLike); + assert_static(StringTraits<T>::isStringLike); + + size_t strLen = strLength(str); + size_t pfLen = strLength(postfix); + if (strLen < pfLen) return false; - const typename S::value_type* cmpBegin = str.c_str() + str.length() - postfix.length(); - return std::equal(cmpBegin, cmpBegin + postfix.length(), - postfix.c_str()); + typedef typename StringTraits<S>::CharType CharType; + + const CharType* cmpBegin = strBegin(str) + strLen - pfLen; + return std::equal(cmpBegin, cmpBegin + pfLen, + strBegin(postfix)); } // get all characters after the last occurence of ch // (returns the whole string if ch not found) -template <class S> -inline -S afterLast(const S& str, typename S::value_type ch) +template <class S, class T> inline +S afterLast(const S& str, const T& ch) { + assert_static(StringTraits<T>::isStringLike); + const size_t pos = str.rfind(ch); if (pos != S::npos) - return S(str.c_str() + pos + 1, str.length() - pos - 1); + { + size_t chLen = strLength(ch); + return S(str.c_str() + pos + chLen, str.length() - pos - chLen); + } else return str; } @@ -216,10 +331,11 @@ S afterLast(const S& str, typename S::value_type ch) // get all characters before the last occurence of ch // (returns empty string if ch not found) -template <class S> -inline -S beforeLast(const S& str, typename S::value_type ch) +template <class S, class T> inline +S beforeLast(const S& str, const T& ch) { + assert_static(StringTraits<T>::isStringLike); + const size_t pos = str.rfind(ch); if (pos != S::npos) return S(str.c_str(), pos); //data is non-empty string in this context: else ch would not have been found! @@ -229,13 +345,17 @@ S beforeLast(const S& str, typename S::value_type ch) //returns empty string if ch not found -template <class S> -inline -S afterFirst(const S& str, typename S::value_type ch) +template <class S, class T> inline +S afterFirst(const S& str, const T& ch) { + assert_static(StringTraits<T>::isStringLike); + const size_t pos = str.find(ch); if (pos != S::npos) - return S(str.c_str() + pos + 1, str.length() - pos - 1); + { + size_t chLen = strLength(ch); + return S(str.c_str() + pos + chLen, str.length() - pos - chLen); + } else return S(); @@ -243,11 +363,12 @@ S afterFirst(const S& str, typename S::value_type ch) //returns the whole string if ch not found -template <class S> -inline -S beforeFirst(const S& str, typename S::value_type ch) +template <class S, class T> inline +S beforeFirst(const S& str, const T& ch) { - const size_t pos = str.find(ch, 0); + assert_static(StringTraits<T>::isStringLike); + + const size_t pos = str.find(ch); if (pos != S::npos) return S(str.c_str(), pos); //data is non-empty string in this context: else ch would not have been found! else @@ -255,18 +376,19 @@ S beforeFirst(const S& str, typename S::value_type ch) } -template <class S, class T> -inline +template <class S, class T> inline std::vector<S> split(const S& str, const T& delimiter) { - const S delim = S() + delimiter; //handle char, char* and string + assert_static(StringTraits<T>::isStringLike); + std::vector<S> output; size_t bockStart = 0; - if (!delim.empty()) + size_t delimLen = strLength(delimiter); + if (delimLen != 0) { - for (size_t blockEnd = str.find(delim, bockStart); + for (size_t blockEnd = str.find(delimiter, bockStart); blockEnd != S::npos; - bockStart = blockEnd + delim.size(), blockEnd = str.find(delim, bockStart)) + bockStart = blockEnd + delimLen, blockEnd = str.find(delimiter, bockStart)) { output.push_back(S(str.c_str() + bockStart, blockEnd - bockStart)); } @@ -276,8 +398,7 @@ std::vector<S> split(const S& str, const T& delimiter) } -template <class S> -inline +template <class S> inline void truncate(S& str, size_t newLen) { if (newLen < str.length()) @@ -285,18 +406,19 @@ void truncate(S& str, size_t newLen) } -template <class S> -inline -void replace(S& str, const typename S::value_type* old, const typename S::value_type* replacement, bool replaceAll) +template <class S, class T, class U> inline +void replace(S& str, const T& old, const U& replacement, bool replaceAll) { - const size_t oldLen = cStringLength(old); - const size_t replacementLen = cStringLength(replacement); + assert_static(StringTraits<T>::isStringLike); + assert_static(StringTraits<U>::isStringLike); size_t pos = 0; + size_t oldLen = strLength(old); + size_t repLen = strLength(replacement); while ((pos = str.find(old, pos)) != S::npos) { - str.replace(pos, oldLen, replacement, replacementLen); - pos += replacementLen; //move past the string that was replaced + str.replace(pos, oldLen, replacement); + pos += repLen; //move past the string that was replaced if (!replaceAll) break; @@ -304,8 +426,7 @@ void replace(S& str, const typename S::value_type* old, const typename S::value_ } -template <class S> -inline +template <class S> inline void trim(S& str, bool fromLeft, bool fromRight) { assert(fromLeft || fromRight); @@ -334,93 +455,205 @@ void trim(S& str, bool fromLeft, bool fromRight) } -namespace +namespace implementation { template <class S, class T> struct CnvtStringToString { - T convert(const S& src) const { return T(src.c_str(), src.size()); } + T convert(const S& src) const { return T(strBegin(src), strLength(src)); } }; template <class S> -struct CnvtStringToString<S, S> //optimization: for "basic_string -> basic_string" we don't need a deep copy +struct CnvtStringToString<S, S> //perf: we don't need a deep copy if string types match { - S convert(const S& src) const { return src; } + const S& convert(const S& src) const { return src; } }; +} +template <class T, class S> inline +T cvrtString(const S& str) { return implementation::CnvtStringToString<S, T>().convert(str); } -template <class S, class Num> + +namespace implementation +{ +enum NumberType +{ + NUM_TYPE_SIGNED_INT, + NUM_TYPE_UNSIGNED_INT, + NUM_TYPE_FLOATING_POINT, + NUM_TYPE_OTHER, +}; + + +template <class S, class Num, NumberType> struct CvrtNumberToString { - S convert(const Num& number) const //convert string to number using streams: convenient, but SLOW + S convert(const Num& number) const //default number to string conversion using streams: convenient, but SLOW, SLOW, SLOW!!!! (~ factor of 20) { - typedef typename S::value_type CharType; + typedef typename StringTraits<S>::CharType CharType; std::basic_ostringstream<CharType> ss; ss << number; - return CnvtStringToString<std::basic_string<CharType>, S>().convert(ss.str()); + return cvrtString<S>(ss.str()); } }; -template <class S, class Num, bool isIntegral> -struct CvrtStringToNumber +template <class S, class Num> +struct CvrtNumberToString<S, Num, NUM_TYPE_FLOATING_POINT> { - Num convert(const S& str) const //convert number to string using streams: convenient, but SLOW + S convert(const Num& number) const { return convertFloat(number, typename StringTraits<S>::CharType()); } + +private: + S convertFloat(const Num& number, char) const + { + char buffer[50]; + int charsWritten = std::sprintf(buffer, "%f", static_cast<double>(number)); + return charsWritten > 0 ? S(buffer, charsWritten) : S(); + } + S convertFloat(const Num& number, wchar_t) const { - typedef typename S::value_type CharType; + wchar_t buffer[50]; +#ifdef __MINGW32__ + int charsWritten = ::swprintf(buffer, L"%f", static_cast<double>(number)); //MinGW does not comply to the C standard! +#else + int charsWritten = std::swprintf(buffer, 50, L"%f", static_cast<double>(number)); +#endif + return charsWritten > 0 ? S(buffer, charsWritten) : S(); + } +}; + +/* +perf: integer to string: (executed 10 mio. times) + std::stringstream - 14796 ms + std::sprintf - 3086 ms + hand coded - 778 ms +*/ + +template <class S, class Num> inline +S formatInteger(Num n, bool hasMinus) +{ + assert(n >= 0); + S output; + do + { + output += '0' + n % 10; + n /= 10; + } + while (n != 0); + if (hasMinus) + output += '-'; + + std::reverse(output.begin(), output.end()); + return output; +} +template <class S, class Num> +struct CvrtNumberToString<S, Num, NUM_TYPE_SIGNED_INT> +{ + S convert(const Num& number) const { return formatInteger<S>(number < 0 ? -number : number, number < 0); } +}; + +template <class S, class Num> +struct CvrtNumberToString<S, Num, NUM_TYPE_UNSIGNED_INT> +{ + S convert(const Num& number) const { return formatInteger<S>(number, false); } +}; + +//-------------------------------------------------------------------------------- + +template <class S, class Num, NumberType> +struct CvrtStringToNumber +{ + Num convert(const S& str) const //default string to number conversion using streams: convenient, but SLOW + { + typedef typename StringTraits<S>::CharType CharType; Num number = 0; - std::basic_istringstream<CharType>(CnvtStringToString<S, std::basic_string<CharType> >().convert(str)) >> number; + std::basic_istringstream<CharType>(cvrtString<std::basic_string<CharType> >(str)) >> number; return number; } }; template <class S, class Num> -struct CvrtStringToNumber<S, Num, true> +struct CvrtStringToNumber<S, Num, NUM_TYPE_FLOATING_POINT> { - Num convert(const S& str) const //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic - { - typedef typename S::value_type CharType; + Num convert(const S& str) const { return convertFloat(strBegin(str)); } + +private: + Num convertFloat(const char* str) const { return std::strtod(str, NULL); } + Num convertFloat(const wchar_t* str) const { return std::wcstod(str, NULL); } +}; - const CharType* first = str.c_str(); - const CharType* last = first + str.size(); +template <class Num, class S> +Num extractInteger(const S& str, bool& hasMinusSign) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic +{ + typedef typename StringTraits<S>::CharType CharType; - while (first != last && cStringIsWhiteSpace(*first)) //skip leading whitespace - ++first; + const CharType* first = strBegin(str); + const CharType* last = first + strLength(str); - bool hasMinusSign = false; //handle minus sign - if (first != last) + while (first != last && cStringIsWhiteSpace(*first)) //skip leading whitespace + ++first; + + hasMinusSign = false; //handle minus sign + if (first != last) + { + if (*first == '-') { - if (*first == '-') - { - hasMinusSign = true; - ++first; - } - else if (*first == '+') - ++first; + hasMinusSign = true; + ++first; } + else if (*first == '+') + ++first; + } - Num number = 0; - for (const CharType* iter = first; iter != last; ++iter) + Num number = 0; + for (const CharType* iter = first; iter != last; ++iter) + { + const CharType c = *iter; + if ('0' <= c && c <= '9') + { + number *= 10; + number += c - '0'; + } + else { - const CharType c = *iter; - if ('0' <= c && c <= '9') - { - number *= 10; - number += c - '0'; - } - else - { - assert(std::find_if(iter, last, std::not1(std::ptr_fun(&cStringIsWhiteSpace<CharType>))) == last); //rest of string should contain whitespace only - break; - } + assert(std::find_if(iter, last, std::not1(std::ptr_fun(&cStringIsWhiteSpace<CharType>))) == last); //rest of string should contain whitespace only + break; } + } + return number; +} + +template <class S, class Num> +struct CvrtStringToNumber<S, Num, NUM_TYPE_SIGNED_INT> +{ + Num convert(const S& str) const + { + bool hasMinusSign = false; //handle minus sign + const Num number = extractInteger<Num>(str, hasMinusSign); return hasMinusSign ? -number : number; } }; + + +template <class S, class Num> +struct CvrtStringToNumber<S, Num, NUM_TYPE_UNSIGNED_INT> +{ + Num convert(const S& str) const //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic + { + bool hasMinusSign = false; //handle minus sign + const Num number = extractInteger<Num>(str, hasMinusSign); + if (hasMinusSign) + { + assert(false); + return 0U; + } + return number; + } +}; } @@ -428,15 +661,27 @@ template <class S, class Num> inline S toString(const Num& number) //convert number to string the C++ way { - return CvrtNumberToString<S, Num>().convert(number); + using namespace implementation; + return CvrtNumberToString<S, Num, + Loki::TypeTraits<Num>::isSignedInt ? NUM_TYPE_SIGNED_INT : + Loki::TypeTraits<Num>::isUnsignedInt ? NUM_TYPE_UNSIGNED_INT : + Loki::TypeTraits<Num>::isFloat ? NUM_TYPE_FLOATING_POINT : + NUM_TYPE_OTHER + >().convert(number); } template <class Num, class S> inline -Num toNumber(const S& str) //convert number to string the C++ way +Num toNumber(const S& str) //convert string to number the C++ way { - return CvrtStringToNumber<S, Num, Loki::TypeTraits<Num>::isIntegral>().convert(str); + using namespace implementation; + return CvrtStringToNumber<S, Num, + Loki::TypeTraits<Num>::isSignedInt ? NUM_TYPE_SIGNED_INT : + Loki::TypeTraits<Num>::isUnsignedInt ? NUM_TYPE_UNSIGNED_INT : + Loki::TypeTraits<Num>::isFloat ? NUM_TYPE_FLOATING_POINT : + NUM_TYPE_OTHER + >().convert(str); } } |