string.h

Go to the documentation of this file.

#ifndef _STRINGTEMPLATE_CLASS_HEADER_
#define _STRINGTEMPLATE_CLASS_HEADER_
 
#include <cstdio>
#include <cstdarg>
#ifdef _MSC_VER
    #include <sal.h>
#endif
 
namespace A_UTILS_NS
{

template <class storageT> class string_list_base;

template <class storageT>
class string_base
{
    public:// public definitions
        //StorageType
        typedef string_base<storageT>                           _myType;
        typedef storageT                                        _StorageType;
 
        //has to be of type tChar, char or tUInt8
        typedef typename _StorageType::value_type               value_type;

        typedef typename _StorageType::iterator                 iterator;
        typedef typename _StorageType::const_iterator           const_iterator;
        typedef typename _StorageType::reverse_iterator         reverse_iterator;
        typedef typename _StorageType::const_reverse_iterator   const_reverse_iterator;
 
    public:
        static const _myType Empty;
        static const tSize   InvalidPos;
    private:
        _StorageType      m_oStorageBuffer;
 
    public:
        string_base()
        {
            Clear();
        }
        string_base() {…}

        string_base(const _myType& strValue)
        {
            Set(strValue);
        }
        string_base(const _myType& strValue) {…}

        string_base& operator=(const _myType& strValue)
        {
            if (this != &strValue)
            {
                Set(strValue);
            }
            return *this;
        }
        string_base& operator=(const _myType& strValue) {…}

        string_base(_myType&& strValue)
        {
            Set(strValue);
        }
        string_base(_myType&& strValue) {…}

        string_base& operator=(_myType&& strValue)
        {
            if (this != &strValue)
            {
                Set(strValue);
            }
            return *this;
        }
        string_base& operator=(_myType&& strValue) {…}

        template<class T2>
        string_base(const string_base<T2>& strValue)
        {
            Set(strValue.GetPtr());
        }
        string_base(const string_base<T2>& strValue) {…}

        template<class T2>
        string_base& operator=(const string_base<T2>& strValue)
        {
            Set(strValue.GetPtr());
            return *this;
        }
        string_base& operator=(const string_base<T2>& strValue) {…}

        string_base(const _StorageType& strValue)
        {
            m_oStorageBuffer = strValue;
        }
        string_base(const _StorageType& strValue) {…}

        string_base& operator=(const _StorageType& strValue)
        {
            m_oStorageBuffer = strValue;
            return *this;
        }
        string_base& operator=(const _StorageType& strValue) {…}

        string_base(const tChar& strValue)
        {
            Set(strValue, 1);
        }
        string_base(const tChar& strValue) {…}

        string_base& operator=(const tChar& strValue)
        {
            Set(strValue, 1);
            return *this;
        }
        string_base& operator=(const tChar& strValue) {…}

        string_base(const tChar* strValue)
        {
            Set(strValue);
        }
        string_base(const tChar* strValue) {…}

        string_base(const tChar* strValue, tSize szLength)
        {
            Set(strValue, szLength);
        }
        string_base(const tChar* strValue, tSize szLength) {…}

        string_base& operator=(const tChar* strValue)
        {
            Set(strValue);
            return *this;
        }
        string_base& operator=(const tChar* strValue) {…}

        virtual ~string_base()
        {
            //value_type must be tChar or tUInt8
            static_assert(std::is_same<value_type, tChar>::value
                || std::is_same<value_type, tUInt8>::value,
                "storageT::value_type must be tChar or tUInt8 and specified !!");
        }
        virtual ~string_base() {…}

        iterator begin()
        {
            return m_oStorageBuffer.begin();
        }
        iterator begin() {…}

        iterator end()
        {
            return m_oStorageBuffer.end();
        }
        iterator end() {…}

        reverse_iterator rbegin()
        {
            return m_oStorageBuffer.rbegin();
        }
        reverse_iterator rbegin() {…}

        reverse_iterator rend()
        {
            return m_oStorageBuffer.rend();
        }
        reverse_iterator rend() {…}

        const_iterator cbegin() const
        {
            return m_oStorageBuffer.cbegin();
        }
        const_iterator cbegin() const {…}

        const_iterator cend() const
        {
            return m_oStorageBuffer.cend();
        }
        const_iterator cend() const {…}

        const_reverse_iterator crbegin() const
        {
            return m_oStorageBuffer.crbegin();
        }
        const_reverse_iterator crbegin() const {…}

        const_reverse_iterator crend() const
        {
            return m_oStorageBuffer.crend();
        }
        const_reverse_iterator crend() const {…}

        tVoid Clear()
        {
            m_oStorageBuffer.clear();
        }
        tVoid Clear() {…}

        _myType& Set(const _myType& strStringToSet, tSize nLength = InvalidPos)
        {
            if (nLength == InvalidPos)
            {
                m_oStorageBuffer.assign(strStringToSet.m_oStorageBuffer);
            }
            else
            {
                m_oStorageBuffer.assign(strStringToSet.m_oStorageBuffer, 0, nLength);
            }
            return *this;
        }
        _myType& Set(const _myType& strStringToSet, tSize nLength = InvalidPos) {…}

        _myType& Set(const tChar* pString, tSize nLength = InvalidPos)
        {
            if (pString != nullptr)
            {
                if (nLength == InvalidPos)
                {
                    m_oStorageBuffer.assign(pString);
                }
                else
                {
                    m_oStorageBuffer.assign(pString, nLength);
                }
            }
            return *this;
        }
        _myType& Set(const tChar* pString, tSize nLength = InvalidPos) {…}

