4.1

1 files changed, 0 insertions, 687 deletions

diff --git a/shared/string_tools.h b/shared/string_tools.h
deleted file mode 100644
index 8951d942..00000000
--- a/shared/string_tools.h
+++ /dev/null
@@ -1,687 +0,0 @@
-// **************************************************************************
-// * 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* 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, 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);
-
-//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);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//---------------------- implementation ----------------------
-
-template <class C> inline
-size_t cStringLength(const C* str) //strlen()
-{
-    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
-bool cStringIsWhiteSpace(char ch)
-{
-    //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
-bool cStringIsDigit(char ch)
-{
-    return std::isdigit(static_cast<unsigned char>(ch)) != 0; //caveat: takes an int, but expects an unsigned char
-}
-
-
-template <>
-inline
-bool cStringIsDigit(wchar_t ch)
-{
-    return std::iswdigit(ch) != 0;
-}
-
-namespace implementation
-{
-template <class T>
-struct UnArray { typedef T NonArrayType; };
-
-template <class T, int N>
-struct UnArray<T[N]> { typedef T NonArrayType; };
-
-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
-{
-    typedef char Yes[1];
-    typedef char No [2];
-
-    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(...);
-
-public:
-    enum { Result = sizeof(hasMemberValueType<T>(NULL)) == sizeof(Yes)
-         };
-};
-
-
-template<typename T, bool isClassType>
-class HasStringMembers
-{
-public:
-    enum { Result = false };
-};
-
-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>
-struct StringTraits
-{
-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;
-
-    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)
-{
-    assert_static(StringTraits<S>::isStringLike);
-    assert_static(StringTraits<T>::isStringLike);
-
-    const size_t pfLength = strLength(prefix);
-    if (strLength(str) < pfLength)
-        return false;
-
-    return std::equal(strBegin(str), strBegin(str) + pfLength,
-                      strBegin(prefix));
-}
-
-
-template <class S, class T> inline
-bool endsWith(const S& str, const T& postfix)
-{
-    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;
-
-    typedef typename StringTraits<S>::CharType CharType;
-
-    const CharType* cmpBegin = strBegin(str) + strLen - pfLen;
-    return std::equal(cmpBegin, cmpBegin + pfLen,
-                      strBegin(postfix));
-}
-
-
-//returns the whole string if ch not found
-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)
-    {
-        size_t chLen = strLength(ch);
-        return S(str.c_str() + pos + chLen, str.length() - pos - chLen);
-    }
-    else
-        return str;
-}
-
-
-//returns empty string if ch not found
-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!
-    else
-        return S();
-}
-
-
-//returns empty string if ch not found
-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)
-    {
-        size_t chLen = strLength(ch);
-        return S(str.c_str() + pos + chLen, str.length() - pos - chLen);
-    }
-    else
-        return S();
-
-}
-
-
-//returns the whole string if ch not found
-template <class S, class T> inline
-S beforeFirst(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); //data is non-empty string in this context: else ch would not have been found!
-    else
-        return str;
-}
-
-
-template <class S, class T> inline
-std::vector<S> split(const S& str, const T& delimiter)
-{
-    assert_static(StringTraits<T>::isStringLike);
-
-    std::vector<S> output;
-    size_t bockStart = 0;
-    size_t delimLen = strLength(delimiter);
-    if (delimLen != 0)
-    {
-        for (size_t blockEnd = str.find(delimiter, bockStart);
-             blockEnd != S::npos;
-             bockStart = blockEnd + delimLen, blockEnd = str.find(delimiter, bockStart))
-        {
-            output.push_back(S(str.c_str() + bockStart, blockEnd - bockStart));
-        }
-    }
-    output.push_back(S(str.c_str() + bockStart, str.length() - bockStart));
-    return output;
-}
-
-
-template <class S> inline
-void truncate(S& str, size_t newLen)
-{
-    if (newLen < str.length())
-        str.resize(newLen);
-}
-
-
-template <class S, class T, class U> inline
-void replace(S& str, const T& old, const U& replacement, bool replaceAll)
-{
-    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);
-        pos += repLen; //move past the string that was replaced
-
-        if (!replaceAll)
-            break;
-    }
-}
-
-
-template <class S> inline
-void trim(S& str, bool fromLeft, bool fromRight)
-{
-    assert(fromLeft || fromRight);
-
-    typedef typename S::value_type CharType;
-
-    const CharType* newBegin = str.c_str();
-    const CharType* newEnd   = str.c_str() + str.length();
-
-    if (fromRight)
-        while (newBegin != newEnd && cStringIsWhiteSpace(newEnd[-1]))
-            --newEnd;
-
-    if (fromLeft)
-        while (newBegin != newEnd && cStringIsWhiteSpace(*newBegin))
-            ++newBegin;
-
-    const size_t newLength = newEnd - newBegin;
-    if (newLength != str.length())
-    {
-        if (newBegin != str.c_str())
-            str = S(newBegin, newLength); //minor inefficiency: in case "str" is not shared, we could save an allocation and do a memory move only
-        else
-            str.resize(newLength);
-    }
-}
-
-
-namespace implementation
-{
-template <class S, class T>
-struct CnvtStringToString
-{
-    T convert(const S& src) const { return T(strBegin(src), strLength(src)); }
-};
-
-template <class S>
-struct CnvtStringToString<S, S> //perf: we don't need a deep copy if string types match
-{
-    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); }
-
-
-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 //default number to string conversion using streams: convenient, but SLOW, SLOW, SLOW!!!! (~ factor of 20)
-    {
-        typedef typename StringTraits<S>::CharType CharType;
-
-        std::basic_ostringstream<CharType> ss;
-        ss << number;
-        return cvrtString<S>(ss.str());
-    }
-};
-
-
-template <class S, class Num>
-struct CvrtNumberToString<S, Num, NUM_TYPE_FLOATING_POINT>
-{
-    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
-    {
-        wchar_t buffer[50];
-#ifdef __MINGW32__
-        int charsWritten = ::swprintf(buffer, L"%f", static_cast<double>(number)); //MinGW does not comply to the C standard here
-#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>(cvrtString<std::basic_string<CharType> >(str)) >> number;
-        return number;
-    }
-};
-
-
-template <class S, class Num>
-struct CvrtStringToNumber<S, Num, NUM_TYPE_FLOATING_POINT>
-{
-    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); }
-};
-
-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;
-
-    const CharType* first = strBegin(str);
-    const CharType* last  = first + strLength(str);
-
-    while (first != last && cStringIsWhiteSpace(*first)) //skip leading whitespace
-        ++first;
-
-    hasMinusSign = false; //handle minus sign
-    if (first != last)
-    {
-        if (*first == '-')
-        {
-            hasMinusSign = true;
-            ++first;
-        }
-        else if (*first == '+')
-            ++first;
-    }
-
-    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
-        {
-            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;
-    }
-};
-}
-
-
-template <class S, class Num>
-inline
-S toString(const Num& number) //convert number to string the C++ way
-{
-    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 string to number the C++ way
-{
-    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);
-}
-
-}
-
-#endif //STRING_TOOLS_HEADER_213458973046