XString.h

Go to the documentation of this file.

//! @file XString.h
//! @brief CXStringT is a template class for handling unicode, utf8 or ansi strings
//! 
//!  Created by Mootools initially based on David Nash code
///////////////////////////////////////////////////////////////////////////////////
#ifndef CXTSTRING_CLASS_H
#define CXTSTRING_CLASS_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#ifdef __WINDOWS__
#pragma warning(push)
#pragma warning(disable: 4996)
#endif
 
// CXTString code based on:
//
// Win32++ Version 7.3
// Released: 30th November 2011
//
// David Nash
// email: dnash@bigpond.net.au
// url: https://sourceforge.net/projects/win32-framework
//
//
// Copyright (c) 2005-2011 David Nash
//
// Permission is hereby granted, free of charge, to
// any person obtaining a copy of this software and
// associated documentation files (the "Software"),
// to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice
// shall be included in all copies or substantial portions
// of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.
//
////////////////////////////////////////////////////////
//
// Acknowledgements:
// Thanks to Adam Szulc for his initial CXTString code.
//
////////////////////////////////////////////////////////
// xstring.h
// Declaration of the xstring.h
//
// This class is intended to provide a simple alternative to the MFC/ATL
// CXTString class that ships with Microsoft compilers. The CXTString class
// specified here is compatible with other compilers such as Borland 5.5
// and MinGW.
//
// Differences between this class and the MFC/ATL CXTString class
// ------------------------------------------------------------
// 1) The constructors for this class accepts both ANSI and Unicode characters and
// automatically converts these to TCHAR as required.
//
// 2) This class is not reference counted, so these CStrings should be passed as
// references or const references when used as function arguments. As a result there
// is no need for functions like LockBuffer and UnLockBuffer.
//
// 3) The Format functions only accepts POD (Plain Old Data) arguments. It does not
// accept arguments which are class or struct objects. In particular it does not
// accept CXTString objects, unless these are cast to LPCTSTR.
// This is demonstrates valid and invalid usage:
// CXTString string1(_T("Hello World"));
// CXTString string2;
//
// // This is invalid, and produces undefined behaviour.
// string2.Format(_T("String1 is: %s"), string1); // No! you can't do this
//
// // This is ok
// string2.Format(_T("String1 is: %s"), (LPCTSTR)string1); // Yes, this is correct
//
// Note: The MFC/ATL CXTString class uses a non portable hack to make its CXTString class
// behave like a POD. Other compilers (such as the MinGW compiler) specifically
// prohibit the use of non POD types for functions with variable argument lists.
//
// 4) This class provides a few additional functions:
// data         Returns a const TCHAR string. This is an alternative for casting to LPCTSTR.
// GetErrorString   Assigns CXTString to the error string for the specified System Error Code
// (from ::GetLastErrror() for example).
// GetString        Returns a reference to the underlying std::basic_string<TCHAR>. This
//                      reference can be used to modify the string directly.
 
// MacOS: cf. note at the end of the file
#if defined(__WINDOWS__) && defined(MOOTOOLS_DLL_IMPORTS_ALL)
// When using the class through a dll under windows, template instantiation are exported
// we use only exported version and removing inline prevents to use inline expansion as it could generate dependency missing functions
// CXTString<char> and CXTString<wchart_t> are exported at the end of the file
#define MOOTOOLS_XSTRINGS_NO_INLINE
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
 
    template<class XCHAR> class CXTString;
    template<class XCHAR> class CXTCharArray;
 
    typedef CXTCharArray<TCHAR> CXCharArray;
    typedef CXTCharArray<char> CXCharArrayA;
    typedef CXTCharArray<wchar_t> CXCharArrayW;
 
    typedef CXTString<TCHAR> CXString; //!< CXString depend on the target OS. Could be CXStringW (Windows) or CXStringA (Linux / Macos)
    typedef CXTString<char> CXStringA; //!< CXStringA is an ansi / utf8 char string. Cf. CXTString
    typedef CXTString<wchar_t> CXStringW; //!< CXStringA is an unicode wchar_t string. Cf. CXTString
 
#if defined(_DEBUG) && !defined(MOOTOOLS_NO_TRACE)
    extern DLL_TOOLSFUNCTION void XTRACE(LPCTSTR lpszFormat, ...);
#else
    #define XTRACE(...) __noop
#endif
 
    #define ISXCHARUNICODE(TYPE) ((sizeof(TYPE) == sizeof(wchar_t)))
 
    template<class XCHAR> class CXTCharArray
    {
        friend class CXTString<XCHAR>;
 
        protected:
            XCHAR *buffer; // Set it first, so &CXString() points directly to the buffer
            varint bufCharCount, maxBufCount; // bufCharCount is the number of characters (excluding null), maxBufCount is the max number of char of the buffer
        public:
            typedef enum { firstCharCount = 16, secondCharCount = 64 } XCharDefaults;
 
            ///////////////////////////////////////////////////////////////
            // CXTCharArray
            CXTCharArray();
            CXTCharArray(const XCHAR *string, size_t charCount);
            CXTCharArray(XCHAR value, size_t charCount);
            ~CXTCharArray();
 
            void setlength(SIZET newSize);
            varint length() const; // Not signed to enable substraction
            void init();
            bool belongto(varint index, const XCHAR *string, size_t charCount = -1) const;
            void remove(varint pos, size_t charCount = -1);
            void assign(const CXTCharArray<XCHAR>& chars, varint first = 0, size_t charCount = -1);
            void assign(const XCHAR *string, size_t charCount = -1);
            size_t insert(varint index, const XCHAR *string, size_t charCount = -1); // Return the number of inserted char
            void append(const XCHAR *string, size_t charCount = -1);
            const XCHAR *data() const;
            XCHAR *data();
            XCHAR *detach(); // Detach buffer. Caller must free buffer with xfree
            void empty();
 
            // these methods using same name for char and wchar_t allows resolving linking based on the XCHAR type
            static void xchar_memset(XCHAR *str, XCHAR value, SIZET count);
            static SIZET xchar_strlen(const XCHAR *str);
            static int xchar_strcmp(const XCHAR *char1, const XCHAR *char2);
            static int xchar_strcoll(const XCHAR *char1, const XCHAR *char2);
            static int xchar_stricoll(const XCHAR *char1, const XCHAR *char2);
            static int xchar_stricmp(const XCHAR *char1, const XCHAR *char2);
            static int xchar_isspace(const XCHAR char1);
            static int xchar_toupper(XCHAR char1);
            static int xchar_tolower(XCHAR char1);
            static int xchar_vnprintf(XCHAR *buffer, SIZET count, const XCHAR *format, va_list argptr);
            static int xchar_vscanf_s(const XCHAR *buffer, const XCHAR *format, va_list argptr);
    };
 