        _myType& Set(tChar c, tSize nCount)
        {
            if (nCount > 0 && nCount != InvalidPos)
            {
                m_oStorageBuffer.assign(nCount, c);
            }
 
            return *this;
        }
        _myType& Set(tChar c, tSize nCount) {…}

        tSize GetLength() const
        {
            return cStringUtil::GetLength(GetPtr());
        }
        tSize GetLength() const {…}

        tSize SetBuffer(tSize szSize)
        {
            if (szSize != InvalidPos)
            {
                m_oStorageBuffer.resize(szSize);
                if (GetBufferSize() >= szSize)
                {
                    return szSize;
                }
                else
                {
                    return InvalidPos;
                }
            }
            else
            {
                return szSize;
            }
        }
        tSize SetBuffer(tSize szSize) {…}

        tSize GetBufferSize() const
        {
            return m_oStorageBuffer.capacity();
        }
        tSize GetBufferSize() const {…}

        tChar GetAt(tSize nIdx) const
        {
            if (nIdx >= GetLength())
            {
                return '\0';
            }
            return m_oStorageBuffer[nIdx];
        }
        tChar GetAt(tSize nIdx) const {…}

        tVoid SetAt(tSize nIdx, tChar c)
        {
            if (nIdx >= GetLength())
            {
                return;
            }
            m_oStorageBuffer[nIdx] = c;
        }
        tVoid SetAt(tSize nIdx, tChar c) {…}

        const tChar& operator[](tSize nIdx) const
        {
            return m_oStorageBuffer[nIdx];
        }
        const tChar& operator[](tSize nIdx) const {…}

        tChar& operator[](tSize nIdx)
        {
            return m_oStorageBuffer[nIdx];
        }
        tChar& operator[](tSize nIdx) {…}
 
 

        tBool IsEmpty() const
        {
            return (cStringUtil::GetLength(GetPtr()) == 0);
        }
        tBool IsEmpty() const {…}

        tBool IsNotEmpty() const
        {
            return !IsEmpty();
        }
        tBool IsNotEmpty() const {…}

        const tChar* GetPtr() const
        {
            return m_oStorageBuffer.c_str();
        }
        const tChar* GetPtr() const {…}

        tChar* GetBuffer()
        {
            return m_oStorageBuffer.data();
        }
        tChar* GetBuffer() {…}

        _myType& Append(const _myType& strString, tSize nLength = InvalidPos)
        {
            tSize szLength = GetLength();
            if (szLength < m_oStorageBuffer.length())
            {
                //we will insert if the buffer is damaged by the 0-termination append cheese of STL
                if (nLength == InvalidPos)
                {
                    m_oStorageBuffer.insert(szLength, strString.m_oStorageBuffer, 0, strString.GetLength());
                }
                else
                {
                    m_oStorageBuffer.insert(szLength, strString.m_oStorageBuffer, 0, nLength);
                }
            }
            else
            {
                if (nLength == InvalidPos)
                {
                    m_oStorageBuffer.append(strString.m_oStorageBuffer);
                }
                else
                {
                    m_oStorageBuffer.append(strString.m_oStorageBuffer, 0, nLength);
                }
            }
            return *this;
        }
        _myType& Append(const _myType& strString, tSize nLength = InvalidPos) {…}

        _myType& Append(tChar c)
        {
            if (c != '\0')
            {
                //strange handling within the STL append will append to the Buffer!! not to the string
                //0-Termination will be damaged  !!
                tSize szLastPos = GetLength();
                if (m_oStorageBuffer.length() > szLastPos)
                {
                    m_oStorageBuffer[szLastPos] = c;
                    if (m_oStorageBuffer.length() > (szLastPos+1))
                    {
                        m_oStorageBuffer[szLastPos+1] = '\0';
                    }
                    else
                    {
                        m_oStorageBuffer.append(1, '\0');
                    }
                }
                else
                {
                    m_oStorageBuffer.append(1, c);
                }
            }
            return *this;
        }
        _myType& Append(tChar c) {…}

        _myType& Delete(tSize nPos, tSize nLength = InvalidPos)
        {
            if (nPos == InvalidPos)
            {
                nPos = 0;
            }
            // nothing to delete in an emtpy string
            if (IsEmpty())
            {
                //do nothing
            }
            else if (nPos == 0 && nLength == InvalidPos)
            {
                Clear();
            }
            else if (nLength == InvalidPos)
            {
                if (nPos < GetLength())
                {
                    m_oStorageBuffer.erase(nPos);
                }
                else
                {
                    //do nothing
                }
            }
            else if (nPos == 0)
            {
                m_oStorageBuffer.erase(0, nLength);
            }
            else
            {
                if (nPos < GetLength())
                {
                    m_oStorageBuffer.erase(nPos, nLength);
                }
                else
                {
                    //do nothing
                }
            }
            return *this;
        }
        _myType& Delete(tSize nPos, tSize nLength = InvalidPos) {…}

        _myType& Insert(const _myType& strToInsertString, tSize nPos, tSize nLength = InvalidPos)
        {
            if (nPos == InvalidPos || nPos >= GetLength())
            {
                return Append(strToInsertString, nLength);
            }
            else
            {
                m_oStorageBuffer.insert(nPos, strToInsertString.m_oStorageBuffer, 0, nLength);
                return *this;
            }
        }
        _myType& Insert(const _myType& strToInsertString, tSize nPos, tSize nLength = InvalidPos) {…}
 

        _myType& Insert(const tChar* pToInsertString, tSize nPos, tSize nLength = InvalidPos)
        {
            if (pToInsertString != nullptr)
            {
                return Insert(_myType(pToInsertString), nPos, nLength);
            }
            return *this;
        }
        _myType& Insert(const tChar* pToInsertString, tSize nPos, tSize nLength = InvalidPos) {…}

