X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f4c90fdfaf2fd2ea1652f958c66e16fc9faff602..bc5443ba0701dd68eac6f987319ece2b7faba33d:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 735e75ef77..3bc5588f9a 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -169,7 +169,7 @@ inline int Stricmp(const char *psz1, const char *psz2) // Lightweight object returned by wxString::c_str() and implicitly convertible // to either const char* or const wchar_t*. -class wxCStrData +class WXDLLIMPEXP_BASE wxCStrData { private: // Ctors; for internal use by wxString and wxCStrData only @@ -182,29 +182,35 @@ public: wxCStrData(char *buf); wxCStrData(wchar_t *buf); - ~wxCStrData(); + inline ~wxCStrData(); - // FIXME: we'll need convertors for both char* and wchar_t* and NONE - // for wxChar*, but that's after completing the transition to - // "smart" wxUniChar class. For now, just have conversion to - // char* in ANSI build and wchar_t in Unicode build. -#if wxUSE_UNICODE + // methods defined inline below must be declared inline or mingw32 3.4.5 + // warns about " defined locally after being referenced with + // dllimport linkage" +#if wxUSE_UNICODE_WCHAR + inline +#endif const wchar_t* AsWChar() const; operator const wchar_t*() const { return AsWChar(); } -#else + + inline operator bool() const; + +#if !wxUSE_UNICODE + inline +#endif const char* AsChar() const; const unsigned char* AsUnsignedChar() const { return (const unsigned char *) AsChar(); } - operator const void*() const { return AsChar(); } operator const char*() const { return AsChar(); } operator const unsigned char*() const { return AsUnsignedChar(); } -#endif - wxString AsString() const; + operator const void*() const { return AsChar(); } + + inline wxString AsString() const; // allow expressions like "c_str()[0]": + inline wxUniChar operator[](size_t n) const; wxUniChar operator[](int n) const { return operator[](size_t(n)); } - wxUniChar operator[](size_t n) const; wxUniChar operator[](long n) const { return operator[](size_t(n)); } #ifndef wxSIZE_T_IS_UINT wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); } @@ -235,14 +241,14 @@ public: } wxCStrData operator-(size_t n) const { - wxASSERT_MSG( n <= (int)m_offset, + wxASSERT_MSG( n <= m_offset, _T("attempt to construct address before the beginning of the string") ); return wxCStrData(m_str, m_offset - n, m_owned); } // this operator is needed to make expressions like "*c_str()" or // "*(c_str() + 2)" work - wxUniChar operator*() const; + inline wxUniChar operator*() const; private: const wxString *m_str; @@ -365,13 +371,14 @@ private: T data; size_t len; - SubstrBufFromType() {} SubstrBufFromType(const T& data_, size_t len_) : data(data_), len(len_) {} }; #if wxUSE_UNICODE_UTF8 - // FIXME-UTF8: this will have to use slightly different type + // even char* -> char* needs conversion, from locale charset to UTF-8 + typedef SubstrBufFromType SubstrBufFromWC; + typedef SubstrBufFromType SubstrBufFromMB; #elif wxUSE_UNICODE_WCHAR typedef SubstrBufFromType SubstrBufFromWC; typedef SubstrBufFromType SubstrBufFromMB; @@ -386,8 +393,12 @@ private: // between UTF-8 and wchar_t* representations of the string are mostly // contained here. -#if wxUSE_UNICODE - // FIXME-UTF8: This will need changes when UTF8 build is introduced +#if wxUSE_UNICODE_UTF8 + static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength, + const wxMBConv& conv); + static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength, + const wxMBConv& conv); +#elif wxUSE_UNICODE_WCHAR static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength, const wxMBConv& conv); #else @@ -399,18 +410,22 @@ private: // returns C string encoded as the implementation expects: #if wxUSE_UNICODE static const wchar_t* ImplStr(const wchar_t* str) - { return str; } + { return str ? str : wxT(""); } static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) - { return SubstrBufFromWC(str, n == npos ? wxWcslen(str) : n); } - static wxWCharBuffer ImplStr(const char* str) - { return ConvertStr(str, npos, wxConvLibc).data; } - static SubstrBufFromMB ImplStr(const char* str, size_t n) - { return ConvertStr(str, n, wxConvLibc); } + { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); } + static wxWCharBuffer 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); } #else - static const char* ImplStr(const char* str) - { return str; } - static const SubstrBufFromMB ImplStr(const char* str, size_t n) - { return SubstrBufFromMB(str, n == npos ? wxStrlen(str) : n); } + static const char* ImplStr(const char* str, + const wxMBConv& WXUNUSED(conv) = wxConvLibc) + { return str ? str : ""; } + static const SubstrBufFromMB ImplStr(const char* str, size_t n, + const wxMBConv& WXUNUSED(conv) = wxConvLibc) + { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); } static wxCharBuffer ImplStr(const wchar_t* str) { return ConvertStr(str, npos, wxConvLibc).data; } static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) @@ -437,6 +452,7 @@ private: // 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: @@ -444,15 +460,61 @@ private: static void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) { *implPos = pos; *implLen = len; } + static size_t LenToImpl(size_t len) { return len; } static size_t PosFromImpl(size_t pos) { return pos; } #else // wxUSE_UNICODE_UTF8 - typedef char Utf8CharBuffer[5]; + // 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]; + } + + // 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; + size_t PosToImpl(size_t pos) const { if ( pos == 0 || pos == npos ) @@ -461,6 +523,15 @@ private: return wxStringImpl::const_iterator(begin() + pos) - m_impl.begin(); } + void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const; + + size_t LenToImpl(size_t len) const + { + size_t pos, len2; + PosLenToImpl(0, len, &pos, &len2); + return len2; + } + size_t PosFromImpl(size_t pos) const { if ( pos == 0 || pos == npos ) @@ -469,13 +540,23 @@ private: return const_iterator(m_impl.begin() + pos) - begin(); } - // FIXME: return as-is without copying under UTF8 locale, return - // converted string under other locales - needs wxCharBuffer - // changes - static wxCharBuffer ImplStr(const char* str); + 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 wxConvUTF8.cWC2MB(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 @@ -483,78 +564,71 @@ 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) { } + + wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { } + // string containing nRepeat copies of ch wxString(wxUniChar ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(size_t nRepeat, wxUniChar ch) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(wxUniCharRef ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(size_t nRepeat, wxUniCharRef ch) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(char ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(size_t nRepeat, char ch) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(wchar_t ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } + { assign(nRepeat, ch); } wxString(size_t nRepeat, wchar_t ch) - : m_impl(nRepeat, ch) { } - // ctor takes first nLength characters from C string - // (default value of npos means take all the string) - wxString(const wxChar *psz) - : m_impl(psz ? psz : wxT("")) { } - wxString(const wxChar *psz, size_t nLength) - : m_impl(psz, nLength) { } - wxString(const wxChar *psz, - const wxMBConv& WXUNUSED(conv), - size_t nLength = npos) - : m_impl(psz, nLength == npos ? wxStrlen(psz) : nLength) { } - - // even if we're not built with wxUSE_STL == 1 it is very convenient to allow - // implicit conversions from std::string to wxString as this allows to use - // the same strings in non-GUI and GUI code, however we don't want to - // unconditionally add this ctor as it would make wx lib dependent on - // libstdc++ on some Linux versions which is bad, so instead we ask the - // client code to define this wxUSE_STD_STRING symbol if they need it -#if wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING - wxString(const wxStdString& s) - : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s -#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING - -#if wxUSE_UNICODE - // from multibyte string - wxString(const char *psz, - const wxMBConv& conv = wxConvLibc, - size_t nLength = npos); - // from multibyte string for ANSI compatibility, with wxConvLibc - wxString(const char *psz, size_t nLength); - // from wxWCharBuffer (i.e. return from wxGetString) - wxString(const wxWCharBuffer& psz) : m_impl(psz.data()) { } -#else // ANSI - // from C string (for compilers using unsigned char) - wxString(const unsigned char* psz) - : m_impl((const char*)psz) { } - // from part of C string (for compilers using unsigned char) - wxString(const unsigned char* psz, size_t nLength) - : m_impl((const char*)psz, nLength) { } + { 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); + } -#if wxUSE_WCHAR_T - // from wide (Unicode) string - wxString(const wchar_t *pwz, - const wxMBConv& conv = wxConvLibc, - size_t nLength = npos); - // from wide string for Unicode compatibility, with wxConvLibc - wxString(const wchar_t *pwz, size_t nLength); -#endif // !wxUSE_WCHAR_T + // 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); + } - // from wxCharBuffer - wxString(const wxCharBuffer& psz) - : m_impl(psz) { } -#endif // Unicode/ANSI + // 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) { } @@ -562,12 +636,24 @@ public: // as we provide both ctors with this signature for both char and unsigned // char string, we need to provide one for wxCStrData to resolve ambiguity wxString(const wxCStrData& cstr, size_t nLength) - { assign(cstr.AsString(), nLength); } + : 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); } + : 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 @@ -581,7 +667,12 @@ public: typedef wxUniChar const_reference; #if wxUSE_STL - #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag + #if wxUSE_UNICODE_UTF8 + // random access is not O(1), as required by Random Access Iterator + #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag + #else + #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag + #endif #else #define WX_STR_ITERATOR_TAG void /* dummy type */ #endif @@ -597,8 +688,6 @@ public: typedef reference_type reference; \ typedef pointer_type pointer; \ \ - iterator_name(const iterator_name& i) : m_cur(i.m_cur) {} \ - \ reference operator*() const { return reference_ctor; } \ reference operator[](size_t n) const { return *(*this + n); } \ \ @@ -619,27 +708,19 @@ public: return tmp; \ } \ \ - iterator_name operator+(int n) const \ - { return iterator_name(wxString::AddToIter(m_cur, n)); } \ - iterator_name operator+(size_t n) const \ - { return iterator_name(wxString::AddToIter(m_cur, (int)n)); } \ - iterator_name operator-(int n) const \ - { return iterator_name(wxString::AddToIter(m_cur, -n)); } \ - iterator_name operator-(size_t n) const \ - { return iterator_name(wxString::AddToIter(m_cur, -(int)n)); } \ - iterator_name operator+=(int n) \ + iterator_name& operator+=(int n) \ { m_cur = wxString::AddToIter(m_cur, n); return *this; } \ - iterator_name operator+=(size_t n) \ + iterator_name& operator+=(size_t n) \ { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; } \ - iterator_name operator-=(int n) \ + iterator_name& operator-=(int n) \ { m_cur = wxString::AddToIter(m_cur, -n); return *this; } \ - iterator_name operator-=(size_t n) \ + iterator_name& operator-=(size_t n) \ { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; } \ \ - unsigned operator-(const iterator_name& i) const \ + difference_type operator-(const iterator_name& i) const \ { return wxString::DiffIters(m_cur, i.m_cur); } \ \ - bool operator==(const iterator_name&i) const \ + bool operator==(const iterator_name& i) const \ { return m_cur == i.m_cur; } \ bool operator!=(const iterator_name& i) const \ { return m_cur != i.m_cur; } \ @@ -655,34 +736,100 @@ public: \ private: \ /* for internal wxString use only: */ \ - iterator_name(underlying_iterator ptr) : m_cur(ptr) {} \ operator underlying_iterator() const { return m_cur; } \ \ friend class WXDLLIMPEXP_BASE wxString; \ friend class WXDLLIMPEXP_BASE wxCStrData; \ \ private: \ - underlying_iterator m_cur; + underlying_iterator m_cur class 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. + WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef, - wxUniCharRef::CreateForString(m_cur)) + wxUniCharRef::CreateForString(m_str, m_cur)); + + public: + iterator(const iterator& i) : m_cur(i.m_cur), m_str(i.m_str) {} + + 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)); } + + 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) {} + + wxStringImpl& m_str; + + friend class const_iterator; + }; +#else // !wxUSE_UNICODE_UTF8 + class iterator + { + WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef, + wxUniCharRef::CreateForString(m_cur)); + + public: + 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)); } + + private: + // for internal wxString use only: + iterator(underlying_iterator ptr) : m_cur(ptr) {} + iterator(wxString *WXUNUSED(str), underlying_iterator ptr) : m_cur(ptr) {} friend class const_iterator; }; +#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8 class const_iterator { // NB: reference_type is intentionally value, not reference, the character // may be encoded differently in wxString data: WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar, - wxUniChar(*m_cur)) + wxString::DecodeChar(m_cur)); public: + 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)); } + + private: + // for internal wxString use only: + const_iterator(underlying_iterator ptr) : m_cur(ptr) {} }; #undef WX_STR_ITERATOR_TAG @@ -721,14 +868,15 @@ public: reverse_iterator_impl operator--(int) { 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); } + { return reverse_iterator_impl(m_cur - n); } reverse_iterator_impl operator+(size_t n) const - { return reverse_iterator_impl(m_cur - n); } + { return reverse_iterator_impl(m_cur - n); } reverse_iterator_impl operator-(int n) const - { return reverse_iterator_impl(m_cur + n); } + { return reverse_iterator_impl(m_cur + n); } reverse_iterator_impl operator-(size_t n) const - { return reverse_iterator_impl(m_cur + n); } + { 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) @@ -764,10 +912,10 @@ public: // first valid index position const_iterator begin() const { return const_iterator(m_impl.begin()); } - iterator begin() { return iterator(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()); } - iterator end() { return iterator(m_impl.end()); } + iterator end() { return iterator(this, m_impl.end()); } // first element of the reversed string const_reverse_iterator rbegin() const @@ -914,14 +1062,21 @@ public: // implicit conversion to C string operator wxCStrData() const { return c_str(); } - operator const wxChar*() const { return c_str(); } + operator const char*() const { return c_str(); } + operator const wchar_t*() const { return c_str(); } // identical to c_str(), for MFC compatibility const wxCStrData GetData() const { return c_str(); } // explicit conversion to C string in internal representation (char*, // wchar_t*, UTF-8-encoded char*, depending on the build): - const_pointer wx_str() const { return m_impl.c_str(); } + const wxStringCharType *wx_str() const { return m_impl.c_str(); } + + // 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(); } + wxWritableWCharBuffer wchar_str() const { return wc_str(); } // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for // converting numbers or strings which are certain not to contain special @@ -953,26 +1108,31 @@ public: const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } - const wxChar* wc_str() const { return c_str(); } - +#if wxUSE_UNICODE_WCHAR + const wxChar* wc_str() const { return wx_str(); } +#elif wxUSE_UNICODE_UTF8 + const wxWCharBuffer wc_str() const; +#endif // for compatibility with !wxUSE_UNICODE version - const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); } + const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const + { return wc_str(); } #if wxMBFILES const wxCharBuffer fn_str() const { return mb_str(wxConvFile); } #else // !wxMBFILES - const wxChar* fn_str() const { return c_str(); } + const wxWX2WCbuf fn_str() const { return wc_str(); } #endif // wxMBFILES/!wxMBFILES + #else // ANSI - const wxChar* mb_str() const { return c_str(); } + const wxChar* mb_str() const { return wx_str(); } // for compatibility with wxUSE_UNICODE version - const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); } + const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); } const wxWX2MBbuf mbc_str() const { return mb_str(); } #if wxUSE_WCHAR_T - const wxWCharBuffer wc_str(const wxMBConv& conv) const; + 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 ) ); } @@ -983,8 +1143,8 @@ public: // overloaded assignment // from another wxString - wxString& operator=(const wxStringImpl& stringSrc) - { m_impl = stringSrc; return *this; } + wxString& operator=(const wxString& stringSrc) + { m_impl = stringSrc.m_impl; return *this; } wxString& operator=(const wxCStrData& cstr) { return *this = cstr.AsString(); } // from a character @@ -994,36 +1154,32 @@ public: { return operator=((wxUniChar)ch); } wxString& operator=(char ch) { return operator=(wxUniChar(ch)); } + wxString& operator=(unsigned char ch) + { return operator=(wxUniChar(ch)); } wxString& operator=(wchar_t ch) { return operator=(wxUniChar(ch)); } // from a C string - STL probably will crash on NULL, // so we need to compensate in that case #if wxUSE_STL_BASED_WXSTRING - wxString& operator=(const wxChar *psz) - { if(psz) m_impl = psz; else Clear(); return *this; } + wxString& operator=(const char *psz) + { if (psz) m_impl = ImplStr(psz); else Clear(); return *this; } + wxString& operator=(const wchar_t *pwz) + { if (pwz) m_impl = ImplStr(pwz); else Clear(); return *this; } #else - wxString& operator=(const wxChar *psz) - { m_impl = psz; return *this; } + wxString& operator=(const char *psz) + { m_impl = ImplStr(psz); return *this; } + wxString& operator=(const wchar_t *pwz) + { m_impl = ImplStr(pwz); return *this; } #endif + wxString& operator=(const unsigned char *psz) + { return operator=((const char*)psz); } -#if wxUSE_UNICODE // from wxWCharBuffer wxString& operator=(const wxWCharBuffer& s) - { (void) operator=((const wchar_t *)s); return *this; } - // from C string - wxString& operator=(const char* psz) - { return operator=(wxString(psz)); } -#else // ANSI - // from another kind of C string - wxString& operator=(const unsigned char* psz); -#if wxUSE_WCHAR_T - // from a wide string - wxString& operator=(const wchar_t *pwz); -#endif + { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs // from wxCharBuffer - wxString& operator=(const wxCharBuffer& psz) - { (void) operator=((const char *)psz); return *this; } -#endif // Unicode/ANSI + wxString& operator=(const wxCharBuffer& s) + { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs // string concatenation // in place concatenation @@ -1054,6 +1210,7 @@ public: wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; } wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; } wxString& operator<<(char ch) { append(1, ch); return *this; } + wxString& operator<<(unsigned char ch) { append(1, ch); return *this; } wxString& operator<<(wchar_t ch) { append(1, ch); return *this; } // string += buffer (i.e. from wxGetString) @@ -1090,6 +1247,8 @@ public: { append(count, ch); return *this; } wxString& Append(char ch, size_t count = 1u) { append(count, ch); return *this; } + wxString& Append(unsigned char ch, size_t count = 1u) + { append(count, ch); return *this; } wxString& Append(wchar_t ch, size_t count = 1u) { append(count, ch); return *this; } wxString& Append(const char* psz, size_t nLen) @@ -1170,16 +1329,29 @@ public: { return CmpNoCase(wxString(pwz)); } // test for the string equality, either considering case or not // (if compareWithCase then the case matters) - bool IsSameAs(const char *psz, bool compareWithCase = true) const - { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; } - bool IsSameAs(const wchar_t *pwz, bool compareWithCase = true) const - { return (compareWithCase ? Cmp(pwz) : CmpNoCase(pwz)) == 0; } + bool IsSameAs(const wxString& str, bool compareWithCase = true) const + { 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; } // 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)); } + // FIXME-UTF8: remove these overloads + bool IsSameAs(wxUniCharRef c, bool compareWithCase = true) const + { return IsSameAs(wxUniChar(c), compareWithCase); } + bool IsSameAs(char c, bool compareWithCase = true) const + { return IsSameAs(wxUniChar(c), compareWithCase); } + bool IsSameAs(unsigned char c, bool compareWithCase = true) const + { return IsSameAs(wxUniChar(c), compareWithCase); } + bool IsSameAs(wchar_t c, bool compareWithCase = true) const + { return IsSameAs(wxUniChar(c), compareWithCase); } + bool IsSameAs(int c, bool compareWithCase = true) const + { return IsSameAs(wxUniChar(c), compareWithCase); } // simple sub-string extraction // return substring starting at nFirst of length nCount (or till the end @@ -1240,16 +1412,40 @@ public: // searching and replacing // searching (return starting index, or -1 if not found) int Find(wxUniChar ch, bool bFromEnd = false) const; // like strchr/strrchr + int Find(wxUniCharRef ch, bool bFromEnd = false) const + { return Find(wxUniChar(ch), bFromEnd); } + int Find(char ch, bool bFromEnd = false) const + { return Find(wxUniChar(ch), bFromEnd); } + int Find(unsigned char ch, bool bFromEnd = false) const + { return Find(wxUniChar(ch), bFromEnd); } + int Find(wchar_t ch, bool bFromEnd = false) const + { return Find(wxUniChar(ch), bFromEnd); } // searching (return starting index, or -1 if not found) - int Find(const wxChar *pszSub) const; // like strstr + // FIXME-UTF8: keep wxString overload only + int Find(const wxString& sub) const // like strstr + { + size_type idx = find(sub); + return (idx == npos) ? wxNOT_FOUND : (int)idx; + } + int Find(const char *sub) const // like strstr + { + size_type idx = find(sub); + return (idx == npos) ? wxNOT_FOUND : (int)idx; + } + int Find(const wchar_t *sub) const // like strstr + { + size_type idx = find(sub); + return (idx == npos) ? wxNOT_FOUND : (int)idx; + } + // replace first (or all of bReplaceAll) occurences of substring with // another string, returns the number of replacements made - size_t Replace(const wxChar *szOld, - const wxChar *szNew, + size_t Replace(const wxString& strOld, + const wxString& strNew, bool bReplaceAll = true); // check if the string contents matches a mask containing '*' and '?' - bool Matches(const wxChar *szMask) const; + bool Matches(const wxString& mask) const; // conversion to numbers: all functions return true only if the whole // string is a number and put the value of this number into the pointer @@ -1350,10 +1546,12 @@ public: // use Find() int First( wxUniChar ch ) const { return Find(ch); } + int First( wxUniCharRef ch ) const { return Find(ch); } 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 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; } @@ -1365,13 +1563,19 @@ public: // take nLen chars starting at nPos wxString(const wxString& str, size_t nPos, size_t nLen) : m_impl(str.m_impl, nPos, nLen) { } - // take all characters from pStart to pEnd - wxString(const void *pStart, const void *pEnd) - : m_impl((const wxChar*)pStart, (const wxChar*)pEnd) { } + // take all characters from first to last wxString(const_iterator first, const_iterator last) : m_impl(first, last) { } - wxString(iterator first, iterator last) - : m_impl(first, last) { } + wxString(const char *first, const char *last) + { + SubstrBufFromMB str(ImplStr(first, last - first)); + m_impl.assign(str.data, str.len); + } + wxString(const wchar_t *first, const wchar_t *last) + { + SubstrBufFromWC str(ImplStr(first, last - first)); + m_impl.assign(str.data, str.len); + } // lib.string.modifiers // append elements str[pos], ..., str[pos+n] @@ -1418,10 +1622,19 @@ public: // append from first to last wxString& append(const_iterator first, const_iterator last) { m_impl.append(first, last); return *this; } + 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); } // same as `this_string = str' wxString& assign(const wxString& str) { m_impl = str.m_impl; return *this; } + wxString& assign(const wxString& str, size_t len) + { + m_impl.assign(str.m_impl, 0, str.LenToImpl(len)); + return *this; + } // same as ` = str[pos..pos + n] wxString& assign(const wxString& str, size_t pos, size_t n) { @@ -1458,9 +1671,23 @@ public: m_impl.assign(n, (wxStringCharType)ch); return *this; } + + wxString& assign(size_t n, wxUniCharRef ch) + { return assign(n, wxUniChar(ch)); } + wxString& assign(size_t n, char ch) + { return assign(n, wxUniChar(ch)); } + wxString& assign(size_t n, unsigned char ch) + { return assign(n, wxUniChar(ch)); } + wxString& assign(size_t n, wchar_t ch) + { return assign(n, wxUniChar(ch)); } + // assign from first to last wxString& assign(const_iterator first, const_iterator last) { m_impl.assign(first, last); return *this; } + 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); } // string comparison int compare(const wxString& str) const; @@ -1511,21 +1738,36 @@ public: { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.insert(begin() + nPos, EncodeNChars(n, ch)); + m_impl.insert(PosToImpl(nPos), EncodeNChars(n, ch)); else #endif - m_impl.insert(begin() + nPos, n, (wxStringCharType)ch); + m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch); return *this; } iterator insert(iterator it, wxUniChar ch) - { return iterator(m_impl.insert(it, EncodeChar(ch))); } + { +#if wxUSE_UNICODE_UTF8 + if ( !ch.IsAscii() ) + { + size_t pos = IterToImplPos(it); + m_impl.insert(pos, EncodeChar(ch)); + return iterator(this, m_impl.begin() + pos); + } + else +#endif + return iterator(this, m_impl.insert(it, (wxStringCharType)ch)); + } void insert(iterator it, const_iterator first, const_iterator last) { m_impl.insert(it, first, last); } + 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) + { insert(it - begin(), first, last - first); } void insert(iterator it, size_type n, wxUniChar ch) { #if wxUSE_UNICODE_UTF8 if ( !ch.IsAscii() ) - m_impl.insert(it, EncodeNChars(n, ch)); + m_impl.insert(IterToImplPos(it), EncodeNChars(n, ch)); else #endif m_impl.insert(it, n, (wxStringCharType)ch); @@ -1539,10 +1781,11 @@ public: m_impl.erase(from, len); return *this; } + // delete characters from first up to last iterator erase(iterator first, iterator last) - { return iterator(m_impl.erase(first, last)); } + { return iterator(this, m_impl.erase(first, last)); } iterator erase(iterator first) - { return iterator(m_impl.erase(first)); } + { return iterator(this, m_impl.erase(first)); } #ifdef wxSTRING_BASE_HASNT_CLEAR void clear() { erase(); } @@ -1622,6 +1865,15 @@ public: m_impl.replace(from, len, str.data, str.len); return *this; } + wxString& replace(size_t nStart, size_t nLen, + const wxString& s, size_t nCount) + { + size_t from, len; + PosLenToImpl(nStart, nLen, &from, &len); + m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount)); + return *this; + } + wxString& replace(iterator first, iterator last, const char* s) { m_impl.replace(first, last, ImplStr(s)); return *this; } wxString& replace(iterator first, iterator last, const wchar_t* s) @@ -1653,6 +1905,12 @@ public: wxString& replace(iterator first, iterator last, const_iterator first1, const_iterator last1) { m_impl.replace(first, last, first1, last1); return *this; } + wxString& replace(iterator first, iterator last, + const char *first1, const char *last1) + { replace(first, last, first1, last1 - first1); return *this; } + wxString& replace(iterator first, iterator last, + const wchar_t *first1, const wchar_t *last1) + { replace(first, last, first1, last1 - first1); return *this; } // swap two strings void swap(wxString& str) @@ -1681,6 +1939,8 @@ public: { return find(wxUniChar(ch), nStart); } size_t find(char ch, size_t nStart = 0) const { return find(wxUniChar(ch), nStart); } + size_t find(unsigned char ch, size_t nStart = 0) const + { return find(wxUniChar(ch), nStart); } size_t find(wchar_t ch, size_t nStart = 0) const { return find(wxUniChar(ch), nStart); } @@ -1708,6 +1968,8 @@ public: { return rfind(wxUniChar(ch), nStart); } size_t rfind(char ch, size_t nStart = npos) const { return rfind(wxUniChar(ch), nStart); } + size_t rfind(unsigned char ch, size_t nStart = npos) const + { return rfind(wxUniChar(ch), nStart); } size_t rfind(wchar_t ch, size_t nStart = npos) const { return rfind(wxUniChar(ch), nStart); } @@ -1773,7 +2035,11 @@ 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); } +#else { return find_first_of((const wxChar*)str.c_str(), nStart); } +#endif // same as above size_t find_first_of(const char* sz, size_t nStart = 0) const; size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const; @@ -1784,7 +2050,11 @@ public: { return find(c, nStart); } // find the last (starting from nStart) char from str in this string size_t find_last_of (const wxString& str, size_t nStart = npos) const +#if wxUSE_UNICODE // FIXME-UTF8: temporary + { return find_last_of(str.mb_str().data(), nStart); } +#else { return find_last_of((const wxChar*)str.c_str(), nStart); } +#endif // same as above size_t find_last_of (const char* sz, size_t nStart = npos) const; size_t find_last_of (const wchar_t* sz, size_t nStart = npos) const; @@ -1798,7 +2068,11 @@ 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); } +#else { return find_first_not_of((const wxChar*)str.c_str(), nStart); } +#endif // same as above size_t find_first_not_of(const char* sz, size_t nStart = 0) const; size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const; @@ -1808,7 +2082,11 @@ public: size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const; // as strcspn() size_t find_last_not_of(const wxString& str, size_t nStart = npos) const +#if wxUSE_UNICODE // FIXME-UTF8: temporary + { return find_last_not_of(str.mb_str().data(), nStart); } +#else { return find_last_not_of((const wxChar*)str.c_str(), nStart); } +#endif // same as above size_t find_last_not_of(const char* sz, size_t nStart = npos) const; size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const; @@ -1824,24 +2102,32 @@ public: { return find_first_of(wxUniChar(ch), nStart); } size_t find_first_of(char ch, size_t nStart = 0) const { return find_first_of(wxUniChar(ch), nStart); } + size_t find_first_of(unsigned char ch, size_t nStart = 0) const + { return find_first_of(wxUniChar(ch), nStart); } size_t find_first_of(wchar_t ch, size_t nStart = 0) const { return find_first_of(wxUniChar(ch), nStart); } size_t find_last_of(wxUniCharRef ch, size_t nStart = npos) const { return find_last_of(wxUniChar(ch), nStart); } size_t find_last_of(char ch, size_t nStart = npos) const { return find_last_of(wxUniChar(ch), nStart); } + size_t find_last_of(unsigned char ch, size_t nStart = npos) const + { return find_last_of(wxUniChar(ch), nStart); } size_t find_last_of(wchar_t ch, size_t nStart = npos) const { return find_last_of(wxUniChar(ch), nStart); } size_t find_first_not_of(wxUniCharRef ch, size_t nStart = 0) const { return find_first_not_of(wxUniChar(ch), nStart); } size_t find_first_not_of(char ch, size_t nStart = 0) const { return find_first_not_of(wxUniChar(ch), nStart); } + size_t find_first_not_of(unsigned char ch, size_t nStart = 0) const + { return find_first_not_of(wxUniChar(ch), nStart); } size_t find_first_not_of(wchar_t ch, size_t nStart = 0) const { return find_first_not_of(wxUniChar(ch), nStart); } size_t find_last_not_of(wxUniCharRef ch, size_t nStart = npos) const { return find_last_not_of(wxUniChar(ch), nStart); } size_t find_last_not_of(char ch, size_t nStart = npos) const { return find_last_not_of(wxUniChar(ch), nStart); } + size_t find_last_not_of(unsigned char ch, size_t nStart = npos) const + { return find_last_not_of(wxUniChar(ch), nStart); } size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const { return find_last_not_of(wxUniChar(ch), nStart); } @@ -1890,6 +2176,35 @@ private: private: wxStringImpl m_impl; + + // buffers for compatibility conversion from (char*)c_str() and + // (wchar_t*)c_str(): + // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers + template + struct ConvertedBuffer + { + ConvertedBuffer() : m_buf(NULL) {} + ~ConvertedBuffer() + { free(m_buf); } + + operator T*() const { return m_buf; } + + ConvertedBuffer& operator=(T *str) + { + free(m_buf); + m_buf = str; + return *this; + } + + T *m_buf; + }; +#if wxUSE_UNICODE + ConvertedBuffer m_convertedToChar; +#endif +#if !wxUSE_UNICODE_WCHAR + ConvertedBuffer m_convertedToWChar; +#endif + friend class WXDLLIMPEXP_BASE wxCStrData; }; #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN @@ -2156,12 +2471,8 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING) #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar() #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar() -// FIXME: these ifdefs must be removed when wxCStrData has both conversions -#if wxUSE_UNICODE - wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA) -#else - wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA) -#endif +wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA) +wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA) #undef wxCMP_CHAR_CSTRDATA #undef wxCMP_WCHAR_CSTRDATA @@ -2176,6 +2487,10 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING) WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&); +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&); +#ifndef __BORLANDC__ +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&); +#endif #endif // wxSTD_STRING_COMPATIBILITY @@ -2194,15 +2509,26 @@ inline wxCStrData::~wxCStrData() delete m_str; } -#if wxUSE_UNICODE +inline wxCStrData::operator bool() const +{ + return !m_str->empty(); +} + +// simple cases for AsChar() and AsWChar(), the complicated ones are +// in string.cpp +#if wxUSE_UNICODE_WCHAR inline const wchar_t* wxCStrData::AsWChar() const -#else +{ + return m_str->wx_str() + m_offset; +} +#endif // wxUSE_UNICODE_WCHAR + +#if !wxUSE_UNICODE inline const char* wxCStrData::AsChar() const -#endif { - // FIXME-UTF8: incorrect position, incorrect charset return m_str->wx_str() + m_offset; } +#endif // !wxUSE_UNICODE inline wxString wxCStrData::AsString() const { @@ -2225,14 +2551,35 @@ inline wxUniChar wxCStrData::operator[](size_t n) const return m_str->at(m_offset + n); } +// ---------------------------------------------------------------------------- +// more wxCStrData operators +// ---------------------------------------------------------------------------- + +// we need to define those to allow "size_t pos = p - s.c_str()" where p is +// some pointer into the string +inline size_t operator-(const char *p, const wxCStrData& cs) +{ + return p - cs.AsChar(); +} + +inline size_t operator-(const wchar_t *p, const wxCStrData& cs) +{ + return p - cs.AsWChar(); +} + // ---------------------------------------------------------------------------- // implementation of wx[W]CharBuffer inline methods using wxCStrData // ---------------------------------------------------------------------------- -// FIXME-UTF8: move this to buffer.h; provide versions for both variants -inline wxWxCharBuffer::wxWxCharBuffer(const wxCStrData& cstr) - : wxCharTypeBufferBase((const wxChar *)cstr) +// FIXME-UTF8: move this to buffer.h +inline wxCharBuffer::wxCharBuffer(const wxCStrData& cstr) + : wxCharTypeBufferBase(cstr.AsChar()) +{ +} + +inline wxWCharBuffer::wxWCharBuffer(const wxCStrData& cstr) + : wxCharTypeBufferBase(cstr.AsWChar()) { } -#endif // _WX_WXSTRING_H__ +#endif // _WX_WXSTRING_H_