X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5c0217af06e9a7a418d8c9c4d380337939e1b856..7d73178688319a42524df406bf50e032bf05a21d:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 6e9003595b..f1be0afe89 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -1,6 +1,6 @@ /////////////////////////////////////////////////////////////////////////////// -// Name: string.h -// Purpose: wxString and wxArrayString classes +// Name: wx/string.h +// Purpose: wxString class // Author: Vadim Zeitlin // Modified by: // Created: 29/01/98 @@ -11,16 +11,12 @@ /* Efficient string class [more or less] compatible with MFC CString, - wxWindows version 1 wxString and std::string and some handy functions + wxWidgets version 1 wxString and std::string and some handy functions missing from string.h. */ -#ifndef _WX_WXSTRINGH__ -#define _WX_WXSTRINGH__ - -#if defined(__GNUG__) && !defined(__APPLE__) - #pragma interface "string.h" -#endif +#ifndef _WX_WXSTRING_H__ +#define _WX_WXSTRING_H__ // ---------------------------------------------------------------------------- // headers @@ -32,10 +28,6 @@ #include #endif -#ifdef __EMX__ - #include -#endif - #if defined(__VISAGECPP__) && __IBMCPP__ >= 400 // problem in VACPP V4 with including stdlib.h multiple times // strconv includes it anyway @@ -51,13 +43,22 @@ # include #endif -#ifdef HAVE_STRINGS_H +#ifdef HAVE_STRCASECMP_IN_STRINGS_H #include // for strcasecmp() -#endif // HAVE_STRINGS_H +#endif // HAVE_STRCASECMP_IN_STRINGS_H -#include "wx/wxchar.h" // for wxChar +#ifdef __WXPALMOS__ + #include +#endif + +#include "wx/wxchar.h" // for wxChar, wxStrlen() etc. +#include "wx/strvararg.h" #include "wx/buffer.h" // for wxCharBuffer #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes +#include "wx/stringimpl.h" +#include "wx/unichar.h" + +class WXDLLIMPEXP_BASE wxString; // --------------------------------------------------------------------------- // macros @@ -70,48 +71,39 @@ #define wxMBSTRINGCAST (char *)(const char *) #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *) -// implementation only -#define wxASSERT_VALID_INDEX(i) \ - wxASSERT_MSG( (size_t)(i) <= length(), _T("invalid index in wxString") ) - // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- -#if defined(__VISAGECPP__) && __IBMCPP__ >= 400 -// must define this static for VA or else you get multiply defined symbols everywhere -extern const unsigned int wxSTRING_MAXLEN; +#if WXWIN_COMPATIBILITY_2_6 -#else +// deprecated in favour of wxString::npos, don't use in new code +// // maximum possible length for a string means "take all string" everywhere -// (as sizeof(StringData) is unknown here, we substract 100) -const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100; +#define wxSTRING_MAXLEN wxString::npos -#endif - -// ---------------------------------------------------------------------------- -// global data -// ---------------------------------------------------------------------------- - -// global pointer to empty string -extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString; +#endif // WXWIN_COMPATIBILITY_2_6 // --------------------------------------------------------------------------- // global functions complementing standard C string library replacements for // strlen() and portable strcasecmp() //--------------------------------------------------------------------------- -// Use wxXXX() functions from wxchar.h instead! These functions are for +#if WXWIN_COMPATIBILITY_2_8 +// Use wxXXX() functions from wxcrt.h instead! These functions are for // backwards compatibility only. // checks whether the passed in pointer is NULL and if the string is empty +wxDEPRECATED( inline bool IsEmpty(const char *p) ); inline bool IsEmpty(const char *p) { return (!p || !*p); } // safe version of strlen() (returns 0 if passed NULL pointer) +wxDEPRECATED( inline size_t Strlen(const char *psz) ); inline size_t Strlen(const char *psz) { return psz ? strlen(psz) : 0; } // portable strcasecmp/_stricmp +wxDEPRECATED( inline int Stricmp(const char *psz1, const char *psz2) ); inline int Stricmp(const char *psz1, const char *psz2) { #if defined(__VISUALC__) && defined(__WXWINCE__) @@ -138,7 +130,10 @@ inline int Stricmp(const char *psz1, const char *psz2) return stricmp(psz1, psz2); #elif defined(__WXPM__) return stricmp(psz1, psz2); -#elif defined(__UNIX__) || defined(__GNUWIN32__) +#elif defined(__WXPALMOS__) || \ + defined(HAVE_STRCASECMP_IN_STRING_H) || \ + defined(HAVE_STRCASECMP_IN_STRINGS_H) || \ + defined(__GNUWIN32__) return strcasecmp(psz1, psz2); #elif defined(__MWERKS__) && !defined(__INTEL__) register char c1, c2; @@ -166,461 +161,164 @@ inline int Stricmp(const char *psz1, const char *psz2) #endif // OS/compiler } -// return an empty wxString -class WXDLLIMPEXP_BASE wxString; // not yet defined -inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; } +#endif // WXWIN_COMPATIBILITY_2_8 -#if wxUSE_STL +// ---------------------------------------------------------------------------- +// wxCStrData +// ---------------------------------------------------------------------------- + +// Lightweight object returned by wxString::c_str() and implicitly convertible +// to either const char* or const wchar_t*. +class wxCStrData +{ +private: + // Ctors; for internal use by wxString and wxCStrData only + wxCStrData(const wxString *str, size_t offset = 0, bool owned = false) + : m_str(str), m_offset(offset), m_owned(owned) {} -#include "wx/beforestd.h" -#include -#include "wx/afterstd.h" +public: + // Ctor constructs the object from char literal; they are needed to make + // operator?: compile and they intentionally take char*, not const char* + wxCStrData(char *buf); + wxCStrData(wchar_t *buf); + + ~wxCStrData(); + // FIXME: we'll need convertors for both char* and wchar_t* and NONE + // for wxChar*, but that's after completing the transition to + // "smart" wxUniChar class. For now, just have conversion to + // char* in ANSI build and wchar_t in Unicode build. #if wxUSE_UNICODE - #if HAVE_STD_WSTRING - typedef std::wstring wxStringBase; - #else - typedef std::basic_string wxStringBase; - #endif + const wchar_t* AsWChar() const; + operator const wchar_t*() const { return AsWChar(); } #else - typedef std::string wxStringBase; + const char* AsChar() const; + const unsigned char* AsUnsignedChar() const + { return (const unsigned char *) AsChar(); } + operator const void*() const { return AsChar(); } + operator const char*() const { return AsChar(); } + operator const unsigned char*() const { return AsUnsignedChar(); } #endif -#if (defined(__GNUG__) && (__GNUG__ < 3)) || \ - (defined(_MSC_VER) && (_MSC_VER <= 1100)) - #define wxSTRING_BASE_HASNT_CLEAR -#endif + wxString AsString() const; -#else // if !wxUSE_STL + // allow expressions like "c_str()[0]": + wxUniChar operator[](int n) const { return operator[](size_t(n)); } + wxUniChar operator[](size_t n) const; + wxUniChar operator[](long n) const { return operator[](size_t(n)); } +#ifndef wxSIZE_T_IS_UINT + wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); } +#endif // size_t != unsigned int -#ifndef HAVE_STD_STRING_COMPARE - #define HAVE_STD_STRING_COMPARE -#endif + // these operators are needed to emulate the pointer semantics of c_str(): + // expressions like "wxChar *p = str.c_str() + 1;" should continue to work + // (we need both versions to resolve ambiguities): + wxCStrData operator+(int n) const + { return wxCStrData(m_str, m_offset + n, m_owned); } + wxCStrData operator+(long n) const + { return wxCStrData(m_str, m_offset + n, m_owned); } + wxCStrData operator+(size_t n) const + { return wxCStrData(m_str, m_offset + n, m_owned); } -// --------------------------------------------------------------------------- -// string data prepended with some housekeeping info (used by wxString class), -// is never used directly (but had to be put here to allow inlining) -// --------------------------------------------------------------------------- + // this operator is needed to make expressions like "*c_str()" or + // "*(c_str() + 2)" work + wxUniChar operator*() const; -struct WXDLLIMPEXP_BASE wxStringData -{ - int nRefs; // reference count - size_t nDataLength, // actual string length - nAllocLength; // allocated memory size +private: + const wxString *m_str; + size_t m_offset; + bool m_owned; - // mimics declaration 'wxChar data[nAllocLength]' - wxChar* data() const { return (wxChar*)(this + 1); } + friend class WXDLLIMPEXP_BASE wxString; +}; - // empty string has a special ref count so it's never deleted - bool IsEmpty() const { return (nRefs == -1); } - bool IsShared() const { return (nRefs > 1); } +// ---------------------------------------------------------------------------- +// wxStringPrintfMixin +// --------------------------------------------------------------------------- - // lock/unlock - void Lock() { if ( !IsEmpty() ) nRefs++; } +// NB: VC6 has a bug that causes linker errors if you have template methods +// in a class using __declspec(dllimport). The solution is to split such +// class into two classes, one that contains the template methods and does +// *not* use WXDLLIMPEXP_BASE and another class that contains the rest +// (with DLL linkage). +// +// We only do this for VC6 here, because the code is less efficient +// (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler +// cannot compile this code. - // VC++ will refuse to inline Unlock but profiling shows that it is wrong -#if defined(__VISUALC__) && (__VISUALC__ >= 1200) - __forceinline +#if defined(__VISUALC__) && __VISUALC__ < 1300 + #define wxNEEDS_WXSTRING_PRINTF_MIXIN #endif - // VC++ free must take place in same DLL as allocation when using non dll - // run-time library (e.g. Multithreaded instead of Multithreaded DLL) -#if defined(__VISUALC__) && defined(_MT) && !defined(_DLL) - void Unlock() { if ( !IsEmpty() && --nRefs == 0) Free(); } - // we must not inline deallocation since allocation is not inlined - void Free(); -#else - void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); } -#endif - - // if we had taken control over string memory (GetWriteBuf), it's - // intentionally put in invalid state - void Validate(bool b) { nRefs = (b ? 1 : 0); } - bool IsValid() const { return (nRefs != 0); } -}; -class WXDLLIMPEXP_BASE wxStringBase +#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN +// this class contains implementation of wxString's vararg methods, it's +// exported from wxBase DLL +class WXDLLIMPEXP_BASE wxStringPrintfMixinBase { -#if !wxUSE_STL -friend class WXDLLIMPEXP_BASE wxArrayString; -#endif -public : - // an 'invalid' value for string index, moved to this place due to a CW bug - static const size_t npos; protected: - // points to data preceded by wxStringData structure with ref count info - wxChar *m_pchData; - - // accessor to string data - wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; } - - // string (re)initialization functions - // initializes the string to the empty value (must be called only from - // ctors, use Reinit() otherwise) - void Init() { m_pchData = (wxChar *)wxEmptyString; } - // initializaes the string with (a part of) C-string - void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos); - // as Init, but also frees old data - void Reinit() { GetStringData()->Unlock(); Init(); } - - // memory allocation - // allocates memory for string of length nLen - bool AllocBuffer(size_t nLen); - // copies data to another string - bool AllocCopy(wxString&, int, int) const; - // effectively copies data to string - bool AssignCopy(size_t, const wxChar *); - - // append a (sub)string - bool ConcatSelf(size_t nLen, const wxChar *src, size_t nMaxLen); - bool ConcatSelf(size_t nLen, const wxChar *src) - { return ConcatSelf(nLen, src, nLen); } - - // functions called before writing to the string: they copy it if there - // are other references to our data (should be the only owner when writing) - bool CopyBeforeWrite(); - bool AllocBeforeWrite(size_t); - - // compatibility with wxString - bool Alloc(size_t nLen); -public: - // standard types - typedef wxChar value_type; - typedef wxChar char_type; - typedef size_t size_type; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type *iterator; - typedef const value_type *const_iterator; - - // constructors and destructor - // ctor for an empty string - wxStringBase() { Init(); } - // copy ctor - wxStringBase(const wxStringBase& stringSrc) - { - wxASSERT_MSG( stringSrc.GetStringData()->IsValid(), - _T("did you forget to call UngetWriteBuf()?") ); - - if ( stringSrc.empty() ) { - // nothing to do for an empty string - Init(); - } - else { - m_pchData = stringSrc.m_pchData; // share same data - GetStringData()->Lock(); // => one more copy - } - } - // string containing nRepeat copies of ch - wxStringBase(size_type nRepeat, wxChar ch); - // ctor takes first nLength characters from C string - // (default value of npos means take all the string) - wxStringBase(const wxChar *psz) - { InitWith(psz, 0, npos); } - wxStringBase(const wxChar *psz, size_t nLength) - { InitWith(psz, 0, nLength); } - wxStringBase(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos) - { InitWith(psz, 0, nLength); } - // take nLen chars starting at nPos - wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen) - { - wxASSERT_MSG( str.GetStringData()->IsValid(), - _T("did you forget to call UngetWriteBuf()?") ); - Init(); - size_t strLen = str.length() - nPos; nLen = strLen < nLen ? strLen : nLen; - InitWith(str.c_str(), nPos, nLen); - } - // take all characters from pStart to pEnd - wxStringBase(const void *pStart, const void *pEnd); - - // dtor is not virtual, this class must not be inherited from! - ~wxStringBase() { GetStringData()->Unlock(); } - - // overloaded assignment - // from another wxString - wxStringBase& operator=(const wxStringBase& stringSrc); - // from a character - wxStringBase& operator=(wxChar ch); - // from a C string - wxStringBase& operator=(const wxChar *psz); - - // return the length of the string - size_type size() const { return GetStringData()->nDataLength; } - // return the length of the string - size_type length() const { return size(); } - // return the maximum size of the string - size_type max_size() const { return wxSTRING_MAXLEN; } - // resize the string, filling the space with c if c != 0 - void resize(size_t nSize, wxChar ch = wxT('\0')); - // delete the contents of the string - void clear() { erase(0, npos); } - // returns true if the string is empty - bool empty() const { return size() == 0; } - // inform string about planned change in size - void reserve(size_t sz) { Alloc(sz); } - size_type capacity() const { return GetStringData()->nAllocLength; } - - // lib.string.access - // return the character at position n - value_type at(size_type n) const - { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } - value_type operator[](size_type n) const { return at(n); } - // returns the writable character at position n - reference at(size_type n) - { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } - reference operator[](size_type n) - { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } - - // lib.string.modifiers - // append elements str[pos], ..., str[pos+n] - wxStringBase& append(const wxStringBase& str, size_t pos, size_t n) - { - wxASSERT(pos <= str.length()); - ConcatSelf(n, str.c_str() + pos, str.length() - pos); - return *this; - } - // append a string - wxStringBase& append(const wxStringBase& str) - { ConcatSelf(str.length(), str.c_str()); return *this; } - // append first n (or all if n == npos) characters of sz - wxStringBase& append(const wxChar *sz) - { ConcatSelf(wxStrlen(sz), sz); return *this; } - wxStringBase& append(const wxChar *sz, size_t n) - { ConcatSelf(n, sz); return *this; } - // append n copies of ch - wxStringBase& append(size_t n, wxChar ch); - // append from first to last - wxStringBase& append(const_iterator first, const_iterator last) - { ConcatSelf(last - first, first); return *this; } - - // same as `this_string = str' - wxStringBase& assign(const wxStringBase& str) - { return *this = str; } - // same as ` = str[pos..pos + n] - wxStringBase& assign(const wxStringBase& str, size_t pos, size_t n) - { clear(); return append(str, pos, n); } - // same as `= first n (or all if n == npos) characters of sz' - wxStringBase& assign(const wxChar *sz) - { clear(); return append(sz, wxStrlen(sz)); } - wxStringBase& assign(const wxChar *sz, size_t n) - { clear(); return append(sz, n); } - // same as `= n copies of ch' - wxStringBase& assign(size_t n, wxChar ch) - { clear(); return append(n, ch); } - // assign from first to last - wxStringBase& assign(const_iterator first, const_iterator last) - { clear(); return append(first, last); } - - // first valid index position - const_iterator begin() const { return m_pchData; } - // position one after the last valid one - const_iterator end() const { return m_pchData + length(); } - - // first valid index position - iterator begin() { CopyBeforeWrite(); return m_pchData; } - // position one after the last valid one - iterator end() { CopyBeforeWrite(); return m_pchData + length(); } - - // insert another string - wxStringBase& insert(size_t nPos, const wxStringBase& str) - { - wxASSERT( str.GetStringData()->IsValid() ); - return insert(nPos, str.c_str(), str.length()); - } - // insert n chars of str starting at nStart (in str) - wxStringBase& insert(size_t nPos, const wxStringBase& str, size_t nStart, size_t n) - { - wxASSERT( str.GetStringData()->IsValid() ); - wxASSERT( nStart < str.length() ); - size_t strLen = str.length() - nStart; - n = strLen < n ? strLen : n; - return insert(nPos, str.c_str() + nStart, n); - } - // insert first n (or all if n == npos) characters of sz - wxStringBase& insert(size_t nPos, const wxChar *sz, size_t n = npos); - // insert n copies of ch - wxStringBase& insert(size_t nPos, size_t n, wxChar ch) - { return insert(nPos, wxStringBase(n, ch)); } - iterator insert(iterator it, wxChar ch) - { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; } - void insert(iterator it, const_iterator first, const_iterator last) - { insert(it - begin(), first, last - first); } - void insert(iterator it, size_type n, wxChar ch) - { insert(it - begin(), n, ch); } - - // delete characters from nStart to nStart + nLen - wxStringBase& erase(size_type pos = 0, size_type n = npos); - iterator erase(iterator first, iterator last) - { - size_t idx = first - begin(); - erase(idx, last - first); - return begin() + idx; - } - iterator erase(iterator first); - - // explicit conversion to C string (use this with printf()!) - const wxChar* c_str() const { return m_pchData; } - const wxChar* data() const { return m_pchData; } - - // replaces the substring of length nLen starting at nStart - wxStringBase& replace(size_t nStart, size_t nLen, const wxChar* sz); - // replaces the substring of length nLen starting at nStart - wxStringBase& replace(size_t nStart, size_t nLen, const wxStringBase& str) - { return replace(nStart, nLen, str.c_str()); } - // replaces the substring with nCount copies of ch - wxStringBase& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch); - // replaces a substring with another substring - wxStringBase& replace(size_t nStart, size_t nLen, - const wxStringBase& str, size_t nStart2, size_t nLen2); - // replaces the substring with first nCount chars of sz - wxStringBase& replace(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount); - wxStringBase& replace(iterator first, iterator last, const_pointer s) - { return replace(first - begin(), last - first, s); } - wxStringBase& replace(iterator first, iterator last, const_pointer s, - size_type n) - { return replace(first - begin(), last - first, s, n); } - wxStringBase& replace(iterator first, iterator last, const wxStringBase& s) - { return replace(first - begin(), last - first, s); } - wxStringBase& replace(iterator first, iterator last, size_type n, wxChar c) - { return replace(first - begin(), last - first, n, c); } - wxStringBase& replace(iterator first, iterator last, - const_iterator first1, const_iterator last1) - { return replace(first - begin(), last - first, first1, last1 - first1); } - - // swap two strings - void swap(wxStringBase& str); - - // All find() functions take the nStart argument which specifies the - // position to start the search on, the default value is 0. All functions - // return npos if there were no match. - - // find a substring - size_t find(const wxStringBase& str, size_t nStart = 0) const; - - // VC++ 1.5 can't cope with this syntax. -#if !defined(__VISUALC__) || defined(__WIN32__) - // find first n characters of sz - size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const; -#endif // VC++ 1.5 - - // find the first occurence of character ch after nStart - size_t find(wxChar ch, size_t nStart = 0) const; + wxStringPrintfMixinBase() {} - // rfind() family is exactly like find() but works right to left - - // as find, but from the end - size_t rfind(const wxStringBase& str, size_t nStart = npos) const; - - // VC++ 1.5 can't cope with this syntax. - // as find, but from the end - size_t rfind(const wxChar* sz, size_t nStart = npos, - size_t n = npos) const; - // as find, but from the end - size_t rfind(wxChar ch, size_t nStart = npos) const; - - // find first/last occurence of any character in the set - - // as strpbrk() but starts at nStart, returns npos if not found - size_t find_first_of(const wxStringBase& str, size_t nStart = 0) const - { return find_first_of(str.c_str(), nStart); } - // same as above - size_t find_first_of(const wxChar* sz, size_t nStart = 0) const; - // same as find(char, size_t) - size_t find_first_of(wxChar c, size_t nStart = 0) const - { return find(c, nStart); } - // find the last (starting from nStart) char from str in this string - size_t find_last_of (const wxStringBase& str, size_t nStart = npos) const - { return find_last_of(str.c_str(), nStart); } - // same as above - size_t find_last_of (const wxChar* sz, size_t nStart = npos) const; - // same as above - size_t find_last_of(wxChar c, size_t nStart = npos) const - { return rfind(c, nStart); } - - // find first/last occurence of any character not in the set - - // as strspn() (starting from nStart), returns npos on failure - size_t find_first_not_of(const wxStringBase& str, size_t nStart = 0) const - { return find_first_not_of(str.c_str(), nStart); } - // same as above - size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const; - // same as above - size_t find_first_not_of(wxChar ch, size_t nStart = 0) const; - // as strcspn() - size_t find_last_not_of(const wxStringBase& str, size_t nStart = npos) const - { return find_first_not_of(str.c_str(), nStart); } - // same as above - size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const; - // same as above - size_t find_last_not_of(wxChar ch, size_t nStart = npos) const; - - // All compare functions return -1, 0 or 1 if the [sub]string is less, - // equal or greater than the compare() argument. + int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2; + static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1; +}; - // just like strcmp() - int compare(const wxStringBase& str) const - { return wxStrcmp(c_str(), str.c_str()); } - // comparison with a substring - int compare(size_t nStart, size_t nLen, const wxStringBase& str) const; - // comparison of 2 substrings - int compare(size_t nStart, size_t nLen, - const wxStringBase& str, size_t nStart2, size_t nLen2) const; - // just like strcmp() - int compare(const wxChar* sz) const - { return wxStrcmp(c_str(), sz); } - // substring comparison with first nCount characters of sz - int compare(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount = npos) const; +// this class contains template wrappers for wxString's vararg methods, it's +// intentionally *not* exported from the DLL in order to fix the VC6 bug +// described above +class wxStringPrintfMixin : public wxStringPrintfMixinBase +{ +private: + // to further complicate things, we can't return wxString from + // wxStringPrintfMixin::Format() because wxString is not yet declared at + // this point; the solution is to use this fake type trait template - this + // way the compiler won't know the return type until Format() is used + // (this doesn't compile with Watcom, but VC6 compiles it just fine): + template struct StringReturnType + { + typedef wxString type; + }; - size_type copy(wxChar* s, size_type n, size_type pos = 0); +public: + // these are duplicated wxString methods, they're also declared below + // if !wxNEEDS_WXSTRING_PRINTF_MIXIN: - // substring extraction - wxStringBase substr(size_t nStart = 0, size_t nLen = npos) const; + // int Printf(const wxChar *pszFormat, ...); + WX_DEFINE_VARARG_FUNC(int, Printf, DoPrintf) + // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1; + WX_DEFINE_VARARG_FUNC(static typename StringReturnType::type, + Format, DoFormat) + // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; + WX_DEFINE_VARARG_FUNC(int, sprintf, DoPrintf) - // string += string - wxStringBase& operator+=(const wxStringBase& s) { return append(s); } - // string += C string - wxStringBase& operator+=(const wxChar *psz) { return append(psz); } - // string += char - wxStringBase& operator+=(wxChar ch) { return append(1, ch); } +protected: + wxStringPrintfMixin() : wxStringPrintfMixinBase() {} }; +#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN -#endif // !wxUSE_STL -// --------------------------------------------------------------------------- -// This is (yet another one) String class for C++ programmers. It doesn't use -// any of "advanced" C++ features (i.e. templates, exceptions, namespaces...) -// thus you should be able to compile it with practicaly any C++ compiler. -// This class uses copy-on-write technique, i.e. identical strings share the -// same memory as long as neither of them is changed. -// -// This class aims to be as compatible as possible with the new standard -// std::string class, but adds some additional functions and should be at -// least as efficient than the standard implementation. -// -// Performance note: it's more efficient to write functions which take "const -// String&" arguments than "const char *" if you assign the argument to -// another string. -// -// It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5. -// -// To do: -// - ressource support (string tables in ressources) -// - more wide character (UNICODE) support -// - regular expressions support +// ---------------------------------------------------------------------------- +// wxString: string class trying to be compatible with std::string, MFC +// CString and wxWindows 1.x wxString all at once // --------------------------------------------------------------------------- -class WXDLLIMPEXP_BASE wxString : public wxStringBase -{ -#if !wxUSE_STL -friend class WXDLLIMPEXP_BASE wxArrayString; +#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN + // "non dll-interface class 'wxStringPrintfMixin' used as base interface + // for dll-interface class 'wxString'" -- this is OK in our case + #pragma warning (disable:4275) #endif +class WXDLLIMPEXP_BASE wxString +#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN + : public wxStringPrintfMixin +#endif +{ // NB: special care was taken in arranging the member functions in such order // that all inline functions can be effectively inlined, verify that all - // performace critical functions are still inlined if you change order! + // performance critical functions are still inlined if you change order! +public: + // an 'invalid' value for string index, moved to this place due to a CW bug + static const size_t npos; + private: // if we hadn't made these operators private, it would be possible to // compile "wxString s; s = 17;" without any warnings as 17 is implicitly @@ -637,56 +335,478 @@ private: // try `s << i' or `s.Printf("%d", i)' instead wxString(int); + + // buffer for holding temporary substring when using any of the methods + // that take (char*,size_t) or (wchar_t*,size_t) arguments: + // FIXME-UTF8: This will need changes when UTF8 build is introduced + template + struct SubstrBufFromType + { + T data; + size_t len; + + SubstrBufFromType() {} + SubstrBufFromType(const T& data_, size_t len_) + : data(data_), len(len_) {} + }; + +#if wxUSE_UNICODE_UTF8 + // FIXME-UTF8: this will have to use slightly different type +#elif wxUSE_UNICODE_WCHAR + typedef SubstrBufFromType SubstrBufFromWC; + typedef SubstrBufFromType SubstrBufFromMB; +#else + typedef SubstrBufFromType SubstrBufFromMB; + typedef SubstrBufFromType SubstrBufFromWC; +#endif + + + // Functions implementing primitive operations on string data; wxString + // methods and iterators are implemented in terms of it. The differences + // between UTF-8 and wchar_t* representations of the string are mostly + // contained here. + +#if wxUSE_UNICODE + // FIXME-UTF8: This will need changes when UTF8 build is introduced + static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength, + const wxMBConv& conv); +#else + static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength, + const wxMBConv& conv); +#endif + +#if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE + // returns C string encoded as the implementation expects: + #if wxUSE_UNICODE + static const wchar_t* ImplStr(const wchar_t* str) + { return str; } + static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) + { return SubstrBufFromWC(str, n == npos ? wxWcslen(str) : n); } + static wxWCharBuffer ImplStr(const char* str) + { return ConvertStr(str, npos, wxConvLibc).data; } + static SubstrBufFromMB ImplStr(const char* str, size_t n) + { return ConvertStr(str, n, wxConvLibc); } + #else + static const char* ImplStr(const char* str) + { return str; } + static const SubstrBufFromMB ImplStr(const char* str, size_t n) + { return SubstrBufFromMB(str, n == npos ? wxStrlen(str) : n); } + static wxCharBuffer ImplStr(const wchar_t* str) + { return ConvertStr(str, npos, wxConvLibc).data; } + static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) + { return ConvertStr(str, n, wxConvLibc); } + #endif + + // moves the iterator to the next Unicode character + static void IncIter(wxStringImpl::iterator& i) { ++i; } + static void IncIter(wxStringImpl::const_iterator& i) { ++i; } + // moves the iterator to the previous Unicode character + static void DecIter(wxStringImpl::iterator& i) { --i; } + static void DecIter(wxStringImpl::const_iterator& i) { --i; } + // moves the iterator by n Unicode characters + static wxStringImpl::iterator AddToIter(wxStringImpl::iterator i, int n) + { return i + n; } + static wxStringImpl::const_iterator AddToIter(wxStringImpl::const_iterator i, int n) + { return i + n; } + // returns distance of the two iterators in Unicode characters + static int DiffIters(wxStringImpl::iterator i1, wxStringImpl::iterator i2) + { return i1 - i2; } + static int DiffIters(wxStringImpl::const_iterator i1, wxStringImpl::const_iterator i2) + { return i1 - i2; } + + // encodes the character to a form used to represent it in internal + // representation (returns a string in UTF8 version) + static wxChar EncodeChar(wxUniChar ch) { return (wxChar)ch; } + + // translates position index in wxString to/from index in underlying + // wxStringImpl: + static size_t PosToImpl(size_t pos) { return pos; } + static void PosLenToImpl(size_t pos, size_t len, + size_t *implPos, size_t *implLen) + { *implPos = pos; *implLen = len; } + static size_t PosFromImpl(size_t pos) { return pos; } + +#else // wxUSE_UNICODE_UTF8 + + typedef char Utf8CharBuffer[5]; + static Utf8CharBuffer EncodeChar(wxUniChar ch); + // returns n copies of ch encoded in UTF-8 string + static wxCharBuffer EncodeNChars(size_t n, wxUniChar ch); + + size_t PosToImpl(size_t pos) const + { + if ( pos == 0 || pos == npos ) + return pos; + else + return wxStringImpl::const_iterator(begin() + pos) - m_impl.begin(); + } + + size_t PosFromImpl(size_t pos) const + { + if ( pos == 0 || pos == npos ) + return pos; + else + return const_iterator(m_impl.begin() + pos) - begin(); + } + + // FIXME: return as-is without copying under UTF8 locale, return + // converted string under other locales - needs wxCharBuffer + // changes + static wxCharBuffer ImplStr(const char* str); + + static wxCharBuffer ImplStr(const wchar_t* str) + { return wxConvUTF8.cWC2MB(str); } +#endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8 + + public: // constructors and destructor // ctor for an empty string - wxString() : wxStringBase() { } + wxString() {} // copy ctor - wxString(const wxStringBase& stringSrc) : wxStringBase(stringSrc) { } - wxString(const wxString& stringSrc) : wxStringBase(stringSrc) { } + wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { } + wxString(const wxString& stringSrc) : m_impl(stringSrc) { } // string containing nRepeat copies of ch - wxString(wxChar ch, size_t nRepeat = 1) - : wxStringBase(nRepeat, ch) { } - wxString(size_t nRepeat, wxChar ch) - : wxStringBase(nRepeat, ch) { } + wxString(wxUniChar ch, size_t nRepeat = 1) + : m_impl(nRepeat, ch) { } + wxString(size_t nRepeat, wxUniChar ch) + : m_impl(nRepeat, ch) { } + wxString(wxUniCharRef ch, size_t nRepeat = 1) + : m_impl(nRepeat, ch) { } + wxString(size_t nRepeat, wxUniCharRef ch) + : m_impl(nRepeat, ch) { } + wxString(char ch, size_t nRepeat = 1) + : m_impl(nRepeat, ch) { } + wxString(size_t nRepeat, char ch) + : m_impl(nRepeat, ch) { } + wxString(wchar_t ch, size_t nRepeat = 1) + : m_impl(nRepeat, ch) { } + wxString(size_t nRepeat, wchar_t ch) + : m_impl(nRepeat, ch) { } // ctor takes first nLength characters from C string // (default value of npos means take all the string) wxString(const wxChar *psz) - : wxStringBase(psz ? psz : wxT("")) { } + : m_impl(psz ? psz : wxT("")) { } wxString(const wxChar *psz, size_t nLength) - : wxStringBase(psz, nLength) { } - wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos) - : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { } + : m_impl(psz, nLength) { } + wxString(const wxChar *psz, + const wxMBConv& WXUNUSED(conv), + size_t nLength = npos) + : m_impl(psz, nLength == npos ? wxStrlen(psz) : nLength) { } + + // even if we're not built with wxUSE_STL == 1 it is very convenient to allow + // implicit conversions from std::string to wxString as this allows to use + // the same strings in non-GUI and GUI code, however we don't want to + // unconditionally add this ctor as it would make wx lib dependent on + // libstdc++ on some Linux versions which is bad, so instead we ask the + // client code to define this wxUSE_STD_STRING symbol if they need it +#if wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING + wxString(const wxStdString& s) + : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s +#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING #if wxUSE_UNICODE // from multibyte string - // (NB: nLength is right now number of Unicode characters, not - // characters in psz! So try not to use it yet!) - wxString(const char *psz, wxMBConv& conv, size_t nLength = npos); + wxString(const char *psz, + const wxMBConv& conv = wxConvLibc, + size_t nLength = npos); + // from multibyte string for ANSI compatibility, with wxConvLibc + wxString(const char *psz, size_t nLength); // from wxWCharBuffer (i.e. return from wxGetString) - wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { } + wxString(const wxWCharBuffer& psz) : m_impl(psz.data()) { } #else // ANSI // from C string (for compilers using unsigned char) - wxString(const unsigned char* psz, size_t nLength = npos) - : wxStringBase((const char*)psz, nLength) { } + wxString(const unsigned char* psz) + : m_impl((const char*)psz) { } + // from part of C string (for compilers using unsigned char) + wxString(const unsigned char* psz, size_t nLength) + : m_impl((const char*)psz, nLength) { } #if wxUSE_WCHAR_T // from wide (Unicode) string - wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = npos); + wxString(const wchar_t *pwz, + const wxMBConv& conv = wxConvLibc, + size_t nLength = npos); + // from wide string for Unicode compatibility, with wxConvLibc + wxString(const wchar_t *pwz, size_t nLength); #endif // !wxUSE_WCHAR_T // from wxCharBuffer wxString(const wxCharBuffer& psz) - : wxStringBase(psz, npos) { } + : m_impl(psz) { } #endif // Unicode/ANSI + wxString(const wxCStrData& cstr) + : m_impl(cstr.AsString().m_impl) { } + + // as we provide both ctors with this signature for both char and unsigned + // char string, we need to provide one for wxCStrData to resolve ambiguity + wxString(const wxCStrData& cstr, size_t nLength) + { assign(cstr.AsString(), nLength); } + + // and because wxString is convertible to wxCStrData and const wxChar * + // we also need to provide this one + wxString(const wxString& str, size_t nLength) + { assign(str, nLength); } + +public: + // standard types + typedef wxUniChar value_type; + typedef wxUniChar char_type; + typedef wxUniCharRef reference; + typedef wxChar* pointer; + typedef const wxChar* const_pointer; + + typedef size_t size_type; + typedef wxUniChar const_reference; + +#if wxUSE_STL + #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag +#else + #define WX_STR_ITERATOR_TAG void /* dummy type */ +#endif + + #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \ + reference_type, reference_ctor) \ + private: \ + typedef wxStringImpl::iterator_name underlying_iterator; \ + public: \ + typedef WX_STR_ITERATOR_TAG iterator_category; \ + typedef wxUniChar value_type; \ + typedef int difference_type; \ + typedef reference_type reference; \ + typedef pointer_type pointer; \ + \ + iterator_name(const iterator_name& i) : m_cur(i.m_cur) {} \ + \ + reference operator*() const { return reference_ctor; } \ + reference operator[](size_t n) const { return *(*this + n); } \ + \ + iterator_name& operator++() \ + { wxString::IncIter(m_cur); return *this; } \ + iterator_name& operator--() \ + { wxString::DecIter(m_cur); return *this; } \ + iterator_name operator++(int) \ + { \ + iterator_name tmp = *this; \ + wxString::IncIter(m_cur); \ + return tmp; \ + } \ + iterator_name operator--(int) \ + { \ + iterator_name tmp = *this; \ + wxString::DecIter(m_cur); \ + return tmp; \ + } \ + \ + iterator_name operator+(int n) const \ + { return iterator_name(wxString::AddToIter(m_cur, n)); } \ + iterator_name operator+(size_t n) const \ + { return iterator_name(wxString::AddToIter(m_cur, (int)n)); } \ + iterator_name operator-(int n) const \ + { return iterator_name(wxString::AddToIter(m_cur, -n)); } \ + iterator_name operator-(size_t n) const \ + { return iterator_name(wxString::AddToIter(m_cur, -(int)n)); } \ + iterator_name operator+=(int n) \ + { m_cur = wxString::AddToIter(m_cur, n); return *this; } \ + iterator_name operator+=(size_t n) \ + { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; } \ + iterator_name operator-=(int n) \ + { m_cur = wxString::AddToIter(m_cur, -n); return *this; } \ + iterator_name operator-=(size_t n) \ + { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; } \ + \ + unsigned operator-(const iterator_name& i) const \ + { return wxString::DiffIters(m_cur, i.m_cur); } \ + \ + bool operator==(const iterator_name&i) const \ + { return m_cur == i.m_cur; } \ + bool operator!=(const iterator_name& i) const \ + { return m_cur != i.m_cur; } \ + \ + bool operator<(const iterator_name& i) const \ + { return m_cur < i.m_cur; } \ + bool operator>(const iterator_name& i) const \ + { return m_cur > i.m_cur; } \ + bool operator<=(const iterator_name& i) const \ + { return m_cur <= i.m_cur; } \ + bool operator>=(const iterator_name& i) const \ + { return m_cur >= i.m_cur; } \ + \ + private: \ + /* for internal wxString use only: */ \ + iterator_name(underlying_iterator ptr) : m_cur(ptr) {} \ + operator underlying_iterator() const { return m_cur; } \ + \ + friend class WXDLLIMPEXP_BASE wxString; \ + friend class WXDLLIMPEXP_BASE wxCStrData; \ + \ + private: \ + underlying_iterator m_cur; + + class const_iterator; + + class iterator + { + WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef, + wxUniCharRef::CreateForString(m_cur)) + + friend class const_iterator; + }; + + class const_iterator + { + // NB: reference_type is intentionally value, not reference, the character + // may be encoded differently in wxString data: + WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar, + wxUniChar(*m_cur)) + + public: + const_iterator(const iterator& i) : m_cur(i.m_cur) {} + }; + + #undef WX_STR_ITERATOR_TAG + #undef WX_STR_ITERATOR_IMPL + + friend class iterator; + friend class const_iterator; + + template + class reverse_iterator_impl + { + public: + typedef T iterator_type; + + typedef typename T::iterator_category iterator_category; + typedef typename T::value_type value_type; + typedef typename T::difference_type difference_type; + typedef typename T::reference reference; + typedef typename T::pointer *pointer; + + reverse_iterator_impl(iterator_type i) : m_cur(i) {} + reverse_iterator_impl(const reverse_iterator_impl& ri) + : m_cur(ri.m_cur) {} + + iterator_type base() const { return m_cur; } + + reference operator*() const { return *(m_cur-1); } + reference operator[](size_t n) const { return *(*this + n); } + + reverse_iterator_impl& operator++() + { --m_cur; return *this; } + reverse_iterator_impl operator++(int) + { reverse_iterator_impl tmp = *this; --m_cur; return tmp; } + reverse_iterator_impl& operator--() + { ++m_cur; return *this; } + reverse_iterator_impl operator--(int) + { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; } + + reverse_iterator_impl operator+(int n) const + { return reverse_iterator_impl(m_cur - n); } + reverse_iterator_impl operator+(size_t n) const + { return reverse_iterator_impl(m_cur - n); } + reverse_iterator_impl operator-(int n) const + { return reverse_iterator_impl(m_cur + n); } + reverse_iterator_impl operator-(size_t n) const + { return reverse_iterator_impl(m_cur + n); } + reverse_iterator_impl operator+=(int n) + { m_cur -= n; return *this; } + reverse_iterator_impl operator+=(size_t n) + { m_cur -= n; return *this; } + reverse_iterator_impl operator-=(int n) + { m_cur += n; return *this; } + reverse_iterator_impl operator-=(size_t n) + { m_cur += n; return *this; } + + unsigned operator-(const reverse_iterator_impl& i) const + { return i.m_cur - m_cur; } + + bool operator==(const reverse_iterator_impl& ri) const + { return m_cur == ri.m_cur; } + bool operator!=(const reverse_iterator_impl& ri) const + { return !(*this == ri); } + + bool operator<(const reverse_iterator_impl& i) const + { return m_cur > i.m_cur; } + bool operator>(const reverse_iterator_impl& i) const + { return m_cur < i.m_cur; } + bool operator<=(const reverse_iterator_impl& i) const + { return m_cur >= i.m_cur; } + bool operator>=(const reverse_iterator_impl& i) const + { return m_cur <= i.m_cur; } + + private: + iterator_type m_cur; + }; + + typedef reverse_iterator_impl reverse_iterator; + typedef reverse_iterator_impl const_reverse_iterator; + + // first valid index position + const_iterator begin() const { return const_iterator(m_impl.begin()); } + iterator begin() { return iterator(m_impl.begin()); } + // position one after the last valid one + const_iterator end() const { return const_iterator(m_impl.end()); } + iterator end() { return iterator(m_impl.end()); } + + // first element of the reversed string + const_reverse_iterator rbegin() const + { return const_reverse_iterator(end()); } + reverse_iterator rbegin() + { return reverse_iterator(end()); } + // one beyond the end of the reversed string + const_reverse_iterator rend() const + { return const_reverse_iterator(begin()); } + reverse_iterator rend() + { return reverse_iterator(begin()); } + + // std::string methods: +#if wxUSE_UNICODE_UTF8 + size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize! +#else + size_t length() const { return m_impl.length(); } +#endif + + size_type size() const { return length(); } + size_type max_size() const { return npos; } + + bool empty() const { return m_impl.empty(); } + + size_type capacity() const { return m_impl.capacity(); } // FIXME-UTF8 + void reserve(size_t sz) { m_impl.reserve(sz); } // FIXME-UTF8 + + void resize(size_t nSize, wxUniChar ch = wxT('\0')) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + { + size_t len = length(); + if ( nSize == len) + return; + else if ( nSize < len ) + erase(nSize); + else + append(nSize - len, ch); + } + else +#endif + m_impl.resize(nSize, (wxStringCharType)ch); + } + + wxString substr(size_t nStart = 0, size_t nLen = npos) const + { + size_t pos, len; + PosLenToImpl(nStart, nLen, &pos, &len); + return m_impl.substr(pos, len); + } + // generic attributes & operations // as standard strlen() size_t Len() const { return length(); } // string contains any characters? bool IsEmpty() const { return empty(); } - // empty string is "FALSE", so !str will return TRUE - bool operator!() const { return IsEmpty(); } + // empty string is "false", so !str will return true + bool operator!() const { return empty(); } // truncate the string to given length wxString& Truncate(size_t uiLen); // empty string contents @@ -694,7 +814,7 @@ public: { Truncate(0); - wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") ); + wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") ); } // empty the string and free memory void Clear() @@ -713,76 +833,75 @@ public: // data access (all indexes are 0 based) // read access - wxChar GetChar(size_t n) const - { return operator[](n); } + wxUniChar at(size_t n) const + { return *(begin() + n); } // FIXME-UTF8: optimize? + wxUniChar GetChar(size_t n) const + { return at(n); } // read/write access - wxChar& GetWritableChar(size_t n) - { return operator[](n); } + wxUniCharRef at(size_t n) + { return *(begin() + n); } // FIXME-UTF8: optimize? + wxUniCharRef GetWritableChar(size_t n) + { return at(n); } // write access - void SetChar(size_t n, wxChar ch) - { operator[](n) = ch; } + void SetChar(size_t n, wxUniChar ch) + { at(n) = ch; } // get last character - wxChar Last() const + wxUniChar Last() const { - wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") ); + wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); - return operator[](length() - 1); + return at(length() - 1); } // get writable last character - wxChar& Last() + wxUniCharRef Last() { - wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") ); - return operator[](length() - 1); + wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); + return at(length() - 1); } /* - So why do we have all these overloaded operator[]s? A bit of history: - initially there was only one of them, taking size_t. Then people - started complaining because they wanted to use ints as indices (I - wonder why) and compilers were giving warnings about it, so we had to - add the operator[](int). Then it became apparent that you couldn't - write str[0] any longer because there was ambiguity between two - overloads and so you now had to write str[0u] (or, of course, use the - explicit casts to either int or size_t but nobody did this). - - Finally, someone decided to compile wxWin on an Alpha machine and got - a surprize: str[0u] didn't compile there because it is of type - unsigned int and size_t is unsigned _long_ on Alpha and so there was - ambiguity between converting uint to int or ulong. To fix this one we - now add operator[](uint) for the machines where size_t is not already - the same as unsigned int - hopefully this fixes the problem (for some - time) - - The only real fix is, of course, to remove all versions but the one - taking size_t... + Note that we we must define all of the overloads below to avoid + ambiguity when using str[0]. */ - - // operator version of GetChar - wxChar operator[](int n) const - { return wxStringBase::operator[](n); } - wxChar& operator[](size_type n) - { return wxStringBase::operator[](n); } - wxChar operator[](size_type n) const - { return wxStringBase::operator[](n); } + wxUniChar operator[](int n) const + { return at(n); } + wxUniChar operator[](long n) const + { return at(n); } + wxUniChar operator[](size_t n) const + { return at(n); } #ifndef wxSIZE_T_IS_UINT - // operator version of GetChar - wxChar operator[](unsigned int n) const - { return wxStringBase::operator[](n); } + wxUniChar operator[](unsigned int n) const + { return at(n); } +#endif // size_t != unsigned int - // operator version of GetWriteableChar - wxChar& operator[](unsigned int n) - { return wxStringBase::operator[](n); } + // operator versions of GetWriteableChar() + wxUniCharRef operator[](int n) + { return at(n); } + wxUniCharRef operator[](long n) + { return at(n); } + wxUniCharRef operator[](size_t n) + { return at(n); } +#ifndef wxSIZE_T_IS_UINT + wxUniCharRef operator[](unsigned int n) + { return at(n); } #endif // size_t != unsigned int + // explicit conversion to C string (use this with printf()!) + wxCStrData c_str() const { return wxCStrData(this); } + wxCStrData data() const { return c_str(); } + // implicit conversion to C string + operator wxCStrData() const { return c_str(); } operator const wxChar*() const { return c_str(); } - // identical to c_str(), for wxWin 1.6x compatibility - const wxChar* wx_str() const { return c_str(); } // identical to c_str(), for MFC compatibility - const wxChar* GetData() const { return c_str(); } + const wxCStrData GetData() const { return c_str(); } + + // explicit conversion to C string in internal representation (char*, + // wchar_t*, UTF-8-encoded char*, depending on the build): + const_pointer wx_str() const { return m_impl.c_str(); } // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for // converting numbers or strings which are certain not to contain special @@ -810,15 +929,14 @@ public: // type differs because a function may either return pointer to the buffer // directly or have to use intermediate buffer for translation. #if wxUSE_UNICODE - const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const - { return conv.cWC2MB(c_str()); } + const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const; const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } const wxChar* wc_str() const { return c_str(); } // for compatibility with !wxUSE_UNICODE version - const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); } + const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); } #if wxMBFILES const wxCharBuffer fn_str() const { return mb_str(wxConvFile); } @@ -829,32 +947,52 @@ public: const wxChar* mb_str() const { return c_str(); } // for compatibility with wxUSE_UNICODE version - const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); } + const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); } const wxWX2MBbuf mbc_str() const { return mb_str(); } #if wxUSE_WCHAR_T - const wxWCharBuffer wc_str(wxMBConv& conv) const - { return conv.cMB2WC(c_str()); } + const wxWCharBuffer wc_str(const wxMBConv& conv) const; #endif // wxUSE_WCHAR_T - +#ifdef __WXOSX__ + const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); } +#else const wxChar* fn_str() const { return c_str(); } +#endif #endif // Unicode/ANSI // overloaded assignment // from another wxString - wxString& operator=(const wxStringBase& stringSrc) - { return (wxString&)wxStringBase::operator=(stringSrc); } + wxString& operator=(const wxStringImpl& stringSrc) + { m_impl = stringSrc; return *this; } + wxString& operator=(const wxCStrData& cstr) + { return *this = cstr.AsString(); } // from a character - wxString& operator=(wxChar ch) - { return (wxString&)wxStringBase::operator=(ch); } - // from a C string + wxString& operator=(wxUniChar ch) + { m_impl = EncodeChar(ch); return *this; } + wxString& operator=(wxUniCharRef ch) + { return operator=((wxUniChar)ch); } + wxString& operator=(char ch) + { return operator=(wxUniChar(ch)); } + wxString& operator=(wchar_t ch) + { return operator=(wxUniChar(ch)); } + // from a C string - STL probably will crash on NULL, + // so we need to compensate in that case +#if wxUSE_STL_BASED_WXSTRING wxString& operator=(const wxChar *psz) - { return (wxString&)wxStringBase::operator=(psz); } + { if(psz) m_impl = psz; else Clear(); return *this; } +#else + wxString& operator=(const wxChar *psz) + { m_impl = psz; return *this; } +#endif + #if wxUSE_UNICODE // from wxWCharBuffer - wxString& operator=(const wxWCharBuffer& psz) - { (void) operator=((const wchar_t *)psz); return *this; } + wxString& operator=(const wxWCharBuffer& s) + { (void) operator=((const wchar_t *)s); return *this; } + // from C string + wxString& operator=(const char* psz) + { return operator=(wxString(psz)); } #else // ANSI // from another kind of C string wxString& operator=(const unsigned char* psz); @@ -877,8 +1015,8 @@ public: // string += string wxString& operator<<(const wxString& s) { -#if !wxUSE_STL - wxASSERT_MSG( s.GetStringData()->IsValid(), +#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 + wxASSERT_MSG( s.IsValid(), _T("did you forget to call UngetWriteBuf()?") ); #endif @@ -886,57 +1024,81 @@ public: return *this; } // string += C string - wxString& operator<<(const wxChar *psz) + wxString& operator<<(const char *psz) { append(psz); return *this; } + wxString& operator<<(const wchar_t *pwz) + { append(pwz); return *this; } + wxString& operator<<(const wxCStrData& psz) + { append(psz.AsString()); return *this; } // string += char - wxString& operator<<(wxChar ch) { append(1, ch); return *this; } + wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; } + wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; } + wxString& operator<<(char ch) { append(1, ch); return *this; } + wxString& operator<<(wchar_t ch) { append(1, ch); return *this; } // string += buffer (i.e. from wxGetString) -#if wxUSE_UNICODE wxString& operator<<(const wxWCharBuffer& s) - { (void)operator<<((const wchar_t *)s); return *this; } - void operator+=(const wxWCharBuffer& s) - { (void)operator<<((const wchar_t *)s); } -#else // !wxUSE_UNICODE + { return operator<<((const wchar_t *)s); } + wxString& operator+=(const wxWCharBuffer& s) + { return operator<<((const wchar_t *)s); } + wxString& operator<<(const wxCharBuffer& s) - { (void)operator<<((const char *)s); return *this; } - void operator+=(const wxCharBuffer& s) - { (void)operator<<((const char *)s); } -#endif // wxUSE_UNICODE/!wxUSE_UNICODE + { return operator<<((const char *)s); } + wxString& operator+=(const wxCharBuffer& s) + { return operator<<((const char *)s); } // string += C string wxString& Append(const wxString& s) { - // test for IsEmpty() to share the string if possible - if ( IsEmpty() ) + // test for empty() to share the string if possible + if ( empty() ) *this = s; else append(s); return *this; } - wxString& Append(const wxChar* psz) + wxString& Append(const wxCStrData& psz) + { append(psz); return *this; } + wxString& Append(const char* psz) { append(psz); return *this; } + wxString& Append(const wchar_t* pwz) + { append(pwz); return *this; } // append count copies of given character - wxString& Append(wxChar ch, size_t count = 1u) + wxString& Append(wxUniChar ch, size_t count = 1u) + { append(count, ch); return *this; } + wxString& Append(wxUniCharRef ch, size_t count = 1u) + { append(count, ch); return *this; } + wxString& Append(char ch, size_t count = 1u) { append(count, ch); return *this; } - wxString& Append(const wxChar* psz, size_t nLen) + wxString& Append(wchar_t ch, size_t count = 1u) + { append(count, ch); return *this; } + wxString& Append(const char* psz, size_t nLen) { append(psz, nLen); return *this; } + wxString& Append(const wchar_t* pwz, size_t nLen) + { append(pwz, nLen); return *this; } // prepend a string, return the string itself wxString& Prepend(const wxString& str) { *this = str + *this; return *this; } // non-destructive concatenation - // - friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2); - // - friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch); - // - friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string); - // - friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz); - // - friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string); + // two strings + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, + const wxString& string2); + // string with a single char + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch); + // char with a string + friend wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string); + // string with C string + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, + const char *psz); + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, + const wchar_t *pwz); + // C string with string + friend wxString WXDLLIMPEXP_BASE operator+(const char *psz, + const wxString& string); + friend wxString WXDLLIMPEXP_BASE operator+(const wchar_t *pwz, + const wxString& string); // stream-like functions // insert an int into string @@ -951,6 +1113,20 @@ public: // insert an unsigned long into string wxString& operator<<(unsigned long ul) { return (*this) << Format(_T("%lu"), ul); } +#if defined wxLongLong_t && !defined wxLongLongIsLong + // insert a long long if they exist and aren't longs + wxString& operator<<(wxLongLong_t ll) + { + const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d"); + return (*this) << Format(fmt, ll); + } + // insert an unsigned long long + wxString& operator<<(wxULongLong_t ull) + { + const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u"); + return (*this) << Format(fmt , ull); + } +#endif // insert a float into string wxString& operator<<(float f) { return (*this) << Format(_T("%f"), f); } @@ -960,15 +1136,26 @@ public: // string comparison // case-sensitive comparison (returns a value < 0, = 0 or > 0) - int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); } + int Cmp(const char *psz) const + { return compare(psz); } + int Cmp(const wchar_t *pwz) const + { return compare(pwz); } + int Cmp(const wxString& s) const + { return compare(s); } // same as Cmp() but not case-sensitive - int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); } + int CmpNoCase(const wxString& s) const; + int CmpNoCase(const char *psz) const + { return CmpNoCase(wxString(psz)); } + int CmpNoCase(const wchar_t *pwz) const + { return CmpNoCase(wxString(pwz)); } // test for the string equality, either considering case or not // (if compareWithCase then the case matters) - bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const + bool IsSameAs(const char *psz, bool compareWithCase = true) const { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; } - // comparison with a signle character: returns TRUE if equal - bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const + bool IsSameAs(const wchar_t *pwz, bool compareWithCase = true) const + { return (compareWithCase ? Cmp(pwz) : CmpNoCase(pwz)) == 0; } + // comparison with a single character: returns true if equal + bool IsSameAs(wxUniChar c, bool compareWithCase = true) const { return (length() == 1) && (compareWithCase ? GetChar(0u) == c : wxToupper(GetChar(0u)) == wxToupper(c)); @@ -983,10 +1170,14 @@ public: wxString operator()(size_t start, size_t len) const { return Mid(start, len); } - // check that the string starts with prefix and return the rest of the - // string in the provided pointer if it is not NULL, otherwise return - // FALSE + // check if the string starts with the given prefix and return the rest + // of the string in the provided pointer if it is not NULL; otherwise + // return false bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const; + // check if the string ends with the given suffix and return the + // beginning of the string before the suffix in the provided pointer if + // it is not NULL; otherwise return false + bool EndsWith(const wxChar *suffix, wxString *rest = NULL) const; // get first nCount characters wxString Left(size_t nCount) const; @@ -994,20 +1185,20 @@ public: wxString Right(size_t nCount) const; // get all characters before the first occurance of ch // (returns the whole string if ch not found) - wxString BeforeFirst(wxChar ch) const; + wxString BeforeFirst(wxUniChar ch) const; // get all characters before the last occurence of ch // (returns empty string if ch not found) - wxString BeforeLast(wxChar ch) const; + wxString BeforeLast(wxUniChar ch) const; // get all characters after the first occurence of ch // (returns empty string if ch not found) - wxString AfterFirst(wxChar ch) const; + wxString AfterFirst(wxUniChar ch) const; // get all characters after the last occurence of ch // (returns the whole string if ch not found) - wxString AfterLast(wxChar ch) const; + wxString AfterLast(wxUniChar ch) const; // for compatibility only, use more explicitly named functions above - wxString Before(wxChar ch) const { return BeforeLast(ch); } - wxString After(wxChar ch) const { return AfterFirst(ch); } + wxString Before(wxUniChar ch) const { return BeforeLast(ch); } + wxString After(wxUniChar ch) const { return AfterFirst(ch); } // case conversion // convert to upper case in place, return the string itself @@ -1022,25 +1213,25 @@ public: // trimming/padding whitespace (either side) and truncating // remove spaces from left or from right (default) side - wxString& Trim(bool bFromRight = TRUE); + wxString& Trim(bool bFromRight = true); // add nCount copies chPad in the beginning or at the end (default) - wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE); + wxString& Pad(size_t nCount, wxUniChar chPad = wxT(' '), bool bFromRight = true); // searching and replacing // searching (return starting index, or -1 if not found) - int Find(wxChar ch, bool bFromEnd = FALSE) const; // like strchr/strrchr + int Find(wxUniChar ch, bool bFromEnd = false) const; // like strchr/strrchr // searching (return starting index, or -1 if not found) int Find(const wxChar *pszSub) const; // like strstr // replace first (or all of bReplaceAll) occurences of substring with // another string, returns the number of replacements made size_t Replace(const wxChar *szOld, const wxChar *szNew, - bool bReplaceAll = TRUE); + bool bReplaceAll = true); // check if the string contents matches a mask containing '*' and '?' bool Matches(const wxChar *szMask) const; - // conversion to numbers: all functions return TRUE only if the whole + // conversion to numbers: all functions return true only if the whole // string is a number and put the value of this number into the pointer // provided, the base is the numeric base in which the conversion should be // done and must be comprised between 2 and 36 or be 0 in which case the @@ -1049,20 +1240,33 @@ public: bool ToLong(long *val, int base = 10) const; // convert to an unsigned integer bool ToULong(unsigned long *val, int base = 10) const; + // convert to wxLongLong +#if defined(wxLongLong_t) + bool ToLongLong(wxLongLong_t *val, int base = 10) const; + // convert to wxULongLong + bool ToULongLong(wxULongLong_t *val, int base = 10) const; +#endif // wxLongLong_t // convert to a double bool ToDouble(double *val) const; - // formated input/output + +#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN + // formatted input/output // as sprintf(), returns the number of characters written or < 0 on error // (take 'this' into account in attribute parameter count) - int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; + // int Printf(const wxChar *pszFormat, ...); + WX_DEFINE_VARARG_FUNC(int, Printf, DoPrintf) +#endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN // as vprintf(), returns the number of characters written or < 0 on error - int PrintfV(const wxChar* pszFormat, va_list argptr); + int PrintfV(const wxString& format, va_list argptr); +#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // returns the string containing the result of Printf() to it - static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1; + // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1; + WX_DEFINE_VARARG_FUNC(static wxString, Format, DoFormat) +#endif // the same as above, but takes a va_list - static wxString FormatV(const wxChar *pszFormat, va_list argptr); + static wxString FormatV(const wxString& format, va_list argptr); // raw access to string memory // ensure that string has space for at least nLen characters @@ -1071,16 +1275,18 @@ public: // minimize the string's memory // only works if the data of this string is not shared bool Shrink(); -#if !wxUSE_STL +#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 + // These are deprecated, use wxStringBuffer or wxStringBufferLength instead + // // get writable buffer of at least nLen bytes. Unget() *must* be called // a.s.a.p. to put string back in a reasonable state! - wxChar *GetWriteBuf(size_t nLen); + wxDEPRECATED( wxChar *GetWriteBuf(size_t nLen) ); // call this immediately after GetWriteBuf() has been used - void UngetWriteBuf(); - void UngetWriteBuf(size_t nLen); -#endif + wxDEPRECATED( void UngetWriteBuf() ); + wxDEPRECATED( void UngetWriteBuf(size_t nLen) ); +#endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && wxUSE_UNICODE_UTF8 - // wxWindows version 1 compatibility functions + // wxWidgets version 1 compatibility functions // use Mid() wxString SubString(size_t from, size_t to) const @@ -1090,18 +1296,21 @@ public: // values for first parameter of Strip function enum stripType {leading = 0x1, trailing = 0x2, both = 0x3}; +#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // use Printf() // (take 'this' into account in attribute parameter count) - int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; + // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; + WX_DEFINE_VARARG_FUNC(int, sprintf, DoPrintf) +#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN // use Cmp() inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); } - // use Len + // use length() size_t Length() const { return length(); } // Count the number of characters - int Freq(wxChar ch) const; + int Freq(wxUniChar ch) const; // use MakeLower void LowerCase() { MakeLower(); } // use MakeUpper @@ -1111,7 +1320,7 @@ public: // use Find (more general variants not yet supported) size_t Index(const wxChar* psz) const { return Find(psz); } - size_t Index(wxChar ch) const { return Find(ch); } + size_t Index(wxUniChar ch) const { return Find(ch); } // use Truncate wxString& Remove(size_t pos) { return Truncate(pos); } wxString& RemoveLast(size_t n = 1) { return Truncate(length() - n); } @@ -1120,165 +1329,615 @@ public: { return (wxString&)erase( nStart, nLen ); } // use Find() - int First( const wxChar ch ) const { return Find(ch); } + int First( wxUniChar ch ) const { return Find(ch); } + int First( char ch ) const { return Find(ch); } + int First( wchar_t ch ) const { return Find(ch); } int First( const wxChar* psz ) const { return Find(psz); } int First( const wxString &str ) const { return Find(str); } - int Last( const wxChar ch ) const { return Find(ch, TRUE); } - bool Contains(const wxString& str) const { return Find(str) != -1; } + int Last( wxUniChar ch ) const { return Find(ch, true); } + bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; } - // use IsEmpty() - bool IsNull() const { return IsEmpty(); } + // use empty() + bool IsNull() const { return empty(); } // std::string compatibility functions // take nLen chars starting at nPos wxString(const wxString& str, size_t nPos, size_t nLen) - : wxStringBase(str, nPos, nLen) { } + : m_impl(str.m_impl, nPos, nLen) { } // take all characters from pStart to pEnd wxString(const void *pStart, const void *pEnd) - : wxStringBase((const char*)pStart, (const char*)pEnd) { } -#if wxUSE_STL + : m_impl((const wxChar*)pStart, (const wxChar*)pEnd) { } wxString(const_iterator first, const_iterator last) - : wxStringBase(first, last) { } -#endif + : m_impl(first, last) { } + wxString(iterator first, iterator last) + : m_impl(first, last) { } // lib.string.modifiers // append elements str[pos], ..., str[pos+n] wxString& append(const wxString& str, size_t pos, size_t n) - { return (wxString&)wxStringBase::append(str, pos, n); } + { + size_t from, len; + str.PosLenToImpl(pos, n, &from, &len); + m_impl.append(str.m_impl, from, len); + return *this; + } // append a string wxString& append(const wxString& str) - { return (wxString&)wxStringBase::append(str); } + { m_impl.append(str.m_impl); return *this; } + wxString& append(const wxCStrData& str) + { m_impl.append(str.AsString().m_impl); return *this; } // append first n (or all if n == npos) characters of sz - wxString& append(const wxChar *sz) - { return (wxString&)wxStringBase::append(sz); } - wxString& append(const wxChar *sz, size_t n) - { return (wxString&)wxStringBase::append(sz, n); } + wxString& append(const char *sz) + { m_impl.append(ImplStr(sz)); return *this; } + wxString& append(const wchar_t *sz) + { m_impl.append(ImplStr(sz)); return *this; } + wxString& append(const char *sz, size_t n) + { + SubstrBufFromMB str(ImplStr(sz, n)); + m_impl.append(str.data, str.len); + return *this; + } + wxString& append(const wchar_t *sz, size_t n) + { + SubstrBufFromWC str(ImplStr(sz, n)); + m_impl.append(str.data, str.len); + return *this; + } // append n copies of ch - wxString& append(size_t n, wxChar ch) - { return (wxString&)wxStringBase::append(n, ch); } + wxString& append(size_t n, wxUniChar ch) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.append(EncodeNChars(n, ch)); + else +#endif + m_impl.append(n, (wxStringCharType)ch); + return *this; + } // append from first to last wxString& append(const_iterator first, const_iterator last) - { return (wxString&)wxStringBase::append(first, last); } + { m_impl.append(first, last); return *this; } // same as `this_string = str' wxString& assign(const wxString& str) - { return (wxString&)wxStringBase::assign(str); } + { m_impl = str.m_impl; return *this; } // same as ` = str[pos..pos + n] wxString& assign(const wxString& str, size_t pos, size_t n) - { return (wxString&)wxStringBase::assign(str, pos, n); } + { + size_t from, len; + str.PosLenToImpl(pos, n, &from, &len); + m_impl.assign(str.m_impl, from, len); + return *this; + } // same as `= first n (or all if n == npos) characters of sz' - wxString& assign(const wxChar *sz) - { return (wxString&)wxStringBase::assign(sz); } - wxString& assign(const wxChar *sz, size_t n) - { return (wxString&)wxStringBase::assign(sz, n); } + wxString& assign(const char *sz) + { m_impl.assign(ImplStr(sz)); return *this; } + wxString& assign(const wchar_t *sz) + { m_impl.assign(ImplStr(sz)); return *this; } + wxString& assign(const char *sz, size_t n) + { + SubstrBufFromMB str(ImplStr(sz, n)); + m_impl.assign(str.data, str.len); + return *this; + } + wxString& assign(const wchar_t *sz, size_t n) + { + SubstrBufFromWC str(ImplStr(sz, n)); + m_impl.assign(str.data, str.len); + return *this; + } // same as `= n copies of ch' - wxString& assign(size_t n, wxChar ch) - { return (wxString&)wxStringBase::assign(n, ch); } + wxString& assign(size_t n, wxUniChar ch) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.assign(EncodeNChars(n, ch)); + else +#endif + m_impl.assign(n, (wxStringCharType)ch); + return *this; + } // assign from first to last wxString& assign(const_iterator first, const_iterator last) - { return (wxString&)wxStringBase::assign(first, last); } + { m_impl.assign(first, last); return *this; } // string comparison -#ifndef HAVE_STD_STRING_COMPARE - int compare(const wxStringBase& str) const; + int compare(const wxString& str) const; // comparison with a substring - int compare(size_t nStart, size_t nLen, const wxStringBase& str) const; + int compare(size_t nStart, size_t nLen, const wxString& str) const; // comparison of 2 substrings int compare(size_t nStart, size_t nLen, - const wxStringBase& str, size_t nStart2, size_t nLen2) const; + const wxString& str, size_t nStart2, size_t nLen2) const; // just like strcmp() - int compare(const wxChar* sz) const; + int compare(const char* sz) const; + int compare(const wchar_t* sz) const; // substring comparison with first nCount characters of sz int compare(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount = npos) const; -#endif // !defined HAVE_STD_STRING_COMPARE + const char* sz, size_t nCount = npos) const; + int compare(size_t nStart, size_t nLen, + const wchar_t* sz, size_t nCount = npos) const; // insert another string wxString& insert(size_t nPos, const wxString& str) - { return (wxString&)wxStringBase::insert(nPos, str); } + { insert(begin() + nPos, str.begin(), str.end()); return *this; } // insert n chars of str starting at nStart (in str) wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n) - { return (wxString&)wxStringBase::insert(nPos, str, nStart, n); } + { + size_t from, len; + str.PosLenToImpl(nStart, n, &from, &len); + m_impl.insert(PosToImpl(nPos), str.m_impl, from, len); + return *this; + } // insert first n (or all if n == npos) characters of sz - wxString& insert(size_t nPos, const wxChar *sz) - { return (wxString&)wxStringBase::insert(nPos, sz); } - wxString& insert(size_t nPos, const wxChar *sz, size_t n) - { return (wxString&)wxStringBase::insert(nPos, sz, n); } + wxString& insert(size_t nPos, const char *sz) + { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; } + wxString& insert(size_t nPos, const wchar_t *sz) + { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; } + wxString& insert(size_t nPos, const char *sz, size_t n) + { + SubstrBufFromMB str(ImplStr(sz, n)); + m_impl.insert(PosToImpl(nPos), str.data, str.len); + return *this; + } + wxString& insert(size_t nPos, const wchar_t *sz, size_t n) + { + SubstrBufFromWC str(ImplStr(sz, n)); + m_impl.insert(PosToImpl(nPos), str.data, str.len); + return *this; + } // insert n copies of ch - wxString& insert(size_t nPos, size_t n, wxChar ch) - { return (wxString&)wxStringBase::insert(nPos, n, ch); } - iterator insert(iterator it, wxChar ch) - { return wxStringBase::insert(it, ch); } + wxString& insert(size_t nPos, size_t n, wxUniChar ch) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.insert(begin() + nPos, EncodeNChars(n, ch)); + else +#endif + m_impl.insert(begin() + nPos, n, (wxStringCharType)ch); + return *this; + } + iterator insert(iterator it, wxUniChar ch) + { return iterator(m_impl.insert(it, EncodeChar(ch))); } void insert(iterator it, const_iterator first, const_iterator last) - { wxStringBase::insert(it, first, last); } - void insert(iterator it, size_type n, wxChar ch) - { wxStringBase::insert(it, n, ch); } + { m_impl.insert(it, first, last); } + void insert(iterator it, size_type n, wxUniChar ch) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.insert(it, EncodeNChars(n, ch)); + else +#endif + m_impl.insert(it, n, (wxStringCharType)ch); + } // delete characters from nStart to nStart + nLen wxString& erase(size_type pos = 0, size_type n = npos) - { return (wxString&)wxStringBase::erase(pos, n); } + { + size_t from, len; + PosLenToImpl(pos, n, &from, &len); + m_impl.erase(from, len); + return *this; + } iterator erase(iterator first, iterator last) - { return wxStringBase::erase(first, last); } + { return iterator(m_impl.erase(first, last)); } iterator erase(iterator first) - { return wxStringBase::erase(first); } + { return iterator(m_impl.erase(first)); } #ifdef wxSTRING_BASE_HASNT_CLEAR void clear() { erase(); } +#else + void clear() { m_impl.clear(); } #endif // replaces the substring of length nLen starting at nStart - wxString& replace(size_t nStart, size_t nLen, const wxChar* sz) - { return (wxString&)wxStringBase::replace(nStart, nLen, sz); } + wxString& replace(size_t nStart, size_t nLen, const char* sz) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + m_impl.replace(from, len, ImplStr(sz)); + return *this; + } + wxString& replace(size_t nStart, size_t nLen, const wchar_t* sz) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + m_impl.replace(from, len, ImplStr(sz)); + return *this; + } // replaces the substring of length nLen starting at nStart wxString& replace(size_t nStart, size_t nLen, const wxString& str) - { return (wxString&)wxStringBase::replace(nStart, nLen, str); } + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + m_impl.replace(from, len, str.m_impl); + return *this; + } // replaces the substring with nCount copies of ch - wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch) - { return (wxString&)wxStringBase::replace(nStart, nLen, nCount, ch); } + wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.replace(from, len, EncodeNChars(nCount, ch)); + else +#endif + m_impl.replace(from, len, nCount, (wxStringCharType)ch); + return *this; + } // replaces a substring with another substring wxString& replace(size_t nStart, size_t nLen, const wxString& str, size_t nStart2, size_t nLen2) - { return (wxString&)wxStringBase::replace(nStart, nLen, str, - nStart2, nLen2); } + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + + size_t from2, len2; + str.PosLenToImpl(nStart2, nLen2, &from2, &len2); + + m_impl.replace(from, len, str.m_impl, from2, len2); + return *this; + } // replaces the substring with first nCount chars of sz wxString& replace(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount) - { return (wxString&)wxStringBase::replace(nStart, nLen, sz, nCount); } - wxString& replace(iterator first, iterator last, const_pointer s) - { return (wxString&)wxStringBase::replace(first, last, s); } - wxString& replace(iterator first, iterator last, const_pointer s, - size_type n) - { return (wxString&)wxStringBase::replace(first, last, s, n); } + const char* sz, size_t nCount) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + + SubstrBufFromMB str(ImplStr(sz, nCount)); + + m_impl.replace(from, len, str.data, str.len); + return *this; + } + wxString& replace(size_t nStart, size_t nLen, + const wchar_t* sz, size_t nCount) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + + SubstrBufFromWC str(ImplStr(sz, nCount)); + + m_impl.replace(from, len, str.data, str.len); + return *this; + } + wxString& replace(iterator first, iterator last, const char* s) + { m_impl.replace(first, last, ImplStr(s)); return *this; } + wxString& replace(iterator first, iterator last, const wchar_t* s) + { m_impl.replace(first, last, ImplStr(s)); return *this; } + wxString& replace(iterator first, iterator last, const char* s, size_type n) + { + SubstrBufFromMB str(ImplStr(s, n)); + m_impl.replace(first, last, str.data, str.len); + return *this; + } + wxString& replace(iterator first, iterator last, const wchar_t* s, size_type n) + { + SubstrBufFromWC str(ImplStr(s, n)); + m_impl.replace(first, last, str.data, str.len); + return *this; + } wxString& replace(iterator first, iterator last, const wxString& s) - { return (wxString&)wxStringBase::replace(first, last, s); } - wxString& replace(iterator first, iterator last, size_type n, wxChar c) - { return (wxString&)wxStringBase::replace(first, last, n, c); } + { m_impl.replace(first, last, s.m_impl); return *this; } + wxString& replace(iterator first, iterator last, size_type n, wxUniChar ch) + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl.replace(first, last, EncodeNChars(n, ch)); + else +#endif + m_impl.replace(first, last, n, (wxStringCharType)ch); + return *this; + } wxString& replace(iterator first, iterator last, const_iterator first1, const_iterator last1) - { return (wxString&)wxStringBase::replace(first, last, first1, last1); } + { m_impl.replace(first, last, first1, last1); return *this; } + + // swap two strings + void swap(wxString& str) + { m_impl.swap(str.m_impl); } + + // find a substring + size_t find(const wxString& str, size_t nStart = 0) const + { return PosFromImpl(m_impl.find(str.m_impl, PosToImpl(nStart))); } + + // find first n characters of sz + size_t find(const char* sz, size_t nStart = 0, size_t n = npos) const + { + SubstrBufFromMB str(ImplStr(sz, n)); + return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len)); + } + size_t find(const wchar_t* sz, size_t nStart = 0, size_t n = npos) const + { + SubstrBufFromWC str(ImplStr(sz, n)); + return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len)); + } + + // find the first occurence of character ch after nStart + size_t find(wxUniChar ch, size_t nStart = 0) const + { return PosFromImpl(m_impl.find(EncodeChar(ch), PosToImpl(nStart))); } + size_t find(wxUniCharRef ch, size_t nStart = 0) const + { return find(wxUniChar(ch), nStart); } + size_t find(char ch, size_t nStart = 0) const + { return find(wxUniChar(ch), nStart); } + size_t find(wchar_t ch, size_t nStart = 0) const + { return find(wxUniChar(ch), nStart); } + + // rfind() family is exactly like find() but works right to left + + // as find, but from the end + size_t rfind(const wxString& str, size_t nStart = npos) const + { return PosFromImpl(m_impl.rfind(str.m_impl, PosToImpl(nStart))); } + + // as find, but from the end + size_t rfind(const char* sz, size_t nStart = npos, size_t n = npos) const + { + SubstrBufFromMB str(ImplStr(sz, n)); + return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len)); + } + size_t rfind(const wchar_t* sz, size_t nStart = npos, size_t n = npos) const + { + SubstrBufFromWC str(ImplStr(sz, n)); + return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len)); + } + // as find, but from the end + size_t rfind(wxUniChar ch, size_t nStart = npos) const + { return PosFromImpl(m_impl.rfind(EncodeChar(ch), PosToImpl(nStart))); } + size_t rfind(wxUniCharRef ch, size_t nStart = npos) const + { return rfind(wxUniChar(ch), nStart); } + size_t rfind(char ch, size_t nStart = npos) const + { return rfind(wxUniChar(ch), nStart); } + size_t rfind(wchar_t ch, size_t nStart = npos) const + { return rfind(wxUniChar(ch), nStart); } + + // find first/last occurence of any character (not) in the set: +#if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 + // FIXME-UTF8: this is not entirely correct, because it doesn't work if + // sizeof(wchar_t)==2 and surrogates are present in the string; + // should we care? Probably not. + size_t find_first_of(const wxString& str, size_t nStart = 0) const + { return m_impl.find_first_of(str.m_impl, nStart); } + size_t find_first_of(const char* sz, size_t nStart = 0) const + { return m_impl.find_first_of(ImplStr(sz), nStart); } + size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const + { return m_impl.find_first_of(ImplStr(sz), nStart); } + size_t find_first_of(const char* sz, size_t nStart, size_t n) const + { return m_impl.find_first_of(ImplStr(sz), nStart, n); } + size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const + { return m_impl.find_first_of(ImplStr(sz), nStart, n); } + size_t find_first_of(wxUniChar c, size_t nStart = 0) const + { return m_impl.find_first_of((wxChar)c, nStart); } + + size_t find_last_of(const wxString& str, size_t nStart = npos) const + { return m_impl.find_last_of(str.m_impl, nStart); } + size_t find_last_of(const char* sz, size_t nStart = npos) const + { return m_impl.find_last_of(ImplStr(sz), nStart); } + size_t find_last_of(const wchar_t* sz, size_t nStart = npos) const + { return m_impl.find_last_of(ImplStr(sz), nStart); } + size_t find_last_of(const char* sz, size_t nStart, size_t n) const + { return m_impl.find_last_of(ImplStr(sz), nStart, n); } + size_t find_last_of(const wchar_t* sz, size_t nStart, size_t n) const + { return m_impl.find_last_of(ImplStr(sz), nStart, n); } + size_t find_last_of(wxUniChar c, size_t nStart = npos) const + { return m_impl.find_last_of((wxChar)c, nStart); } + + size_t find_first_not_of(const wxString& str, size_t nStart = 0) const + { return m_impl.find_first_not_of(str.m_impl, nStart); } + size_t find_first_not_of(const char* sz, size_t nStart = 0) const + { return m_impl.find_first_not_of(ImplStr(sz), nStart); } + size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const + { return m_impl.find_first_not_of(ImplStr(sz), nStart); } + size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const + { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); } + size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const + { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); } + size_t find_first_not_of(wxUniChar c, size_t nStart = 0) const + { return m_impl.find_first_not_of((wxChar)c, nStart); } + + size_t find_last_not_of(const wxString& str, size_t nStart = npos) const + { return m_impl.find_last_not_of(str.m_impl, nStart); } + size_t find_last_not_of(const char* sz, size_t nStart = npos) const + { return m_impl.find_last_not_of(ImplStr(sz), nStart); } + size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const + { return m_impl.find_last_not_of(ImplStr(sz), nStart); } + size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const + { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); } + size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const + { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); } + size_t find_last_not_of(wxUniChar c, size_t nStart = npos) const + { return m_impl.find_last_not_of((wxChar)c, nStart); } +#else + // we can't use std::string implementation in UTF-8 build, because the + // character sets would be interpreted wrongly: + + // as strpbrk() but starts at nStart, returns npos if not found + size_t find_first_of(const wxString& str, size_t nStart = 0) const + { return find_first_of((const wxChar*)str.c_str(), nStart); } + // same as above + size_t find_first_of(const char* sz, size_t nStart = 0) const; + size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const; + size_t find_first_of(const char* sz, size_t nStart, size_t n) const; + size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const; + // same as find(char, size_t) + size_t find_first_of(wxUniChar c, size_t nStart = 0) const + { return find(c, nStart); } + // find the last (starting from nStart) char from str in this string + size_t find_last_of (const wxString& str, size_t nStart = npos) const + { return find_last_of((const wxChar*)str.c_str(), nStart); } + // same as above + size_t find_last_of (const char* sz, size_t nStart = npos) const; + size_t find_last_of (const wchar_t* sz, size_t nStart = npos) const; + size_t find_last_of(const char* sz, size_t nStart, size_t n) const; + size_t find_last_of(const wchar_t* sz, size_t nStart, size_t n) const; + // same as above + size_t find_last_of(wxUniChar c, size_t nStart = npos) const + { return rfind(c, nStart); } + + // find first/last occurence of any character not in the set + + // as strspn() (starting from nStart), returns npos on failure + size_t find_first_not_of(const wxString& str, size_t nStart = 0) const + { return find_first_not_of((const wxChar*)str.c_str(), nStart); } + // same as above + size_t find_first_not_of(const char* sz, size_t nStart = 0) const; + size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const; + size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const; + size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const; + // same as above + size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const; + // as strcspn() + size_t find_last_not_of(const wxString& str, size_t nStart = npos) const + { return find_last_not_of((const wxChar*)str.c_str(), nStart); } + // same as above + size_t find_last_not_of(const char* sz, size_t nStart = npos) const; + size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const; + size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const; + size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const; + // same as above + size_t find_last_not_of(wxUniChar ch, size_t nStart = npos) const; +#endif // wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 or not + + // provide char/wchar_t/wxUniCharRef overloads for char-finding functions + // above to resolve ambiguities: + size_t find_first_of(wxUniCharRef ch, size_t nStart = 0) const + { return find_first_of(wxUniChar(ch), nStart); } + size_t find_first_of(char ch, size_t nStart = 0) const + { return find_first_of(wxUniChar(ch), nStart); } + size_t find_first_of(wchar_t ch, size_t nStart = 0) const + { return find_first_of(wxUniChar(ch), nStart); } + size_t find_last_of(wxUniCharRef ch, size_t nStart = npos) const + { return find_last_of(wxUniChar(ch), nStart); } + size_t find_last_of(char ch, size_t nStart = npos) const + { return find_last_of(wxUniChar(ch), nStart); } + size_t find_last_of(wchar_t ch, size_t nStart = npos) const + { return find_last_of(wxUniChar(ch), nStart); } + size_t find_first_not_of(wxUniCharRef ch, size_t nStart = 0) const + { return find_first_not_of(wxUniChar(ch), nStart); } + size_t find_first_not_of(char ch, size_t nStart = 0) const + { return find_first_not_of(wxUniChar(ch), nStart); } + size_t find_first_not_of(wchar_t ch, size_t nStart = 0) const + { return find_first_not_of(wxUniChar(ch), nStart); } + size_t find_last_not_of(wxUniCharRef ch, size_t nStart = npos) const + { return find_last_not_of(wxUniChar(ch), nStart); } + size_t find_last_not_of(char ch, size_t nStart = npos) const + { return find_last_not_of(wxUniChar(ch), nStart); } + size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const + { return find_last_not_of(wxUniChar(ch), nStart); } // string += string wxString& operator+=(const wxString& s) - { return (wxString&)wxStringBase::operator+=(s); } + { m_impl += s.m_impl; return *this; } // string += C string - wxString& operator+=(const wxChar *psz) - { return (wxString&)wxStringBase::operator+=(psz); } + wxString& operator+=(const char *psz) + { m_impl += ImplStr(psz); return *this; } + wxString& operator+=(const wchar_t *pwz) + { m_impl += ImplStr(pwz); return *this; } + wxString& operator+=(const wxCStrData& s) + { m_impl += s.AsString().m_impl; return *this; } // string += char - wxString& operator+=(wxChar ch) - { return (wxString&)wxStringBase::operator+=(ch); } + wxString& operator+=(wxUniChar ch) + { m_impl += EncodeChar(ch); return *this; } + wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); } + wxString& operator+=(int ch) { return *this += wxUniChar(ch); } + wxString& operator+=(char ch) { return *this += wxUniChar(ch); } + wxString& operator+=(unsigned char ch) { return *this += wxUniChar(ch); } + wxString& operator+=(wchar_t ch) { return *this += wxUniChar(ch); } + +private: +#if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 + // helpers for wxStringBuffer and wxStringBufferLength + wxStringCharType *DoGetWriteBuf(size_t nLen) + { return m_impl.DoGetWriteBuf(nLen); } + void DoUngetWriteBuf() + { m_impl.DoUngetWriteBuf(); } + void DoUngetWriteBuf(size_t nLen) + { m_impl.DoUngetWriteBuf(nLen); } + + friend class WXDLLIMPEXP_BASE wxStringBuffer; + friend class WXDLLIMPEXP_BASE wxStringBufferLength; +#endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 + +#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN + int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2; + static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1; +#endif + +#if !wxUSE_STL_BASED_WXSTRING + // check string's data validity + bool IsValid() const { return m_impl.GetStringData()->IsValid(); } +#endif + +private: + wxStringImpl m_impl; }; -// define wxArrayString, for compatibility -#if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL - #include "wx/arrstr.h" +#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN + #pragma warning (default:4275) #endif +// string iterator operators that satisfy STL Random Access Iterator +// requirements: +inline wxString::iterator operator+(int n, wxString::iterator i) + { return i + n; } +inline wxString::iterator operator+(size_t n, wxString::iterator i) + { return i + n; } +inline wxString::const_iterator operator+(int n, wxString::const_iterator i) + { return i + n; } +inline wxString::const_iterator operator+(size_t n, wxString::const_iterator i) + { return i + n; } +inline wxString::reverse_iterator operator+(int n, wxString::reverse_iterator i) + { return i + n; } +inline wxString::reverse_iterator operator+(size_t n, wxString::reverse_iterator i) + { return i + n; } +inline wxString::const_reverse_iterator operator+(int n, wxString::const_reverse_iterator i) + { return i + n; } +inline wxString::const_reverse_iterator operator+(size_t n, wxString::const_reverse_iterator i) + { return i + n; } + +// notice that even though for many compilers the friend declarations above are +// enough, from the point of view of C++ standard we must have the declarations +// here as friend ones are not injected in the enclosing namespace and without +// them the code fails to compile with conforming compilers such as xlC or g++4 +wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2); +wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const char *psz); +wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wchar_t *pwz); +wxString WXDLLIMPEXP_BASE operator+(const char *psz, const wxString& string); +wxString WXDLLIMPEXP_BASE operator+(const wchar_t *pwz, const wxString& string); + +wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch); +wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string); + +inline wxString operator+(const wxString& string, wxUniCharRef ch) + { return string + (wxUniChar)ch; } +inline wxString operator+(const wxString& string, char ch) + { return string + wxUniChar(ch); } +inline wxString operator+(const wxString& string, wchar_t ch) + { return string + wxUniChar(ch); } +inline wxString operator+(wxUniCharRef ch, const wxString& string) + { return (wxUniChar)ch + string; } +inline wxString operator+(char ch, const wxString& string) + { return wxUniChar(ch) + string; } +inline wxString operator+(wchar_t ch, const wxString& string) + { return wxUniChar(ch) + string; } + + +#if wxUSE_STL_BASED_WXSTRING + // return an empty wxString (not very useful with wxUSE_STL == 1) + inline const wxString wxGetEmptyString() { return wxString(); } +#else // !wxUSE_STL_BASED_WXSTRING + // return an empty wxString (more efficient than wxString() here) + inline const wxString& wxGetEmptyString() + { + return *(wxString *)&wxEmptyString; + } +#endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING + // ---------------------------------------------------------------------------- // wxStringBuffer: a tiny class allowing to get a writable pointer into string // ---------------------------------------------------------------------------- -#if wxUSE_STL +#if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8 class WXDLLIMPEXP_BASE wxStringBuffer { @@ -1331,16 +1990,16 @@ private: DECLARE_NO_COPY_CLASS(wxStringBufferLength) }; -#else // if !wxUSE_STL +#else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 class WXDLLIMPEXP_BASE wxStringBuffer { public: wxStringBuffer(wxString& str, size_t lenWanted = 1024) : m_str(str), m_buf(NULL) - { m_buf = m_str.GetWriteBuf(lenWanted); } + { m_buf = m_str.DoGetWriteBuf(lenWanted); } - ~wxStringBuffer() { m_str.UngetWriteBuf(); } + ~wxStringBuffer() { m_str.DoUngetWriteBuf(); } operator wxChar*() const { return m_buf; } @@ -1356,12 +2015,15 @@ class WXDLLIMPEXP_BASE wxStringBufferLength public: wxStringBufferLength(wxString& str, size_t lenWanted = 1024) : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false) - { m_buf = m_str.GetWriteBuf(lenWanted); } + { + m_buf = m_str.DoGetWriteBuf(lenWanted); + wxASSERT(m_buf != NULL); + } ~wxStringBufferLength() { wxASSERT(m_lenSet); - m_str.UngetWriteBuf(m_len); + m_str.DoUngetWriteBuf(m_len); } operator wxChar*() const { return m_buf; } @@ -1376,97 +2038,32 @@ private: DECLARE_NO_COPY_CLASS(wxStringBufferLength) }; -#endif // !wxUSE_STL +#endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 // --------------------------------------------------------------------------- // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- -#if wxUSE_STL +#define wxCMP_WXCHAR_STRING(p, s, op) s.Cmp(p) op 0 -inline bool operator==(const wxString& s1, const wxString& s2) - { return s1.compare(s2) == 0; } -inline bool operator==(const wxString& s1, const wxChar * s2) - { return s1.compare(s2) == 0; } -inline bool operator==(const wxChar * s1, const wxString& s2) - { return s2.compare(s1) == 0; } -inline bool operator!=(const wxString& s1, const wxString& s2) - { return s1.compare(s2) != 0; } -inline bool operator!=(const wxString& s1, const wxChar * s2) - { return s1.compare(s2) != 0; } -inline bool operator!=(const wxChar * s1, const wxString& s2) - { return s2.compare(s1) != 0; } -inline bool operator< (const wxString& s1, const wxString& s2) - { return s1.compare(s2) < 0; } -inline bool operator< (const wxString& s1, const wxChar * s2) - { return s1.compare(s2) < 0; } -inline bool operator< (const wxChar * s1, const wxString& s2) - { return s2.compare(s1) > 0; } -inline bool operator> (const wxString& s1, const wxString& s2) - { return s1.compare(s2) > 0; } -inline bool operator> (const wxString& s1, const wxChar * s2) - { return s1.compare(s2) > 0; } -inline bool operator> (const wxChar * s1, const wxString& s2) - { return s2.compare(s1) < 0; } -inline bool operator<=(const wxString& s1, const wxString& s2) - { return s1.compare(s2) <= 0; } -inline bool operator<=(const wxString& s1, const wxChar * s2) - { return s1.compare(s2) <= 0; } -inline bool operator<=(const wxChar * s1, const wxString& s2) - { return s2.compare(s1) >= 0; } -inline bool operator>=(const wxString& s1, const wxString& s2) - { return s1.compare(s2) >= 0; } -inline bool operator>=(const wxString& s1, const wxChar * s2) - { return s1.compare(s2) >= 0; } -inline bool operator>=(const wxChar * s1, const wxString& s2) - { return s2.compare(s1) <= 0; } +wxDEFINE_ALL_COMPARISONS(const wxChar *, const wxString&, wxCMP_WXCHAR_STRING) -#else // if !wxUSE_STL +#undef wxCMP_WXCHAR_STRING +// note that there is an optimization in operator==() and !=(): we (quickly) +// checks the strings length first, before comparing their data inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); } -inline bool operator==(const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) == 0; } -inline bool operator==(const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) == 0; } inline bool operator!=(const wxString& s1, const wxString& s2) { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); } -inline bool operator!=(const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) != 0; } -inline bool operator!=(const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) != 0; } inline bool operator< (const wxString& s1, const wxString& s2) { return s1.Cmp(s2) < 0; } -inline bool operator< (const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) < 0; } -inline bool operator< (const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) > 0; } inline bool operator> (const wxString& s1, const wxString& s2) { return s1.Cmp(s2) > 0; } -inline bool operator> (const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) > 0; } -inline bool operator> (const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) < 0; } inline bool operator<=(const wxString& s1, const wxString& s2) { return s1.Cmp(s2) <= 0; } -inline bool operator<=(const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) <= 0; } -inline bool operator<=(const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) >= 0; } inline bool operator>=(const wxString& s1, const wxString& s2) { return s1.Cmp(s2) >= 0; } -inline bool operator>=(const wxString& s1, const wxChar * s2) - { return s1.Cmp(s2) >= 0; } -inline bool operator>=(const wxChar * s1, const wxString& s2) - { return s2.Cmp(s1) <= 0; } - -#endif // !wxUSE_STL - -// comparison with char -inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); } -inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); } -inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); } -inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); } #if wxUSE_UNICODE inline bool operator==(const wxString& s1, const wxWCharBuffer& s2) @@ -1488,16 +2085,6 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) != 0); } #endif // wxUSE_UNICODE/!wxUSE_UNICODE -#if !wxUSE_STL - -wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2); -wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch); -wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string); -wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz); -wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string); - -#endif // !wxUSE_STL - #if wxUSE_UNICODE inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) { return string + (const wchar_t *)buf; } @@ -1510,20 +2097,122 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string) { return (const char *)buf + string; } #endif // wxUSE_UNICODE/!wxUSE_UNICODE +// comparison with char +inline bool operator==(const wxUniChar& c, const wxString& s) { return s.IsSameAs(c); } +inline bool operator==(const wxUniCharRef& c, const wxString& s) { return s.IsSameAs(c); } +inline bool operator==(char c, const wxString& s) { return s.IsSameAs(c); } +inline bool operator==(wchar_t c, const wxString& s) { return s.IsSameAs(c); } +inline bool operator==(int c, const wxString& s) { return s.IsSameAs(c); } +inline bool operator==(const wxString& s, const wxUniChar& c) { return s.IsSameAs(c); } +inline bool operator==(const wxString& s, const wxUniCharRef& c) { return s.IsSameAs(c); } +inline bool operator==(const wxString& s, char c) { return s.IsSameAs(c); } +inline bool operator==(const wxString& s, wchar_t c) { return s.IsSameAs(c); } +inline bool operator!=(const wxUniChar& c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(const wxUniCharRef& c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(char c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(wchar_t c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(int c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(const wxString& s, const wxUniChar& c) { return !s.IsSameAs(c); } +inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsSameAs(c); } +inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); } +inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); } + +// comparison with C string in Unicode build +#if wxUSE_UNICODE + +#define wxCMP_CHAR_STRING(p, s, op) wxString(p) op s + +wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING) + +#undef wxCMP_CHAR_STRING + +#endif // wxUSE_UNICODE + +// we also need to provide the operators for comparison with wxCStrData to +// resolve ambiguity between operator(const wxChar *,const wxString &) and +// operator(const wxChar *, const wxChar *) for "p == s.c_str()" +// +// notice that these are (shallow) pointer comparisons, not (deep) string ones +#define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar() +#define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar() + +// FIXME: these ifdefs must be removed when wxCStrData has both conversions +#if wxUSE_UNICODE + wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA) +#else + wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA) +#endif + +#undef wxCMP_CHAR_CSTRDATA +#undef wxCMP_WCHAR_CSTRDATA + // --------------------------------------------------------------------------- // Implementation only from here until the end of file // --------------------------------------------------------------------------- -// don't pollute the library user's name space -#undef wxASSERT_VALID_INDEX - #if wxUSE_STD_IOSTREAM #include "wx/iosfwrap.h" -WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&); WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&); #endif // wxSTD_STRING_COMPATIBILITY -#endif // _WX_WXSTRINGH__ +// --------------------------------------------------------------------------- +// wxCStrData implementation +// --------------------------------------------------------------------------- + +inline wxCStrData::wxCStrData(char *buf) + : m_str(new wxString(buf)), m_offset(0), m_owned(true) {} +inline wxCStrData::wxCStrData(wchar_t *buf) + : m_str(new wxString(buf)), m_offset(0), m_owned(true) {} + +inline wxCStrData::~wxCStrData() +{ + if ( m_owned ) + delete m_str; +} + +#if wxUSE_UNICODE +inline const wchar_t* wxCStrData::AsWChar() const +#else +inline const char* wxCStrData::AsChar() const +#endif +{ + // FIXME-UTF8: incorrect position, incorrect charset + return m_str->wx_str() + m_offset; +} + +inline wxString wxCStrData::AsString() const +{ + if ( m_offset == 0 ) + return *m_str; + else + return m_str->Mid(m_offset); +} + +inline wxUniChar wxCStrData::operator*() const +{ + if ( m_str->empty() ) + return wxUniChar(_T('\0')); + else + return (*m_str)[m_offset]; +} + +inline wxUniChar wxCStrData::operator[](size_t n) const +{ + return m_str->at(m_offset + n); +} + +// ---------------------------------------------------------------------------- +// implementation of wx[W]CharBuffer inline methods using wxCStrData +// ---------------------------------------------------------------------------- + +// FIXME-UTF8: move this to buffer.h; provide versions for both variants +inline wxWxCharBuffer::wxWxCharBuffer(const wxCStrData& cstr) + : wxCharTypeBufferBase((const wxChar *)cstr) +{ +} + +#endif // _WX_WXSTRING_H__