        tInt Compare(const _myType& strString,
                     tSize nPos = 0,
                     tSize nLength = InvalidPos) const
        {
            return cStringUtil::Compare(GetPtr(), strString.GetPtr(), nPos, nLength);
        }
        tInt Compare(const _myType& strString, {…}

        tInt Compare(const tChar* strString,
                     tSize nPos = 0,
                     tSize nLength = InvalidPos) const
        {
            return cStringUtil::Compare(GetPtr(), strString, nPos, nLength);
        }
        tInt Compare(const tChar* strString, {…}

        tInt CompareNoCase(const _myType& strString,
                           tSize nPos = 0,
                           tSize nLength = InvalidPos) const
        {
            return cStringUtil::CompareNoCase(GetPtr(), strString.GetPtr(), nPos, nLength);
        }
        tInt CompareNoCase(const _myType& strString, {…}

        tBool IsEqual(const _myType &strCmp,
                      tSize nPos = 0,
                      tSize nLength = InvalidPos) const
        {
            return(Compare(strCmp, nPos, nLength) == 0) ? tTrue : tFalse;
        }
        tBool IsEqual(const _myType &strCmp, {…}
 

        tBool IsEqualNoCase(const _myType &strCmp,
                            tSize nPos = 0,
                            tSize nLength = InvalidPos) const
        {
            return(cStringUtil::CompareNoCase(GetPtr(), strCmp.GetPtr(), nPos, nLength) == 0) ? tTrue : tFalse;
        }
        tBool IsEqualNoCase(const _myType &strCmp, {…}

        tBool IsNotEqual(const _myType &strCmp,
                        tSize nPos = 0,
                        tSize nLength = InvalidPos) const
        {
            return(Compare(strCmp, nPos, nLength) == 0) ? tFalse : tTrue;
        }
        tBool IsNotEqual(const _myType &strCmp, {…}
 

        tBool IsNotEqualNoCase(const _myType &strCmp,
                               tSize nPos = 0,
                               tSize nLength = InvalidPos) const
        {
            return(CompareNoCase(strCmp, nPos, nLength) == 0) ? tFalse : tTrue;
        }
        tBool IsNotEqualNoCase(const _myType &strCmp, {…}

        tSize Find(const _myType& strStringToFind,
                   tSize nStart = 0,
                   const tBool bNoCase = tFalse) const
        {
            if (bNoCase)
            {
                _myType strTmp, strCompare;
                strTmp = *this;
                strTmp.ToLower();
                strCompare = *this;
                strCompare.ToLower();
                return strTmp.Find(strCompare, nStart);
            }
 
            return m_oStorageBuffer.find(strStringToFind.m_oStorageBuffer, nStart);
        }
        tSize Find(const _myType& strStringToFind, {…}

        tSize Find(tChar cToFind, tSize nStart = 0) const
        {
            return Find(_myType(cToFind), nStart, tFalse);
        }
        tSize Find(tChar cToFind, tSize nStart = 0) const {…}

        tSize RFind(tChar cChar, tSize nStart = 0) const
        {
            if (nStart == 0)
            {
                return m_oStorageBuffer.rfind(cChar);
            }
 
            return m_oStorageBuffer.rfind(cChar, GetLength() - nStart);
        }
        tSize RFind(tChar cChar, tSize nStart = 0) const {…}

        tSize FindToken(const _myType& strTokenList, tSize nStart = 0) const
        {
            if (IsEmpty())
            {
                return InvalidPos;
            }
 
            if (nStart == 0)
            {
                return m_oStorageBuffer.find_first_of(strTokenList.m_oStorageBuffer);
            }
 
            return m_oStorageBuffer.find_first_of(strTokenList.m_oStorageBuffer, nStart);
        }
        tSize FindToken(const _myType& strTokenList, tSize nStart = 0) const {…}

        tSize FindNotToken(const _myType& strTokenList, tSize nStart = 0) const
        {
            if (IsEmpty())
            {
                return InvalidPos;
            }
 
            if (nStart == 0)
            {
                return m_oStorageBuffer.find_first_not_of(strTokenList.m_oStorageBuffer);
            }
 
            return m_oStorageBuffer.find_first_not_of(strTokenList.m_oStorageBuffer, nStart);
        }
        tSize FindNotToken(const _myType& strTokenList, tSize nStart = 0) const {…}

        tSize CountString(const _myType& strFind, tSize nStart = 0) const
        {
            tSize nFindSize = strFind.GetLength();
            if (IsEmpty() || nFindSize == 0)
            {
                return InvalidPos;
            }
 
            tSize nCnt = 0;
            while (nStart != InvalidPos)
            {
                nStart = Find(strFind, nStart);
                if (nStart != InvalidPos)
                {
                    nStart += nFindSize;
                    nCnt++;
                }
            }
            return nCnt;
        }
        tSize CountString(const _myType& strFind, tSize nStart = 0) const {…}

        tSize Replace(const _myType& strOld, const _myType& strNew, tBool bReplaceAll = tTrue)
        {
            if (IsEmpty() || strOld.IsEmpty())
            {
                return 0;
            }
 
            tSize nReplaceCount = 0;
 
            _myType strBuffer;
            tSize nSearchLen = strOld.GetLength();
            tSize nPos;
            tSize nStartPos = 0;
            do
            {
                nPos = Find(strOld, nStartPos);
                if (nPos != InvalidPos)
                {
                    strBuffer.Append(Mid(nStartPos, (nPos - nStartPos)));
                    strBuffer.Append(strNew);
                    nStartPos = nPos + nSearchLen;
                    nReplaceCount++;
                    if (!bReplaceAll)
                    {
                        strBuffer.Append(Mid(nStartPos));
                        break;
                    }
                }
                else
                {
                    strBuffer.Append(Mid(nStartPos));
                }
 
            } while (nPos != InvalidPos);
 
            m_oStorageBuffer.swap(strBuffer.m_oStorageBuffer);
            return nReplaceCount;
        }
        tSize Replace(const _myType& strOld, const _myType& strNew, tBool bReplaceAll = tTrue) {…}

        tSize Replace(tChar cOld, tChar cNew,tBool bReplaceAll = tTrue)
        {
            if (IsEmpty())
            {
                return 0;
            }
 
            tSize nReplacements = 0;
            _myType::iterator oIt = begin();
            _myType::iterator oItEnd = end();
            for (; oIt != oItEnd; ++oIt)
            {
                if (*oIt == cOld)
                {
                    *oIt = cNew;
                    ++nReplacements;
                    if (!bReplaceAll)
                    {
                        break;
                    }
                }
            }
            return nReplacements;
        }
        tSize Replace(tChar cOld, tChar cNew,tBool bReplaceAll = tTrue) {…}

        tSize Filter(tChar cChar)
        {
            return Filter(_myType(cChar));
        }
        tSize Filter(tChar cChar) {…}

        tSize Filter(const _myType& strCharList)
        {
            if (IsEmpty())
            {
                return 0;
            }
 
            tSize nSize = GetLength();
            _myType strTmp;
            strTmp.SetBuffer(nSize);
            tSize nFiltered = 0;
            for (tSize nPos = 0; nPos < nSize; ++nPos)
            {
                tChar cCurrent = GetAt(nPos);
                if (strCharList.Find(cCurrent) == InvalidPos)
                {
                    strTmp.Append(cCurrent);
                }
                else
                {
                    ++nFiltered;
                }
            }
 
            m_oStorageBuffer.swap(strTmp.m_oStorageBuffer);
            return nFiltered;
        }
        tSize Filter(const _myType& strCharList) {…}

        tBool StartsWith(const _myType& strStartsWith, const tBool bNoCase = tFalse) const
        {
            if (strStartsWith.IsEmpty() || strStartsWith.GetLength() > GetLength())
            {
                return tFalse;
            }
 
            if (bNoCase)
            {
                return (CompareNoCase(strStartsWith, 0, strStartsWith.GetLength()) == 0);
            }
            else
            {
                return (Compare(strStartsWith, 0, strStartsWith.GetLength()) == 0);
            }
        }
        tBool StartsWith(const _myType& strStartsWith, const tBool bNoCase = tFalse) const {…}
 
        tSize RSplitByToken(const tChar cToken, _myType& strFirst, _myType& strSecond) const
        {
            tSize szRight = RFind(cToken);
            if (szRight != InvalidPos)
            {
                strFirst  = Left(szRight);
                strSecond = Right(GetLength() - (szRight + 1));
            }
            return szRight;
        }
 
        tSize SplitByToken(const tChar cToken, _myType& strFirst, _myType& strSecond) const
        {
            tSize szRight = Find(cToken);
            if (szRight != InvalidPos)
            {
                strFirst = Left(szRight);
                strSecond = Right(GetLength() - (szRight + 1));
            }
            return szRight;
        }

        tBool EndsWith(const _myType& strEndsWith, const tBool bNoCase = tFalse) const
        {
            //@TODO: Compare can be done without new memory allocation!!
            tSize szStringLength = GetLength();
            if (szStringLength == 0
                || (strEndsWith.GetLength() > szStringLength))
            {
                return tFalse;
            }
 
            _myType strPart = Right(strEndsWith.GetLength());
            if (bNoCase)
            {
                return strPart.IsEqualNoCase(strEndsWith);
            }
            else
            {
                return strPart.IsEqual(strEndsWith);
            }
        }
        tBool EndsWith(const _myType& strEndsWith, const tBool bNoCase = tFalse) const {…}

        operator const tChar*() const
        {
            return GetPtr();
        }
        operator const tChar*() const {…}
 
 
 
 

        const _myType& operator+= (const _myType& strString)
        {
            Append(strString);
            return *this;
        }
        const _myType& operator+= (const _myType& strString) {…}

        tBool operator==(const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) == 0);
        }
        tBool operator==(const tChar* pString) const {…}

        tBool operator!=(const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) != 0);
        }
        tBool operator!=(const tChar* pString) const {…}

        tBool operator< (const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) < 0);
        }
        tBool operator< (const tChar* pString) const {…}

        tBool operator> (const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) > 0);
        }
        tBool operator> (const tChar* pString) const {…}

