X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9183da066e07f3e9105bf4cec9e3e8c1ddb04b72..0c73d133517098480565f3dbb529a5f2a72ef68f:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 7c4bf74d87..deecb1795b 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -78,14 +78,6 @@ class WXDLLIMPEXP_FWD_BASE wxString; #define wxMBSTRINGCAST (char *)(const char *) #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *) -// like _T(), but for literals in wxString's internal representation, i.e. -// char* in UTF-8 build and wxChar* otherwise: -#if wxUSE_UNICODE_UTF8 - #define wxSTRING_TEXT(str) str -#else - #define wxSTRING_TEXT(str) _T(str) -#endif - // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -133,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__) @@ -247,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 - { - 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 + // 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 <= 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); } @@ -613,25 +593,15 @@ public: return tmp; \ } \ \ - iterator_name& operator+=(int n) \ + iterator_name& operator+=(ptrdiff_t n) \ { \ m_cur = wxStringOperations::AddToIter(m_cur, n); \ return *this; \ } \ - iterator_name& operator+=(size_t n) \ - { \ - m_cur = wxStringOperations::AddToIter(m_cur, (int)n); \ - return *this; \ - } \ - iterator_name& operator-=(int n) \ + iterator_name& operator-=(ptrdiff_t n) \ { \ m_cur = wxStringOperations::AddToIter(m_cur, -n); \ return *this; \ - } \ - iterator_name& operator-=(size_t n) \ - { \ - m_cur = wxStringOperations::AddToIter(m_cur, -(int)n); \ - return *this; \ } \ \ difference_type operator-(const iterator_name& i) const \ @@ -687,19 +657,22 @@ public: iterator(const iterator& i) : m_cur(i.m_cur), m_node(i.str(), &m_cur) {} iterator& operator=(const iterator& i) - { m_cur = i.m_cur; m_node.set(i.str(), &m_cur); return *this; } + { + if (&i != this) + { + m_cur = i.m_cur; + m_node.set(i.str(), &m_cur); + } + return *this; + } reference operator*() { return wxUniCharRef::CreateForString(m_node, m_cur); } - iterator operator+(int n) const + iterator operator+(ptrdiff_t n) const { return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); } - iterator operator+(size_t n) const - { return iterator(str(), wxStringOperations::AddToIter(m_cur, (int)n)); } - iterator operator-(int n) const + iterator operator-(ptrdiff_t n) const { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } - iterator operator-(size_t n) const - { return iterator(str(), wxStringOperations::AddToIter(m_cur, -(int)n)); } private: iterator(wxString *str, underlying_iterator ptr) @@ -726,21 +699,24 @@ public: : m_cur(i.m_cur), m_node(i.str(), &m_cur) {} const_iterator& operator=(const const_iterator& i) - { m_cur = i.m_cur; m_node.set(i.str(), &m_cur); return *this; } + { + 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+(int n) const + const_iterator operator+(ptrdiff_t n) const { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, n)); } - const_iterator operator+(size_t n) const - { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, (int)n)); } - const_iterator operator-(int n) const + const_iterator operator-(ptrdiff_t n) const { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); } - const_iterator operator-(size_t n) const - { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -(int)n)); } private: // for internal wxString use only: @@ -768,14 +744,10 @@ public: reference operator*() { return wxUniCharRef::CreateForString(m_cur); } - iterator operator+(int n) const + iterator operator+(ptrdiff_t n) const { return iterator(wxStringOperations::AddToIter(m_cur, n)); } - iterator operator+(size_t n) const - { return iterator(wxStringOperations::AddToIter(m_cur, (int)n)); } - iterator operator-(int n) const + iterator operator-(ptrdiff_t n) const { return iterator(wxStringOperations::AddToIter(m_cur, -n)); } - iterator operator-(size_t n) const - { return iterator(wxStringOperations::AddToIter(m_cur, -(int)n)); } private: // for internal wxString use only: @@ -799,14 +771,10 @@ public: reference operator*() const { return wxStringOperations::DecodeChar(m_cur); } - const_iterator operator+(int n) const + const_iterator operator+(ptrdiff_t n) const { return const_iterator(wxStringOperations::AddToIter(m_cur, n)); } - const_iterator operator+(size_t n) const - { return const_iterator(wxStringOperations::AddToIter(m_cur, (int)n)); } - const_iterator operator-(int n) const + const_iterator operator-(ptrdiff_t n) const { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); } - const_iterator operator-(size_t n) const - { return const_iterator(wxStringOperations::AddToIter(m_cur, -(int)n)); } private: // for internal wxString use only: @@ -854,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 + reverse_iterator_impl operator-(ptrdiff_t 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) + reverse_iterator_impl operator+=(ptrdiff_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 @@ -1378,12 +1338,20 @@ public: // 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 = wxStringOperations::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) @@ -1562,14 +1530,23 @@ public: { return compare(s); } // same as Cmp() but not case-sensitive int CmpNoCase(const wxString& s) const; + // 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 @@ -2273,8 +2250,15 @@ public: // find the first occurence of character ch after nStart size_t find(wxUniChar ch, size_t nStart = 0) const { - return PosFromImpl(m_impl.find(wxStringOperations::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); } @@ -2311,8 +2295,14 @@ public: // as find, but from the end size_t rfind(wxUniChar ch, size_t nStart = npos) const { - return PosFromImpl(m_impl.rfind(wxStringOperations::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); } @@ -2550,7 +2540,15 @@ public: { return operator+=(s.data()); } // string += char wxString& operator+=(wxUniChar ch) - { m_impl += wxStringOperations::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); } @@ -2647,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 @@ -2906,12 +2896,10 @@ 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)