#ifndef MOOTOOLS_XSTRINGS_NO_INLINE
    // Specialization char
    template <> inline void CXTCharArray<char>::xchar_memset(char *str, char value, SIZET count)
    {
        return xmemset(str, value, count);
    }
 
    template <> inline SIZET CXTCharArray<char>::xchar_strlen(const char *str)
    {
        return xstrlen(str);
    }
 
    template <> inline int CXTCharArray<char>::xchar_strcmp(const char *char1, const char *char2)
    {
        return xstrcmp(char1, char2);
    }
 
    template <> inline int CXTCharArray<char>::xchar_strcoll(const char *char1, const char *char2)
    {
        return xstrcoll(char1, char2);
    }
 
    template <> inline int CXTCharArray<char>::xchar_stricoll(const char *char1, const char *char2)
    {
        return xstricoll(char1, char2);
    }
 
    template <> inline int CXTCharArray<char>::xchar_stricmp(const char *char1, const char *char2)
    {
        return xstricmp(char1, char2);
    }
 
    template <> inline int CXTCharArray<char>::xchar_isspace(char char1)
    {
        return xisspace(char1);
    }
 
    template <> inline int CXTCharArray<char>::xchar_toupper(char char1)
    {
        return xtoupper(char1);
    }
 
    template <> inline int CXTCharArray<char>::xchar_tolower(char char1)
    {
        return xtolower(char1);
    }
 
    template <> inline int CXTCharArray<char>::xchar_vnprintf(char *buffer, SIZET count, const char *format, va_list argptr)
    {
        return xvnprintf(buffer, count, format, argptr);
    }
 
    template <> inline int CXTCharArray<char>::xchar_vscanf_s(const char *buffer, const char *format, va_list argptr)
    {
        return xvscanf_s(buffer, format, argptr);
    }
 
    // Specialization wchar_t
    template <> inline void CXTCharArray<wchar_t>::xchar_memset(wchar_t *str, wchar_t value, SIZET count)
    {
        return xwmemset(str, value, count);
    }
 
    template <> inline SIZET CXTCharArray<wchar_t>::xchar_strlen(const wchar_t *str)
    {
        return xwstrlen(str);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_strcmp(const wchar_t *char1, const wchar_t *char2)
    {
        return xwstrcmp(char1, char2);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_strcoll(const wchar_t *char1, const wchar_t *char2)
    {
        return xwstrcoll(char1, char2);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_stricoll(const wchar_t *char1, const wchar_t *char2)
    {
        return xwstricoll(char1, char2);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_stricmp(const wchar_t *char1, const wchar_t *char2)
    {
        return xwstricmp(char1, char2);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_isspace(wchar_t char1)
    {
        return xwisspace(char1);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_toupper(wchar_t char1)
    {
        return xwtoupper(char1);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_tolower(wchar_t char1)
    {
        return xwtolower(char1);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_vnprintf(wchar_t *buffer, SIZET count, const wchar_t *format, va_list argptr)
    {
        return xwvnprintf(buffer, count, format, argptr);
    }
 
    template <> inline int CXTCharArray<wchar_t>::xchar_vscanf_s(const wchar_t *buffer, const wchar_t *format, va_list argptr)
    {
        return xwvscanf_s(buffer, format, argptr);
    }
 
    // Implementation
    template <class XCHAR> inline CXTCharArray<XCHAR>::CXTCharArray()
    {
        buffer = NULL;
        init();
    }
 
    template <class XCHAR> inline CXTCharArray<XCHAR>::CXTCharArray(const XCHAR *string, size_t charCount)
    {
        buffer = NULL;
        bufCharCount = 0;
        maxBufCount = 0;
        assign(string, charCount);
    }
 
    template <class XCHAR> inline CXTCharArray<XCHAR>::CXTCharArray(XCHAR value, size_t charCount)
    {
        buffer = NULL;
        bufCharCount = 0;
        maxBufCount = 0;
 
        setlength(charCount);
        if (charCount > 0)
            xchar_memset(buffer, value, charCount);
    }
 
    template <class XCHAR> inline CXTCharArray<XCHAR>::~CXTCharArray()
    {
        xfree(buffer);
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::setlength(SIZET newCharCount)
    {
        size_t newSize = (newCharCount+1)*sizeof(XCHAR); // don't forget null
        if (newSize <= maxBufCount*sizeof(XCHAR))
        {
            bufCharCount = (varint)newCharCount;
            buffer[bufCharCount] = '\0';
            return;
        }
 
        maxBufCount = (varint)((newCharCount * 2)+1);
        if (maxBufCount < firstCharCount)
            maxBufCount = firstCharCount;
        else if (maxBufCount < secondCharCount)
            maxBufCount = secondCharCount;
        
        buffer = (XCHAR *)xrealloc(buffer, maxBufCount*sizeof(XCHAR));
        bufCharCount = (varint)newCharCount;
        buffer[bufCharCount] = '\0';
    }
 
    template<class XCHAR> inline void CXTCharArray<XCHAR>::init()
    {
        if (buffer)
            xfree(buffer);
 
        buffer = NULL;
        bufCharCount = 0;
        maxBufCount = 0;
 
        setlength(0);
    }
 
    template <class XCHAR> inline varint CXTCharArray<XCHAR>::length() const
    {
        return bufCharCount;
    }
 
    template<class XCHAR> inline bool CXTCharArray<XCHAR>::belongto(varint index, const XCHAR *string, size_t charSetCount) const
    {
        if (index < 0 || index >= bufCharCount)
            return false;
 
        if (string == NULL)
            return false;
 
        XASSERT(charSetCount <= xchar_strlen(string));
        if (charSetCount == -1)
            charSetCount = xchar_strlen(string);
 
        if (charSetCount == 0)
            return false;
 
        size_t pos = 0;
        const XCHAR *chars = &buffer[index];
        while (pos < charSetCount)
        {
            if (*chars == *string)
                return true;
 
            string++;
            pos++;
        }
 
        return false;
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::remove(varint first, size_t charCount)
    {
        if (first < 0 || first >= length() || charCount == 0)
            return;
 
        if (charCount == (size_t)(-1) || first + (varint)charCount >= length())
            bufCharCount = first;
        else
        {
            size_t copyCount = size_t(length()-(first + charCount));
            xmemmove_s(buffer + first, (bufCharCount-first)*sizeof(XCHAR), buffer + first + charCount, copyCount*sizeof(XCHAR));
            bufCharCount -= (varint)charCount;
        }
    
        setlength(bufCharCount);
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::assign(const CXTCharArray<XCHAR>& chars, varint first, size_t charCount)
    {
        if (first > chars.length() || charCount == 0)
        {
            setlength(0);
            return;
        }
 
        if (charCount == (size_t)(-1) || first + (varint)charCount > chars.length())
            charCount = size_t(chars.length() - first);
 
        setlength(charCount);
        xmemcpy_s(buffer, bufCharCount*sizeof(XCHAR), chars.buffer+first, charCount*sizeof(XCHAR));
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::assign(const XCHAR *string, size_t charCount)
    {
        if (string == NULL)
            charCount = 0;
        else if (charCount == (size_t)(-1))
            charCount = xchar_strlen(string);
 
        setlength(charCount);
 
        if (charCount > 0)
            xmemcpy_s(buffer, bufCharCount*sizeof(XCHAR), string, charCount*sizeof(XCHAR));
    }
 
    template <class XCHAR> inline size_t CXTCharArray<XCHAR>::insert(varint index, const XCHAR *string, size_t charCount)
    {
        if (charCount == 0 || string == NULL)
            return 0;
 
        if (index < 0 || index > bufCharCount)
            return 0;
 
        XASSERT(charCount == -1 || charCount <= xchar_strlen(string));
        if (charCount == -1)
            charCount = xchar_strlen(string);
 
        varint prevSize = bufCharCount;
        setlength(bufCharCount + charCount);
 
        if (prevSize-index > 0)
            xmemmove_s(buffer + index + charCount, (bufCharCount-(index+charCount))*sizeof(XCHAR), buffer+index, (prevSize - index)*sizeof(XCHAR));
 
        xmemcpy_s(buffer + index, (bufCharCount-index)*sizeof(XCHAR), string, charCount*sizeof(XCHAR));
 
        return charCount;
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::append(const XCHAR *string, size_t charCount)
    {
        size_t prevSize = bufCharCount;
 
        XASSERT(charCount == (size_t)(-1) || charCount <= xchar_strlen(string));
        if (string == NULL)
            charCount = 0;
        else if (charCount == (size_t)-1)
            charCount = xchar_strlen(string);
        
        setlength(prevSize + charCount);
 
        if (charCount > 0)
            xmemcpy_s(buffer + prevSize, (bufCharCount-prevSize)*sizeof(XCHAR), string, charCount*sizeof(XCHAR));
    }
 
    template <class XCHAR> inline const XCHAR *CXTCharArray<XCHAR>::data() const
    {
        return buffer;
    }
 
    template <class XCHAR> inline XCHAR *CXTCharArray<XCHAR>::data()
    {
        return buffer;
    }
 
    template <class XCHAR> inline XCHAR *CXTCharArray<XCHAR>::detach()
    {
        XCHAR *buf = buffer;
        buffer = NULL;
        return buf;
    }
 
    template <class XCHAR> inline void CXTCharArray<XCHAR>::empty()
    {
        setlength(0);
    }
#endif // inline
 
END_MOOTOOLS_NAMESPACE
 
#include "xstringoperation.h"
 
#ifdef __LINUX__
#define XSTRING_FRIEND template<XCHAR> // Avoid warning: friend declaration declares a non-template function [-Wnon-template-friend]
#else
#define XSTRING_FRIEND  // defining template<XCHAR> makes VS having trouble to deduces template args
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
//! @class CXTString
//! @brief CXStringT is the template class for handling strings.
//! @details CXStringT is declined and CXStringW (unicode strings) and CXStringA (ansi or utf8 strings).
//!
//!  CXString is the default string class. It depends on the OS:
//! * CXString = CXStringW under Windows.
//! * CXString = CXStringA under Linux or Macos. In that case, the string are encoded in UTF8.
//!
//! There are also convenient defines such:
//! * LPCWSTR / LPWSTR for a pointer to const wchar_t or wchar_t
//! * LPCSTR / LPSTR for a pointer to const char / char
//!
//! A generic defines is declared and depends on the OS:
//! * LPCTSTR / LPTSTR which is a const pointer / pointer on wchar_t * under Windows
//! * LPCTSTR / LPTSTR which is a const pointer / pointer on char * under Linux and Macos
//! 
//! CXString contains all needed methods to add, substract, extract, convert, format, scan strings.\n
//! XCW2A, XCA2W are convenients class to convert unicode to ansi / utf8 and vice versa.
//! 
//! @template XCHAR is char or wchar_t
//! 
    template<class XCHAR> class DLL_TOOLSFUNCTION CXTString
    {
        typedef XCHAR* LPXSTR;
        typedef const XCHAR* LPCXSTR;
        typedef CXTCharArray<XCHAR> XARRAYSTR;
 
        // friend functions of CXTString
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION CXTString<XCHAR> operator + (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION CXTString<XCHAR> operator + (const CXTString<XCHAR>& string, LPCXSTR pszText);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION CXTString<XCHAR> operator + (const CXTString<XCHAR>& string, XCHAR ch);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION CXTString<XCHAR> operator + (LPCXSTR pszText, const CXTString<XCHAR>& string);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION CXTString<XCHAR> operator + (char ch, const CXTString<XCHAR>& string);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator < (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator > (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator <= (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator >= (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator < (const CXTString<XCHAR>& string1, LPCXSTR pszText);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator > (const CXTString<XCHAR>& string1, LPCXSTR pszText);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator <= (const CXTString<XCHAR>& string1, LPCXSTR pszText);
        XSTRING_FRIEND friend DLL_TOOLSFUNCTION bool operator >= (const CXTString<XCHAR>& string1, LPCXSTR pszText);
 
#ifndef MOOTOOLS_XSTRINGS_NO_INLINE
        // friend functions of CXTString
        friend DLL_TOOLSFUNCTION inline CXTString<XCHAR> operator + (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2)
        {
            CXTString str(string1);
            str.m_str.append(string2.m_str.data());
            return str;
        }
 
        friend DLL_TOOLSFUNCTION inline CXTString<XCHAR> operator + (const CXTString<XCHAR>& string, typename CXTString<XCHAR>::LPCXSTR pszText)
        {
            CXTString str(string);
            if (pszText)
                str.m_str.append(pszText);
            return str;
        }
 
        friend DLL_TOOLSFUNCTION inline CXTString<XCHAR> operator + (const CXTString<XCHAR>& string, XCHAR ch)
        {
            CXTString str(string);
            str.m_str.append(&ch, 1);
            return str;
        }
 
        friend DLL_TOOLSFUNCTION inline CXTString<XCHAR> operator + (typename CXTString<XCHAR>::LPCXSTR pszText, const CXTString<XCHAR>& string)
        {
            CXTString str(pszText);
            str.m_str.append(string);
            return str;
        }
 
        friend DLL_TOOLSFUNCTION inline CXTString<XCHAR> operator + (char ch, const CXTString<XCHAR>& string)
        {
            CXTString str(ch);
            str.m_str.append(string);
            return str;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator < (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2)
        {
            return string1.Compare(string2) < 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator > (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2)
        {
            return string1.Compare(string2) > 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator <= (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2)
        {
            return string1.Compare(string2) <= 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator >= (const CXTString<XCHAR>& string1, const CXTString<XCHAR>& string2)
        {
            return string1.Compare(string2) >= 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool    operator < (const CXTString<XCHAR>& string1, typename CXTString<XCHAR>::LPCXSTR pszText)
        {
            return string1.Compare(pszText) < 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool    operator > (const CXTString<XCHAR>& string1, typename CXTString<XCHAR>::LPCXSTR pszText)
        {
            return string1.Compare(pszText) > 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator <= (const CXTString<XCHAR>& string1, typename CXTString<XCHAR>::LPCXSTR pszText)
        {
            return string1.Compare(pszText) <= 0;
        }
 
        friend DLL_TOOLSFUNCTION inline bool operator >= (const CXTString<XCHAR>& string1, typename CXTString<XCHAR>::LPCXSTR pszText)
        {
            return string1.Compare(pszText) >= 0;
        }
#endif // inline
 
        int FindInternal(LPCXSTR pszText, int nStart, bool endpos) const;
        int FindInternalNoCase(LPCXSTR pszText, int nStart, bool endpos) const;
 
    public:
        CXTString();
        ~CXTString();
        CXTString(const CXTString<XCHAR>& str);
        CXTString(LPCSTR pszText);
        CXTString(LPCWSTR pszText);
        CXTString(XCHAR ch, int nLength = 1);
        CXTString(LPCXSTR pszText, int nLength);
 
        CXTString<XCHAR>& operator = (const CXTString<XCHAR>& str);
        CXTString<XCHAR>& operator = (const XCHAR ch);
        CXTString<XCHAR>& operator = (const unsigned char *pszText);
        CXTString<XCHAR>& operator = (LPCSTR pszText);
        CXTString<XCHAR>& operator = (LPCWSTR pszText);
 
        void Copy(LPCXSTR szText, int nCount); // Faster than operator = if we know the number of bytes to copy
 
        bool operator == (LPCXSTR pszText) const;
        bool operator != (LPCXSTR pszText) const;
        operator LPCXSTR() const;
        operator CXTCharArray<XCHAR>&();
        XCHAR operator [] (int nIndex);
        CXTString<XCHAR>& operator += (XCHAR ch);
        CXTString<XCHAR>& operator += (const CXTString<XCHAR>& str);
        CXTString<XCHAR>& operator += (LPCSTR szText);
        CXTString<XCHAR>& operator += (LPCWSTR szText);
 
        // Attributes
        static xStringEncoding GetDefaultEncoding();
        int GetLength() const; //!< returns the length of the buffer in characters (can be greater than strlen, if set by GetBufferSetLength)
 
        // Operations
        void AppendFormat(LPCXSTR pszFormat,...);
        void AppendFormat(unsigned int nFormatID, ...);
        int Compare(LPCXSTR pszText) const;
        int CompareNoCase(LPCXSTR pszText) const;
        int Delete(int nIndex, int nCount = 1);
        int Find(XCHAR ch, int nIndex = 0) const;
        int FindNoCase(XCHAR ch, int nIndex = 0) const;
        int Find(LPCXSTR pszText, int nStart = 0, bool caseInsensitive = false) const;
        int FindEndPos(LPCXSTR pszText, int nStart = 0, bool caseInsensitive = false) const;
        int FindOneOf(LPCXSTR pszText) const;
        int ScanS(LPCXSTR pszFormat, ...) const;
        int ScanVS(LPCXSTR pszFormat, va_list args) const;
        int ScanVS(int offsetCount, LPCXSTR pszFormat, va_list args) const;
        void Format(unsigned int nID, ...);
        void Format(LPCXSTR pszFormat,...);
        void FormatV(LPCXSTR pszFormat, va_list args);
        XCHAR GetAt(int nIndex) const;
        LPCXSTR GetAtPtr(int nIndex) const;
        LPCXSTR GetConstBuffer(int nMinBufLength = -1);
        LPXSTR GetBuffer(int nMinBufLength = -1);
        LPXSTR GetBufferSetLength(int nBufferLength);
        void ReleaseBuffer(int nNewLength = -1);
        LPXSTR DetachBuffer();  //!< Detach buffer. Caller must free buffer with xfree
        void Empty();
        int Insert(int nIndex, XCHAR ch);
        int Insert(int nIndex, const CXTString<XCHAR>& str);
        bool IsEmpty() const;
        CXTString Left(int nCount) const;
        bool LoadString(unsigned int nID);
        void MakeLower(int count = -1);
        void MakeReverse();
        void MakeUpper(int count = -1);
        CXTString Mid(int nFirst, int nCount = -1) const;
        int Remove(XCHAR ch);
        int Remove(LPCXSTR pszText, bool caseInsensitive = false);
        int Replace(XCHAR chOld, XCHAR chNew);
        int Replace(LPCXSTR pszOld, LPCXSTR pszNew);
        int ReverseFind(XCHAR pszText, int nStart = -1) const;
        int ReverseFind(LPCXSTR pszText, int nStart = -1) const;
        CXTString Right(int nCount) const;
        void SetAt(int nIndex, XCHAR ch);
        CXTString SpanExcluding(LPCXSTR pszText) const;
        CXTString SpanIncluding(LPCXSTR pszText) const;
        CXTString Tokenize(LPCXSTR pszTokens, int& iStart) const;
        void Trim(); //!< Remove left and right space char
        void TrimLeft();
        void TrimLeft(XCHAR chTarget); //!< Remove left specified character
        void TrimLeft(LPCXSTR pszTargets); //!< Remove any character from pszTargets string on the left side of the string
        void TrimRight();
        void TrimRight(XCHAR chTarget);
        void TrimRight(LPCXSTR pszTargets);
        int Collate(LPCXSTR pszText) const;
        int CollateNoCase(LPCXSTR pszText) const;
 
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
        CXTString(const CStringA& txt);
        CXTString<XCHAR>& operator = (const CStringA& str);
        CXTString(const CStringW& txt);
        CXTString<XCHAR>& operator = (const CStringW& str);
#endif
 
    private:
        XARRAYSTR m_str; // Set it first, so &CXString() points directly to the buffer
    };
    
#ifndef MOOTOOLS_XSTRINGS_NO_INLINE
    ///////////////////////////////////////////////////////////
    // CXTString implementation
 
    template <class XCHAR> inline CXTString<XCHAR>::CXTString()
    {
    }
 
    template <class XCHAR> inline CXTString<XCHAR>::~CXTString()
    {
    }
 
    template <class XCHAR> inline CXTString<XCHAR>::CXTString(const CXTString<XCHAR>& str) : m_str(str, str.GetLength())
    {
    }
 
    template <class XCHAR> inline CXTString<XCHAR>::CXTString(XCHAR ch, int nLength) : m_str(ch, nLength)
    {
    }
 
    template <class XCHAR> inline CXTString<XCHAR>::CXTString(LPCXSTR pszText, int nLength) : m_str(pszText, nLength)
    {
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::GetLength() const
    {
        return static_cast<int>(m_str.length());
    }
 
    template <class XCHAR> inline CXTString<XCHAR>& CXTString<XCHAR>::operator = (const CXTString<XCHAR>& str)
    {
        // use str.GetLength(), otherwise assign use something similar to strlen, which is not correct, as GetBufferSetLength() / ReleaseBuffer(count) leads
        // to have a buffer size which value elements (potentially containing multiple null characters). Copy must keep that size value, which is not the case using assign(str)
        m_str.assign(str, str.GetLength());
        return *this;
    }
 
    template <class XCHAR> inline CXTString<XCHAR>& CXTString<XCHAR>::operator = (const unsigned char *pszText)
    {
        *this = reinterpret_cast<LPCSTR>(pszText);
        return *this;
    }
 
    template <class XCHAR> inline CXTString<XCHAR>& CXTString<XCHAR>::operator = (const XCHAR ch)
    {
        m_str.assign(&ch, 1);
        return *this;
    }
 
    template <class XCHAR> inline bool CXTString<XCHAR>::operator == (LPCXSTR pszText) const
    // Returns TRUE if the strings have the same content
    {
        return (Compare(pszText) == 0);
    }
 
    template <class XCHAR> inline bool CXTString<XCHAR>::operator != (LPCXSTR pszText) const
    // Returns TRUE if the strings have a different content
    {
        return (Compare(pszText) != 0);
    }
 
    template <class XCHAR> inline CXTString<XCHAR>::operator LPCXSTR() const
    {
        return m_str.data();
    }
 
    template<class XCHAR>
    inline CXTString<XCHAR>::operator CXTCharArray<XCHAR>&()
    {
        return m_str;
    }
 
    template <class XCHAR> inline XCHAR CXTString<XCHAR>::operator [] (int nIndex)
    {
        XASSERT(nIndex >= 0);
        XASSERT(nIndex < GetLength());
        return m_str.data()[nIndex];
    }
 
    template <class XCHAR> inline CXTString<XCHAR>& CXTString<XCHAR>::operator += (XCHAR ch)
    {
        m_str.append(&ch, 1);
        return *this;
    }
 
    template <class XCHAR> inline CXTString<XCHAR>& CXTString<XCHAR>::operator += (const CXTString<XCHAR>& str)
    {
        m_str.append(str);
        return *this;
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::AppendFormat(LPCXSTR pszFormat,...)
    // Appends formatted data to an the CXTString content.
    {
        if (!pszFormat)
            return;
 
        CXTString str;
 
        va_list args;
        va_start(args, pszFormat);
        str.FormatV(pszFormat, args);
        va_end(args);
 
        m_str.append(str);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::AppendFormat(unsigned int nFormatID, ...)
    // Appends formatted data to an the CXTString content.
    {
        CXTString str1;
        CXTString str2;
 
        if (str1.LoadString(nFormatID))
        {
            va_list args;
            va_start(args, nFormatID);
            str2.FormatV(str1.m_str.data(), args);
            va_end(args);
 
            m_str.append(str2);
        }
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Collate(LPCXSTR pszText) const
    // Performs a case sensitive comparison of the two strings using locale-specific information.
    {
        if (pszText == NULL && GetLength() == 0)
            return 0;
 
        if (pszText == NULL) // GetLength() != 0
            return 1;
 
        return CXTCharArray<XCHAR>::xchar_strcoll(m_str.data(), pszText);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::CollateNoCase(LPCXSTR pszText) const
    // Performs a case insensitive comparison of the two strings using locale-specific information.
    {
        if (pszText == NULL && GetLength() == 0)
            return 0;
 
        if (pszText == NULL) // GetLength() != 0
            return 1;
 
        return CXTCharArray<XCHAR>::xchar_stricoll(m_str.data(), pszText);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Compare(LPCXSTR pszText) const
    // Performs a case sensitive comparison of the two strings.
    {
        if (pszText == NULL && GetLength() == 0)
            return 0;
 
        if (pszText == NULL) // GetLength() != 0
            return 1;
 
        return CXTCharArray<XCHAR>::xchar_strcmp(m_str.data(), pszText);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::CompareNoCase(LPCXSTR pszText) const
    // Performs a case insensitive comparison of the two strings.
    {
        if (pszText == NULL && GetLength() == 0)
            return 0;
 
        if (pszText == NULL) // GetLength() != 0
            return 1;
 
        return CXTCharArray<XCHAR>::xchar_stricmp(m_str.data(), pszText);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Delete(int nIndex, int nCount /* = 1 */)
    // Deletes a character or characters from the string.
    {
        XASSERT(nIndex >= 0 && nIndex < GetLength());
        XASSERT(nCount >= 0);
        if (nIndex < 0 || nIndex >= GetLength())
            return GetLength();
 
        if (nCount <= 0)
            return GetLength();
 
        m_str.remove(nIndex, nCount);
        return (int)GetLength();
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::Empty()
    // Erases the contents of the string.
    {
        m_str.empty();
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::SetAt(int nIndex, XCHAR ch)
        // Sets the character at the specificed position to the specified value.
    {
        XASSERT(nIndex >= 0);
        XASSERT(nIndex < m_str.length());
        if (nIndex >= m_str.length())
            return;
 
        *(m_str.data() + nIndex) = ch;
    }
 
    template <class XCHAR> inline XCHAR CXTString<XCHAR>::GetAt(int nIndex) const
    // Returns the character at the specified location within the string.
    {
        XASSERT(nIndex >= 0);
        XASSERT(nIndex < GetLength());
        if (nIndex >= GetLength())
            return 0;
 
        return m_str.data()[nIndex];
    }
 
    template <class XCHAR> inline const XCHAR* CXTString<XCHAR>::GetAtPtr(int nIndex) const
        // Returns the character at the specified location within the string.
    {
        XASSERT(nIndex >= 0);
        XASSERT(nIndex < GetLength());
        if (nIndex >= GetLength())
            return NULL;
 
        return &m_str.data()[nIndex];
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::ReleaseBuffer(int refLength /*= -1*/)
        // This copies the contents of the buffer (acquired by GetBuffer) to this CXTString,
        // and releases the contents of the buffer. The default length of -1 copies from the
        // buffer until a null terminator is reached. If the buffer doesn't contain a null
        // terminator, you must specify the buffer's length.
    {
        XASSERT(refLength >= 0 || refLength == -1);
        SIZET newLength = refLength;
        if (newLength == -1)
            newLength = CXTCharArray<XCHAR>::xchar_strlen(m_str.data()); // string must be null terminated
 
        XASSERT((varint)newLength <= m_str.length());
        if ((varint)newLength > m_str.length())
            newLength = m_str.length() - 1;
 
        m_str.setlength(newLength);
    }
 
    template <class XCHAR> inline XCHAR *CXTString<XCHAR>::GetBufferSetLength(int nLength)
    // Creates a buffer of nLength charaters and return a pointer to this buffer. 
    // This buffer can be used by any function which accepts a LPCXSTR.
    // Care must be taken not to exceed the length of the buffer. Use ReleaseBuffer to safely
    // copy this buffer back to the CXTString object.
    {
        m_str.setlength(nLength); // The string must have the required length size, in case ReleaseBuffer not called (MFC compliant)
        return m_str.data();
    }
 
    template <class XCHAR> inline const XCHAR *CXTString<XCHAR>::GetConstBuffer(int nMinBufLength)
        // Get the string in a buffer which size is at least nMinBufLength.
        // if nMinBufLength lower than the string size+1 (null char), then nMinBufLength is set to the string size+1
    {
        if (nMinBufLength < static_cast<int>(m_str.length())) // Include trailing null char
            nMinBufLength = static_cast<int>(m_str.length());
 
        return GetBufferSetLength(nMinBufLength);
    }
 
    template <class XCHAR> inline XCHAR *CXTString<XCHAR>::GetBuffer(int nMinBufLength)
    // Get the string in a buffer which size is at least nMinBufLength.
    // if nMinBufLength lower than the string size+1 (null char), then nMinBufLength is set to the string size+1
    {
        if (nMinBufLength < static_cast<int>(m_str.length())) // Include trailing null char
            nMinBufLength = static_cast<int>(m_str.length());
 
        return GetBufferSetLength(nMinBufLength);
    }
 
    template <class XCHAR> inline XCHAR *CXTString<XCHAR>::DetachBuffer()
    {
        return m_str.detach();
    }
    
    template <class XCHAR> inline int CXTString<XCHAR>::Insert(int nIndex, XCHAR ch)
    // Inserts a single character or a substring at the given index within the string.
    {
        XASSERT(nIndex >= 0);
        XASSERT(ch);
 
        m_str.insert(nIndex, &ch, 1);
        return (int)m_str.length();
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Insert(int nIndex, const CXTString<XCHAR>& str)
    // Inserts a single character or a substring at the given index within the string.
    {
        XASSERT(nIndex >= 0 && nIndex <= GetLength());
 
        m_str.insert(nIndex, str);
        return (int)m_str.length();
    }
 
    template <class XCHAR> inline bool CXTString<XCHAR>::IsEmpty() const
    // Returns TRUE if the string is empty
    {
        return (m_str.length() == 0);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::MakeLower(int count)
    // Converts all the characters in this string to lowercase characters.
    {
        varint length = m_str.length();
        if (count != -1 && count < length)
            length = count;
 
        XCHAR *chars = m_str.data();
        varint pos = 0;
        while (pos < length)
        {
            *chars = (XCHAR)m_str.xchar_tolower(*chars);
            chars++;
            pos++;
        }
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::MakeReverse()
    // Reverses the string.
    {
        XCHAR tmp;
        varint length = m_str.length();
        XCHAR *beginchars = m_str.data();
        XCHAR *endchars = beginchars + length;
        while (beginchars < endchars)
        {
            tmp = *endchars;
            *endchars = *beginchars;
            *beginchars = tmp;
 
            beginchars++;
            endchars--;
        }
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::MakeUpper(int count)
    // Converts all the characters in this string to uppercase characters.
    {
        varint length = m_str.length();
        if (count != -1 && count < length)
            length = count;
 
        XCHAR *chars = m_str.data();
        varint pos = 0;
        while (pos < length)
        {
            *chars = (XCHAR)m_str.xchar_toupper(*chars);
            chars++;
            pos++;
        }
    }
 
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::Mid(int nFirst, int nCount) const
    // Extracts the middle part of a string.
    {
        XASSERT(nCount == -1 || nCount >= 0);
        if (nFirst < 0)
            nFirst = 0;
 
        if (nCount >= 0 && (nFirst + nCount > m_str.length()))
            nCount = LInt2Int(m_str.length()- nFirst);
 
        CXTString str;
        str.m_str.assign(m_str, nFirst, nCount);
        return str;
    }
 
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::Left(int nCount) const
        // Extracts the left part of a string.
    {
        if (nCount < 0)
            return CXTString();
 
        if (nCount > m_str.length())
            nCount = LInt2Int(m_str.length());
 
        return CXTString(m_str.data(), nCount);
    }
    
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::Right(int nCount) const
        // Extracts the right part of a string.
    {
        if (nCount < 0)
            return CXTString();
 
        if (nCount > m_str.length())
            nCount = LInt2Int(m_str.length());
 
        return CXTString(m_str.data() + m_str.length() - nCount, nCount);
    }
    
    template <class XCHAR> inline int CXTString<XCHAR>::FindOneOf(LPCXSTR pszText) const
        // Finds the first matching character from a set.
    {
        if (!pszText)
            return (int)-1;
 
        size_t searchLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (searchLength == 0)
            return -1;
 
        int nIndex = 0;
        size_t i = 0;
        while (i < searchLength)
        {
            if ((nIndex = Find(pszText[i])) != -1)
                return nIndex;
            i++;
        }
 
        return -1;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Find(XCHAR ch, int nIndex /* = 0 */) const
        // Finds a character in the string.
    {
        XASSERT(nIndex >= 0);
        if (nIndex >= GetLength())
            return -1;
 
        varint length = m_str.length();
        const XCHAR *chars = m_str.data();
        varint pos = nIndex;
        while (pos < length)
        {
            if (chars[pos] == ch)
                return LInt2Int(pos);
 
            pos++;
        }
 
        return -1;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::FindNoCase(XCHAR ch, int nIndex /* = 0 */) const
        // Finds a character in the string.
    {
        XASSERT(nIndex >= 0);
        if (nIndex >= GetLength())
            return -1;
 
        ch = xttolower(ch);
 
        varint length = m_str.length();
        const XCHAR* chars = m_str.data();
        varint pos = nIndex;
        while (pos < length)
        {
            if (xttolower(chars[pos]) == ch)
                return LInt2Int(pos);
 
            pos++;
        }
 
        return -1;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::FindEndPos(LPCXSTR pszText, int nIndex /* = 0 */, bool caseInsensitive) const
        // Finds a substring within the string and return the first character position after that string
    {
        return caseInsensitive ? FindInternalNoCase(pszText, nIndex, false) : FindInternal(pszText, nIndex, true);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Find(LPCXSTR pszText, int nIndex /* = 0 */, bool caseInsensitive) const
        // Finds a substring within the string.
    {
        return caseInsensitive ? FindInternalNoCase(pszText, nIndex, false) : FindInternal(pszText, nIndex, false);
    }
    
    template <class XCHAR> inline int CXTString<XCHAR>::FindInternal(LPCXSTR pszText, int nIndex, bool endpos) const
        // Finds a substring within the string.
        // If string found, it always returns a position, which can be the last null character.
    {
        XASSERT(nIndex >= 0);
        if (!pszText)
            return -1;
 
        if (nIndex >= GetLength())
            return -1;
 
        size_t searchLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (searchLength == 0)
            return -1;
 
        const XCHAR *chars = m_str.data();
        while ((nIndex = Find(pszText[0], nIndex)) != -1)
        {
            size_t firstpos = nIndex, i = 0;
            while (++i < searchLength) // First char already found
            {
                nIndex++;
                if (nIndex >= GetLength())
                    return -1;
 
                if (chars[nIndex] != pszText[i])
                    break;
            }
 
            if (i == searchLength)
            {
                if (endpos)
                    firstpos += searchLength;
 
                return LInt2Int(firstpos); // This might return null termination character pos.
            }
        }
 
        return -1;
    }
    
    template <class XCHAR> inline int CXTString<XCHAR>::FindInternalNoCase(LPCXSTR pszText, int nIndex, bool endpos) const
        // Finds a substring within the string.
        // If string found, it always returns a position, which can be the last null character.
    {
        XASSERT(nIndex >= 0);
        if (!pszText)
            return -1;
 
        if (nIndex >= GetLength())
            return -1;
 
        size_t searchLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (searchLength == 0)
            return -1;
 
        const XCHAR* chars = m_str.data();
        while ((nIndex = FindNoCase(pszText[0], nIndex)) != -1)
        {
            size_t firstpos = nIndex, i = 0;
            while (++i < searchLength) // First char already found
            {
                nIndex++;
                if (nIndex >= GetLength())
                    return -1;
 
                if (xttolower(chars[nIndex]) != xttolower(pszText[i]))
                    break;
            }
 
            if (i == searchLength)
            {
                if (endpos)
                    firstpos += searchLength;
 
                return LInt2Int(firstpos); // This might return null termination character pos.
            }
        }
 
        return -1;
    }
    
    template <class XCHAR> inline int CXTString<XCHAR>::ReverseFind(XCHAR ch, int nIndex /* = -1 */) const
        // Search for a substring within the string, starting from the end.
    {
        XASSERT(nIndex == -1 || nIndex >= 0 );
        if (m_str.length() == 0)
            return -1;
 
        if (nIndex == -1 || nIndex >= m_str.length())
            nIndex = LInt2Int(m_str.length() - 1);
 
        XASSERT(nIndex >= 0);
        const XCHAR *chars = m_str.data();
        while (nIndex >= 0) // nIndex should be signed
        {
            if (chars[nIndex] == ch)
                return nIndex;
 
            nIndex--;
    }
 
        return -1;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::ReverseFind(LPCXSTR pszText, int nIndex /* = -1 */) const
    // Search for a substring within the string, starting from the end.
    {
        XASSERT(nIndex == -1 || nIndex >= 0);
        if (!pszText || m_str.length() == 0)
            return -1;
 
        if (nIndex == -1 || nIndex >= m_str.length())
            nIndex = LInt2Int(m_str.length() - 1);
 
        XASSERT(nIndex >= 0);
 
        size_t searchLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (searchLength == 0)
            return -1;
 
        const XCHAR *chars = m_str.data();
        while ((nIndex = ReverseFind(pszText[searchLength-1], nIndex)) != -1)
        {
            varint i = searchLength-1;
            while (--i >= 0) // last char already found
            {
                nIndex--;
                if (nIndex < 0)
                    return -1;
 
                if (chars[nIndex] != pszText[i])
                    break;
            }
 
            if (i < 0)
                return nIndex;
        }
 
        return -1;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Remove(XCHAR ch)
    // Removes each occurrence of the specified substring from the string.
    {
        varint removed = 0, length = m_str.length();
        varint pos = 0;
        const XCHAR *chars = m_str.data();
        while (pos < length)
        {
            if (chars[pos] == ch)
        {
                m_str.remove(pos, 1);
                removed++;
                length--;
            }
            else
                pos++;
        }
 
        return LInt2Int(removed);
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Remove(LPCXSTR pszText, bool noCase)
    // Removes each occurrence of the specified substring from the string.
    {
        if (pszText == NULL)
            return 0;
 
        size_t length = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (length == 0)
            return 0;
 
        int nCount = 0;
        int pos = 0;
        while ((pos = Find(pszText, pos, noCase)) != -1)
        {
            m_str.remove(pos, length);
            ++nCount;
        }
 
        return nCount;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Replace(XCHAR chOld, XCHAR chNew)
    // Replaces each occurance of the old character with the new character.
    {
        varint length = m_str.length();
        XCHAR *chars = m_str.data();
 
        int nCount = 0;
        varint pos = 0;
        while (pos < length)
        {
            if (*chars == chOld)
            {
                *chars = chNew;
                nCount++;
            }
            chars++;
            pos++;
        }
 
        return nCount;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::Replace(LPCXSTR pszOld, LPCXSTR pszNew)
    // Replaces each occurance of the old substring with the new substring.
    {
        if (pszOld == NULL || pszNew == NULL)
            return 0;
 
        size_t oldlength = CXTCharArray<XCHAR>::xchar_strlen(pszOld);
        size_t newlength = CXTCharArray<XCHAR>::xchar_strlen(pszNew);
 
        int nCount = 0;
        varint pos = 0;
        while ((pos = Find(pszOld, (int)pos)) != -1)
        {
            m_str.remove(pos, oldlength);
            pos += (varint)m_str.insert(pos, pszNew, newlength);
            ++nCount;
        }
 
        return nCount;
    }
 
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::SpanExcluding(LPCXSTR pszText) const
    // Extracts characters from the string, starting with the first character,
    // that are not in the set of characters identified by pszCharSet.
    {
        if (pszText == NULL)
            return CXTString<XCHAR>();
 
        size_t spanLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (spanLength == 0)
            return *this;
 
        varint pos = 0;
        varint length = m_str.length();
 
        CXTString str;
        const XCHAR *chars = m_str.data();
        while (pos < length)
        {
            if (!m_str.belongto(pos, pszText, spanLength))
                str.m_str.append(chars + pos, 1);
 
            pos++;
        }
 
        return str;
    }
 
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::SpanIncluding(LPCXSTR pszText) const
    // Extracts a substring that contains only the characters in a set.
    {
        if (pszText == NULL)
            return CXTString<XCHAR>();
 
        size_t spanLength = CXTCharArray<XCHAR>::xchar_strlen(pszText);
        if (spanLength == 0)
            return CXTString<XCHAR>();
 
        varint pos = 0;
        varint length = m_str.length();
 
        CXTString str;
        const XCHAR *chars = m_str.data();
        while (pos < length)
        {
            if (m_str.belongto(pos, pszText, spanLength))
                str.m_str.append(chars + pos, 1);
 
            pos++;
        }
 
        return str;
    }
 
    template <class XCHAR> inline CXTString<XCHAR> CXTString<XCHAR>::Tokenize(LPCXSTR pszTokens, int& index) const
    // Extracts specified tokens in a target string.
    {
        varint length = m_str.length();
 
        if (index < 0 || index >= (varint)length)
        {
            index = -1;
            return CXTString();
        }
        
        if (!pszTokens)
        {
            index = -1;
            return CXTString();
        }
 
        size_t tokenLength = CXTCharArray<XCHAR>::xchar_strlen(pszTokens);
        if (tokenLength == 0)
        {
            index = -1;
            return CXTString();
        }
 
        varint pos = index;
        varint otherpos = -1;
        while (pos < length)
        {
            if (!m_str.belongto(pos, pszTokens, tokenLength))
            {
                otherpos = pos++;
                break;
            }
 
            pos++;
        }
 
        varint tokenpos = -1;
        while (pos < length)
        {
            if (m_str.belongto(pos, pszTokens, tokenLength))
            {
                tokenpos = pos;
                break;
            }
 
            pos++;
        }
 
        if (tokenpos == -1)
        {
            index = -1; // no more token
            tokenpos = length;
        }
        else
            index = (int)tokenpos + 1;
 
        if (otherpos != -1)
            return Mid(LInt2Int(otherpos), LInt2Int(tokenpos-otherpos));
 
        return CXTString();
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::Trim()
    // Trims all leading and trailing whitespace characters from the string.
    {
        TrimLeft();
        TrimRight();
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimLeft()
    // Trims leading whitespace characters from the string.
    {
        varint length = m_str.length();
        varint count = 0;
        const XCHAR *chars = m_str.data();
        while (count < length)
        {
            if (!CXTCharArray<XCHAR>::xchar_isspace(*chars))
                break;
 
            chars++;
            count++;
        }
 
        m_str.remove(0, count);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimLeft(XCHAR chTarget)
    // Trims the specified character from the beginning of the string.
    {
        varint length = m_str.length();
        if (length == 0)
            return;
 
        varint count = 0;
        const XCHAR *chars = m_str.data();
        while (count < length)
        {
            if (*chars != chTarget)
                break;
 
            chars++;
            count++;
        }
 
        m_str.remove(0, count);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimLeft(LPCXSTR pszTargets)
    // Trims the specified set of characters from the beginning of the string.
    {
        if (pszTargets == NULL)
            return;
 
        size_t targetLength = CXTCharArray<XCHAR>::xchar_strlen(pszTargets);
        if (targetLength <= 0)
            return;
 
        varint length = m_str.length();
        if (length == 0)
            return;
 
        varint count = 0;
        while (count < length)
        {
            if (!m_str.belongto(count, pszTargets, targetLength))
                break;
 
            count++;
        }
 
        m_str.remove(0, count);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimRight()
    // Trims trailing whitespace characters from the string.
    {
        varint length = m_str.length();
        varint count = 0;
        const XCHAR *chars = m_str.data();
        chars += (length-1);
        while (count < length)
        {
            if (!CXTCharArray<XCHAR>::xchar_isspace(*chars))
                break;
 
            chars--;
            count++;
        }
 
        m_str.remove(size_t(length - count), count);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimRight(XCHAR chTarget)
    // Trims the specified character from the end of the string.
    {
        varint length = m_str.length();
        if (length == 0)
            return;
 
        varint count = 0;
        const XCHAR *chars = m_str.data();
        chars += (length-1);
        while (count < length)
        {
            if (*chars != chTarget)
                break;
 
            chars--;
            count++;
        }
 
        m_str.remove(size_t(length - count), count);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::TrimRight(LPCXSTR pszTargets)
    // Trims the specified set of characters from the end of the string.
    {
        if (pszTargets == NULL)
            return;
 
        size_t targetLength = CXTCharArray<XCHAR>::xchar_strlen(pszTargets);
        if (targetLength <= 0)
            return;
 
        varint length = m_str.length();
        if (length == 0)
            return;
 
        varint count = 0;
        while (count < length)
        {
            if (!m_str.belongto(size_t(length-count-1), pszTargets, targetLength))
                break;
 
            count++;
        }
 
        m_str.remove(size_t(length - count), count);
    }
 
    // Scan
    template <class XCHAR> inline int CXTString<XCHAR>::ScanS(LPCXSTR pszFormat, ...) const
        // Formats the string as sprintf does.
    {
        if (pszFormat == NULL)
            return 0;
 
        va_list args;
        va_start(args, pszFormat);
        int result = ScanVS(pszFormat, args);
        va_end(args);
 
        return result;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::ScanVS(LPCXSTR pszFormat, va_list args) const
    {
        if (pszFormat && GetLength() > 0)
            return CXTCharArray<XCHAR>::xchar_vscanf_s(m_str.data(), pszFormat, args);
        
        return 0;
    }
 
    template <class XCHAR> inline int CXTString<XCHAR>::ScanVS(int offsetCount, LPCXSTR pszFormat, va_list args) const
    {
        if (pszFormat && GetLength() > offsetCount)
            return CXTCharArray<XCHAR>::xchar_vscanf_s(m_str.data()+offsetCount, pszFormat, args);
        
        return 0;
    }
 
    // Format
    template <class XCHAR> inline void CXTString<XCHAR>::Format(LPCXSTR pszFormat, ...)
        // Formats the string as sprintf does.
    {
        if (pszFormat == NULL)
            return;
 
        va_list args;
        va_start(args, pszFormat);
        FormatV(pszFormat, args);
        va_end(args);
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::Format(unsigned int nID, ...)
        // Formats the string as sprintf does.
    {
        CXTString str;
        if (str.LoadString(nID))
        {
            va_list args;
            va_start(args, nID);
            FormatV(str.m_str.data(), args);
            va_end(args);
        }
    }
 
    template <class XCHAR> inline void CXTString<XCHAR>::FormatV(LPCXSTR pszFormat, va_list args)
    // Formats the string using a variable list of arguments.
    {
        if (pszFormat == NULL)
            return;
 
        va_list argscpy; // Needed as a single access is allowed for args on some OS
        va_copy(argscpy, args);
        int length = CXTCharArray<XCHAR>::xchar_vnprintf(0, 0, pszFormat, argscpy);
        va_end(argscpy);
 
        if (length == -1)
        {
            Empty();
#ifdef _DEBUG
            XTRACE(_T("CXTString<XCHAR>::Format: an error occurs when formatting the string\n"));
#endif
            return;
        }
 
        m_str.setlength(length); // this add space for null char
 
#ifdef _DEBUG
        int result = CXTCharArray<XCHAR>::xchar_vnprintf(m_str.data(), length+1, pszFormat, args); // null char must be counted
        if (result != length)
            XTRACE(_T("CXTString<XCHAR>::Format: computed buffer is too short (%d != %d)\n"), result, length);
#else
        CXTCharArray<XCHAR>::xchar_vnprintf(m_str.data(), length+1, pszFormat, args);
#endif
    }
 
    template <class XCHAR> bool CXTString<XCHAR>::LoadString(unsigned int resourceID)
    {
        *this = xLoadString(resourceID);
        return !IsEmpty();
    }
 
    ///////////////////////////////////////////////////////////////////////////////////////////
    // Specialization
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>::CXTString(LPCSTR pszText)
    {
        if (pszText)
            m_str.assign(pszText);
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>::CXTString(LPCWSTR pszText)
    {
        if (pszText)
            m_str.assign(pszText);
    }
 
    template<> inline DLL_TOOLSFUNCTION
        xStringEncoding CXTString<char>::GetDefaultEncoding()
    {
    #ifdef __WINDOWS__
        return xStringAnsi;
    #elif defined(__APPLE__) || defined(__LINUX__)
        return xStringUtf8;
    #endif
    }
 
    template<> inline DLL_TOOLSFUNCTION
    xStringEncoding CXTString<wchar_t>::GetDefaultEncoding()
    {
    #ifdef __WINDOWS__
        return xStringUtf16;
    #elif defined(__APPLE__) || defined(__LINUX__)
        return xStringUtf16;
    #endif
    }
 
    // Assignements
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator = (LPCSTR pszText)
    {
        if (pszText)
            m_str.assign(pszText);
        else
            m_str.empty();
 
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator = (LPCWSTR pszText)
    {
        if (pszText)
            m_str.assign(pszText);
        else
            m_str.empty();
 
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator += (LPCSTR szText)
    {
        if (szText)
            m_str.append(szText);
 
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator += (LPCWSTR szText)
    {
        if (szText)
            m_str.append(szText);
 
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>::CXTString(LPCWSTR pszText)
    {
        XFASTCW2A(m_str, pszText);
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>::CXTString(LPCSTR pszText)
    {
        XFASTCA2W(m_str, pszText);
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator = (LPCWSTR pszText)
    {
        XFASTCW2A(m_str, pszText);
        return *this;
    }
 
    template<class XCHAR>
    inline void CXTString<XCHAR>::Copy(LPCXSTR pszText, int nCount)
    {
        if (pszText && nCount > 0)
            m_str.assign(pszText, nCount);
        else
            m_str.empty();
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator = (LPCSTR pszText)
    {
        XFASTCA2W(m_str, pszText);
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator += (LPCWSTR szText)
    {
        if (szText)
            m_str.append(XCW2A(szText));
 
        return *this;
    }
 
    template<> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator += (LPCSTR szText)
    {
        if (szText)
            m_str.append(XCA2W(szText));
 
        return *this;
    }
 
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
    template <> inline DLL_TOOLSFUNCTION
    CXTString<char>::CXTString(const CStringA& string) : CXTString((LPCSTR)string)
    {
    }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<char>::CXTString(const CStringW& string) : CXTString((LPCWSTR)string)
    {
    }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>::CXTString(const CStringA& string) : CXTString((LPCSTR)string)
    {
    }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>::CXTString(const CStringW& string) : CXTString((LPCWSTR)string)
    {
    }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator = (const CStringA& string)
    {
        this->operator=((LPCSTR)string);
        return *this;
        }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<char>& CXTString<char>::operator = (const CStringW& string)
    {
        this->operator=((LPCWSTR)string);
        return *this;
        }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator = (const CStringA& string)
    {
        this->operator=((LPCSTR)string);
        return *this;
    }
 
    template <> inline DLL_TOOLSFUNCTION
    CXTString<wchar_t>& CXTString<wchar_t>::operator = (const CStringW& string)
    {
        this->operator=((LPCWSTR)string);
        return *this;
    }
#endif
#endif // inline
 
// If the template is used through DLL, this is better to have the class only once in a dll.
// Windows: In this case DLL_TOOLSFUNCTION is __declspec(dllexport) for one project and  __declspec(dllimport) for the others
// MacOS: template are not exported and are used as inline function
// From Apple doc: "Note: Although template declarations can be marked with the visibility attribute, template instantiations cannot. This is a known limitation and may be fixed in a future version of GCC."
#if defined(__WINDOWS__)
template class DLL_TOOLSFUNCTION CXTString<char>;
template class DLL_TOOLSFUNCTION CXTString<wchar_t>;
#endif
 
END_MOOTOOLS_NAMESPACE
 
#ifdef __WINDOWS__
#pragma warning(pop)
#endif
#endif//CXTSTRING_CLASS_H