        tBool operator<=(const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) <= 0);
        }
        tBool operator<=(const tChar* pString) const {…}

        tBool operator>=(const tChar* pString) const
        {
            return (cStringUtil::Compare(GetPtr(), pString) >= 0);
        }
        tBool operator>=(const tChar* pString) const {…}
 

        tBool operator==(const _myType& strString) const
        {
            return (Compare(strString) == 0);
        }
        tBool operator==(const _myType& strString) const {…}

        tBool operator!=(const _myType& strString) const
        {
            return (Compare(strString) != 0);
        }
        tBool operator!=(const _myType& strString) const {…}

        tBool operator< (const _myType& strString) const
        {
            return (Compare(strString) < 0);
        }
        tBool operator< (const _myType& strString) const {…}

        tBool operator> (const _myType& strString) const
        {
            return (Compare(strString) > 0);
        }
        tBool operator> (const _myType& strString) const {…}

        tBool operator<=(const _myType& strString) const
        {
            return (Compare(strString) <= 0);
        }
        tBool operator<=(const _myType& strString) const {…}

        tBool operator>=(const _myType& strString) const
        {
            return (Compare(strString) >= 0);
        }
        tBool operator>=(const _myType& strString) const {…}

        _myType SubString(tSize nPos, tSize nLength = InvalidPos) const
        {
            if (nPos > GetLength())
            {
                return Empty;
            }
            return m_oStorageBuffer.substr(nPos, nLength);
        }
        _myType SubString(tSize nPos, tSize nLength = InvalidPos) const {…}
 
 

        _myType Mid(tSize nPos, tSize nLength = InvalidPos) const
        {
            if (IsEmpty() || nPos >= GetLength() || nPos == InvalidPos)
            {
                return Empty;
            }
            _myType strRes;
            if (nLength == InvalidPos)
            {
                strRes = SubString(nPos);
            }
            else
            {
                strRes = SubString(nPos, nLength);
            }
            return strRes;
        }
        _myType Mid(tSize nPos, tSize nLength = InvalidPos) const {…}

        _myType Left(tSize nLength) const
        {
            return SubString(0, nLength);
        }
        _myType Left(tSize nLength) const {…}

        _myType Right(tSize nLength) const
        {
            tSize nPos = (GetLength() - nLength);
            if (GetLength() < nLength)
            {
                nPos = 0;
            }
            else
            {
                nPos = GetLength() - nLength;
            }
            return SubString(nPos, nLength);
        }
        _myType Right(tSize nLength) const {…}
 
 

        tVoid Split(string_list_base<_myType>& lstSplittedResult, tChar cToken) const
        {
            Split(lstSplittedResult, _myType(cToken));
        }
        tVoid Split(string_list_base<_myType>& lstSplittedResult, tChar cToken) const {…}

        tVoid Split(string_list_base<_myType>& lstSplittedResult, const _myType& strToken) const
        {
            lstSplittedResult.Clear();
            if (IsEmpty())
            {
                return;
            }
 
            tSize nTokenLen = strToken.GetLength();
            tSize nPos = InvalidPos;
            tSize nStartPos;
            tSize nToSplitStringSize = GetLength();
            do
            {
                nStartPos = nPos + 1;
                nPos = Find(strToken, nStartPos);
                if (nPos != InvalidPos)
                {
                    if (nPos != 0)
                    {
                        lstSplittedResult.Append(Mid(nStartPos, nPos - nStartPos));
                    }
                    else
                    {
                        lstSplittedResult.Append(_myType(""));
                    }
                    nPos += nTokenLen - 1;
                }
                else
                {
                    if (nStartPos < nToSplitStringSize)
                    {
                        lstSplittedResult.Append(Mid(nStartPos));
                    }
                    else if (EndsWith(strToken))
                    {
                        lstSplittedResult.Append(_myType(""));
                    }
                    break;
                }
            } while (nPos != InvalidPos);
        }
        tVoid Split(string_list_base<_myType>& lstSplittedResult, const _myType& strToken) const {…}
 

        tVoid SplitToken(string_list_base<_myType>& lstList, const _myType& strTokenList) const
        {
            lstList.Clear();
 
            _myType strPart;
 
            tSize nLastPos = 0;
            tSize nPos = 0;
            while (nPos != InvalidPos)
            {
                nPos = FindToken(strTokenList, nLastPos);
                if (nPos == InvalidPos)
                {
                    strPart = Mid(nLastPos);
                    if (strPart.IsNotEmpty())
                    {
                        lstList.Append(strPart);
                    }
                    break;
                }
                else
                {
                    if (nPos > nLastPos)
                    {
                        strPart = Mid(nLastPos, nPos - nLastPos);
                        lstList.Append(strPart);
                    }
                    nLastPos = nPos + 1;
                }
            }
        }
        tVoid SplitToken(string_list_base<_myType>& lstList, const _myType& strTokenList) const {…}

        tVoid Trim()
        {
            LeftTrim();
            RightTrim();
        }
        tVoid Trim() {…}

        tVoid LeftTrim(tBool bNumTrim=tFalse)
        {
            tSize szLength = 0;
            tBool bLast0 = tFalse;
            iterator it = begin();
            for (;
                 it != end() && (cStringUtil::IsWhiteChar(*it) || (bNumTrim && *it == '0'));
                 it++)
            {
                if (*it == '0')
                {
                    bLast0 = tTrue;
                }
                else
                {
                    bLast0 = tFalse;
                }
                szLength++;
            }
            if (it != end() && bNumTrim && bLast0 && cStringUtil::IsOneOf(*it,".,"))
            {
                szLength--;
            }
            Delete(0, szLength);
        }
        tVoid LeftTrim(tBool bNumTrim=tFalse) {…}

        tVoid RightTrim()
        {
            tSize szLength = 0;
            for (reverse_iterator it = rbegin();
                it != rend() && cStringUtil::IsWhiteChar(*it);
                it++)
            {
                szLength++;
            }
            Delete(GetLength() - szLength, InvalidPos);
        }
        tVoid RightTrim() {…}

        tVoid NumTrim()
        {
            //@TODO : should be optimized
            LeftTrim(tTrue);
            RightTrim();
 
            if (IsEmpty())
            {
                return;
            }
 
            tSize nPoint = FindToken(_myType(".,"));
            if (nPoint != InvalidPos)
            {
                tSize nPos = GetLength() - 1;
                tChar c;
                tBool bLastWasZero = tFalse;
                while (nPos != InvalidPos)
                {
                    c = GetAt(nPos);
                    if (c == '0')
                    {
                        bLastWasZero = tTrue;
                    }
                    else if (c == ' ')
                    {
                        bLastWasZero = tFalse;
                    }
                    else
                    {
                        if (cStringUtil::IsOneOf(c, ".,") && bLastWasZero) // keep trailing zero
                        {
                            nPos++;
                        }
 
                        break;
                    }
                    nPos--;
                }
                Delete(nPos + 1);
            }
        }
        tVoid NumTrim() {…}

        tVoid DropQuotes()
        {
            if (IsEmpty())
            {
                return;
            }
 
            tSize nEndPos = GetLength() - 1;
 
            if (*rbegin() == '\"' || *rbegin() == '\'')
            {
                Delete(nEndPos, 1);
            }
 
            if (*begin() == '\"' || *begin() == '\'')
            {
                Delete(0, 1);
            }
        }
        tVoid DropQuotes() {…}

        tVoid ToLower()
        {
            if (IsEmpty())
            {
                return;
            }
            for (auto it = begin();
                it != end();
                ++it)
            {
                // tolower delivers an int, but we can assume that it fits into char
                *it = static_cast<tChar>(::tolower(*it));
            }
 
        }
        tVoid ToLower() {…}

        tVoid ToUpper()
        {
            if (IsEmpty())
            {
                return;
            }
            for (auto it = begin();
                it != end();
                ++it)
            {
                *it = ::toupper(static_cast<tChar>(*it));
            }
        }
        tVoid ToUpper() {…}

        _myType& Escape()
        {
            //@TODO : this needs to be rework using stack!!
            if (IsEmpty())
            {
                return *this;
            }
 
            _myType oTemp;
            oTemp.SetBuffer(GetLength() * 2 + 1);
 
            iterator ptr2 = oTemp.begin();
            const tChar* ptr = GetPtr();
 
            tChar c1, c2;
            tBool bEscaped;
            tSize szEnd = oTemp.GetBufferSize();
            tSize szCounter = 0;
            while (*ptr != '\0' && szCounter < szEnd)
            {
                c1 = *ptr;
                bEscaped = tTrue;
                switch (c1)
                {
                case '\a':
                    c2 = 'a';
                    break;
                case '\b':
                    c2 = 'b';
                    break;
                case '\f':
                    c2 = 'f';
                    break;
                case '\n':
                    c2 = 'n';
                    break;
                case '\r':
                    c2 = 'r';
                    break;
                case '\t':
                    c2 = 't';
                    break;
                case '\v':
                    c2 = 'v';
                    break;
                case '\'':
                    c2 = '\'';
                    break;
                case '\"':
                    c2 = '\"';
                    break;
                case '\\':
                    c2 = '\\';
                    break;
                case '\?':
                    c2 = '\?';
                    break;
                default:
                    c2 = c1;
                    bEscaped = tFalse;
                    break;
                }
 
                if (bEscaped)
                {
                    *(ptr2++) = '\\';
                }
 
                *(ptr2++) = c2;
 
                ptr++;
            }
 
            *ptr2 = '\0';
 
            Set(oTemp);
            return *this;
        }
        _myType& Escape() {…}

        _myType& Unescape()
        {
            //@TODO : this needs to be rework using stack only!!
            if (IsEmpty())
            {
                return (*this);
            }
 
            _myType oTemp;
            oTemp.SetBuffer(GetLength() + 1);
 
            iterator ptr2 = oTemp.begin();
            const tChar* ptr = GetPtr();
 
            tChar c1, c2;
            while (*ptr != '\0')
            {
                if (*ptr != '\\')
                {
                    *(ptr2++) = *ptr;
                }
                else
                {
                    ptr++;
                    c1 = *ptr;
                    switch (c1)
                    {
                    case 'a':
                        c2 = '\a';
                        break;
                    case 'b':
                        c2 = '\b';
                        break;
                    case 'f':
                        c2 = '\f';
                        break;
                    case 'n':
                        c2 = '\n';
                        break;
                    case 'r':
                        c2 = '\r';
                        break;
                    case 't':
                        c2 = '\t';
                        break;
                    case 'v':
                        c2 = '\v';
                        break;
                    case '\'':
                        c2 = '\'';
                        break;
                    case '\"':
                        c2 = '\"';
                        break;
                    case '\\':
                        c2 = '\\';
                        break;
                    case '\?':
                        c2 = '\?';
                        break;
                    default:
                        c2 = *ptr;
                        break;
                    }
 
                    *(ptr2++) = c2;
                }
 
                ptr++;
            }
            *ptr2 = '\0';
 
            Set(oTemp);
            return *this;
        }
        _myType& Unescape() {…}

        tBool IsInteger() const
        {
            return cStringUtil::IsInteger(GetPtr());
        }
        tBool IsInteger() const {…}

        tBool IsFloat() const
        {
            return cStringUtil::IsFloat(GetPtr());
        }
        tBool IsFloat() const {…}

        tBool IsNumeric() const
        {
            return (IsInteger() || IsFloat());
        }
        tBool IsNumeric() const {…}
 
    public:

        static _myType Repeat(tChar c, tSize nCount)
        {
            return _myType().Set(c, nCount);
        }
        static _myType Repeat(tChar c, tSize nCount) {…}
 

        tInt32 AsInt32() const
        {
            tInt32 nRetValue = 0;
            ToType(nRetValue);
            return nRetValue;
        }
        tInt32 AsInt32() const {…}

        tVoid ToType(tInt32& i32Value) const
        {
            cStringUtil::ToType(GetPtr(), i32Value);
        }
        tVoid ToType(tInt32& i32Value) const {…}

        static _myType FromType(tInt32 i32Value, const _myType& strFormat = Empty)
        {
            return _myType(ToStringFromType(i32Value, strFormat.m_oStorageBuffer));
        }
        static _myType FromType(tInt32 i32Value, const _myType& strFormat = Empty) {…}

        tUInt32 AsUInt32() const
        {
            tUInt32 nRetValue = 0;
            ToType(nRetValue);
            return nRetValue;
        }
        tUInt32 AsUInt32() const {…}

        tVoid ToType(tUInt32& ui32Value) const
        {
            cStringUtil::ToType(GetPtr(), ui32Value);
        }
        tVoid ToType(tUInt32& ui32Value) const {…}

        static _myType FromType(tUInt32 ui32Value, const _myType& strFormat = Empty)
        {
            return ToStringFromType(ui32Value, strFormat.m_oStorageBuffer);
        }
        static _myType FromType(tUInt32 ui32Value, const _myType& strFormat = Empty) {…}
 

        tInt64 AsInt64() const
        {
            tInt64 nRetValue = 0;
            ToType(nRetValue);
            return nRetValue;
        }
        tInt64 AsInt64() const {…}

        tVoid ToType(tInt64& i64Value) const
        {
            cStringUtil::ToType(GetPtr(), i64Value);
        }
        tVoid ToType(tInt64& i64Value) const {…}

        static _myType FromType(tInt64 i64Value, const _myType& strFormat = Empty)
        {
            return ToStringFromType(i64Value, strFormat.m_oStorageBuffer);
        }
        static _myType FromType(tInt64 i64Value, const _myType& strFormat = Empty) {…}

        tUInt64 AsUInt64() const
        {
            tUInt64 nRetValue = 0;
            ToType(nRetValue);
            return nRetValue;
        }
        tUInt64 AsUInt64() const {…}

        tVoid ToType(tUInt64& ui64Value) const
        {
            cStringUtil::ToType(GetPtr(), ui64Value);
        }
        tVoid ToType(tUInt64& ui64Value) const {…}

        static _myType FromType(tUInt64 ui64Value, const _myType& strFormat = Empty)
        {
            return ToStringFromType(ui64Value, strFormat);
        }
        static _myType FromType(tUInt64 ui64Value, const _myType& strFormat = Empty) {…}

        tFloat64 AsFloat64() const
        {
            tFloat64 fRetValue = 0;
            ToType(fRetValue);
            return fRetValue;
        }
        tFloat64 AsFloat64() const {…}

        tVoid ToType(tFloat64& f64Value) const
        {
            cStringUtil::ToType(GetPtr(), f64Value);
        }
        tVoid ToType(tFloat64& f64Value) const {…}

        static _myType FromType(tFloat64 f64Value, const _myType& strFormat = Empty)
        {
            return ToStringFromType(f64Value, strFormat);
        }
        static _myType FromType(tFloat64 f64Value, const _myType& strFormat = Empty) {…}

        tFloat32 AsFloat32() const
        {
            tFloat32 fRetValue = 0;
            ToType(fRetValue);
            return fRetValue;
        }
        tFloat32 AsFloat32() const {…}

        tVoid ToType(tFloat32& f32Value) const
        {
            cStringUtil::ToType(GetPtr(), f32Value);
        }
        tVoid ToType(tFloat32& f32Value) const {…}

        static _myType FromType(tFloat32 f32Value, const _myType& strFormat = Empty)
        {
            return ToStringFromType(f32Value, strFormat);
        }
        static _myType FromType(tFloat32 f32Value, const _myType& strFormat = Empty) {…}

        tBool AsBool() const
        {
            tBool bRetValue = 0;
            ToType(bRetValue);
            return bRetValue;
        }
        tBool AsBool() const {…}

        tVoid ToType(tBool& bValue) const
        {
            cStringUtil::ToType(GetPtr(), bValue);
        }
        tVoid ToType(tBool& bValue) const {…}

        static _myType FromType(tBool bValue, const _myType& strFormat = Empty)
        {
            return ToStringFromType(bValue, strFormat);
        }
        static _myType FromType(tBool bValue, const _myType& strFormat = Empty) {…}
 

        tInt64 HexToInt64() const
        {
            tInt64 nRetValue = 0;
            HexToType(nRetValue);
            return nRetValue;
        }
        tInt64 HexToInt64() const {…}

        tSize GetMaxBufferSize() const
        {
            return m_oStorageBuffer.max_size();
        }
        tSize GetMaxBufferSize() const {…}

        tVoid HexToType(tInt64& i64Value) const
        {
            cStringUtil::HexToType(GetPtr(), i64Value);
        }
        tVoid HexToType(tInt64& i64Value) const {…}

        static inline _myType Format(
#ifdef _MSC_VER
            _In_z_ _Printf_format_string_
#endif // _MSC_VER
            const value_type* strFormat,
            ...)
