X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7c74e7fe1de14f32dcd6f3c9cdd727de540bbd0e..b71e94da10e5f6db42ad10182655450b11ebda2f:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 7cd776c85f..b4a6fa1df7 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 @@ -29,16 +29,13 @@ // 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 // ---------------------------------------------------------------------------- -#ifdef __WXMAC__ +#include "wx/defs.h" // everybody should include this + +#if defined(__WXMAC__) || defined(__VISAGECPP__) #include #endif @@ -46,49 +43,59 @@ #include #endif -#include -#include -#include -#include -#include +#if defined(__VISAGECPP__) && __IBMCPP__ >= 400 + // problem in VACPP V4 with including stdlib.h multiple times + // strconv includes it anyway +# include +# include +# include +# include +#else +# include +# include +# include +# include +# include +#endif #ifdef HAVE_STRINGS_H #include // for strcasecmp() -#endif // AIX +#endif // HAVE_STRINGS_H -#include "wx/defs.h" // everybody should include this -#include "wx/debug.h" // for wxASSERT() #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 // ---------------------------------------------------------------------------- +#if defined(__VISAGECPP__) && __IBMCPP__ >= 400 +// must define this static for VA or else you get multiply defined symbols everywhere +extern const unsigned int wxSTRING_MAXLEN; + +#else // maximum possible length for a string means "take all string" everywhere // (as sizeof(StringData) is unknown here, we substract 100) const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100; +#endif + // ---------------------------------------------------------------------------- // global data // ---------------------------------------------------------------------------- @@ -105,14 +112,14 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString; // backwards compatibility only. // checks whether the passed in pointer is NULL and if the string is empty -inline bool WXDLLEXPORT IsEmpty(const char *p) { return (!p || !*p); } +inline bool IsEmpty(const char *p) { return (!p || !*p); } // safe version of strlen() (returns 0 if passed NULL pointer) -inline size_t WXDLLEXPORT Strlen(const char *psz) +inline size_t Strlen(const char *psz) { return psz ? strlen(psz) : 0; } // portable strcasecmp/_stricmp -inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2) +inline int Stricmp(const char *psz1, const char *psz2) { #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) ) return _stricmp(psz1, psz2); @@ -124,6 +131,8 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2) return stricmp(psz1, psz2); #elif defined(__WATCOMC__) return stricmp(psz1, psz2); +#elif defined(__DJGPP__) + return stricmp(psz1, psz2); #elif defined(__EMX__) return stricmp(psz1, psz2); #elif defined(__WXPM__) @@ -180,6 +189,12 @@ struct WXDLLEXPORT wxStringData // lock/unlock void Lock() { if ( !IsEmpty() ) nRefs++; } + + // VC++ will refuse to inline this function but profiling shows that it + // is wrong +#if defined(__VISUALC__) && (__VISUALC__ >= 1200) + __forceinline +#endif void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); } // if we had taken control over string memory (GetWriteBuf), it's @@ -211,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 @@ -242,36 +250,45 @@ 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(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) - void CopyBeforeWrite(); - void AllocBeforeWrite(size_t); + bool CopyBeforeWrite(); + bool AllocBeforeWrite(size_t); - // this method is not implemented - there is _no_ conversion from int to + // 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 + // converted to char in C and we do have operator=(char) + // + // NB: we don't need other versions (short/long and unsigned) as attempt + // to assign another numeric type to wxString will now result in + // ambiguity between operator=(char) and operator=(int) + wxString& operator=(int); + + // these methods are not implemented - there is _no_ conversion from int to // string, you're doing something wrong if the compiler wants to call it! // // try `s << i' or `s.Printf("%d", i)' instead wxString(int); - wxString(long); 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 @@ -287,32 +304,35 @@ 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) + : 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); } - // from multibyte string - wxString(const char *psz, wxMBConv& WXUNUSED(conv) , size_t nLength = wxSTRING_MAXLEN) - { InitWith(psz, 0, nLength); } + : m_pchData(NULL) + { InitWith((const char*)psz, 0, nLength); } #if wxUSE_WCHAR_T // from wide (Unicode) string - wxString(const wchar_t *pwz); + wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN); #endif // !wxUSE_WCHAR_T // 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! @@ -325,14 +345,14 @@ public: bool IsEmpty() const { return Len() == 0; } // empty string is "FALSE", so !str will return TRUE bool operator!() const { return IsEmpty(); } + // truncate the string to given length + wxString& Truncate(size_t uiLen); // empty string contents void Empty() { - if ( !IsEmpty() ) - Reinit(); + Truncate(0); - // should be empty - wxASSERT( GetStringData()->nDataLength == 0 ); + wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") ); } // empty the string and free memory void Clear() @@ -340,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 @@ -355,59 +376,119 @@ 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: + initially there was only one of them, taking size_t. Then people + started complaining because they wanted to use ints as indices (I + wonder why) and compilers were giving warnings about it, so we had to + add the operator[](int). Then it became apparent that you couldn't + write str[0] any longer because there was ambiguity between two + overloads and so you now had to write str[0u] (or, of course, use the + explicit casts to either int or size_t but nobody did this). + + Finally, someone decided to compile wxWin on an Alpha machine and got + a surprize: str[0u] didn't compile there because it is of type + unsigned int and size_t is unsigned _long_ on Alpha and so there was + ambiguity between converting uint to int or ulong. To fix this one we + now add operator[](uint) for the machines where size_t is not already + the same as unsigned int - hopefully this fixes the problem (for some + time) + + The only real fix is, of course, to remove all versions but the one + taking size_t... + */ // 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]; } -#ifdef __alpha__ - // operator version of GetChar - wxChar operator[](unsigned int n) const - { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } -#endif - + { 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]; } -#ifdef __alpha__ + { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } + +#ifndef wxSIZE_T_IS_UINT + // operator version of GetChar + wxChar operator[](unsigned int n) const + { 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]; } -#endif + wxChar& operator[](unsigned int 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; } - // (and this with [wx]Printf()!) + // 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 + // return an ANSI (multibyte) string, wc_str() to return a wide string and + // fn_str() to return a string which should be used with the OS APIs + // accepting the file names. The return value is always the same, but the + // type differs because a function may either return pointer to the buffer + // directly or have to use intermediate buffer for translation. #if wxUSE_UNICODE - const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const { return conv.cWC2MB(m_pchData); } + const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const + { return conv.cWC2MB(m_pchData); } + const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } - const wxChar* wc_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const { return m_pchData; } + const wxChar* wc_str() const { return m_pchData; } + + // for compatibility with !wxUSE_UNICODE version + const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; } #if wxMBFILES const wxCharBuffer fn_str() const { return mb_str(wxConvFile); } @@ -415,17 +496,18 @@ public: const wxChar* fn_str() const { return m_pchData; } #endif // wxMBFILES/!wxMBFILES #else // ANSI -#if wxUSE_MULTIBYTE - const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const - { return m_pchData; } - const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } -#else // !mmultibyte const wxChar* mb_str() const { return m_pchData; } + + // for compatibility with wxUSE_UNICODE version + const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; } + const wxWX2MBbuf mbc_str() const { return mb_str(); } -#endif // multibyte/!multibyte + #if wxUSE_WCHAR_T - const wxWCharBuffer wc_str(wxMBConv& conv) const { return conv.cMB2WC(m_pchData); } + const wxWCharBuffer wc_str(wxMBConv& conv) const + { return conv.cMB2WC(m_pchData); } #endif // wxUSE_WCHAR_T + const wxChar* fn_str() const { return m_pchData; } #endif // Unicode/ANSI @@ -438,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); @@ -447,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 @@ -460,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; @@ -480,19 +565,34 @@ 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 wxString& Append(wxChar ch, size_t count = 1u) { wxString str(ch, count); return *this << str; } + wxString& Append(const wxChar* psz, size_t nLen) + { ConcatSelf(nLen, psz); return *this; } // prepend a string, return the string itself wxString& Prepend(const wxString& str) @@ -512,11 +612,23 @@ public: // stream-like functions // insert an int into string - wxString& operator<<(int i); + wxString& operator<<(int i) + { return (*this) << Format(_T("%d"), i); } + // insert an unsigned int into string + wxString& operator<<(unsigned int ui) + { return (*this) << Format(_T("%u"), ui); } + // insert a long into string + wxString& operator<<(long l) + { return (*this) << Format(_T("%ld"), l); } + // insert an unsigned long into string + wxString& operator<<(unsigned long ul) + { return (*this) << Format(_T("%lu"), ul); } // insert a float into string - wxString& operator<<(float f); + wxString& operator<<(float f) + { return (*this) << Format(_T("%f"), f); } // insert a double into string - wxString& operator<<(double d); + wxString& operator<<(double d) + { return (*this) << Format(_T("%g"), d); } // string comparison // case-sensitive comparison (returns a value < 0, = 0 or > 0) @@ -539,15 +651,20 @@ public: // if nCount = default value) wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const; - // operator version of Mid() + // operator version of Mid() wxString operator()(size_t start, size_t len) const { return Mid(start, len); } + // check that the string starts with prefix and return the rest of the + // string in the provided pointer if it is not NULL, otherwise return + // FALSE + bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const; + // get first nCount characters wxString Left(size_t nCount) const; // get last nCount characters wxString Right(size_t nCount) const; - // get all characters before the first occurence of ch + // get all characters before the first occurance of ch // (returns the whole string if ch not found) wxString BeforeFirst(wxChar ch) const; // get all characters before the last occurence of ch @@ -580,8 +697,6 @@ public: wxString& Trim(bool bFromRight = TRUE); // add nCount copies chPad in the beginning or at the end (default) wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE); - // truncate string to given length - wxString& Truncate(size_t uiLen); // searching and replacing // searching (return starting index, or -1 if not found) @@ -597,24 +712,43 @@ 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, 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 = 10) const; + // convert to an unsigned integer + 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, ...) 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); // call this immediately after GetWriteBuf() has been used void UngetWriteBuf(); + void UngetWriteBuf(size_t nLen); // wxWindows version 1 compatibility functions @@ -626,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 @@ -649,7 +784,7 @@ public: size_t Index(wxChar ch) const { return Find(ch); } // use Truncate wxString& Remove(size_t pos) { return Truncate(pos); } - wxString& RemoveLast() { return Truncate(Len() - 1); } + wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); } wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); } @@ -668,6 +803,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 @@ -676,8 +813,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 @@ -696,6 +836,8 @@ public: void clear() { Empty(); } // returns true if the string is empty bool empty() const { return IsEmpty(); } + // inform string about planned change in size + void reserve(size_t sz) { Alloc(sz); } // lib.string.access // return the character at position n @@ -708,6 +850,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) @@ -723,16 +870,17 @@ public: wxString& append(size_t n, wxChar ch) { return Pad(n, ch); } // same as `this_string = str' - wxString& assign(const wxString& str) { return (*this) = str; } + wxString& assign(const wxString& str) + { return *this = str; } // same as ` = str[pos..pos + n] wxString& assign(const wxString& str, size_t pos, size_t n) - { return *this = wxString((const wxChar *)str + pos, n); } + { Empty(); return Append(str.c_str() + pos, n); } // same as `= first n (or all if n == npos) characters of sz' wxString& assign(const wxChar *sz, size_t n = npos) - { return *this = wxString(sz, n); } + { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); } // same as `= n copies of ch' wxString& assign(size_t n, wxChar ch) - { return *this = wxString(ch, n); } + { Empty(); return Append(ch, n); } // insert another string wxString& insert(size_t nPos, const wxString& str); @@ -758,8 +906,8 @@ public: wxString& replace(size_t nStart, size_t nLen, const wxString& str, size_t nStart2, size_t nLen2); // replaces the substring with first nCount chars of sz - wxString& replace(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount); + wxString& replace(size_t nStart, size_t nLen, + const wxChar* sz, size_t nCount); // swap two strings void swap(wxString& str); @@ -775,7 +923,7 @@ public: #if !defined(__VISUALC__) || defined(__WIN32__) // find first n characters of sz size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const; -#endif +#endif // VC++ 1.5 // Gives a duplicate symbol (presumably a case-insensitivity problem) #if !defined(__BORLANDC__) @@ -794,7 +942,7 @@ public: size_t n = npos) const; // as find, but from the end size_t rfind(wxChar ch, size_t nStart = npos) const; -#endif +#endif // VC++ 1.5 // find first/last occurence of any character in the set @@ -825,7 +973,8 @@ public: // same as above size_t find_first_not_of(wxChar ch, size_t nStart = 0) const; // as strcspn() - size_t find_last_not_of(const wxString& str, size_t nStart=npos) const; + size_t find_last_not_of(const wxString& str, size_t nStart = npos) const + { return find_first_not_of(str.c_str(), nStart); } // same as above size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const; // same as above @@ -837,18 +986,22 @@ public: // just like strcmp() int compare(const wxString& str) const { return Cmp(str); } // comparison with a substring - int compare(size_t nStart, size_t nLen, const wxString& str) const; + int compare(size_t nStart, size_t nLen, const wxString& str) const + { return Mid(nStart, nLen).Cmp(str); } // comparison of 2 substrings int compare(size_t nStart, size_t nLen, - const wxString& str, size_t nStart2, size_t nLen2) const; + const wxString& str, size_t nStart2, size_t nLen2) const + { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); } // just like strcmp() int compare(const wxChar* sz) const { return Cmp(sz); } // substring comparison with first nCount characters of sz int compare(size_t nStart, size_t nLen, - const wxChar* sz, size_t nCount = npos) const; + const wxChar* sz, size_t nCount = npos) const + { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); } // substring extraction - wxString substr(size_t nStart = 0, size_t nLen = npos) const; + wxString substr(size_t nStart = 0, size_t nLen = npos) const + { return Mid(nStart, nLen); } #endif // wxSTD_STRING_COMPATIBILITY }; @@ -875,9 +1028,21 @@ public: const wxString& second); // constructors and destructor - // default ctor: if autoSort is TRUE, the array is always sorted (in - // alphabetical order) - wxArrayString(bool autoSort = FALSE); + // 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 @@ -906,11 +1071,28 @@ 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 + // 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 @@ -920,13 +1102,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 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 @@ -935,11 +1120,18 @@ public: // 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 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 @@ -961,46 +1153,68 @@ public: { Copy(array); } }; +// ---------------------------------------------------------------------------- +// wxStringBuffer: a tiny class allowing to get a writable pointer into string +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT 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) +}; + // --------------------------------------------------------------------------- // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- -// -inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); } -// -inline bool operator==(const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) == 0); } -// -inline bool operator==(const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) == 0); } -// -inline bool operator!=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) != 0); } -// -inline bool operator!=(const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) != 0); } -// -inline bool operator!=(const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) != 0); } -// -inline bool operator< (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) < 0); } -// -inline bool operator< (const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) < 0); } -// -inline bool operator< (const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) > 0); } -// -inline bool operator> (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) > 0); } -// -inline bool operator> (const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) > 0); } -// -inline bool operator> (const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) < 0); } -// -inline bool operator<=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) <= 0); } -// -inline bool operator<=(const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) <= 0); } -// -inline bool operator<=(const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) >= 0); } -// -inline bool operator>=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) >= 0); } -// -inline bool operator>=(const wxString& s1, const wxChar * s2) { return (s1.Cmp(s2) >= 0); } -// -inline bool operator>=(const wxChar * s1, const wxString& s2) { return (s2.Cmp(s1) <= 0); } +inline bool operator==(const wxString& s1, const wxString& s2) + { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); } +inline bool operator==(const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) == 0; } +inline bool operator==(const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) == 0; } +inline bool operator!=(const wxString& s1, const wxString& s2) + { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); } +inline bool operator!=(const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) != 0; } +inline bool operator!=(const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) != 0; } +inline bool operator< (const wxString& s1, const wxString& s2) + { return s1.Cmp(s2) < 0; } +inline bool operator< (const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) < 0; } +inline bool operator< (const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) > 0; } +inline bool operator> (const wxString& s1, const wxString& s2) + { return s1.Cmp(s2) > 0; } +inline bool operator> (const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) > 0; } +inline bool operator> (const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) < 0; } +inline bool operator<=(const wxString& s1, const wxString& s2) + { return s1.Cmp(s2) <= 0; } +inline bool operator<=(const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) <= 0; } +inline bool operator<=(const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) >= 0; } +inline bool operator>=(const wxString& s1, const wxString& s2) + { return s1.Cmp(s2) >= 0; } +inline bool operator>=(const wxString& s1, const wxChar * s2) + { return s1.Cmp(s2) >= 0; } +inline bool operator>=(const wxChar * s1, const wxString& s2) + { return s2.Cmp(s1) <= 0; } // comparison with char inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); } @@ -1013,12 +1227,20 @@ inline bool operator==(const wxString& s1, const wxWCharBuffer& s2) { return (s1.Cmp((const wchar_t *)s2) == 0); } inline bool operator==(const wxWCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const wchar_t *)s1) == 0); } -#else +inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2) + { return (s1.Cmp((const wchar_t *)s2) != 0); } +inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2) + { return (s2.Cmp((const wchar_t *)s1) != 0); } +#else // !wxUSE_UNICODE inline bool operator==(const wxString& s1, const wxCharBuffer& s2) { return (s1.Cmp((const char *)s2) == 0); } inline bool operator==(const wxCharBuffer& s1, const wxString& s2) { return (s2.Cmp((const char *)s1) == 0); } -#endif +inline bool operator!=(const wxString& s1, const wxCharBuffer& s2) + { return (s1.Cmp((const char *)s2) != 0); } +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); @@ -1026,30 +1248,30 @@ 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); #if wxUSE_UNICODE -inline wxString WXDLLEXPORT operator+(const wxString& string, const wxWCharBuffer& buf) +inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) { return string + (const wchar_t *)buf; } -inline wxString WXDLLEXPORT operator+(const wxWCharBuffer& buf, const wxString& string) +inline wxString operator+(const wxWCharBuffer& buf, const wxString& string) { return (const wchar_t *)buf + string; } -#else -inline wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer& buf) +#else // !wxUSE_UNICODE +inline wxString operator+(const wxString& string, const wxCharBuffer& buf) { return string + (const char *)buf; } -inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& string) +inline wxString operator+(const wxCharBuffer& buf, const wxString& string) { return (const char *)buf + string; } -#endif +#endif // wxUSE_UNICODE/!wxUSE_UNICODE // --------------------------------------------------------------------------- // Implementation only from here until the end of file // --------------------------------------------------------------------------- // 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 istream& operator>>(istream&, wxString&); -WXDLLEXPORT ostream& operator<<(ostream&, const wxString&); +WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&); +WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); #endif // wxSTD_STRING_COMPATIBILITY