X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/817270659e986de1b243586d8eb6ad3a76c87480..0c73d133517098480565f3dbb529a5f2a72ef68f:/include/wx/string.h?ds=sidebyside diff --git a/include/wx/string.h b/include/wx/string.h index 3bc5588f9a..deecb1795b 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -51,14 +51,21 @@ #include #endif -#include "wx/wxchar.h" // for wxChar, wxStrlen() etc. +#include "wx/wxcrtbase.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/stringops.h" #include "wx/unichar.h" -class WXDLLIMPEXP_BASE wxString; +class WXDLLIMPEXP_FWD_BASE wxString; + +// unless this symbol is predefined to disable the compatibility functions, do +// use them +#ifndef WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER + #define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1 +#endif // --------------------------------------------------------------------------- // macros @@ -118,8 +125,6 @@ inline int Stricmp(const char *psz1, const char *psz2) return _stricmp(psz1, psz2); #elif defined(__SC__) return _stricmp(psz1, psz2); -#elif defined(__SALFORDC__) - return stricmp(psz1, psz2); #elif defined(__BORLANDC__) return stricmp(psz1, psz2); #elif defined(__WATCOMC__) @@ -179,8 +184,9 @@ private: 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); + inline wxCStrData(char *buf); + inline wxCStrData(wchar_t *buf); + inline wxCStrData(const wxCStrData& data); inline ~wxCStrData(); @@ -193,9 +199,7 @@ public: const wchar_t* AsWChar() const; operator const wchar_t*() const { return AsWChar(); } - inline operator bool() const; - -#if !wxUSE_UNICODE +#if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY inline #endif const char* AsChar() const; @@ -206,8 +210,15 @@ public: operator const void*() const { return AsChar(); } + inline const wxCharBuffer AsCharBuf() const; + inline const wxWCharBuffer AsWCharBuf() const; + inline wxString AsString() const; + // returns the value as C string in internal representation (equivalent + // to AsString().wx_str(), but more efficient) + const wxStringCharType *AsInternal() const; + // allow expressions like "c_str()[0]": inline wxUniChar operator[](size_t n) const; wxUniChar operator[](int n) const { return operator[](size_t(n)); } @@ -226,22 +237,12 @@ public: wxCStrData operator+(size_t n) const { return wxCStrData(m_str, m_offset + n, m_owned); } - // and these for "str.c_str() + n - 2": - wxCStrData operator-(int n) const - { - wxASSERT_MSG( n <= (int)m_offset, - _T("attempt to construct address before the beginning of the string") ); - return wxCStrData(m_str, m_offset - n, m_owned); - } - wxCStrData operator-(long n) const + // and these for "str.c_str() + (p2 - p1)" (it also works for any integer + // expression but it must be ptrdiff_t and not e.g. int to work in this + // example): + wxCStrData operator-(ptrdiff_t n) const { - wxASSERT_MSG( n <= (int)m_offset, - _T("attempt to construct address before the beginning of the string") ); - return wxCStrData(m_str, m_offset - n, m_owned); - } - wxCStrData operator-(size_t n) const - { - wxASSERT_MSG( n <= m_offset, + wxASSERT_MSG( n <= (ptrdiff_t)m_offset, _T("attempt to construct address before the beginning of the string") ); return wxCStrData(m_str, m_offset - n, m_owned); } @@ -255,7 +256,7 @@ private: size_t m_offset; bool m_owned; - friend class WXDLLIMPEXP_BASE wxString; + friend class WXDLLIMPEXP_FWD_BASE wxString; }; // ---------------------------------------------------------------------------- @@ -284,8 +285,14 @@ class WXDLLIMPEXP_BASE wxStringPrintfMixinBase protected: wxStringPrintfMixinBase() {} - int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2; - static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1; +#if !wxUSE_UTF8_LOCALE_ONLY + int DoPrintfWchar(const wxChar *format, ...); + static wxString DoFormatWchar(const wxChar *format, ...); +#endif +#if wxUSE_UNICODE_UTF8 + int DoPrintfUtf8(const char *format, ...); + static wxString DoFormatUtf8(const char *format, ...); +#endif }; // this class contains template wrappers for wxString's vararg methods, it's @@ -308,13 +315,31 @@ public: // these are duplicated wxString methods, they're also declared below // if !wxNEEDS_WXSTRING_PRINTF_MIXIN: - // 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) + // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1; + WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType::type, + Format, 1, (const wxFormatString&), + DoFormatWchar, DoFormatUtf8) + // We have to implement the version without template arguments manually + // because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC + // normally does it itself. It has to be a template so that we can use + // the hack, even though there's no real template parameter. We can't move + // it to wxStrig, because it would shadow these versions of Format() then. + template + inline static typename StringReturnType::type + Format(const T& fmt) + { + // NB: this doesn't compile if T is not (some form of) a string; + // this makes Format's prototype equivalent to + // Format(const wxFormatString& fmt) + return DoFormatWchar(wxFormatString(fmt)); + } + + // int Printf(const wxString& format, ...); + WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&), + DoPrintfWchar, DoPrintfUtf8) + // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2; + WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&), + DoPrintfWchar, DoPrintfUtf8) protected: wxStringPrintfMixin() : wxStringPrintfMixinBase() {} @@ -333,6 +358,43 @@ protected: #pragma warning (disable:4275) #endif +#if wxUSE_UNICODE_UTF8 +// see the comment near wxString::iterator for why we need this +class WXDLLIMPEXP_BASE wxStringIteratorNode +{ +public: + wxStringIteratorNode() + : m_str(NULL), m_citer(NULL), m_iter(NULL), m_prev(NULL), m_next(NULL) {} + wxStringIteratorNode(const wxString *str, + wxStringImpl::const_iterator *citer) + { DoSet(str, citer, NULL); } + wxStringIteratorNode(const wxString *str, wxStringImpl::iterator *iter) + { DoSet(str, NULL, iter); } + ~wxStringIteratorNode() + { clear(); } + + inline void set(const wxString *str, wxStringImpl::const_iterator *citer) + { clear(); DoSet(str, citer, NULL); } + inline void set(const wxString *str, wxStringImpl::iterator *iter) + { clear(); DoSet(str, NULL, iter); } + + const wxString *m_str; + wxStringImpl::const_iterator *m_citer; + wxStringImpl::iterator *m_iter; + wxStringIteratorNode *m_prev, *m_next; + +private: + inline void clear(); + inline void DoSet(const wxString *str, + wxStringImpl::const_iterator *citer, + wxStringImpl::iterator *iter); + + // the node belongs to a particular iterator instance, it's not copied + // when a copy of the iterator is made + DECLARE_NO_COPY_CLASS(wxStringIteratorNode) +}; +#endif // wxUSE_UNICODE_UTF8 + class WXDLLIMPEXP_BASE wxString #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN : public wxStringPrintfMixin @@ -364,7 +426,6 @@ private: // 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 { @@ -432,28 +493,6 @@ private: { 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; } - static wxUniChar DecodeChar(wxStringImpl::const_iterator i) { return *i; } - // translates position index in wxString to/from index in underlying // wxStringImpl: static size_t PosToImpl(size_t pos) { return pos; } @@ -465,62 +504,24 @@ private: #else // wxUSE_UNICODE_UTF8 - // checks correctness of UTF-8 sequence - static bool IsValidUtf8String(const char *c); -#ifdef __WXDEBUG__ - static bool IsValidUtf8LeadByte(unsigned char c); -#endif - - // table of offsets to skip forward when iterating - static unsigned char ms_utf8IterTable[256]; - - static void IncIter(wxStringImpl::iterator& i) - { - wxASSERT( IsValidUtf8LeadByte(*i) ); - i += ms_utf8IterTable[(unsigned char)*i]; - } - static void IncIter(wxStringImpl::const_iterator& i) - { - wxASSERT( IsValidUtf8LeadByte(*i) ); - i += ms_utf8IterTable[(unsigned char)*i]; - } - - static void DecIter(wxStringImpl::iterator& i); - static void DecIter(wxStringImpl::const_iterator& i); - static wxStringImpl::iterator AddToIter(wxStringImpl::iterator i, int n); - static wxStringImpl::const_iterator AddToIter(wxStringImpl::const_iterator i, int n); - static int DiffIters(wxStringImpl::const_iterator i1, wxStringImpl::const_iterator i2); - static int DiffIters(wxStringImpl::iterator i1, wxStringImpl::iterator i2); - - struct Utf8CharBuffer - { - char data[5]; - operator const char*() const { return data; } - }; - static Utf8CharBuffer EncodeChar(wxUniChar ch); - // returns n copies of ch encoded in UTF-8 string - static wxCharBuffer EncodeNChars(size_t n, wxUniChar ch); - - // returns the length of UTF-8 encoding of the character with lead byte 'c' - static size_t GetUtf8CharLength(char c) - { - wxASSERT( IsValidUtf8LeadByte(c) ); - return ms_utf8IterTable[(unsigned char)c]; - } + static wxCharBuffer ImplStr(const char* str, + const wxMBConv& conv = wxConvLibc) + { return ConvertStr(str, npos, conv).data; } + static SubstrBufFromMB ImplStr(const char* str, size_t n, + const wxMBConv& conv = wxConvLibc) + { return ConvertStr(str, n, conv); } - // decodes single UTF-8 character from UTF-8 string - // FIXME-UTF8: move EncodeChar/DecodeChar and other operations to separate - // class - static wxUniChar DecodeChar(wxStringImpl::const_iterator i) - { return wxUniCharRef::DecodeChar(i); } - friend class WXDLLIMPEXP_BASE wxUniCharRef; + static wxCharBuffer ImplStr(const wchar_t* str) + { return ConvertStr(str, npos, wxMBConvUTF8()).data; } + static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) + { return ConvertStr(str, n, wxMBConvUTF8()); } size_t PosToImpl(size_t pos) const { if ( pos == 0 || pos == npos ) return pos; else - return wxStringImpl::const_iterator(begin() + pos) - m_impl.begin(); + return (begin() + pos).impl() - m_impl.begin(); } void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const; @@ -537,124 +538,10 @@ private: if ( pos == 0 || pos == npos ) return pos; else - return const_iterator(m_impl.begin() + pos) - begin(); + return const_iterator(this, m_impl.begin() + pos) - begin(); } - - size_t IterToImplPos(wxStringImpl::iterator i) const - { return wxStringImpl::const_iterator(i) - m_impl.begin(); } - - // FIXME-UTF8: return as-is without copying under UTF8 locale, return - // converted string under other locales - needs wxCharBuffer - // changes - static wxCharBuffer ImplStr(const char* str, - const wxMBConv& conv = wxConvLibc) - { return ConvertStr(str, npos, conv).data; } - static SubstrBufFromMB ImplStr(const char* str, size_t n, - const wxMBConv& conv = wxConvLibc) - { return ConvertStr(str, n, conv); } - - static wxCharBuffer ImplStr(const wchar_t* str) - { return ConvertStr(str, npos, wxConvUTF8).data; } - static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) - { return ConvertStr(str, n, wxConvUTF8); } #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8 - -public: - // constructors and destructor - // ctor for an empty string - wxString() {} - - // copy ctor - // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build! - wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { } - - wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { } - - // string containing nRepeat copies of ch - wxString(wxUniChar ch, size_t nRepeat = 1) - { assign(nRepeat, ch); } - wxString(size_t nRepeat, wxUniChar ch) - { assign(nRepeat, ch); } - wxString(wxUniCharRef ch, size_t nRepeat = 1) - { assign(nRepeat, ch); } - wxString(size_t nRepeat, wxUniCharRef ch) - { assign(nRepeat, ch); } - wxString(char ch, size_t nRepeat = 1) - { assign(nRepeat, ch); } - wxString(size_t nRepeat, char ch) - { assign(nRepeat, ch); } - wxString(wchar_t ch, size_t nRepeat = 1) - { assign(nRepeat, ch); } - wxString(size_t nRepeat, wchar_t ch) - { assign(nRepeat, ch); } - - // ctors from char* strings: - wxString(const char *psz) - : m_impl(ImplStr(psz)) {} - wxString(const char *psz, const wxMBConv& conv) - : m_impl(ImplStr(psz, conv)) {} - wxString(const char *psz, size_t nLength) - { assign(psz, nLength); } - wxString(const char *psz, const wxMBConv& conv, size_t nLength) - { - SubstrBufFromMB str(ImplStr(psz, nLength, conv)); - m_impl.assign(str.data, str.len); - } - - // and unsigned char*: - wxString(const unsigned char *psz) - : m_impl(ImplStr((const char*)psz)) {} - wxString(const unsigned char *psz, const wxMBConv& conv) - : m_impl(ImplStr((const char*)psz, conv)) {} - wxString(const unsigned char *psz, size_t nLength) - { assign((const char*)psz, nLength); } - wxString(const unsigned char *psz, const wxMBConv& conv, size_t nLength) - { - SubstrBufFromMB str(ImplStr((const char*)psz, nLength, conv)); - m_impl.assign(str.data, str.len); - } - - // ctors from wchar_t* strings: - wxString(const wchar_t *pwz) - : m_impl(ImplStr(pwz)) {} - wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv)) - : m_impl(ImplStr(pwz)) {} - wxString(const wchar_t *pwz, size_t nLength) - { assign(pwz, nLength); } - wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength) - { assign(pwz, nLength); } - - wxString(const wxCharBuffer& buf) - { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length - wxString(const wxWCharBuffer& buf) - { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length - - 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) - : m_impl(cstr.AsString().Mid(0, nLength).m_impl) {} - - // and because wxString is convertible to wxCStrData and const wxChar * - // we also need to provide this one - wxString(const wxString& str, size_t nLength) - : m_impl(str.Mid(0, nLength).m_impl) {} - - // 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) - // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build! - : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s -#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING - public: // standard types typedef wxUniChar value_type; @@ -677,8 +564,7 @@ public: #define WX_STR_ITERATOR_TAG void /* dummy type */ #endif - #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \ - reference_type, reference_ctor) \ + #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \ private: \ typedef wxStringImpl::iterator_name underlying_iterator; \ public: \ @@ -688,37 +574,38 @@ public: typedef reference_type reference; \ typedef pointer_type pointer; \ \ - reference operator*() const { return reference_ctor; } \ reference operator[](size_t n) const { return *(*this + n); } \ \ iterator_name& operator++() \ - { wxString::IncIter(m_cur); return *this; } \ + { wxStringOperations::IncIter(m_cur); return *this; } \ iterator_name& operator--() \ - { wxString::DecIter(m_cur); return *this; } \ + { wxStringOperations::DecIter(m_cur); return *this; } \ iterator_name operator++(int) \ { \ iterator_name tmp = *this; \ - wxString::IncIter(m_cur); \ + wxStringOperations::IncIter(m_cur); \ return tmp; \ } \ iterator_name operator--(int) \ { \ iterator_name tmp = *this; \ - wxString::DecIter(m_cur); \ + wxStringOperations::DecIter(m_cur); \ return tmp; \ } \ \ - 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; } \ + iterator_name& operator+=(ptrdiff_t n) \ + { \ + m_cur = wxStringOperations::AddToIter(m_cur, n); \ + return *this; \ + } \ + iterator_name& operator-=(ptrdiff_t n) \ + { \ + m_cur = wxStringOperations::AddToIter(m_cur, -n); \ + return *this; \ + } \ \ difference_type operator-(const iterator_name& i) const \ - { return wxString::DiffIters(m_cur, i.m_cur); } \ + { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \ \ bool operator==(const iterator_name& i) const \ { return m_cur == i.m_cur; } \ @@ -736,67 +623,131 @@ public: \ private: \ /* for internal wxString use only: */ \ - operator underlying_iterator() const { return m_cur; } \ + underlying_iterator impl() const { return m_cur; } \ \ - friend class WXDLLIMPEXP_BASE wxString; \ - friend class WXDLLIMPEXP_BASE wxCStrData; \ + friend class wxString; \ + friend class wxCStrData; \ \ private: \ underlying_iterator m_cur - class const_iterator; + class WXDLLIMPEXP_FWD_BASE const_iterator; #if wxUSE_UNICODE_UTF8 - class iterator - { - // NB: In UTF-8 build, (non-const) iterator needs to keep reference - // to the underlying wxStringImpl, because UTF-8 is variable-length - // encoding and changing the value pointer to by an iterator using - // its operator* requires calling wxStringImpl::replace() if the old - // and new values differ in their encoding's length. + // NB: In UTF-8 build, (non-const) iterator needs to keep reference + // to the underlying wxStringImpl, because UTF-8 is variable-length + // encoding and changing the value pointer to by an iterator (using + // its operator*) requires calling wxStringImpl::replace() if the old + // and new values differ in their encoding's length. + // + // Furthermore, the replace() call may invalid all iterators for the + // string, so we have to keep track of outstanding iterators and update + // them if replace() happens. + // + // This is implemented by maintaining linked list of iterators for every + // string and traversing it in wxUniCharRef::operator=(). Head of the + // list is stored in wxString. (FIXME-UTF8) - WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef, - wxUniCharRef::CreateForString(m_str, m_cur)); + class WXDLLIMPEXP_BASE iterator + { + WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef); public: - iterator(const iterator& i) : m_cur(i.m_cur), m_str(i.m_str) {} + iterator() {} + iterator(const iterator& i) + : m_cur(i.m_cur), m_node(i.str(), &m_cur) {} + iterator& operator=(const iterator& i) + { + if (&i != this) + { + m_cur = i.m_cur; + m_node.set(i.str(), &m_cur); + } + return *this; + } - iterator operator+(int n) const - { return iterator(m_str, wxString::AddToIter(m_cur, n)); } - iterator operator+(size_t n) const - { return iterator(m_str, wxString::AddToIter(m_cur, (int)n)); } - iterator operator-(int n) const - { return iterator(m_str, wxString::AddToIter(m_cur, -n)); } - iterator operator-(size_t n) const - { return iterator(m_str, wxString::AddToIter(m_cur, -(int)n)); } + reference operator*() + { return wxUniCharRef::CreateForString(m_node, m_cur); } + + iterator operator+(ptrdiff_t n) const + { return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); } + iterator operator-(ptrdiff_t n) const + { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } private: iterator(wxString *str, underlying_iterator ptr) - : m_cur(ptr), m_str(str->m_impl) {} - iterator(wxStringImpl& str, underlying_iterator ptr) - : m_cur(ptr), m_str(str) {} + : m_cur(ptr), m_node(str, &m_cur) {} + + wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); } - wxStringImpl& m_str; + wxStringIteratorNode m_node; friend class const_iterator; }; + + class WXDLLIMPEXP_BASE 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); + + public: + const_iterator() {} + const_iterator(const const_iterator& i) + : m_cur(i.m_cur), m_node(i.str(), &m_cur) {} + const_iterator(const iterator& i) + : m_cur(i.m_cur), m_node(i.str(), &m_cur) {} + + const_iterator& operator=(const const_iterator& i) + { + if (&i != this) + { + m_cur = i.m_cur; + m_node.set(i.str(), &m_cur); + } + return *this; + } + const_iterator& operator=(const iterator& i) + { m_cur = i.m_cur; m_node.set(i.str(), &m_cur); return *this; } + + reference operator*() const + { return wxStringOperations::DecodeChar(m_cur); } + + const_iterator operator+(ptrdiff_t n) const + { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, n)); } + const_iterator operator-(ptrdiff_t n) const + { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } + + private: + // for internal wxString use only: + const_iterator(const wxString *str, underlying_iterator ptr) + : m_cur(ptr), m_node(str, &m_cur) {} + + const wxString* str() const { return m_node.m_str; } + + wxStringIteratorNode m_node; + }; + + size_t IterToImplPos(wxString::iterator i) const + { return wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); } + #else // !wxUSE_UNICODE_UTF8 - class iterator + + class WXDLLIMPEXP_BASE iterator { - WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef, - wxUniCharRef::CreateForString(m_cur)); + WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef); public: + iterator() {} iterator(const iterator& i) : m_cur(i.m_cur) {} - iterator operator+(int n) const - { return iterator(wxString::AddToIter(m_cur, n)); } - iterator operator+(size_t n) const - { return iterator(wxString::AddToIter(m_cur, (int)n)); } - iterator operator-(int n) const - { return iterator(wxString::AddToIter(m_cur, -n)); } - iterator operator-(size_t n) const - { return iterator(wxString::AddToIter(m_cur, -(int)n)); } + reference operator*() + { return wxUniCharRef::CreateForString(m_cur); } + + iterator operator+(ptrdiff_t n) const + { return iterator(wxStringOperations::AddToIter(m_cur, n)); } + iterator operator-(ptrdiff_t n) const + { return iterator(wxStringOperations::AddToIter(m_cur, -n)); } private: // for internal wxString use only: @@ -805,32 +756,33 @@ public: friend class const_iterator; }; -#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8 - class const_iterator + class WXDLLIMPEXP_BASE 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, - wxString::DecodeChar(m_cur)); + WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar); public: + const_iterator() {} const_iterator(const const_iterator& i) : m_cur(i.m_cur) {} const_iterator(const iterator& i) : m_cur(i.m_cur) {} - const_iterator operator+(int n) const - { return const_iterator(wxString::AddToIter(m_cur, n)); } - const_iterator operator+(size_t n) const - { return const_iterator(wxString::AddToIter(m_cur, (int)n)); } - const_iterator operator-(int n) const - { return const_iterator(wxString::AddToIter(m_cur, -n)); } - const_iterator operator-(size_t n) const - { return const_iterator(wxString::AddToIter(m_cur, -(int)n)); } + reference operator*() const + { return wxStringOperations::DecodeChar(m_cur); } + + const_iterator operator+(ptrdiff_t n) const + { return const_iterator(wxStringOperations::AddToIter(m_cur, n)); } + const_iterator operator-(ptrdiff_t n) const + { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); } private: // for internal wxString use only: const_iterator(underlying_iterator ptr) : m_cur(ptr) {} + const_iterator(const wxString *WXUNUSED(str), underlying_iterator ptr) + : m_cur(ptr) {} }; +#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8 #undef WX_STR_ITERATOR_TAG #undef WX_STR_ITERATOR_IMPL @@ -850,6 +802,7 @@ public: typedef typename T::reference reference; typedef typename T::pointer *pointer; + reverse_iterator_impl() {} reverse_iterator_impl(iterator_type i) : m_cur(i) {} reverse_iterator_impl(const reverse_iterator_impl& ri) : m_cur(ri.m_cur) {} @@ -869,21 +822,13 @@ public: { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; } // NB: explicit in the functions below is to keep BCC 5.5 happy - reverse_iterator_impl operator+(int n) const - { return reverse_iterator_impl(m_cur - n); } - reverse_iterator_impl operator+(size_t n) const + reverse_iterator_impl operator+(ptrdiff_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 + reverse_iterator_impl operator-(ptrdiff_t n) const { return reverse_iterator_impl(m_cur + n); } - reverse_iterator_impl operator+=(int n) + reverse_iterator_impl operator+=(ptrdiff_t 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) + reverse_iterator_impl operator-=(ptrdiff_t n) { m_cur += n; return *this; } unsigned operator-(const reverse_iterator_impl& i) const @@ -910,11 +855,169 @@ public: typedef reverse_iterator_impl reverse_iterator; typedef reverse_iterator_impl const_reverse_iterator; +private: + // used to transform an expression built using c_str() (and hence of type + // wxCStrData) to an iterator into the string + static const_iterator CreateConstIterator(const wxCStrData& data) + { + return const_iterator(data.m_str, + (data.m_str->begin() + data.m_offset).impl()); + } + + // in UTF-8 STL build, creation from std::string requires conversion under + // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor; + // instead we define dummy type that lets us have wxString ctor for creation + // from wxStringImpl that couldn't be used by user code (in all other builds, + // "standard" ctors can be used): +#if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING + struct CtorFromStringImplTag {}; + + wxString(CtorFromStringImplTag* WXUNUSED(dummy), const wxStringImpl& src) + : m_impl(src) {} + + static wxString FromImpl(const wxStringImpl& src) + { return wxString((CtorFromStringImplTag*)NULL, src); } +#else + #if !wxUSE_STL_BASED_WXSTRING + wxString(const wxStringImpl& src) : m_impl(src) { } + // else: already defined as wxString(wxStdString) below + #endif + static wxString FromImpl(const wxStringImpl& src) { return wxString(src); } +#endif + +public: + // constructors and destructor + // ctor for an empty string + wxString() {} + + // copy ctor + wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { } + + // string containing nRepeat copies of ch + wxString(wxUniChar ch, size_t nRepeat = 1 ) + { assign(nRepeat, ch); } + wxString(size_t nRepeat, wxUniChar ch) + { assign(nRepeat, ch); } + wxString(wxUniCharRef ch, size_t nRepeat = 1) + { assign(nRepeat, ch); } + wxString(size_t nRepeat, wxUniCharRef ch) + { assign(nRepeat, ch); } + wxString(char ch, size_t nRepeat = 1) + { assign(nRepeat, ch); } + wxString(size_t nRepeat, char ch) + { assign(nRepeat, ch); } + wxString(wchar_t ch, size_t nRepeat = 1) + { assign(nRepeat, ch); } + wxString(size_t nRepeat, wchar_t ch) + { assign(nRepeat, ch); } + + // ctors from char* strings: + wxString(const char *psz) + : m_impl(ImplStr(psz)) {} + wxString(const char *psz, const wxMBConv& conv) + : m_impl(ImplStr(psz, conv)) {} + wxString(const char *psz, size_t nLength) + { assign(psz, nLength); } + wxString(const char *psz, const wxMBConv& conv, size_t nLength) + { + SubstrBufFromMB str(ImplStr(psz, nLength, conv)); + m_impl.assign(str.data, str.len); + } + + // and unsigned char*: + wxString(const unsigned char *psz) + : m_impl(ImplStr((const char*)psz)) {} + wxString(const unsigned char *psz, const wxMBConv& conv) + : m_impl(ImplStr((const char*)psz, conv)) {} + wxString(const unsigned char *psz, size_t nLength) + { assign((const char*)psz, nLength); } + wxString(const unsigned char *psz, const wxMBConv& conv, size_t nLength) + { + SubstrBufFromMB str(ImplStr((const char*)psz, nLength, conv)); + m_impl.assign(str.data, str.len); + } + + // ctors from wchar_t* strings: + wxString(const wchar_t *pwz) + : m_impl(ImplStr(pwz)) {} + wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv)) + : m_impl(ImplStr(pwz)) {} + wxString(const wchar_t *pwz, size_t nLength) + { assign(pwz, nLength); } + wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength) + { assign(pwz, nLength); } + + wxString(const wxCharBuffer& buf) + { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length + wxString(const wxWCharBuffer& buf) + { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length + + 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) + : m_impl(cstr.AsString().Mid(0, nLength).m_impl) {} + + // 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); } + + // even if we're not built with wxUSE_STL == 1 it is very convenient to allow + // implicit conversions from std::string to wxString and vice verse 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 + #if wxUSE_UNICODE_WCHAR + wxString(const wxStdWideString& str) : m_impl(str) {} + #else // UTF-8 or ANSI + wxString(const wxStdWideString& str) + { assign(str.c_str(), str.length()); } + #endif + + #if !wxUSE_UNICODE // ANSI build + // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too + wxString(const std::string& str) : m_impl(str) {} + #else // Unicode + wxString(const std::string& str) + { assign(str.c_str(), str.length()); } + #endif +#endif // wxUSE_STD_STRING + + // Unlike ctor from std::string, we provide conversion to std::string only + // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default), + // because it conflicts with operator const char/wchar_t*: +#if wxUSE_STL + #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING + // wxStringImpl is std::string in the encoding we want + operator const wxStdWideString&() const { return m_impl; } + #else + // wxStringImpl is either not std::string or needs conversion + operator wxStdWideString() const + // FIXME-UTF8: broken for embedded NULs + { return wxStdWideString(wc_str()); } + #endif + + #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING + // wxStringImpl is std::string in the encoding we want + operator const std::string&() const { return m_impl; } + #else + // wxStringImpl is either not std::string or needs conversion + operator std::string() const + // FIXME-UTF8: broken for embedded NULs + { return std::string(mb_str()); } + #endif +#endif // wxUSE_STL + // first valid index position - const_iterator begin() const { return const_iterator(m_impl.begin()); } + const_iterator begin() const { return const_iterator(this, m_impl.begin()); } iterator begin() { return iterator(this, m_impl.begin()); } // position one after the last valid one - const_iterator end() const { return const_iterator(m_impl.end()); } + const_iterator end() const { return const_iterator(this, m_impl.end()); } iterator end() { return iterator(this, m_impl.end()); } // first element of the reversed string @@ -945,19 +1048,25 @@ public: void resize(size_t nSize, wxUniChar ch = wxT('\0')) { + const size_t len = length(); + if ( nSize == len) + return; + #if wxUSE_UNICODE_UTF8 - if ( !ch.IsAscii() ) + if ( nSize < len ) { - size_t len = length(); - if ( nSize == len) - return; - else if ( nSize < len ) - erase(nSize); - else - append(nSize - len, ch); + // we can't use wxStringImpl::resize() for truncating the string as it + // counts in bytes, not characters + erase(nSize); + return; } + + // we also can't use (presumably more efficient) resize() if we have to + // append characters taking more than one byte + if ( !ch.IsAscii() ) + append(nSize - len, ch); else -#endif +#endif // wxUSE_UNICODE_UTF8 m_impl.resize(nSize, (wxStringCharType)ch); } @@ -965,7 +1074,7 @@ public: { size_t pos, len; PosLenToImpl(nStart, nLen, &pos, &len); - return m_impl.substr(pos, len); + return FromImpl(m_impl.substr(pos, len)); } // generic attributes & operations @@ -1016,18 +1125,17 @@ public: // get last character wxUniChar Last() const - { - wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); - - return at(length() - 1); - } + { + wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); + return *rbegin(); + } // get writable last character wxUniCharRef Last() - { - wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); - return at(length() - 1); - } + { + wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") ); + return *rbegin(); + } /* Note that we we must define all of the overloads below to avoid @@ -1062,9 +1170,22 @@ public: // implicit conversion to C string operator wxCStrData() const { return c_str(); } + + // the first two operators conflict with operators for conversion to + // std::string and they must be disabled in STL build; the next one only + // makes sense if conversions to char* are also defined and not defining it + // in STL build also helps us to get more clear error messages for the code + // which relies on implicit conversion to char* in STL build +#if !wxUSE_STL operator const char*() const { return c_str(); } operator const wchar_t*() const { return c_str(); } + // implicit conversion to untyped pointer for compatibility with previous + // wxWidgets versions: this is the same as conversion to const char * so it + // may fail! + operator const void*() const { return c_str(); } +#endif // wxUSE_STL + // identical to c_str(), for MFC compatibility const wxCStrData GetData() const { return c_str(); } @@ -1075,7 +1196,8 @@ public: // conversion to *non-const* multibyte or widestring buffer; modifying // returned buffer won't affect the string, these methods are only useful // for passing values to const-incorrect functions - wxWritableCharBuffer char_str() const { return mb_str(); } + wxWritableCharBuffer char_str(const wxMBConv& conv = wxConvLibc) const + { return mb_str(conv); } wxWritableWCharBuffer wchar_str() const { return wc_str(); } // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for @@ -1085,14 +1207,84 @@ public: // the behaviour of these functions with the strings containing anything // else than 7 bit ASCII characters is undefined, use at your own risk. #if wxUSE_UNICODE - static wxString FromAscii(const char *ascii); // string - static wxString FromAscii(const char ascii); // char - const wxCharBuffer ToAscii() const; + static wxString FromAscii(const char *ascii, size_t len); + static wxString FromAscii(const char *ascii); + static wxString FromAscii(char ascii); + const wxCharBuffer ToAscii() const; +#else // ANSI + static wxString FromAscii(const char *ascii) { return wxString( ascii ); } + static wxString FromAscii(const char *ascii, size_t len) + { return wxString( ascii, len ); } + static wxString FromAscii(char ascii) { return wxString( ascii ); } + const char *ToAscii() const { return c_str(); } +#endif // Unicode/!Unicode + + // also provide unsigned char overloads as signed/unsigned doesn't matter + // for 7 bit ASCII characters + static wxString FromAscii(const unsigned char *ascii) + { return FromAscii((const char *)ascii); } + static wxString FromAscii(const unsigned char *ascii, size_t len) + { return FromAscii((const char *)ascii, len); } + + // conversion to/from UTF-8: +#if wxUSE_UNICODE_UTF8 + static wxString FromUTF8(const char *utf8) + { + if ( !utf8 ) + return wxEmptyString; + + wxASSERT( wxStringOperations::IsValidUtf8String(utf8) ); + return FromImpl(wxStringImpl(utf8)); + } + static wxString FromUTF8(const char *utf8, size_t len) + { + if ( !utf8 ) + return wxEmptyString; + if ( len == npos ) + return FromUTF8(utf8); + + wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) ); + return FromImpl(wxStringImpl(utf8, len)); + } + const char* utf8_str() const { return wx_str(); } + const char* ToUTF8() const { return wx_str(); } +#elif wxUSE_UNICODE_WCHAR + static wxString FromUTF8(const char *utf8) + { return wxString(utf8, wxMBConvUTF8()); } + static wxString FromUTF8(const char *utf8, size_t len) + { return wxString(utf8, wxMBConvUTF8(), len); } + const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); } + const wxCharBuffer ToUTF8() const { return utf8_str(); } +#else // ANSI + static wxString FromUTF8(const char *utf8) + { return wxString(wxMBConvUTF8().cMB2WC(utf8)); } + static wxString FromUTF8(const char *utf8, size_t len) + { + size_t wlen; + wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen)); + return wxString(buf.data(), wlen); + } + const wxCharBuffer utf8_str() const + { return wxMBConvUTF8().cWC2MB(wc_str()); } + const wxCharBuffer ToUTF8() const { return utf8_str(); } +#endif + + // functions for storing binary data in wxString: +#if wxUSE_UNICODE + static wxString From8BitData(const char *data, size_t len) + { return wxString(data, wxConvISO8859_1, len); } + // version for NUL-terminated data: + static wxString From8BitData(const char *data) + { return wxString(data, wxConvISO8859_1); } + const wxCharBuffer To8BitData() const { return mb_str(wxConvISO8859_1); } #else // ANSI - static wxString FromAscii(const char *ascii) { return wxString( ascii ); } - static wxString FromAscii(const char ascii) { return wxString( ascii ); } - const char *ToAscii() const { return c_str(); } -#endif // Unicode/!Unicode + static wxString From8BitData(const char *data, size_t len) + { return wxString(data, len); } + // version for NUL-terminated data: + static wxString From8BitData(const char *data) + { return wxString(data); } + const char *To8BitData() const { return c_str(); } +#endif // Unicode/ANSI // conversions with (possible) format conversions: have to return a // buffer with temporary data @@ -1104,7 +1296,13 @@ 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 + +#if wxUSE_UTF8_LOCALE_ONLY + const char* mb_str() const { return wx_str(); } + const wxCharBuffer mb_str(const wxMBConv& conv) const; +#else const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const; +#endif const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } @@ -1134,22 +1332,26 @@ public: #if wxUSE_WCHAR_T const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) 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 + const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); } #endif // Unicode/ANSI // overloaded assignment // from another wxString wxString& operator=(const wxString& stringSrc) - { m_impl = stringSrc.m_impl; return *this; } + { if (&stringSrc != this) m_impl = stringSrc.m_impl; return *this; } wxString& operator=(const wxCStrData& cstr) { return *this = cstr.AsString(); } // from a character wxString& operator=(wxUniChar ch) - { m_impl = EncodeChar(ch); return *this; } + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl = wxStringOperations::EncodeChar(ch); + else +#endif + m_impl = (wxStringCharType)ch; + return *this; + } wxString& operator=(wxUniCharRef ch) { return operator=((wxUniChar)ch); } wxString& operator=(char ch) @@ -1216,13 +1418,8 @@ public: // string += buffer (i.e. from wxGetString) wxString& operator<<(const wxWCharBuffer& s) { return operator<<((const wchar_t *)s); } - wxString& operator+=(const wxWCharBuffer& s) - { return operator<<((const wchar_t *)s); } - wxString& operator<<(const wxCharBuffer& s) { return operator<<((const char *)s); } - wxString& operator+=(const wxCharBuffer& s) - { return operator<<((const char *)s); } // string += C string wxString& Append(const wxString& s) @@ -1234,12 +1431,16 @@ public: append(s); return *this; } - 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; } + wxString& Append(const wxCStrData& psz) + { append(psz); return *this; } + wxString& Append(const wxCharBuffer& psz) + { append(psz); return *this; } + wxString& Append(const wxWCharBuffer& psz) + { append(psz); return *this; } // append count copies of given character wxString& Append(wxUniChar ch, size_t count = 1u) { append(count, ch); return *this; } @@ -1321,26 +1522,39 @@ public: { return compare(pwz); } int Cmp(const wxString& s) const { return compare(s); } + int Cmp(const wxCStrData& s) const + { return compare(s); } + int Cmp(const wxCharBuffer& s) const + { return compare(s); } + int Cmp(const wxWCharBuffer& s) const + { return compare(s); } // same as Cmp() but not case-sensitive 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 wxString& str, bool compareWithCase = true) const - { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; } + { +#if !wxUSE_UNICODE_UTF8 + // in UTF-8 build, length() is O(n) and doing this would be _slower_ + if ( length() != str.length() ) + return false; +#endif + return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; + } bool IsSameAs(const char *str, bool compareWithCase = true) const { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; } bool IsSameAs(const wchar_t *str, bool compareWithCase = true) const { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; } + + bool IsSameAs(const wxCStrData& str, bool compareWithCase = true) const + { return IsSameAs(str.AsString(), compareWithCase); } + bool IsSameAs(const wxCharBuffer& str, bool compareWithCase = true) const + { return IsSameAs(str.data(), compareWithCase); } + bool IsSameAs(const wxWCharBuffer& str, bool compareWithCase = true) const + { return IsSameAs(str.data(), compareWithCase); } // 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)); - } + bool IsSameAs(wxUniChar c, bool compareWithCase = true) const; // FIXME-UTF8: remove these overloads bool IsSameAs(wxUniCharRef c, bool compareWithCase = true) const { return IsSameAs(wxUniChar(c), compareWithCase); } @@ -1365,11 +1579,11 @@ public: // 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; + bool StartsWith(const wxString& 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; + bool EndsWith(const wxString& suffix, wxString *rest = NULL) const; // get first nCount characters wxString Left(size_t nCount) const; @@ -1421,7 +1635,6 @@ public: int Find(wchar_t ch, bool bFromEnd = false) const { return Find(wxUniChar(ch), bFromEnd); } // searching (return starting index, or -1 if not found) - // FIXME-UTF8: keep wxString overload only int Find(const wxString& sub) const // like strstr { size_type idx = find(sub); @@ -1438,6 +1651,13 @@ public: return (idx == npos) ? wxNOT_FOUND : (int)idx; } + int Find(const wxCStrData& sub) const + { return Find(sub.AsString()); } + int Find(const wxCharBuffer& sub) const + { return Find(sub.data()); } + int Find(const wxWCharBuffer& sub) const + { return Find(sub.data()); } + // replace first (or all of bReplaceAll) occurences of substring with // another string, returns the number of replacements made size_t Replace(const wxString& strOld, @@ -1470,16 +1690,40 @@ public: // 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, ...); - WX_DEFINE_VARARG_FUNC(int, Printf, DoPrintf) + // int Printf(const wxString& format, ...); + WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&), + DoPrintfWchar, DoPrintfUtf8) +#ifdef __WATCOMC__ + // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 + WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wxString&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wxCStrData&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const char*), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wchar_t*), + (wxFormatString(f1))); +#endif #endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN // as vprintf(), returns the number of characters written or < 0 on error 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; - WX_DEFINE_VARARG_FUNC(static wxString, Format, DoFormat) + // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1; + WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxFormatString&), + DoFormatWchar, DoFormatUtf8) +#ifdef __WATCOMC__ + // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 + WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wxString&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wxCStrData&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const char*), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wchar_t*), + (wxFormatString(f1))); +#endif #endif // the same as above, but takes a va_list static wxString FormatV(const wxString& format, va_list argptr); @@ -1496,7 +1740,7 @@ public: // // get writable buffer of at least nLen bytes. Unget() *must* be called // a.s.a.p. to put string back in a reasonable state! - wxDEPRECATED( wxChar *GetWriteBuf(size_t nLen) ); + wxDEPRECATED( wxStringCharType *GetWriteBuf(size_t nLen) ); // call this immediately after GetWriteBuf() has been used wxDEPRECATED( void UngetWriteBuf() ); wxDEPRECATED( void UngetWriteBuf(size_t nLen) ); @@ -1515,8 +1759,20 @@ public: #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN // use Printf() // (take 'this' into account in attribute parameter count) - // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; - WX_DEFINE_VARARG_FUNC(int, sprintf, DoPrintf) + // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2; + WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&), + DoPrintfWchar, DoPrintfUtf8) +#ifdef __WATCOMC__ + // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 + WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wxString&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wxCStrData&), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const char*), + (wxFormatString(f1))); + WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wchar_t*), + (wxFormatString(f1))); +#endif #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN // use Cmp() @@ -1550,7 +1806,6 @@ public: int First( char ch ) const { return Find(ch); } int First( unsigned 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( wxUniChar ch ) const { return Find(ch, true); } bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; } @@ -1562,10 +1817,13 @@ public: // take nLen chars starting at nPos wxString(const wxString& str, size_t nPos, size_t nLen) - : m_impl(str.m_impl, nPos, nLen) { } + { assign(str, nPos, nLen); } // take all characters from first to last wxString(const_iterator first, const_iterator last) - : m_impl(first, last) { } + : m_impl(first.impl(), last.impl()) { } +#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER + // the 2 overloads below are for compatibility with the existing code using + // pointers instead of iterators wxString(const char *first, const char *last) { SubstrBufFromMB str(ImplStr(first, last - first)); @@ -1576,6 +1834,15 @@ public: SubstrBufFromWC str(ImplStr(first, last - first)); m_impl.assign(str.data, str.len); } + // and this one is needed to compile code adding offsets to c_str() result + wxString(const wxCStrData& first, const wxCStrData& last) + : m_impl(CreateConstIterator(first).impl(), + CreateConstIterator(last).impl()) + { + wxASSERT_MSG( first.m_str == last.m_str, + _T("pointers must be into the same string") ); + } +#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER // lib.string.modifiers // append elements str[pos], ..., str[pos+n] @@ -1589,8 +1856,6 @@ public: // append a string wxString& append(const wxString& 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 char *sz) { m_impl.append(ImplStr(sz)); return *this; } @@ -1608,12 +1873,20 @@ public: m_impl.append(str.data, str.len); return *this; } + + wxString& append(const wxCStrData& str) + { return append(str.AsString()); } + wxString& append(const wxCharBuffer& str) + { return append(str.data()); } + wxString& append(const wxWCharBuffer& str) + { return append(str.data()); } + // append n copies of ch wxString& append(size_t n, wxUniChar ch) { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.append(EncodeNChars(n, ch)); + m_impl.append(wxStringOperations::EncodeNChars(n, ch)); else #endif m_impl.append(n, (wxStringCharType)ch); @@ -1621,11 +1894,15 @@ public: } // append from first to last wxString& append(const_iterator first, const_iterator last) - { m_impl.append(first, last); return *this; } + { m_impl.append(first.impl(), last.impl()); return *this; } +#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER wxString& append(const char *first, const char *last) { return append(first, last - first); } wxString& append(const wchar_t *first, const wchar_t *last) { return append(first, last - first); } + wxString& append(const wxCStrData& first, const wxCStrData& last) + { return append(CreateConstIterator(first), CreateConstIterator(last)); } +#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER // same as `this_string = str' wxString& assign(const wxString& str) @@ -1660,12 +1937,26 @@ public: m_impl.assign(str.data, str.len); return *this; } + + wxString& assign(const wxCStrData& str) + { return assign(str.AsString()); } + wxString& assign(const wxCharBuffer& str) + { return assign(str.data()); } + wxString& assign(const wxWCharBuffer& str) + { return assign(str.data()); } + wxString& assign(const wxCStrData& str, size_t len) + { return assign(str.AsString(), len); } + wxString& assign(const wxCharBuffer& str, size_t len) + { return assign(str.data(), len); } + wxString& assign(const wxWCharBuffer& str, size_t len) + { return assign(str.data(), len); } + // same as `= n copies of ch' wxString& assign(size_t n, wxUniChar ch) { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.assign(EncodeNChars(n, ch)); + m_impl.assign(wxStringOperations::EncodeNChars(n, ch)); else #endif m_impl.assign(n, (wxStringCharType)ch); @@ -1683,22 +1974,31 @@ public: // assign from first to last wxString& assign(const_iterator first, const_iterator last) - { m_impl.assign(first, last); return *this; } + { m_impl.assign(first.impl(), last.impl()); return *this; } +#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER wxString& assign(const char *first, const char *last) { return assign(first, last - first); } wxString& assign(const wchar_t *first, const wchar_t *last) { return assign(first, last - first); } + wxString& assign(const wxCStrData& first, const wxCStrData& last) + { return assign(CreateConstIterator(first), CreateConstIterator(last)); } +#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER // string comparison int compare(const wxString& str) const; + int compare(const char* sz) const; + int compare(const wchar_t* sz) const; + int compare(const wxCStrData& str) const + { return compare(str.AsString()); } + int compare(const wxCharBuffer& str) const + { return compare(str.data()); } + int compare(const wxWCharBuffer& str) const + { return compare(str.data()); } // comparison with a substring 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 wxString& str, size_t nStart2, size_t nLen2) const; - // just like strcmp() - 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 char* sz, size_t nCount = npos) const; @@ -1738,7 +2038,7 @@ public: { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.insert(PosToImpl(nPos), EncodeNChars(n, ch)); + m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch)); else #endif m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch); @@ -1750,27 +2050,32 @@ public: if ( !ch.IsAscii() ) { size_t pos = IterToImplPos(it); - m_impl.insert(pos, EncodeChar(ch)); + m_impl.insert(pos, wxStringOperations::EncodeChar(ch)); return iterator(this, m_impl.begin() + pos); } else #endif - return iterator(this, m_impl.insert(it, (wxStringCharType)ch)); + return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch)); } void insert(iterator it, const_iterator first, const_iterator last) - { m_impl.insert(it, first, last); } + { m_impl.insert(it.impl(), first.impl(), last.impl()); } +#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER void insert(iterator it, const char *first, const char *last) { insert(it - begin(), first, last - first); } - void append(iterator it, const wchar_t *first, const wchar_t *last) + void insert(iterator it, const wchar_t *first, const wchar_t *last) { insert(it - begin(), first, last - first); } + void insert(iterator it, const wxCStrData& first, const wxCStrData& last) + { insert(it, CreateConstIterator(first), CreateConstIterator(last)); } +#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER + void insert(iterator it, size_type n, wxUniChar ch) { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.insert(IterToImplPos(it), EncodeNChars(n, ch)); + m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch)); else #endif - m_impl.insert(it, n, (wxStringCharType)ch); + m_impl.insert(it.impl(), n, (wxStringCharType)ch); } // delete characters from nStart to nStart + nLen @@ -1783,9 +2088,9 @@ public: } // delete characters from first up to last iterator erase(iterator first, iterator last) - { return iterator(this, m_impl.erase(first, last)); } + { return iterator(this, m_impl.erase(first.impl(), last.impl())); } iterator erase(iterator first) - { return iterator(this, m_impl.erase(first)); } + { return iterator(this, m_impl.erase(first.impl())); } #ifdef wxSTRING_BASE_HASNT_CLEAR void clear() { erase(); } @@ -1823,7 +2128,7 @@ public: PosLenToImpl(nStart, nLen, &from, &len); #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.replace(from, len, EncodeNChars(nCount, ch)); + m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch)); else #endif m_impl.replace(from, len, nCount, (wxStringCharType)ch); @@ -1875,36 +2180,40 @@ public: } wxString& replace(iterator first, iterator last, const char* s) - { m_impl.replace(first, last, ImplStr(s)); return *this; } + { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; } wxString& replace(iterator first, iterator last, const wchar_t* s) - { m_impl.replace(first, last, ImplStr(s)); return *this; } + { m_impl.replace(first.impl(), last.impl(), 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); + m_impl.replace(first.impl(), last.impl(), 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); + m_impl.replace(first.impl(), last.impl(), str.data, str.len); return *this; } wxString& replace(iterator first, iterator last, const wxString& s) - { m_impl.replace(first, last, s.m_impl); return *this; } + { m_impl.replace(first.impl(), last.impl(), 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)); + m_impl.replace(first.impl(), last.impl(), + wxStringOperations::EncodeNChars(n, ch)); else #endif - m_impl.replace(first, last, n, (wxStringCharType)ch); + m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch); return *this; } wxString& replace(iterator first, iterator last, const_iterator first1, const_iterator last1) - { m_impl.replace(first, last, first1, last1); return *this; } + { + m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl()); + return *this; + } wxString& replace(iterator first, iterator last, const char *first1, const char *last1) { replace(first, last, first1, last1 - first1); return *this; } @@ -1931,10 +2240,26 @@ public: SubstrBufFromWC str(ImplStr(sz, n)); return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len)); } + size_t find(const wxCharBuffer& s, size_t nStart = 0, size_t n = npos) const + { return find(s.data(), nStart, n); } + size_t find(const wxWCharBuffer& s, size_t nStart = 0, size_t n = npos) const + { return find(s.data(), nStart, n); } + size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const + { return find(s.AsWChar(), nStart, n); } // 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))); } + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch), + PosToImpl(nStart))); + else +#endif + return PosFromImpl(m_impl.find((wxStringCharType)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 @@ -1961,9 +2286,24 @@ public: SubstrBufFromWC str(ImplStr(sz, n)); return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len)); } + size_t rfind(const wxCharBuffer& s, size_t nStart = npos, size_t n = npos) const + { return rfind(s.data(), nStart, n); } + size_t rfind(const wxWCharBuffer& s, size_t nStart = npos, size_t n = npos) const + { return rfind(s.data(), nStart, n); } + size_t rfind(const wxCStrData& s, size_t nStart = npos, size_t n = npos) const + { return rfind(s.AsWChar(), nStart, n); } // 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))); } + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch), + PosToImpl(nStart))); + else +#endif + return PosFromImpl(m_impl.rfind((wxStringCharType)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 @@ -2036,9 +2376,9 @@ public: // as strpbrk() but starts at nStart, returns npos if not found size_t find_first_of(const wxString& str, size_t nStart = 0) const #if wxUSE_UNICODE // FIXME-UTF8: temporary - { return find_first_of(str.mb_str().data(), nStart); } + { return find_first_of(str.wc_str(), nStart); } #else - { return find_first_of((const wxChar*)str.c_str(), nStart); } + { return find_first_of(str.mb_str(), nStart); } #endif // same as above size_t find_first_of(const char* sz, size_t nStart = 0) const; @@ -2051,9 +2391,9 @@ public: // 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 #if wxUSE_UNICODE // FIXME-UTF8: temporary - { return find_last_of(str.mb_str().data(), nStart); } + { return find_last_of(str.wc_str(), nStart); } #else - { return find_last_of((const wxChar*)str.c_str(), nStart); } + { return find_last_of(str.mb_str(), nStart); } #endif // same as above size_t find_last_of (const char* sz, size_t nStart = npos) const; @@ -2069,9 +2409,9 @@ public: // as strspn() (starting from nStart), returns npos on failure size_t find_first_not_of(const wxString& str, size_t nStart = 0) const #if wxUSE_UNICODE // FIXME-UTF8: temporary - { return find_first_not_of(str.mb_str().data(), nStart); } + { return find_first_not_of(str.wc_str(), nStart); } #else - { return find_first_not_of((const wxChar*)str.c_str(), nStart); } + { return find_first_not_of(str.mb_str(), nStart); } #endif // same as above size_t find_first_not_of(const char* sz, size_t nStart = 0) const; @@ -2083,9 +2423,9 @@ public: // as strcspn() size_t find_last_not_of(const wxString& str, size_t nStart = npos) const #if wxUSE_UNICODE // FIXME-UTF8: temporary - { return find_last_not_of(str.mb_str().data(), nStart); } + { return find_last_not_of(str.wc_str(), nStart); } #else - { return find_last_not_of((const wxChar*)str.c_str(), nStart); } + { return find_last_not_of(str.mb_str(), nStart); } #endif // same as above size_t find_last_not_of(const char* sz, size_t nStart = npos) const; @@ -2131,6 +2471,59 @@ public: size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const { return find_last_not_of(wxUniChar(ch), nStart); } + // and additional overloads for the versions taking strings: + size_t find_first_of(const wxCStrData& sz, size_t nStart = 0) const + { return find_first_of(sz.AsString(), nStart); } + size_t find_first_of(const wxCharBuffer& sz, size_t nStart = 0) const + { return find_first_of(sz.data(), nStart); } + size_t find_first_of(const wxWCharBuffer& sz, size_t nStart = 0) const + { return find_first_of(sz.data(), nStart); } + size_t find_first_of(const wxCStrData& sz, size_t nStart, size_t n) const + { return find_first_of(sz.AsWChar(), nStart, n); } + size_t find_first_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + { return find_first_of(sz.data(), nStart, n); } + size_t find_first_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + { return find_first_of(sz.data(), nStart, n); } + + size_t find_last_of(const wxCStrData& sz, size_t nStart = 0) const + { return find_last_of(sz.AsString(), nStart); } + size_t find_last_of(const wxCharBuffer& sz, size_t nStart = 0) const + { return find_last_of(sz.data(), nStart); } + size_t find_last_of(const wxWCharBuffer& sz, size_t nStart = 0) const + { return find_last_of(sz.data(), nStart); } + size_t find_last_of(const wxCStrData& sz, size_t nStart, size_t n) const + { return find_last_of(sz.AsWChar(), nStart, n); } + size_t find_last_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + { return find_last_of(sz.data(), nStart, n); } + size_t find_last_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + { return find_last_of(sz.data(), nStart, n); } + + size_t find_first_not_of(const wxCStrData& sz, size_t nStart = 0) const + { return find_first_not_of(sz.AsString(), nStart); } + size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart = 0) const + { return find_first_not_of(sz.data(), nStart); } + size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const + { return find_first_not_of(sz.data(), nStart); } + size_t find_first_not_of(const wxCStrData& sz, size_t nStart, size_t n) const + { return find_first_not_of(sz.AsWChar(), nStart, n); } + size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + { return find_first_not_of(sz.data(), nStart, n); } + size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + { return find_first_not_of(sz.data(), nStart, n); } + + size_t find_last_not_of(const wxCStrData& sz, size_t nStart = 0) const + { return find_last_not_of(sz.AsString(), nStart); } + size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart = 0) const + { return find_last_not_of(sz.data(), nStart); } + size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const + { return find_last_not_of(sz.data(), nStart); } + size_t find_last_not_of(const wxCStrData& sz, size_t nStart, size_t n) const + { return find_last_not_of(sz.AsWChar(), nStart, n); } + size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const + { return find_last_not_of(sz.data(), nStart, n); } + size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const + { return find_last_not_of(sz.data(), nStart, n); } + // string += string wxString& operator+=(const wxString& s) { m_impl += s.m_impl; return *this; } @@ -2141,9 +2534,21 @@ public: { m_impl += ImplStr(pwz); return *this; } wxString& operator+=(const wxCStrData& s) { m_impl += s.AsString().m_impl; return *this; } + wxString& operator+=(const wxCharBuffer& s) + { return operator+=(s.data()); } + wxString& operator+=(const wxWCharBuffer& s) + { return operator+=(s.data()); } // string += char wxString& operator+=(wxUniChar ch) - { m_impl += EncodeChar(ch); return *this; } + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + m_impl += wxStringOperations::EncodeChar(ch); + else +#endif + m_impl += (wxStringCharType)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); } @@ -2151,7 +2556,7 @@ public: wxString& operator+=(wchar_t ch) { return *this += wxUniChar(ch); } private: -#if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 +#if !wxUSE_STL_BASED_WXSTRING // helpers for wxStringBuffer and wxStringBufferLength wxStringCharType *DoGetWriteBuf(size_t nLen) { return m_impl.DoGetWriteBuf(nLen); } @@ -2159,14 +2564,17 @@ private: { 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 +#endif // !wxUSE_STL_BASED_WXSTRING #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN - int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2; - static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1; + #if !wxUSE_UTF8_LOCALE_ONLY + int DoPrintfWchar(const wxChar *format, ...); + static wxString DoFormatWchar(const wxChar *format, ...); + #endif + #if wxUSE_UNICODE_UTF8 + int DoPrintfUtf8(const char *format, ...); + static wxString DoFormatUtf8(const char *format, ...); + #endif #endif #if !wxUSE_STL_BASED_WXSTRING @@ -2198,13 +2606,37 @@ private: T *m_buf; }; -#if wxUSE_UNICODE +#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY ConvertedBuffer m_convertedToChar; #endif #if !wxUSE_UNICODE_WCHAR ConvertedBuffer m_convertedToWChar; #endif - friend class WXDLLIMPEXP_BASE wxCStrData; + +#if wxUSE_UNICODE_UTF8 + // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently + // assigning to character pointer to by wxString::interator may + // change the underlying wxStringImpl iterator, so we have to + // keep track of all iterators and update them as necessary: + struct wxStringIteratorNodeHead + { + wxStringIteratorNodeHead() : ptr(NULL) {} + wxStringIteratorNode *ptr; + + // copying is disallowed as it would result in more than one pointer into + // the same linked list + DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead) + }; + + wxStringIteratorNodeHead m_iterators; + + friend class WXDLLIMPEXP_FWD_BASE wxStringIteratorNode; + friend class WXDLLIMPEXP_FWD_BASE wxUniCharRef; +#endif // wxUSE_UNICODE_UTF8 + + friend class WXDLLIMPEXP_FWD_BASE wxCStrData; + friend class wxStringInternalBuffer; + friend class wxStringInternalBufferLength; }; #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN @@ -2213,21 +2645,13 @@ private: // 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) +inline wxString::iterator operator+(ptrdiff_t n, wxString::iterator i) { return i + n; } -inline wxString::reverse_iterator operator+(size_t n, wxString::reverse_iterator i) +inline wxString::const_iterator operator+(ptrdiff_t n, wxString::const_iterator i) { return i + n; } -inline wxString::const_reverse_iterator operator+(int n, wxString::const_reverse_iterator i) +inline wxString::reverse_iterator operator+(ptrdiff_t n, wxString::reverse_iterator i) { return i + n; } -inline wxString::const_reverse_iterator operator+(size_t n, wxString::const_reverse_iterator i) +inline wxString::const_reverse_iterator operator+(ptrdiff_t n, wxString::const_reverse_iterator i) { return i + n; } // notice that even though for many compilers the friend declarations above are @@ -2257,140 +2681,225 @@ 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 +#define wxGetEmptyString() wxString() // ---------------------------------------------------------------------------- // wxStringBuffer: a tiny class allowing to get a writable pointer into string // ---------------------------------------------------------------------------- -#if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8 - -class WXDLLIMPEXP_BASE wxStringBuffer +#if !wxUSE_STL_BASED_WXSTRING +// string buffer for direct access to string data in their native +// representation: +class wxStringInternalBuffer { public: - wxStringBuffer(wxString& str, size_t lenWanted = 1024) - : m_str(str), m_buf(lenWanted) - { } + typedef wxStringCharType CharType; - ~wxStringBuffer() { m_str.assign(m_buf.data(), wxStrlen(m_buf.data())); } + wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(NULL) + { m_buf = m_str.DoGetWriteBuf(lenWanted); } - operator wxChar*() { return m_buf.data(); } + ~wxStringInternalBuffer() { m_str.DoUngetWriteBuf(); } + + operator wxStringCharType*() const { return m_buf; } private: - wxString& m_str; -#if wxUSE_UNICODE - wxWCharBuffer m_buf; -#else - wxCharBuffer m_buf; -#endif + wxString& m_str; + wxStringCharType *m_buf; - DECLARE_NO_COPY_CLASS(wxStringBuffer) + DECLARE_NO_COPY_CLASS(wxStringInternalBuffer) }; -class WXDLLIMPEXP_BASE wxStringBufferLength +class wxStringInternalBufferLength { public: - wxStringBufferLength(wxString& str, size_t lenWanted = 1024) - : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false) - { } + typedef wxStringCharType CharType; + + wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false) + { + m_buf = m_str.DoGetWriteBuf(lenWanted); + wxASSERT(m_buf != NULL); + } - ~wxStringBufferLength() + ~wxStringInternalBufferLength() { wxASSERT(m_lenSet); - m_str.assign(m_buf.data(), m_len); + m_str.DoUngetWriteBuf(m_len); } - operator wxChar*() { return m_buf.data(); } + operator wxStringCharType*() const { return m_buf; } void SetLength(size_t length) { m_len = length; m_lenSet = true; } private: - wxString& m_str; -#if wxUSE_UNICODE - wxWCharBuffer m_buf; -#else - wxCharBuffer m_buf; -#endif - size_t m_len; - bool m_lenSet; + wxString& m_str; + wxStringCharType *m_buf; + size_t m_len; + bool m_lenSet; - DECLARE_NO_COPY_CLASS(wxStringBufferLength) + DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength) }; -#else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 +#endif // !wxUSE_STL_BASED_WXSTRING -class WXDLLIMPEXP_BASE wxStringBuffer +template +class WXDLLIMPEXP_BASE wxStringTypeBufferBase { public: - wxStringBuffer(wxString& str, size_t lenWanted = 1024) - : m_str(str), m_buf(NULL) - { m_buf = m_str.DoGetWriteBuf(lenWanted); } + typedef T CharType; - ~wxStringBuffer() { m_str.DoUngetWriteBuf(); } + wxStringTypeBufferBase(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(lenWanted) + { } - operator wxChar*() const { return m_buf; } -private: + operator CharType*() { return m_buf.data(); } + +protected: wxString& m_str; - wxChar *m_buf; + wxCharTypeBuffer m_buf; +}; + +template +class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase +{ +public: + typedef T CharType; + + wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false) + { } + + operator CharType*() { return m_buf.data(); } + void SetLength(size_t length) { m_len = length; m_lenSet = true; } - DECLARE_NO_COPY_CLASS(wxStringBuffer) +protected: + wxString& m_str; + wxCharTypeBuffer m_buf; + size_t m_len; + bool m_lenSet; }; -class WXDLLIMPEXP_BASE wxStringBufferLength +template +class wxStringTypeBuffer : public wxStringTypeBufferBase { public: - wxStringBufferLength(wxString& str, size_t lenWanted = 1024) - : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false) + wxStringTypeBuffer(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferBase(str, lenWanted) {} + ~wxStringTypeBuffer() { - m_buf = m_str.DoGetWriteBuf(lenWanted); - wxASSERT(m_buf != NULL); + this->m_str.assign(this->m_buf.data()); } - ~wxStringBufferLength() + DECLARE_NO_COPY_CLASS(wxStringTypeBuffer) +}; + +template +class wxStringTypeBufferLength : public wxStringTypeBufferLengthBase +{ +public: + wxStringTypeBufferLength(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferLengthBase(str, lenWanted) {} + + ~wxStringTypeBufferLength() { - wxASSERT(m_lenSet); - m_str.DoUngetWriteBuf(m_len); + wxASSERT(this->m_lenSet); + this->m_str.assign(this->m_buf.data(), this->m_len); } - operator wxChar*() const { return m_buf; } - void SetLength(size_t length) { m_len = length; m_lenSet = true; } + DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength) +}; -private: - wxString& m_str; - wxChar *m_buf; - size_t m_len; - bool m_lenSet; +#if wxUSE_STL_BASED_WXSTRING + +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase ) + +class wxStringInternalBuffer : public wxStringTypeBufferBase +{ +public: + wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferBase(str, lenWanted) {} + ~wxStringInternalBuffer() + { m_str.m_impl.assign(m_buf.data()); } + + DECLARE_NO_COPY_CLASS(wxStringInternalBuffer) +}; - DECLARE_NO_COPY_CLASS(wxStringBufferLength) +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( + wxStringTypeBufferLengthBase ) + +class wxStringInternalBufferLength + : public wxStringTypeBufferLengthBase +{ +public: + wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferLengthBase(str, lenWanted) {} + + ~wxStringInternalBufferLength() + { + wxASSERT(m_lenSet); + m_str.m_impl.assign(m_buf.data(), m_len); + } + + DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength) }; +#endif // wxUSE_STL_BASED_WXSTRING + +#if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8 +typedef wxStringTypeBuffer wxStringBuffer; +typedef wxStringTypeBufferLength wxStringBufferLength; +#else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 +typedef wxStringInternalBuffer wxStringBuffer; +typedef wxStringInternalBufferLength wxStringBufferLength; #endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 +#if wxUSE_UNICODE_UTF8 +typedef wxStringInternalBuffer wxUTF8StringBuffer; +typedef wxStringInternalBufferLength wxUTF8StringBufferLength; +#elif wxUSE_UNICODE_WCHAR + +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase ) + +class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase +{ +public: + wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferBase(str, lenWanted) {} + ~wxUTF8StringBuffer(); + + DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer) +}; + +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase ) + +class WXDLLIMPEXP_BASE wxUTF8StringBufferLength + : public wxStringTypeBufferLengthBase +{ +public: + wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024) + : wxStringTypeBufferLengthBase(str, lenWanted) {} + ~wxUTF8StringBufferLength(); + + DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength) +}; +#endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR + + // --------------------------------------------------------------------------- // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- -#define wxCMP_WXCHAR_STRING(p, s, op) s.Cmp(p) op 0 +#define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p) wxDEFINE_ALL_COMPARISONS(const wxChar *, const wxString&, wxCMP_WXCHAR_STRING) #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); } + { return s1.IsSameAs(s2); } inline bool operator!=(const wxString& s1, const wxString& s2) - { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); } + { return !s1.IsSameAs(s2); } inline bool operator< (const wxString& s1, const wxString& s2) { return s1.Cmp(s2) < 0; } inline bool operator> (const wxString& s1, const wxString& s2) @@ -2400,7 +2909,15 @@ inline bool operator<=(const wxString& s1, const wxString& s2) inline bool operator>=(const wxString& s1, const wxString& s2) { return s1.Cmp(s2) >= 0; } -#if wxUSE_UNICODE +inline bool operator==(const wxString& s1, const wxCStrData& s2) + { return s1 == s2.AsString(); } +inline bool operator==(const wxCStrData& s1, const wxString& s2) + { return s1.AsString() == s2; } +inline bool operator!=(const wxString& s1, const wxCStrData& s2) + { return s1 != s2.AsString(); } +inline bool operator!=(const wxCStrData& s1, const wxString& s2) + { return s1.AsString() != s2; } + inline bool operator==(const wxString& s1, const wxWCharBuffer& s2) { return (s1.Cmp((const wchar_t *)s2) == 0); } inline bool operator==(const wxWCharBuffer& s1, const wxString& s2) @@ -2409,7 +2926,7 @@ inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2) { return (s1.Cmp((const wchar_t *)s2) != 0); } inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const wchar_t *)s1) != 0); } -#else // !wxUSE_UNICODE + inline bool operator==(const wxString& s1, const wxCharBuffer& s2) { return (s1.Cmp((const char *)s2) == 0); } inline bool operator==(const wxCharBuffer& s1, const wxString& s2) @@ -2418,19 +2935,16 @@ inline bool operator!=(const wxString& s1, const wxCharBuffer& s2) { return (s1.Cmp((const char *)s2) != 0); } inline bool operator!=(const wxCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) != 0); } -#endif // wxUSE_UNICODE/!wxUSE_UNICODE -#if wxUSE_UNICODE inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) { return string + (const wchar_t *)buf; } inline wxString operator+(const wxWCharBuffer& buf, const wxString& string) { return (const wchar_t *)buf + string; } -#else // !wxUSE_UNICODE + inline wxString operator+(const wxString& string, const wxCharBuffer& buf) { return string + (const char *)buf; } 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); } @@ -2492,7 +3006,15 @@ WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&); WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&); #endif -#endif // wxSTD_STRING_COMPATIBILITY +#if wxUSE_UNICODE && defined(HAVE_WOSTREAM) + +WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&); +WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&); +WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxWCharBuffer&); + +#endif // wxUSE_UNICODE && defined(HAVE_WOSTREAM) + +#endif // wxUSE_STD_IOSTREAM // --------------------------------------------------------------------------- // wxCStrData implementation @@ -2503,15 +3025,17 @@ inline wxCStrData::wxCStrData(char *buf) inline wxCStrData::wxCStrData(wchar_t *buf) : m_str(new wxString(buf)), m_offset(0), m_owned(true) {} -inline wxCStrData::~wxCStrData() +inline wxCStrData::wxCStrData(const wxCStrData& data) + : m_str(data.m_owned ? new wxString(*data.m_str) : data.m_str), + m_offset(data.m_offset), + m_owned(data.m_owned) { - if ( m_owned ) - delete m_str; } -inline wxCStrData::operator bool() const +inline wxCStrData::~wxCStrData() { - return !m_str->empty(); + if ( m_owned ) + delete wx_const_cast(wxString*, m_str); // cast to silence warnings } // simple cases for AsChar() and AsWChar(), the complicated ones are @@ -2530,6 +3054,31 @@ inline const char* wxCStrData::AsChar() const } #endif // !wxUSE_UNICODE +#if wxUSE_UTF8_LOCALE_ONLY +inline const char* wxCStrData::AsChar() const +{ + return wxStringOperations::AddToIter(m_str->wx_str(), m_offset); +} +#endif // wxUSE_UTF8_LOCALE_ONLY + +inline const wxCharBuffer wxCStrData::AsCharBuf() const +{ +#if !wxUSE_UNICODE + return wxCharBuffer::CreateNonOwned(AsChar()); +#else + return AsString().mb_str(); +#endif +} + +inline const wxWCharBuffer wxCStrData::AsWCharBuf() const +{ +#if wxUSE_UNICODE_WCHAR + return wxWCharBuffer::CreateNonOwned(AsWChar()); +#else + return AsString().wc_str(); +#endif +} + inline wxString wxCStrData::AsString() const { if ( m_offset == 0 ) @@ -2538,6 +3087,15 @@ inline wxString wxCStrData::AsString() const return m_str->Mid(m_offset); } +inline const wxStringCharType *wxCStrData::AsInternal() const +{ +#if wxUSE_UNICODE_UTF8 + return wxStringOperations::AddToIter(m_str->wx_str(), m_offset); +#else + return m_str->wx_str() + m_offset; +#endif +} + inline wxUniChar wxCStrData::operator*() const { if ( m_str->empty() ) @@ -2548,7 +3106,9 @@ inline wxUniChar wxCStrData::operator*() const inline wxUniChar wxCStrData::operator[](size_t n) const { - return m_str->at(m_offset + n); + // NB: we intentionally use operator[] and not at() here because the former + // works for the terminating NUL while the latter does not + return (*m_str)[m_offset + n]; } // ---------------------------------------------------------------------------- @@ -2573,13 +3133,63 @@ inline size_t operator-(const wchar_t *p, const wxCStrData& cs) // FIXME-UTF8: move this to buffer.h inline wxCharBuffer::wxCharBuffer(const wxCStrData& cstr) - : wxCharTypeBufferBase(cstr.AsChar()) + : wxCharTypeBufferBase(cstr.AsCharBuf()) { } inline wxWCharBuffer::wxWCharBuffer(const wxCStrData& cstr) - : wxCharTypeBufferBase(cstr.AsWChar()) + : wxCharTypeBufferBase(cstr.AsWCharBuf()) +{ +} + +#if wxUSE_UNICODE_UTF8 +// ---------------------------------------------------------------------------- +// implementation of wxStringIteratorNode inline methods +// ---------------------------------------------------------------------------- + +void wxStringIteratorNode::DoSet(const wxString *str, + wxStringImpl::const_iterator *citer, + wxStringImpl::iterator *iter) +{ + m_prev = NULL; + m_iter = iter; + m_citer = citer; + m_str = str; + if ( str ) + { + m_next = str->m_iterators.ptr; + wx_const_cast(wxString*, m_str)->m_iterators.ptr = this; + if ( m_next ) + m_next->m_prev = this; + } + else + { + m_next = NULL; + } +} + +void wxStringIteratorNode::clear() { + if ( m_next ) + m_next->m_prev = m_prev; + if ( m_prev ) + m_prev->m_next = m_next; + else if ( m_str ) // first in the list + wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next; + + m_next = m_prev = NULL; + m_citer = NULL; + m_iter = NULL; + m_str = NULL; } +#endif // wxUSE_UNICODE_UTF8 + +#if WXWIN_COMPATIBILITY_2_8 + // lot of code out there doesn't explicitly include wx/crt.h, but uses + // CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h, + // so let's include this header now that wxString is defined and it's safe + // to do it: + #include "wx/crt.h" +#endif #endif // _WX_WXSTRING_H_