#ifdef __GNUC__
            __attribute__((format(printf, 1, 2)))
#endif // __GNUC__
        {
            va_list args, args_copy;
            va_start(args, strFormat);
            va_copy(args_copy, args);
            _myType strBuffer;
            strBuffer.SetBuffer(static_cast<size_t>(::std::vsnprintf(nullptr, 0, strFormat, args_copy)));
            va_end(args_copy);
            ::std::vsnprintf(strBuffer.GetBuffer(), strBuffer.GetBufferSize() + 1, strFormat, args);
            va_end(args);
            return strBuffer;
        }
        static inline _myType Format( {…}

        template<typename T>
        static _myType ToStringFromType(T oValue, const _myType& strFormat)
        {
            _myType strResult;
            tSize szMaxSize = strResult.GetMaxBufferSize();
            tSize szCurrentBuffer = 42;
            if (szMaxSize < szCurrentBuffer)
            {
                szCurrentBuffer = szMaxSize;
            }
            strResult.SetBuffer(szCurrentBuffer);
            cStringUtil::FromType(oValue, strResult.GetBuffer(), strResult.GetBufferSize(), strFormat.GetPtr());
            return strResult;
        }
        static _myType ToStringFromType(T oValue, const _myType& strFormat) {…}

        static _myType& Copy(_myType& strDestination, const _myType& strSource, tSize szLength = InvalidPos)
        {
            return strDestination.Set(strSource, szLength);
        }
        static _myType& Copy(_myType& strDestination, const _myType& strSource, tSize szLength = InvalidPos) {…}
 
};
class string_base {…};
 
