X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1c2e6a28129dcb918b9bb1531b13de7a7e89a33c..d894c201132341a31790bba39a0c33d03d71aeb8:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index c3380f25ec..c9169837c7 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -18,7 +18,7 @@ #ifndef _WX_WXSTRINGH__ #define _WX_WXSTRINGH__ -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(__APPLE__) #pragma interface "string.h" #endif @@ -29,15 +29,12 @@ // compile the std::string compatibility functions if defined #define wxSTD_STRING_COMPATIBILITY -// define to derive wxString from wxObject (deprecated!) -#ifdef WXSTRING_IS_WXOBJECT - #undef WXSTRING_IS_WXOBJECT -#endif - // ---------------------------------------------------------------------------- // headers // ---------------------------------------------------------------------------- +#include "wx/defs.h" // everybody should include this + #if defined(__WXMAC__) || defined(__VISAGECPP__) #include #endif @@ -65,29 +62,24 @@ #include // for strcasecmp() #endif // HAVE_STRINGS_H -#include "wx/defs.h" // everybody should include this #include "wx/wxchar.h" // for wxChar #include "wx/buffer.h" // for wxCharBuffer #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes -#ifndef WX_PRECOMP - #ifdef WXSTRING_IS_WXOBJECT - #include "wx/object.h" // base class - #endif -#endif // !PCH - // --------------------------------------------------------------------------- // macros // --------------------------------------------------------------------------- -// 'naughty' cast +// casts [unfortunately!] needed to call some broken functions which require +// "char *" instead of "const char *" #define WXSTRINGCAST (wxChar *)(const wxChar *) #define wxCSTRINGCAST (wxChar *)(const wxChar *) #define wxMBSTRINGCAST (char *)(const char *) #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *) // implementation only -#define ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() ) +#define wxASSERT_VALID_INDEX(i) \ + wxASSERT_MSG( (size_t)(i) <= Len(), _T("invalid index in wxString") ) // ---------------------------------------------------------------------------- // constants @@ -173,15 +165,6 @@ 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, ...); - -// 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 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; } @@ -243,15 +226,8 @@ struct WXDLLEXPORT wxStringData // - regular expressions support // --------------------------------------------------------------------------- -#ifdef WXSTRING_IS_WXOBJECT -class WXDLLEXPORT wxString : public wxObject -{ - DECLARE_DYNAMIC_CLASS(wxString) -#else //WXSTRING_IS_WXOBJECT class WXDLLEXPORT wxString { -#endif //WXSTRING_IS_WXOBJECT - friend class WXDLLEXPORT wxArrayString; // NB: special care was taken in arranging the member functions in such order @@ -274,20 +250,20 @@ private: void Reinit() { GetStringData()->Unlock(); Init(); } // memory allocation - // allocates memory for string of lenght nLen - void AllocBuffer(size_t nLen); + // allocates memory for string of length nLen + bool AllocBuffer(size_t nLen); // copies data to another string - void AllocCopy(wxString&, int, int) const; + bool AllocCopy(wxString&, int, int) const; // effectively copies data to string - void AssignCopy(size_t, const wxChar *); + bool AssignCopy(size_t, const wxChar *); // append a (sub)string - void ConcatSelf(int nLen, const wxChar *src); + bool ConcatSelf(int 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) - void CopyBeforeWrite(); - void AllocBeforeWrite(size_t); + bool CopyBeforeWrite(); + bool AllocBeforeWrite(size_t); // if we hadn't made these operators private, it would be possible to // compile "wxString s; s = 17;" without any warnings as 17 is implicitly @@ -307,11 +283,12 @@ private: public: // constructors and destructor // ctor for an empty string - wxString() { Init(); } + wxString() : m_pchData(NULL) { Init(); } // copy ctor - wxString(const wxString& stringSrc) + wxString(const wxString& stringSrc) : m_pchData(NULL) { - wxASSERT( stringSrc.GetStringData()->IsValid() ); + wxASSERT_MSG( stringSrc.GetStringData()->IsValid(), + _T("did you forget to call UngetWriteBuf()?") ); if ( stringSrc.IsEmpty() ) { // nothing to do for an empty string @@ -327,22 +304,25 @@ public: // ctor takes first nLength characters from C string // (default value of wxSTRING_MAXLEN means take all the string) wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN) - { InitWith(psz, 0, nLength); } + : m_pchData(NULL) + { InitWith(psz, 0, nLength); } wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN) - { InitWith(psz, 0, nLength); } + : m_pchData(NULL) + { InitWith(psz, 0, nLength); } #if wxUSE_UNICODE // 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); } #else // ANSI // from C string (for compilers using unsigned char) wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN) - { InitWith((const char*)psz, 0, nLength); } + : m_pchData(NULL) + { InitWith((const char*)psz, 0, nLength); } #if wxUSE_WCHAR_T // from wide (Unicode) string @@ -351,7 +331,8 @@ public: // from wxCharBuffer wxString(const wxCharBuffer& psz) - { InitWith(psz, 0, wxSTRING_MAXLEN); } + : m_pchData(NULL) + { InitWith(psz, 0, wxSTRING_MAXLEN); } #endif // Unicode/ANSI // dtor is not virtual, this class must not be inherited from! @@ -379,8 +360,9 @@ public: if ( !GetStringData()->IsEmpty() ) Reinit(); - wxASSERT( GetStringData()->nDataLength == 0 ); // should be empty - wxASSERT( GetStringData()->nAllocLength == 0 ); // and not own any memory + wxASSERT_MSG( !GetStringData()->nDataLength && + !GetStringData()->nAllocLength, + _T("string should be empty after Clear()") ); } // contents test @@ -394,20 +376,29 @@ public: // data access (all indexes are 0 based) // read access wxChar GetChar(size_t n) const - { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } // read/write access wxChar& GetWritableChar(size_t n) - { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } // write access void SetChar(size_t n, wxChar ch) - { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; } + { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; } // get last character wxChar Last() const - { wxASSERT( !IsEmpty() ); return m_pchData[Len() - 1]; } + { + wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") ); + + return m_pchData[Len() - 1]; + } + // get writable last character wxChar& Last() - { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; } + { + wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") ); + CopyBeforeWrite(); + return m_pchData[Len()-1]; + } /* So why do we have all these overloaded operator[]s? A bit of history: @@ -433,36 +424,53 @@ public: // operator version of GetChar wxChar operator[](size_t n) const - { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } // operator version of GetChar wxChar operator[](int n) const - { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } // operator version of GetWriteableChar wxChar& operator[](size_t n) - { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } #ifndef wxSIZE_T_IS_UINT // operator version of GetChar wxChar operator[](unsigned int n) const - { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; } // operator version of GetWriteableChar wxChar& operator[](unsigned int n) - { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } + { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } #endif // size_t != unsigned int // 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 @@ -512,7 +520,8 @@ public: wxString& operator=(const wxChar *psz); #if wxUSE_UNICODE // from wxWCharBuffer - wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); } + wxString& operator=(const wxWCharBuffer& psz) + { (void) operator=((const wchar_t *)psz); return *this; } #else // ANSI // from another kind of C string wxString& operator=(const unsigned char* psz); @@ -521,7 +530,8 @@ public: wxString& operator=(const wchar_t *pwz); #endif // from wxCharBuffer - wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); } + wxString& operator=(const wxCharBuffer& psz) + { (void) operator=((const char *)psz); return *this; } #endif // Unicode/ANSI // string concatenation @@ -534,7 +544,8 @@ public: // string += string wxString& operator<<(const wxString& s) { - wxASSERT( s.GetStringData()->IsValid() ); + wxASSERT_MSG( s.GetStringData()->IsValid(), + _T("did you forget to call UngetWriteBuf()?") ); ConcatSelf(s.Len(), s); return *this; @@ -554,14 +565,27 @@ public: // string += buffer (i.e. from wxGetString) #if wxUSE_UNICODE - wxString& operator<<(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); return *this; } - void operator+=(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); } -#else - wxString& operator<<(const wxCharBuffer& s) { (void)operator<<((const char *)s); return *this; } - void operator+=(const wxCharBuffer& s) { (void)operator<<((const char *)s); } -#endif + wxString& operator<<(const wxWCharBuffer& s) + { (void)operator<<((const wchar_t *)s); return *this; } + void operator+=(const wxWCharBuffer& s) + { (void)operator<<((const wchar_t *)s); } +#else // !wxUSE_UNICODE + wxString& operator<<(const wxCharBuffer& s) + { (void)operator<<((const char *)s); return *this; } + void operator+=(const wxCharBuffer& s) + { (void)operator<<((const char *)s); } +#endif // wxUSE_UNICODE/!wxUSE_UNICODE // string += C string + wxString& Append(const wxString& s) + { + // test for IsEmpty() to share the string if possible + if ( IsEmpty() ) + *this = s; + else + ConcatSelf(s.Length(), s.c_str()); + return *this; + } wxString& Append(const wxChar* psz) { ConcatSelf(wxStrlen(psz), psz); return *this; } // append count copies of given character @@ -688,33 +712,37 @@ public: // check if the string contents matches a mask containing '*' and '?' bool Matches(const wxChar *szMask) 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 provided + // 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 + // provided, the base is the numeric base in which the conversion should be + // done and must be comprised between 2 and 36 or be 0 in which case the + // standard C rules apply (leading '0' => octal, "0x" => hex) // convert to a signed integer - bool ToLong(long *val, int base = 0) const; + bool ToLong(long *val, int base = 10) const; // convert to an unsigned integer - bool ToULong(unsigned long *val, int base = 0) const; + bool ToULong(unsigned long *val, int base = 10) const; // convert to a double bool ToDouble(double *val) const; // formated input/output // as sprintf(), returns the number of characters written or < 0 on error - int Printf(const wxChar *pszFormat, ...); + // (take 'this' into account in attribute parameter count) + int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; // as vprintf(), returns the number of characters written or < 0 on error int PrintfV(const wxChar* pszFormat, va_list argptr); // returns the string containing the result of Printf() to it - static wxString Format(const wxChar *pszFormat, ...); + static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1; // the same as above, but takes a va_list static wxString FormatV(const wxChar *pszFormat, va_list argptr); // raw access to string memory // ensure that string has space for at least nLen characters // only works if the data of this string is not shared - void Alloc(size_t nLen); + bool Alloc(size_t nLen); // minimize the string's memory // only works if the data of this string is not shared - void Shrink(); + bool Shrink(); // get writable buffer of at least nLen bytes. Unget() *must* be called // a.s.a.p. to put string back in a reasonable state! wxChar *GetWriteBuf(size_t nLen); @@ -732,8 +760,9 @@ public: // values for first parameter of Strip function enum stripType {leading = 0x1, trailing = 0x2, both = 0x3}; - // use Printf() - int sprintf(const wxChar *pszFormat, ...); + // use Printf() + // (take 'this' into account in attribute parameter count) + int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2; // use Cmp() inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const @@ -782,8 +811,11 @@ public: // constructors // take nLen chars starting at nPos wxString(const wxString& str, size_t nPos, size_t nLen) + : m_pchData(NULL) { - wxASSERT( str.GetStringData()->IsValid() ); + wxASSERT_MSG( str.GetStringData()->IsValid(), + _T("did you forget to call UngetWriteBuf()?") ); + InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen); } // take all characters from pStart to pEnd @@ -803,7 +835,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 @@ -990,7 +1022,9 @@ public: // constructors and destructor // default ctor - wxArrayString() { Init(FALSE); } + 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 @@ -999,7 +1033,9 @@ public: // // of course, using explicit would be even better - if all compilers // supported it... - wxArrayString(int autoSort) { Init(autoSort != 0); } + 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 @@ -1028,11 +1064,22 @@ public: // items access (range checking is done in debug version) // get item at position uiIndex wxString& Item(size_t nIndex) const - { wxASSERT( nIndex < m_nCount ); return *(wxString *)&(m_pItems[nIndex]); } + { + wxASSERT_MSG( nIndex < m_nCount, + _T("wxArrayString: index out of bounds") ); + + return *(wxString *)&(m_pItems[nIndex]); + } + // same as Item() wxString& operator[](size_t nIndex) const { return Item(nIndex); } // get last item - wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); } + wxString& Last() const + { + wxASSERT_MSG( !IsEmpty(), + _T("wxArrayString: index out of bounds") ); + return Item(Count() - 1); + } // return a wxString[], useful for the controls which // take one in their ctor. You must delete[] it yourself @@ -1048,16 +1095,16 @@ public: 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 Add(const wxString& str, size_t nInsert = 1); // add new element at given position - void Insert(const wxString& str, size_t uiIndex); + 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); - void RemoveAt(size_t nIndex) { Remove(nIndex); } + 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 @@ -1077,7 +1124,7 @@ protected: void Copy(const wxArrayString& src); // copies the contents of another array private: - void Grow(); // makes array bigger if needed + 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 @@ -1107,7 +1154,8 @@ class WXDLLEXPORT wxStringBuffer { public: wxStringBuffer(wxString& str, size_t lenWanted = 1024) - : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); } + : m_str(str), m_buf(NULL) + { m_buf = m_str.GetWriteBuf(lenWanted); } ~wxStringBuffer() { m_str.UngetWriteBuf(); } @@ -1116,6 +1164,8 @@ public: private: wxString& m_str; wxChar *m_buf; + + DECLARE_NO_COPY_CLASS(wxStringBuffer) }; // --------------------------------------------------------------------------- @@ -1207,11 +1257,11 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string) // --------------------------------------------------------------------------- // don't pollute the library user's name space -#undef ASSERT_VALID_INDEX +#undef wxASSERT_VALID_INDEX #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&);