X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8f93a29f8e50aa9dc6076a900ad6d316fafddcc3..67cff9dc2faf0458bae1057361d1f5839dd8a937:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 2bb59dc033..a7bc6e1d05 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -1,6 +1,6 @@ /////////////////////////////////////////////////////////////////////////////// // Name: wx/string.h -// Purpose: wxString and wxArrayString classes +// Purpose: wxString class // Author: Vadim Zeitlin // Modified by: // Created: 29/01/98 @@ -15,8 +15,8 @@ missing from string.h. */ -#ifndef _WX_WXSTRINGH__ -#define _WX_WXSTRINGH__ +#ifndef _WX_WXSTRING_H__ +#define _WX_WXSTRING_H__ // ---------------------------------------------------------------------------- // headers @@ -55,9 +55,17 @@ #include "wx/strvararg.h" #include "wx/buffer.h" // for wxCharBuffer #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes +#include "wx/stringimpl.h" +#include "wx/unichar.h" class WXDLLIMPEXP_BASE wxString; +// 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 // --------------------------------------------------------------------------- @@ -69,10 +77,6 @@ class WXDLLIMPEXP_BASE wxString; #define wxMBSTRINGCAST (char *)(const char *) #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *) -// implementation only -#define wxASSERT_VALID_INDEX(i) \ - wxASSERT_MSG( (size_t)(i) <= length(), _T("invalid index in wxString") ) - // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -86,13 +90,6 @@ class WXDLLIMPEXP_BASE wxString; #endif // WXWIN_COMPATIBILITY_2_6 -// ---------------------------------------------------------------------------- -// global data -// ---------------------------------------------------------------------------- - -// global pointer to empty string -extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString; - // --------------------------------------------------------------------------- // global functions complementing standard C string library replacements for // strlen() and portable strcasecmp() @@ -172,422 +169,13 @@ inline int Stricmp(const char *psz1, const char *psz2) #endif // WXWIN_COMPATIBILITY_2_8 -// ---------------------------------------------------------------------------- -// deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING -// ---------------------------------------------------------------------------- - -// FIXME-UTF8: using std::string as wxString base class is currently broken, -// so we use the standard wxString with std::string conversion -// enabled, this is API-compatible. -#if 1 -#define wxUSE_STL_BASED_WXSTRING 0 -#if wxUSE_STL - #undef wxUSE_STD_STRING - #define wxUSE_STD_STRING 1 -#endif -#else -#define wxUSE_STL_BASED_WXSTRING wxUSE_STL -#endif - -// in both cases we need to define wxStdString -#if wxUSE_STL_BASED_WXSTRING || wxUSE_STD_STRING - -#include "wx/beforestd.h" -#include -#include "wx/afterstd.h" - -#if wxUSE_UNICODE_WCHAR - #ifdef HAVE_STD_WSTRING - typedef std::wstring wxStdString; - #else - typedef std::basic_string wxStdString; - #endif -#else - typedef std::string wxStdString; -#endif - -#endif // need - -#if wxUSE_STL_BASED_WXSTRING - - // we always want ctor from std::string when using std::string internally - #undef wxUSE_STD_STRING - #define wxUSE_STD_STRING 1 - - #if (defined(__GNUG__) && (__GNUG__ < 3)) || \ - (defined(_MSC_VER) && (_MSC_VER <= 1200)) - #define wxSTRING_BASE_HASNT_CLEAR - #endif - - typedef wxStdString wxStringImpl; -#else // if !wxUSE_STL_BASED_WXSTRING - -// in non-STL mode, compare() is implemented in wxString and not wxStringImpl -#undef HAVE_STD_STRING_COMPARE - -// --------------------------------------------------------------------------- -// string data prepended with some housekeeping info (used by wxString class), -// is never used directly (but had to be put here to allow inlining) -// --------------------------------------------------------------------------- - -struct WXDLLIMPEXP_BASE wxStringData -{ - int nRefs; // reference count - size_t nDataLength, // actual string length - nAllocLength; // allocated memory size - - // mimics declaration 'wxChar data[nAllocLength]' - wxChar* data() const { return (wxChar*)(this + 1); } - - // empty string has a special ref count so it's never deleted - bool IsEmpty() const { return (nRefs == -1); } - bool IsShared() const { return (nRefs > 1); } - - // lock/unlock - void Lock() { if ( !IsEmpty() ) nRefs++; } - - // VC++ will refuse to inline Unlock but profiling shows that it is wrong -#if defined(__VISUALC__) && (__VISUALC__ >= 1200) - __forceinline -#endif - // VC++ free must take place in same DLL as allocation when using non dll - // run-time library (e.g. Multithreaded instead of Multithreaded DLL) -#if defined(__VISUALC__) && defined(_MT) && !defined(_DLL) - void Unlock() { if ( !IsEmpty() && --nRefs == 0) Free(); } - // we must not inline deallocation since allocation is not inlined - void Free(); -#else - void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); } -#endif - - // if we had taken control over string memory (GetWriteBuf), it's - // intentionally put in invalid state - void Validate(bool b) { nRefs = (b ? 1 : 0); } - bool IsValid() const { return (nRefs != 0); } -}; - -class WXDLLIMPEXP_BASE wxStringImpl -{ -public: - // an 'invalid' value for string index, moved to this place due to a CW bug - static const size_t npos; - -protected: - // points to data preceded by wxStringData structure with ref count info - wxStringCharType *m_pchData; - - // accessor to string data - wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; } - - // string (re)initialization functions - // initializes the string to the empty value (must be called only from - // ctors, use Reinit() otherwise) - void Init() { m_pchData = (wxStringCharType *)wxEmptyString; } - // initializes the string with (a part of) C-string - void InitWith(const wxStringCharType *psz, size_t nPos = 0, size_t nLen = npos); - // as Init, but also frees old data - void Reinit() { GetStringData()->Unlock(); Init(); } - - // memory allocation - // allocates memory for string of length nLen - bool AllocBuffer(size_t nLen); - // effectively copies data to string - bool AssignCopy(size_t, const wxStringCharType *); - - // append a (sub)string - bool ConcatSelf(size_t nLen, const wxStringCharType *src, size_t nMaxLen); - bool ConcatSelf(size_t nLen, const wxStringCharType *src) - { return ConcatSelf(nLen, src, nLen); } - - // functions called before writing to the string: they copy it if there - // are other references to our data (should be the only owner when writing) - bool CopyBeforeWrite(); - bool AllocBeforeWrite(size_t); - - // compatibility with wxString - bool Alloc(size_t nLen); - -public: - // standard types - typedef wxStringCharType value_type; - typedef wxStringCharType char_type; - typedef size_t size_type; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type *iterator; - typedef const value_type *const_iterator; - - // constructors and destructor - // ctor for an empty string - wxStringImpl() { Init(); } - // copy ctor - wxStringImpl(const wxStringImpl& stringSrc) - { - wxASSERT_MSG( stringSrc.GetStringData()->IsValid(), - _T("did you forget to call UngetWriteBuf()?") ); - - if ( stringSrc.empty() ) { - // nothing to do for an empty string - Init(); - } - else { - m_pchData = stringSrc.m_pchData; // share same data - GetStringData()->Lock(); // => one more copy - } - } - // string containing nRepeat copies of ch - wxStringImpl(size_type nRepeat, wxStringCharType ch); - // ctor takes first nLength characters from C string - // (default value of npos means take all the string) - wxStringImpl(const wxStringCharType *psz) - { InitWith(psz, 0, npos); } - wxStringImpl(const wxStringCharType *psz, size_t nLength) - { InitWith(psz, 0, nLength); } - // take nLen chars starting at nPos - wxStringImpl(const wxStringImpl& str, size_t nPos, size_t nLen) - { - wxASSERT_MSG( str.GetStringData()->IsValid(), - _T("did you forget to call UngetWriteBuf()?") ); - Init(); - size_t strLen = str.length() - nPos; nLen = strLen < nLen ? strLen : nLen; - InitWith(str.c_str(), nPos, nLen); - } - // take all characters from pStart to pEnd - wxStringImpl(const void *pStart, const void *pEnd); - - // dtor is not virtual, this class must not be inherited from! - ~wxStringImpl() - { -#if defined(__VISUALC__) && (__VISUALC__ >= 1200) - //RN - according to the above VC++ does indeed inline this, - //even though it spits out two warnings - #pragma warning (disable:4714) -#endif - - GetStringData()->Unlock(); - } - -#if defined(__VISUALC__) && (__VISUALC__ >= 1200) - //re-enable inlining warning - #pragma warning (default:4714) -#endif - // overloaded assignment - // from another wxString - wxStringImpl& operator=(const wxStringImpl& stringSrc); - // from a character - wxStringImpl& operator=(wxStringCharType ch); - // from a C string - wxStringImpl& operator=(const wxStringCharType *psz); - - // return the length of the string - size_type length() const { return GetStringData()->nDataLength; } - // return the length of the string - size_type size() const { return length(); } - // return the maximum size of the string - size_type max_size() const { return npos; } - // resize the string, filling the space with c if c != 0 - void resize(size_t nSize, wxStringCharType ch = '\0'); - // delete the contents of the string - void clear() { erase(0, npos); } - // returns true if the string is empty - bool empty() const { return length() == 0; } - // inform string about planned change in size - void reserve(size_t sz) { Alloc(sz); } - size_type capacity() const { return GetStringData()->nAllocLength; } - - // lib.string.access - // return the character at position n - value_type at(size_type n) const - { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } - // returns the writable character at position n - reference at(size_type n) - { - wxASSERT_VALID_INDEX( n ); - CopyBeforeWrite(); - return m_pchData[n]; - } // FIXME-UTF8: not useful for us...? - - // lib.string.modifiers - // append elements str[pos], ..., str[pos+n] - wxStringImpl& append(const wxStringImpl& str, size_t pos, size_t n) - { - wxASSERT(pos <= str.length()); - ConcatSelf(n, str.c_str() + pos, str.length() - pos); - return *this; - } - // append a string - wxStringImpl& append(const wxStringImpl& str) - { ConcatSelf(str.length(), str.c_str()); return *this; } - // append first n (or all if n == npos) characters of sz - wxStringImpl& append(const wxStringCharType *sz) - { ConcatSelf(wxStrlen(sz), sz); return *this; } - wxStringImpl& append(const wxStringCharType *sz, size_t n) - { ConcatSelf(n, sz); return *this; } - // append n copies of ch - wxStringImpl& append(size_t n, wxStringCharType ch); - // append from first to last - wxStringImpl& append(const_iterator first, const_iterator last) - { ConcatSelf(last - first, first); return *this; } - - // same as `this_string = str' - wxStringImpl& assign(const wxStringImpl& str) - { return *this = str; } - // same as ` = str[pos..pos + n] - wxStringImpl& assign(const wxStringImpl& str, size_t pos, size_t n) - { clear(); return append(str, pos, n); } - // same as `= first n (or all if n == npos) characters of sz' - wxStringImpl& assign(const wxStringCharType *sz) - { clear(); return append(sz, wxStrlen(sz)); } - wxStringImpl& assign(const wxStringCharType *sz, size_t n) - { clear(); return append(sz, n); } - // same as `= n copies of ch' - wxStringImpl& assign(size_t n, wxStringCharType ch) - { clear(); return append(n, ch); } - // assign from first to last - wxStringImpl& assign(const_iterator first, const_iterator last) - { clear(); return append(first, last); } - - // first valid index position - const_iterator begin() const { return m_pchData; } - iterator begin(); - // position one after the last valid one - const_iterator end() const { return m_pchData + length(); } - iterator end(); - - // insert another string - wxStringImpl& insert(size_t nPos, const wxStringImpl& str) - { - wxASSERT( str.GetStringData()->IsValid() ); - return insert(nPos, str.c_str(), str.length()); - } - // insert n chars of str starting at nStart (in str) - wxStringImpl& insert(size_t nPos, const wxStringImpl& str, size_t nStart, size_t n) - { - wxASSERT( str.GetStringData()->IsValid() ); - wxASSERT( nStart < str.length() ); - size_t strLen = str.length() - nStart; - n = strLen < n ? strLen : n; - return insert(nPos, str.c_str() + nStart, n); - } - // insert first n (or all if n == npos) characters of sz - wxStringImpl& insert(size_t nPos, const wxStringCharType *sz, size_t n = npos); - // insert n copies of ch - wxStringImpl& insert(size_t nPos, size_t n, wxStringCharType ch)// FIXME-UTF8: tricky - { return insert(nPos, wxStringImpl(n, ch)); } - iterator insert(iterator it, wxStringCharType ch) // FIXME-UTF8: tricky - { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; } - void insert(iterator it, const_iterator first, const_iterator last) - { insert(it - begin(), first, last - first); } - void insert(iterator it, size_type n, wxStringCharType ch) - { insert(it - begin(), n, ch); } - - // delete characters from nStart to nStart + nLen - wxStringImpl& erase(size_type pos = 0, size_type n = npos); - iterator erase(iterator first, iterator last) - { - size_t idx = first - begin(); - erase(idx, last - first); - return begin() + idx; - } - iterator erase(iterator first); - - // explicit conversion to C string (use this with printf()!) - const wxStringCharType* c_str() const { return m_pchData; } - const wxStringCharType* data() const { return m_pchData; } - - // replaces the substring of length nLen starting at nStart - wxStringImpl& replace(size_t nStart, size_t nLen, const wxStringCharType* sz); - // replaces the substring of length nLen starting at nStart - wxStringImpl& replace(size_t nStart, size_t nLen, const wxStringImpl& str) - { return replace(nStart, nLen, str.c_str()); } - // replaces the substring with nCount copies of ch - wxStringImpl& replace(size_t nStart, size_t nLen, size_t nCount, wxStringCharType ch); - // replaces a substring with another substring - wxStringImpl& replace(size_t nStart, size_t nLen, - const wxStringImpl& str, size_t nStart2, size_t nLen2); - // replaces the substring with first nCount chars of sz - wxStringImpl& replace(size_t nStart, size_t nLen, - const wxStringCharType* sz, size_t nCount); - wxStringImpl& replace(iterator first, iterator last, const_pointer s) - { return replace(first - begin(), last - first, s); } - wxStringImpl& replace(iterator first, iterator last, const_pointer s, - size_type n) - { return replace(first - begin(), last - first, s, n); } - wxStringImpl& replace(iterator first, iterator last, const wxStringImpl& s) - { return replace(first - begin(), last - first, s); } - wxStringImpl& replace(iterator first, iterator last, size_type n, wxStringCharType c) - { return replace(first - begin(), last - first, n, c); } - wxStringImpl& replace(iterator first, iterator last, - const_iterator first1, const_iterator last1) - { return replace(first - begin(), last - first, first1, last1 - first1); } - - // swap two strings - void swap(wxStringImpl& str); - - // All find() functions take the nStart argument which specifies the - // position to start the search on, the default value is 0. All functions - // return npos if there were no match. - - // find a substring - size_t find(const wxStringImpl& str, size_t nStart = 0) const; - - // find first n characters of sz - size_t find(const wxStringCharType* sz, size_t nStart = 0, size_t n = npos) const; - - // find the first occurence of character ch after nStart - size_t find(wxStringCharType ch, size_t nStart = 0) const; - - // rfind() family is exactly like find() but works right to left - - // as find, but from the end - size_t rfind(const wxStringImpl& str, size_t nStart = npos) const; - - // as find, but from the end - size_t rfind(const wxStringCharType* sz, size_t nStart = npos, - size_t n = npos) const; - // as find, but from the end - size_t rfind(wxStringCharType ch, size_t nStart = npos) const; - - size_type copy(wxStringCharType* s, size_type n, size_type pos = 0); - - // substring extraction - wxStringImpl substr(size_t nStart = 0, size_t nLen = npos) const; - - // string += string - wxStringImpl& operator+=(const wxStringImpl& s) { return append(s); } - // string += C string - wxStringImpl& operator+=(const wxStringCharType *psz) { return append(psz); } - // string += char - wxStringImpl& operator+=(wxStringCharType ch) { return append(1, ch); } - -#if !wxUSE_UNICODE_UTF8 - // helpers for wxStringBuffer and wxStringBufferLength - wxStringCharType *DoGetWriteBuf(size_t nLen); - void DoUngetWriteBuf(); - void DoUngetWriteBuf(size_t nLen); -#endif - - friend class WXDLLIMPEXP_BASE wxString; -}; - -#endif // !wxUSE_STL_BASED_WXSTRING - -// don't pollute the library user's name space -#undef wxASSERT_VALID_INDEX - -// wx/unichar.h needs wxStringImpl, so it's only possible to include it here -// (it includes string.h if not included from string.h): -#include "wx/unichar.h" - // ---------------------------------------------------------------------------- // wxCStrData // ---------------------------------------------------------------------------- // 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 @@ -600,30 +188,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 wxString() 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)); } @@ -639,9 +232,29 @@ 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 + { + 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; @@ -735,10 +348,8 @@ class WXDLLIMPEXP_BASE wxString // that all inline functions can be effectively inlined, verify that all // performance critical functions are still inlined if you change order! public: -#if !wxUSE_STL_BASED_WXSTRING // an 'invalid' value for string index, moved to this place due to a CW bug static const size_t npos; -#endif private: // if we hadn't made these operators private, it would be possible to @@ -766,21 +377,20 @@ 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; - typedef SubstrBufFromWC SubstrBufFrom; #else typedef SubstrBufFromType SubstrBufFromMB; typedef SubstrBufFromType SubstrBufFromWC; - typedef SubstrBufFromMB SubstrBufFrom; #endif @@ -789,30 +399,39 @@ 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); + 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 static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength, - const wxMBConv& conv); + const wxMBConv& conv); #endif #if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE - // returns C string encoded as the implementation expects (version for - // the same char type as used internally) - static const wxStringCharType* ImplStr(const wxStringCharType* str) - { return str; } - static const SubstrBufFrom ImplStr(const wxStringCharType* str, size_t n) - { return SubstrBufFrom(str, n); } + // returns C string encoded as the implementation expects: #if wxUSE_UNICODE - // returns C string encoded as the implementation expects (version for - // the other char type than the one used internally) - 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); } + static const wchar_t* ImplStr(const wchar_t* str) + { return str ? str : wxT(""); } + static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n) + { 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, + 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) @@ -839,6 +458,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: @@ -846,15 +466,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 ) @@ -863,6 +529,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 ) @@ -871,103 +546,25 @@ 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 - -public: - // constructors and destructor - // ctor for an empty string - wxString() {} - // copy ctor - wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { } - wxString(const wxString& stringSrc) : m_impl(stringSrc) { } - // string containing nRepeat copies of ch - wxString(wxUniChar ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } - wxString(size_t nRepeat, wxUniChar ch) - : m_impl(nRepeat, ch) { } - wxString(wxUniCharRef ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } - wxString(size_t nRepeat, wxUniCharRef ch) - : m_impl(nRepeat, ch) { } - wxString(char ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } - wxString(size_t nRepeat, char ch) - : m_impl(nRepeat, ch) { } - wxString(wchar_t ch, size_t nRepeat = 1) - : m_impl(nRepeat, ch) { } - wxString(size_t nRepeat, wchar_t ch) - : m_impl(nRepeat, ch) { } - // ctor takes first nLength characters from C string - // (default value of npos means take all the string) - wxString(const wxChar *psz) - : 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 - wxString(const wxStdString& s) - : m_impl(s.c_str()) { } -#endif // wxUSE_STD_STRING - -#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) { } - -#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 - - // from wxCharBuffer - wxString(const wxCharBuffer& psz) - : m_impl(psz) { } -#endif // Unicode/ANSI - - // as we provide both ctors with this signature for both char and unsigned - // char string, we need to provide one for wxCStrData to resolve ambiguity - wxString(const wxCStrData& cstr, size_t nLength) - { assign(cstr.AsString(), nLength); } - - // and because wxString is convertible to wxCStrData and const wxChar * - // we also need to provide this one - wxString(const wxString& str, size_t nLength) - { assign(str, nLength); } - public: // standard types typedef wxUniChar value_type; @@ -979,18 +576,30 @@ public: typedef size_t size_type; typedef wxUniChar const_reference; +#if wxUSE_STL + #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 + #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \ reference_type, reference_ctor) \ private: \ typedef wxStringImpl::iterator_name underlying_iterator; \ public: \ + typedef WX_STR_ITERATOR_TAG iterator_category; \ typedef wxUniChar value_type; \ + typedef int difference_type; \ typedef reference_type reference; \ typedef pointer_type pointer; \ \ - iterator_name(const iterator_name& i) : m_cur(i.m_cur) {} \ - \ reference operator*() const { return reference_ctor; } \ + reference operator[](size_t n) const { return *(*this + n); } \ \ iterator_name& operator++() \ { wxString::IncIter(m_cur); return *this; } \ @@ -1009,27 +618,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; } \ @@ -1045,37 +646,103 @@ 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 wxStringImpl; \ 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_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)) + 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 #undef WX_STR_ITERATOR_IMPL friend class iterator; @@ -1086,7 +753,10 @@ public: { public: typedef T iterator_type; + + typedef typename T::iterator_category iterator_category; typedef typename T::value_type value_type; + typedef typename T::difference_type difference_type; typedef typename T::reference reference; typedef typename T::pointer *pointer; @@ -1097,6 +767,7 @@ public: iterator_type base() const { return m_cur; } reference operator*() const { return *(m_cur-1); } + reference operator[](size_t n) const { return *(*this + n); } reverse_iterator_impl& operator++() { --m_cur; return *this; } @@ -1107,14 +778,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) @@ -1148,12 +820,116 @@ 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->begin() + data.m_offset); + } + +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 + + // 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 @@ -1300,14 +1076,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 @@ -1339,26 +1122,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 ) ); } @@ -1369,8 +1157,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 @@ -1380,36 +1168,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 @@ -1440,6 +1224,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) @@ -1476,6 +1261,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) @@ -1556,16 +1343,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 @@ -1626,16 +1426,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 @@ -1736,10 +1560,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; } @@ -1751,13 +1577,30 @@ 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) { } +#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)); + 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); + } + // 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), CreateConstIterator(last)) + { + 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] @@ -1804,10 +1647,23 @@ public: // append from first to last wxString& append(const_iterator first, const_iterator last) { m_impl.append(first, last); 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) { 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) { @@ -1844,9 +1700,27 @@ 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; } +#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; @@ -1897,21 +1771,41 @@ 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); } +#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER + void insert(iterator it, const char *first, const char *last) + { insert(it - begin(), first, last - first); } + 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(it, EncodeNChars(n, ch)); + m_impl.insert(IterToImplPos(it), EncodeNChars(n, ch)); else #endif m_impl.insert(it, n, (wxStringCharType)ch); @@ -1925,10 +1819,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(); } @@ -2008,6 +1903,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) @@ -2039,6 +1943,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) @@ -2067,6 +1977,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); } @@ -2094,6 +2006,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); } @@ -2103,20 +2017,20 @@ public: // sizeof(wchar_t)==2 and surrogates are present in the string; // should we care? Probably not. size_t find_first_of(const wxString& str, size_t nStart = 0) const - { return m_impl.find_first_of(str.impl, nStart); } + { return m_impl.find_first_of(str.m_impl, nStart); } size_t find_first_of(const char* sz, size_t nStart = 0) const { return m_impl.find_first_of(ImplStr(sz), nStart); } size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const { return m_impl.find_first_of(ImplStr(sz), nStart); } - size_t find_first_of(const char* sz, size_t nStart, size_t n) const; + size_t find_first_of(const char* sz, size_t nStart, size_t n) const { return m_impl.find_first_of(ImplStr(sz), nStart, n); } - size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const; + size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const { return m_impl.find_first_of(ImplStr(sz), nStart, n); } size_t find_first_of(wxUniChar c, size_t nStart = 0) const { return m_impl.find_first_of((wxChar)c, nStart); } - size_t find_last_of(const wxStringImpl& str, size_t nStart = npos) const - { return m_impl.find_last_of(str.impl, nStart); } + size_t find_last_of(const wxString& str, size_t nStart = npos) const + { return m_impl.find_last_of(str.m_impl, nStart); } size_t find_last_of(const char* sz, size_t nStart = npos) const { return m_impl.find_last_of(ImplStr(sz), nStart); } size_t find_last_of(const wchar_t* sz, size_t nStart = npos) const @@ -2128,30 +2042,30 @@ public: size_t find_last_of(wxUniChar c, size_t nStart = npos) const { return m_impl.find_last_of((wxChar)c, nStart); } - size_t find_first_not_of(const wxStringImpl& str, size_t nStart = 0) const + size_t find_first_not_of(const wxString& str, size_t nStart = 0) const { return m_impl.find_first_not_of(str.m_impl, nStart); } - size_t find_first_not_of(const char* sz, size_t nStart = 0) const; + size_t find_first_not_of(const char* sz, size_t nStart = 0) const { return m_impl.find_first_not_of(ImplStr(sz), nStart); } - size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const; + size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const { return m_impl.find_first_not_of(ImplStr(sz), nStart); } - size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const; + size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); } - size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const; + size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); } - size_t find_first_not_of(wxUniChar c, size_t nStart = 0) const; + size_t find_first_not_of(wxUniChar c, size_t nStart = 0) const { return m_impl.find_first_not_of((wxChar)c, nStart); } - size_t find_last_not_of(const wxStringImpl& str, size_t nStart = npos) const + size_t find_last_not_of(const wxString& str, size_t nStart = npos) const { return m_impl.find_last_not_of(str.m_impl, nStart); } - size_t find_last_not_of(const char* sz, size_t nStart = npos) const; + size_t find_last_not_of(const char* sz, size_t nStart = npos) const { return m_impl.find_last_not_of(ImplStr(sz), nStart); } - size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const; + size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const { return m_impl.find_last_not_of(ImplStr(sz), nStart); } - size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const; + size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); } - size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const; + size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); } - size_t find_last_not_of(wxUniChar c, size_t nStart = npos) const; + size_t find_last_not_of(wxUniChar c, size_t nStart = npos) const { return m_impl.find_last_not_of((wxChar)c, nStart); } #else // we can't use std::string implementation in UTF-8 build, because the @@ -2159,7 +2073,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; @@ -2170,7 +2088,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; @@ -2184,7 +2106,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; @@ -2194,7 +2120,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; @@ -2210,24 +2140,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); } @@ -2245,6 +2183,7 @@ public: wxString& operator+=(wxUniChar ch) { m_impl += EncodeChar(ch); return *this; } wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); } + wxString& operator+=(int ch) { return *this += wxUniChar(ch); } wxString& operator+=(char ch) { return *this += wxUniChar(ch); } wxString& operator+=(unsigned char ch) { return *this += wxUniChar(ch); } wxString& operator+=(wchar_t ch) { return *this += wxUniChar(ch); } @@ -2275,12 +2214,60 @@ 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 #pragma warning (default:4275) #endif +// string iterator operators that satisfy STL Random Access Iterator +// requirements: +inline wxString::iterator operator+(int n, wxString::iterator i) + { return i + n; } +inline wxString::iterator operator+(size_t n, wxString::iterator i) + { return i + n; } +inline wxString::const_iterator operator+(int n, wxString::const_iterator i) + { return i + n; } +inline wxString::const_iterator operator+(size_t n, wxString::const_iterator i) + { return i + n; } +inline wxString::reverse_iterator operator+(int n, wxString::reverse_iterator i) + { return i + n; } +inline wxString::reverse_iterator operator+(size_t n, wxString::reverse_iterator i) + { return i + n; } +inline wxString::const_reverse_iterator operator+(int n, wxString::const_reverse_iterator i) + { return i + n; } +inline wxString::const_reverse_iterator operator+(size_t n, wxString::const_reverse_iterator i) + { return i + n; } + // notice that even though for many compilers the friend declarations above are // enough, from the point of view of C++ standard we must have the declarations // here as friend ones are not injected in the enclosing namespace and without @@ -2430,11 +2417,6 @@ private: // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- -// note that when wxUSE_STL_BASED_WXSTRING == 1 the comparison operators taking -// std::string are used and defining them also for wxString would only result -// in compilation ambiguities when comparing std::string and wxString -#if !wxUSE_STL_BASED_WXSTRING - #define wxCMP_WXCHAR_STRING(p, s, op) s.Cmp(p) op 0 wxDEFINE_ALL_COMPARISONS(const wxChar *, const wxString&, wxCMP_WXCHAR_STRING) @@ -2488,10 +2470,7 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string) { return (const char *)buf + string; } #endif // wxUSE_UNICODE/!wxUSE_UNICODE -#endif // !wxUSE_STL_BASED_WXSTRING - -// comparison with char (those are not defined by std::[w]string and so should -// be always available) +// comparison with char inline bool operator==(const wxUniChar& c, const wxString& s) { return s.IsSameAs(c); } inline bool operator==(const wxUniCharRef& c, const wxString& s) { return s.IsSameAs(c); } inline bool operator==(char c, const wxString& s) { return s.IsSameAs(c); } @@ -2530,12 +2509,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 @@ -2550,6 +2525,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 @@ -2568,17 +2547,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 { - if ( m_offset == 0 ) - return m_str->wx_str(); // FIXME-UTF8 - else - return (const wxChar*)(m_str->begin() + m_offset); + return m_str->wx_str() + m_offset; } +#endif // !wxUSE_UNICODE inline wxString wxCStrData::AsString() const { @@ -2588,8 +2576,6 @@ inline wxString wxCStrData::AsString() const return m_str->Mid(m_offset); } -inline wxCStrData::operator wxString() const { return AsString(); } - inline wxUniChar wxCStrData::operator*() const { if ( m_str->empty() ) @@ -2603,14 +2589,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_WXSTRINGH__ +#endif // _WX_WXSTRING_H_