template <typename T> const string_base<T> string_base<T>::Empty;
template <typename T> const tSize string_base<T>::InvalidPos = g_npos;

template<class sT, class sT2>
struct string_base_compare_func
{
    tBool operator()(const string_base<sT>& str1, const string_base<sT2>& str2) const
    {
        return ((str1.Compare(str2)) < 0);
    }
    tBool operator()(const string_base<sT>& str1, const string_base<sT2>& str2) const {…}
};
struct string_base_compare_func {…};
 
 

template<class sT, class sT2>
struct string_base_no_case_compare_func
{
    tBool operator()(const string_base<sT>& str1, const string_base<sT2>& str2) const
    {
        return ((str1.CompareNoCase(str2)) < 0);
    }
    tBool operator()(const string_base<sT>& str1, const string_base<sT2>& str2) const {…}
};
struct string_base_no_case_compare_func {…};

template<class sT>
tBool operator==(const tChar* str1, const string_base<sT>& str2)
{
    return str2.IsEqual(str1);
}
tBool operator==(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator!=(const tChar* str1, const string_base<sT>& str2)
{
    return str2.IsNotEqual(str1);
}
tBool operator!=(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator<(const tChar* str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) > 0);
}
tBool operator<(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator>(const tChar* str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) < 0);
}
tBool operator>(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator<=(const tChar* str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) >= 0);
}
tBool operator<=(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator>=(const tChar* str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) <= 0);
}
tBool operator>=(const tChar* str1, const string_base<sT>& str2) {…}
 

