X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7357f981980bad5b272d1dfbf93ec494ba400c3d..941b78cc1da712afca54adb29bb6c04d6ba9b295:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index b9319c6b7a..1bf5e9d1f8 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -6,7 +6,7 @@ // Created: 29/01/98 // RCS-ID: $Id$ // Copyright: (c) 1998 Vadim Zeitlin -// Licence: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// /* @@ -18,7 +18,7 @@ #ifndef _WX_WXSTRINGH__ #define _WX_WXSTRINGH__ -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(__APPLE__) #pragma interface "string.h" #endif @@ -101,7 +101,7 @@ const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100; // ---------------------------------------------------------------------------- // global pointer to empty string -WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString; +extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString; // --------------------------------------------------------------------------- // global functions complementing standard C string library replacements for @@ -121,7 +121,15 @@ inline size_t Strlen(const char *psz) // portable strcasecmp/_stricmp inline int Stricmp(const char *psz1, const char *psz2) { -#if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) ) +#if defined(__VISUALC__) && defined(__WXWINCE__) + register char c1, c2; + do { + c1 = tolower(*psz1++); + c2 = tolower(*psz2++); + } while ( c1 && (c1 == c2) ); + + return c1 - c2; +#elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) ) return _stricmp(psz1, psz2); #elif defined(__SC__) return _stricmp(psz1, psz2); @@ -165,19 +173,8 @@ inline int Stricmp(const char *psz1, const char *psz2) #endif // OS/compiler } -// wxSnprintf() is like snprintf() if it's available and sprintf() (always -// available, but dangerous!) if not -extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len, - const wxChar *format, - ...) ATTRIBUTE_PRINTF_3; - -// and wxVsnprintf() is like vsnprintf() or vsprintf() -extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len, - const wxChar *format, - va_list argptr); - // return an empty wxString -class WXDLLEXPORT wxString; // not yet defined +class WXDLLIMPEXP_BASE wxString; // not yet defined inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; } // --------------------------------------------------------------------------- @@ -185,7 +182,7 @@ inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; // is never used directly (but had to be put here to allow inlining) // --------------------------------------------------------------------------- -struct WXDLLEXPORT wxStringData +struct WXDLLIMPEXP_BASE wxStringData { int nRefs; // reference count size_t nDataLength, // actual string length @@ -201,12 +198,19 @@ struct WXDLLEXPORT wxStringData // lock/unlock void Lock() { if ( !IsEmpty() ) nRefs++; } - // VC++ will refuse to inline this function but profiling shows that it - // is wrong + // 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 @@ -237,9 +241,11 @@ struct WXDLLEXPORT wxStringData // - regular expressions support // --------------------------------------------------------------------------- -class WXDLLEXPORT wxString +class WXDLLIMPEXP_BASE wxString { -friend class WXDLLEXPORT wxArrayString; +#if !wxUSE_STL +friend class WXDLLIMPEXP_BASE wxArrayString; +#endif // NB: special care was taken in arranging the member functions in such order // that all inline functions can be effectively inlined, verify that all @@ -269,7 +275,7 @@ private: bool AssignCopy(size_t, const wxChar *); // append a (sub)string - bool ConcatSelf(int nLen, const wxChar *src); + bool ConcatSelf(size_t nLen, const wxChar *src); // 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) @@ -325,7 +331,7 @@ public: // from multibyte string // (NB: nLength is right now number of Unicode characters, not // characters in psz! So try not to use it yet!) - wxString(const char *psz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN); + wxString(const char *psz, wxMBConv& conv, size_t nLength = wxSTRING_MAXLEN); // from wxWCharBuffer (i.e. return from wxGetString) wxString(const wxWCharBuffer& psz) { InitWith(psz, 0, wxSTRING_MAXLEN); } @@ -457,14 +463,31 @@ public: // implicit conversion to C string operator const wxChar*() const { return m_pchData; } + // explicit conversion to C string (use this with printf()!) const wxChar* c_str() const { return m_pchData; } - // identical to c_str() + // identical to c_str(), for wxWin 1.6x compatibility const wxChar* wx_str() const { return m_pchData; } - // identical to c_str() + // identical to c_str(), for MFC compatibility const wxChar* GetData() const { return m_pchData; } - // conversions with (possible) format convertions: have to return a + // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for + // converting numbers or strings which are certain not to contain special + // chars (typically system functions, X atoms, environment variables etc.) + // + // the behaviour of these functions with the strings containing anything + // else than 7 bit ASCII characters is undefined, use at your own risk. +#if wxUSE_UNICODE + static wxString FromAscii(const char *ascii); // string + static wxString FromAscii(const char ascii); // char + const wxCharBuffer ToAscii() const; +#else // ANSI + static wxString FromAscii(const char *ascii) { return wxString( ascii ); } + static wxString FromAscii(const char ascii) { return wxString( ascii ); } + const char *ToAscii() const { return c_str(); } +#endif // Unicode/!Unicode + + // conversions with (possible) format conversions: have to return a // buffer with temporary data // // the functions defined (in either Unicode or ANSI) mode are mb_str() to @@ -594,15 +617,15 @@ public: // non-destructive concatenation // - friend wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2); + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2); // - friend wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch); + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch); // - friend wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string); + friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string); // - friend wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz); + friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz); // - friend wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string); + friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string); // stream-like functions // insert an int into string @@ -797,6 +820,8 @@ public: // standard types typedef wxChar value_type; + typedef size_t size_type; + typedef value_type *iterator; typedef const value_type *const_iterator; // an 'invalid' value for string index @@ -829,7 +854,7 @@ public: // returns true if the string is empty bool empty() const { return IsEmpty(); } // inform string about planned change in size - void reserve(size_t size) { Alloc(size); } + void reserve(size_t sz) { Alloc(sz); } // lib.string.access // return the character at position n @@ -842,6 +867,11 @@ public: // position one after the last valid one const_iterator end() const { return wx_str() + length(); } + // first valid index position + iterator begin() { CopyBeforeWrite(); return m_pchData; } + // position one after the last valid one + iterator end() { CopyBeforeWrite(); return m_pchData + length(); } + // lib.string.modifiers // append a string wxString& append(const wxString& str) @@ -992,176 +1022,116 @@ public: #endif // wxSTD_STRING_COMPATIBILITY }; +// define wxArrayString, for compatibility +#if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL + #include "wx/arrstr.h" +#endif + // ---------------------------------------------------------------------------- -// The string array uses it's knowledge of internal structure of the wxString -// class to optimize string storage. Normally, we would store pointers to -// string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is -// sizeof(char *)) we store these pointers instead. The cast to "wxString *" is -// really all we need to turn such pointer into a string! -// -// Of course, it can be called a dirty hack, but we use twice less memory and -// this approach is also more speed efficient, so it's probably worth it. -// -// Usage notes: when a string is added/inserted, a new copy of it is created, -// so the original string may be safely deleted. When a string is retrieved -// from the array (operator[] or Item() method), a reference is returned. +// wxStringBuffer: a tiny class allowing to get a writable pointer into string // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxArrayString +#if wxUSE_STL + +class WXDLLIMPEXP_BASE wxStringBuffer { public: - // type of function used by wxArrayString::Sort() - typedef int (*CompareFunction)(const wxString& first, - const wxString& second); - - // constructors and destructor - // default ctor - wxArrayString() - : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE) - { Init(FALSE); } - // if autoSort is TRUE, the array is always sorted (in alphabetical order) - // - // NB: the reason for using int and not bool is that like this we can avoid - // using this ctor for implicit conversions from "const char *" (which - // we'd like to be implicitly converted to wxString instead!) - // - // of course, using explicit would be even better - if all compilers - // supported it... - wxArrayString(int autoSort) - : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE) - { Init(autoSort != 0); } - // copy ctor - wxArrayString(const wxArrayString& array); - // assignment operator - wxArrayString& operator=(const wxArrayString& src); - // not virtual, this class should not be derived from - ~wxArrayString(); - - // memory management - // empties the list, but doesn't release memory - void Empty(); - // empties the list and releases memory - void Clear(); - // preallocates memory for given number of items - void Alloc(size_t nCount); - // minimzes the memory usage (by freeing all extra memory) - void Shrink(); - - // simple accessors - // number of elements in the array - size_t GetCount() const { return m_nCount; } - // is it empty? - bool IsEmpty() const { return m_nCount == 0; } - // number of elements in the array (GetCount is preferred API) - size_t Count() const { return m_nCount; } - - // items access (range checking is done in debug version) - // get item at position uiIndex - wxString& Item(size_t nIndex) const - { - wxASSERT_MSG( nIndex < m_nCount, - _T("wxArrayString: index out of bounds") ); - - return *(wxString *)&(m_pItems[nIndex]); - } + wxStringBuffer(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(lenWanted), m_len(lenWanted) + { } - // same as Item() - wxString& operator[](size_t nIndex) const { return Item(nIndex); } - // get last item - wxString& Last() const - { - wxASSERT_MSG( !IsEmpty(), - _T("wxArrayString: index out of bounds") ); - return Item(Count() - 1); - } + ~wxStringBuffer() { m_str.assign(m_buf.data(), m_len); } - // return a wxString[], useful for the controls which - // take one in their ctor. You must delete[] it yourself - // once you are done with it. Will return NULL if the - // ArrayString was empty. - wxString* GetStringArray() const; - - // item management - // Search the element in the array, starting from the beginning if - // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case - // sensitive (default). Returns index of the first item matched or - // wxNOT_FOUND - int Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const; - // add new element at the end (if the array is not sorted), return its - // index - size_t Add(const wxString& str, size_t nInsert = 1); - // add new element at given position - void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1); - // expand the array to have count elements - void SetCount(size_t count); - // remove first item matching this value - void Remove(const wxChar *sz); - // remove item by index - void Remove(size_t nIndex, size_t nRemove = 1); - void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); } - - // sorting - // sort array elements in alphabetical order (or reversed alphabetical - // order if reverseOrder parameter is TRUE) - void Sort(bool reverseOrder = FALSE); - // sort array elements using specified comparaison function - void Sort(CompareFunction compareFunction); - - // comparison - // compare two arrays case sensitively - bool operator==(const wxArrayString& a) const; - // compare two arrays case sensitively - bool operator!=(const wxArrayString& a) const { return !(*this == a); } - -protected: - void Init(bool autoSort); // common part of all ctors - void Copy(const wxArrayString& src); // copies the contents of another array + operator wxChar*() { return m_buf.data(); } private: - void Grow(size_t nIncrement = 0); // makes array bigger if needed - void Free(); // free all the strings stored - - void DoSort(); // common part of all Sort() variants - - size_t m_nSize, // current size of the array - m_nCount; // current number of elements - - wxChar **m_pItems; // pointer to data + wxString& m_str; +#if wxUSE_UNICODE + wxWCharBuffer m_buf; +#else + wxCharBuffer m_buf; +#endif + size_t m_len; - bool m_autoSort; // if TRUE, keep the array always sorted + DECLARE_NO_COPY_CLASS(wxStringBuffer) }; -class WXDLLEXPORT wxSortedArrayString : public wxArrayString +class WXDLLIMPEXP_BASE wxStringBufferLength { public: - wxSortedArrayString() : wxArrayString(TRUE) - { } - wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE) - { Copy(array); } + wxStringBufferLength(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false) + { } + + ~wxStringBufferLength() + { + wxASSERT(m_lenSet); + m_str.assign(m_buf.data(), m_len); + } + + operator wxChar*() { return m_buf.data(); } + void SetLength(size_t length) { m_len = length; m_lenSet = true; } + +private: + wxString& m_str; +#if wxUSE_UNICODE + wxWCharBuffer m_buf; +#else + wxCharBuffer m_buf; +#endif + size_t m_len; + bool m_lenSet; + + DECLARE_NO_COPY_CLASS(wxStringBufferLength) }; -// ---------------------------------------------------------------------------- -// wxStringBuffer: a tiny class allowing to get a writable pointer into string -// ---------------------------------------------------------------------------- +#else // if !wxUSE_STL -class WXDLLEXPORT wxStringBuffer +class WXDLLIMPEXP_BASE wxStringBuffer { - DECLARE_NO_COPY_CLASS(wxStringBuffer) - public: wxStringBuffer(wxString& str, size_t lenWanted = 1024) : m_str(str), m_buf(NULL) { m_buf = m_str.GetWriteBuf(lenWanted); } - + ~wxStringBuffer() { m_str.UngetWriteBuf(); } - + operator wxChar*() const { return m_buf; } - + private: wxString& m_str; wxChar *m_buf; + + DECLARE_NO_COPY_CLASS(wxStringBuffer) }; +class WXDLLIMPEXP_BASE wxStringBufferLength +{ +public: + wxStringBufferLength(wxString& str, size_t lenWanted = 1024) + : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false) + { m_buf = m_str.GetWriteBuf(lenWanted); } + + ~wxStringBufferLength() + { + wxASSERT(m_lenSet); + m_str.UngetWriteBuf(m_len); + } + + operator wxChar*() const { return m_buf; } + void SetLength(size_t length) { m_len = length; m_lenSet = true; } + +private: + wxString& m_str; + wxChar *m_buf; + size_t m_len; + bool m_lenSet; + + DECLARE_NO_COPY_CLASS(wxStringBufferLength) +}; + +#endif // !wxUSE_STL + // --------------------------------------------------------------------------- // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- @@ -1229,11 +1199,11 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) != 0); } #endif // wxUSE_UNICODE/!wxUSE_UNICODE -wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2); -wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch); -wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string); -wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz); -wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string); +wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2); +wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch); +wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string); +wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz); +wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string); #if wxUSE_UNICODE inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) { return string + (const wchar_t *)buf; } @@ -1255,10 +1225,10 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string) #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM -#include "wx/ioswrap.h" +#include "wx/iosfwrap.h" -WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&); -WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); +WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&); +WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); #endif // wxSTD_STRING_COMPATIBILITY