template<class sT>
tBool operator==(const std::string& str1, const string_base<sT>& str2)
{
    return str2.IsEqual(str1);
}
tBool operator==(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator!=(const std::string& str1, const string_base<sT>& str2)
{
    return str2.IsNotEqual(str1);
}
tBool operator!=(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator<(const std::string& str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) > 0);
}
tBool operator<(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator>(const std::string& str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) < 0);
}
tBool operator>(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator<=(const std::string& str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) >= 0);
}
tBool operator<=(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator>=(const std::string& str1, const string_base<sT>& str2)
{
    return (str2.Compare(str1) <= 0);
}
tBool operator>=(const std::string& str1, const string_base<sT>& str2) {…}

template<class sT>
tBool operator==(const string_base<sT>& str1, const std::string& str2)
{
    return str1.IsEqual(str2);
}
tBool operator==(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT>
tBool operator!=(const string_base<sT>& str1, const std::string& str2)
{
    return str1.IsNotEqual(str2);
}
tBool operator!=(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT>
tBool operator<(const string_base<sT>& str1, const std::string& str2)
{
    return (str1.Compare(str2) < 0);
}
tBool operator<(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT>
tBool operator>(const string_base<sT>& str1, const std::string& str2)
{
    return (str1.Compare(str2) > 0);
}
tBool operator>(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT>
tBool operator<=(const string_base<sT>& str1, const std::string& str2)
{
    return (str1.Compare(str2) <= 0);
}
tBool operator<=(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT>
tBool operator>=(const string_base<sT>& str1, const std::string& str2)
{
    return (str1.Compare(str2) >= 0);
}
tBool operator>=(const string_base<sT>& str1, const std::string& str2) {…}

template<class sT, class sT2>
string_base<sT> operator+(const string_base<sT>& str1, const string_base<sT2>& str2)
{
    return string_base<sT>(str1).Append(str2);
}
string_base<sT> operator+(const string_base<sT>& str1, const string_base<sT2>& str2) {…}

template<class sT>
string_base<sT> operator+(const tChar* str1, const string_base<sT>& str2)
{
    return string_base<sT>(str1).Append(str2);
}
string_base<sT> operator+(const tChar* str1, const string_base<sT>& str2) {…}

template<class sT>
string_base<sT> operator+(const string_base<sT>& str1, const tChar* str2)
{
    return string_base<sT>(str1).Append(str2);
}
string_base<sT> operator+(const string_base<sT>& str1, const tChar* str2) {…}

#define A_UTILS_DEFAULT_SIZE_OF_STRING 64
typedef stack_string_base < A_UTILS_DEFAULT_SIZE_OF_STRING, growinheap_out_of_range > cStackString;

typedef string_base<cStackString> cString;

typedef string_base_compare_func<cStackString, cStackString> cStringCompareFunc;
typedef string_base_no_case_compare_func<cStackString, cStackString> cStringNoCaseCompareFunc;
} // namespace A_UTILS_NS
 
 
 
 
#endif // _STRINGTEMPLATE_CLASS_HEADER_