X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/028a2b5d539dfccfadb4a4ffd829f1214b7d884a..80a58c9968cc740b50fb92cd95d6a014a1c6e9bf:/include/wx/string.h?ds=sidebyside diff --git a/include/wx/string.h b/include/wx/string.h index 903bfcb311..1b0c138ea9 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -9,74 +9,116 @@ // Licence: wxWindows license /////////////////////////////////////////////////////////////////////////////// +/* + Efficient string class [more or less] compatible with MFC CString, + wxWindows version 1 wxString and std::string and some handy functions + missing from string.h. +*/ + #ifndef _WX_WXSTRINGH__ #define _WX_WXSTRINGH__ #ifdef __GNUG__ -#pragma interface "string.h" + #pragma interface "string.h" #endif -#ifdef __WXMAC__ +// ---------------------------------------------------------------------------- +// conditinal compilation +// ---------------------------------------------------------------------------- + +// 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 +// ---------------------------------------------------------------------------- + +#if defined(__WXMAC__) || defined(__VISAGECPP__) #include #endif -#include -#include -#include -#include -#include +#ifdef __EMX__ + #include +#endif + +#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 -#ifndef WX_PRECOMP - #include "wx/defs.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" + #include "wx/object.h" // base class #endif #endif // !PCH -#include "wx/debug.h" -#include "wx/wxchar.h" -#include "wx/buffer.h" - -/* - Efficient string class [more or less] compatible with MFC CString, - wxWindows version 1 wxString and std::string and some handy functions - missing from string.h. -*/ - // --------------------------------------------------------------------------- // macros // --------------------------------------------------------------------------- -// compile the std::string compatibility functions if defined -#define wxSTD_STRING_COMPATIBILITY +// 'naughty' cast +#define WXSTRINGCAST (wxChar *)(const wxChar *) +#define wxCSTRINGCAST (wxChar *)(const wxChar *) +#define wxMBSTRINGCAST (char *)(const char *) +#define wxWCSTRINGCAST (wchar_t *)(const wchar_t *) -// define to derive wxString from wxObject -#ifdef WXSTRING_IS_WXOBJECT -#undef WXSTRING_IS_WXOBJECT -#endif +// implementation only +#define ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() ) +// ---------------------------------------------------------------------------- +// 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) +// (as sizeof(StringData) is unknown here, we substract 100) const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100; -// 'naughty' cast -#define WXSTRINGCAST (wxChar *)(const wxChar *) -#define MBSTRINGCAST (char *)(const char *) -#define WCSTRINGCAST (wchar_t *)(const wchar_t *) +#endif -// implementation only -#define ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() ) +// ---------------------------------------------------------------------------- +// global data +// ---------------------------------------------------------------------------- + +// global pointer to empty string +WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString; // --------------------------------------------------------------------------- -// Global functions complementing standard C string library replacements for +// global functions complementing standard C string library replacements for // strlen() and portable strcasecmp() //--------------------------------------------------------------------------- -// USE wx* FUNCTIONS IN wx/wxchar.h INSTEAD - THIS IS ONLY FOR BINARY COMPATIBILITY + +// Use wxXXX() functions from wxchar.h instead! These functions are for +// 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); } @@ -88,17 +130,21 @@ inline size_t WXDLLEXPORT Strlen(const char *psz) // portable strcasecmp/_stricmp inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2) { -#if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) ) +#if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) ) return _stricmp(psz1, psz2); -#elif defined(__SC__) +#elif defined(__SC__) return _stricmp(psz1, psz2); -#elif defined(__SALFORDC__) +#elif defined(__SALFORDC__) return stricmp(psz1, psz2); #elif defined(__BORLANDC__) return stricmp(psz1, psz2); #elif defined(__WATCOMC__) return stricmp(psz1, psz2); -#elif defined(__UNIX__) || defined(__GNUWIN32__) +#elif defined(__EMX__) + return stricmp(psz1, psz2); +#elif defined(__WXPM__) + return stricmp(psz1, psz2); +#elif defined(__UNIX__) || defined(__GNUWIN32__) return strcasecmp(psz1, psz2); #elif defined(__MWERKS__) && !defined(__INTEL__) register char c1, c2; @@ -126,23 +172,24 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2) #endif // OS/compiler } -// ---------------------------------------------------------------------------- -// global data -// ---------------------------------------------------------------------------- - -WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString; +// 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, ...); -// global pointer to empty string -WXDLLEXPORT_DATA(extern const wxChar*) g_szNul; +// 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 *)&g_szNul; } +inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; } // --------------------------------------------------------------------------- // 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 WXDLLEXPORT wxStringData { int nRefs; // reference count @@ -166,90 +213,6 @@ struct WXDLLEXPORT wxStringData bool IsValid() const { return (nRefs != 0); } }; -// --------------------------------------------------------------------------- -// types of multibyte<->Unicode conversions -// --------------------------------------------------------------------------- -class WXDLLEXPORT wxMBConv -{ - public: - virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; - virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; - const wxWCharBuffer cMB2WC(const char *psz) const - { - size_t nLen = MB2WC((wchar_t *) NULL, psz, 0); - wxWCharBuffer buf(nLen); - MB2WC(WCSTRINGCAST buf, psz, nLen); - return buf; - } - const wxCharBuffer cWC2MB(const wchar_t *psz) const - { - size_t nLen = WC2MB((char *) NULL, psz, 0); - wxCharBuffer buf(nLen); - WC2MB(MBSTRINGCAST buf, psz, nLen); - return buf; - } -#if wxUSE_UNICODE - const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); } - const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); } - const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; } - const wchar_t* cMB2WC(const wchar_t *psz) const { return psz; } -#else - const char* cMB2WX(const char *psz) const { return psz; } - const char* cWX2MB(const char *psz) const { return psz; } - const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); } - const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); } -#endif -}; -WXDLLEXPORT_DATA(extern wxMBConv) wxConv_libc; - -#define wxANOTHER_MBCONV(type) \ -class type : public wxMBConv { \ - public: \ - virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; \ - virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; \ -} - -WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConv_file)) wxConv_file; -WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConv_UTF7)) wxConv_UTF7; -WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConv_UTF8)) wxConv_UTF8; -#if defined(__WXGTK__) && (GTK_MINOR_VERSION > 0) - WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConv_gdk)) wxConv_gdk; -#endif // GTK > 1.0 - -class wxCharacterSet; -class WXDLLEXPORT wxCSConv : public wxMBConv -{ - private: - wxChar *m_name; - wxCharacterSet *m_cset; - bool m_deferred; - public: - wxCSConv(const wxChar *charset); - virtual ~wxCSConv(); - void LoadNow(); - virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; - virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; -}; - -WXDLLEXPORT_DATA(extern wxCSConv) wxConv_local; - -WXDLLEXPORT_DATA(extern wxMBConv *) wxConv_current; - -// filenames are multibyte on Unix and probably widechar on Windows? -#ifdef __UNIX__ -#define wxMBFILES 1 -#else -#define wxMBFILES 0 -#endif - -#if wxMBFILES -#define wxFNCONV(name) wxConv_file.cWX2MB(name) -#define FNSTRINGCAST MBSTRINGCAST -#else -#define wxFNCONV(name) name -#define FNSTRINGCAST WXSTRINGCAST -#endif - // --------------------------------------------------------------------------- // This is (yet another one) String class for C++ programmers. It doesn't use // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...) @@ -297,7 +260,7 @@ private: // string (re)initialization functions // initializes the string to the empty value (must be called only from // ctors, use Reinit() otherwise) - void Init() { m_pchData = (wxChar *)g_szNul; } + void Init() { m_pchData = (wxChar *)wxEmptyString; } // initializaes the string with (a part of) C-string void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = wxSTRING_MAXLEN); // as Init, but also frees old data @@ -324,7 +287,9 @@ private: // // try `s << i' or `s.Printf("%d", i)' instead wxString(int); + wxString(unsigned int); wxString(long); + wxString(unsigned long); public: // constructors and destructor @@ -350,27 +315,33 @@ public: // (default value of wxSTRING_MAXLEN means take all the string) wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN) { 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 = wxConv_libc, size_t nLength = wxSTRING_MAXLEN); + wxString(const char *psz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN); // from wxWCharBuffer (i.e. return from wxGetString) wxString(const wxWCharBuffer& psz) { InitWith(psz, 0, wxSTRING_MAXLEN); } -#else +#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) + wxString(const char *psz, wxMBConv& WXUNUSED(conv) , size_t nLength = wxSTRING_MAXLEN) { InitWith(psz, 0, nLength); } + +#if wxUSE_WCHAR_T // from wide (Unicode) string wxString(const wchar_t *pwz); +#endif // !wxUSE_WCHAR_T + // from wxCharBuffer wxString(const wxCharBuffer& psz) { InitWith(psz, 0, wxSTRING_MAXLEN); } -#endif +#endif // Unicode/ANSI + // dtor is not virtual, this class must not be inherited from! ~wxString() { GetStringData()->Unlock(); } @@ -426,43 +397,64 @@ public: wxChar& Last() { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; } - // under Unix it is tested with configure, assume it works on other - // platforms (there might be overloading problems if size_t and int are - // the same type) -#if !defined(__UNIX__) || wxUSE_SIZE_T_STRING_OPERATOR // operator version of GetChar wxChar operator[](size_t n) const { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } -#endif // operator version of GetChar wxChar operator[](int n) const { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } - // operator version of GetWritableChar +#ifdef __alpha__ + // operator version of GetChar + wxChar operator[](unsigned int n) const + { ASSERT_VALID_INDEX( n ); return m_pchData[n]; } +#endif + + // operator version of GetWriteableChar wxChar& operator[](size_t n) { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } +#ifdef __alpha__ + // operator version of GetWriteableChar + wxChar& operator[](unsigned int n) + { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; } +#endif // 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()!) + const wxChar* wx_str() const { return m_pchData; } + // identical to c_str() const wxChar* GetData() const { return m_pchData; } + + // conversions with (possible) format convertions: have to return a + // buffer with temporary data #if wxUSE_UNICODE - const wxCharBuffer mb_str(wxMBConv& conv = wxConv_libc) const { return conv.cWC2MB(m_pchData); } - const wxChar* wc_str(wxMBConv& WXUNUSED(conv) = wxConv_libc) const { return 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; } + #if wxMBFILES - const wxCharBuffer fn_str() const { return mb_str(wxConv_file); } -#else + const wxCharBuffer fn_str() const { return mb_str(wxConvFile); } +#else // !wxMBFILES const wxChar* fn_str() const { return m_pchData; } -#endif -#else - const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConv_libc ) 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; } + 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); } +#endif // wxUSE_WCHAR_T const wxChar* fn_str() const { return m_pchData; } -#endif - // for convenience - const wxWX2MBbuf mbc_str() const { return mb_str(*wxConv_current); } +#endif // Unicode/ANSI // overloaded assignment // from another wxString @@ -474,14 +466,16 @@ public: #if wxUSE_UNICODE // from wxWCharBuffer wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); } -#else +#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 // from wxCharBuffer wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); } -#endif +#endif // Unicode/ANSI // string concatenation // in place concatenation @@ -526,6 +520,8 @@ public: // 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) @@ -545,21 +541,39 @@ 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) - int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); } + int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); } // same as Cmp() but not case-sensitive - int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); } + int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); } // test for the string equality, either considering case or not // (if compareWithCase then the case matters) bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; } + // comparison with a signle character: returns TRUE if equal + bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const + { + return (Len() == 1) && (compareWithCase ? GetChar(0u) == c + : wxToupper(GetChar(0u)) == wxToupper(c)); + } // simple sub-string extraction // return substring starting at nFirst of length nCount (or till the end @@ -606,7 +620,7 @@ public: // remove spaces from left or from right (default) side wxString& Trim(bool bFromRight = TRUE); // add nCount copies chPad in the beginning or at the end (default) - wxString& Pad(size_t nCount, wxChar chPad = _T(' '), bool bFromRight = TRUE); + wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE); // truncate string to given length wxString& Truncate(size_t uiLen); @@ -624,12 +638,26 @@ 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 + // convert to a signed integer + bool ToLong(long *val) const; + // convert to an unsigned integer + bool ToULong(unsigned long *val) 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, ...); // 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, ...); + // 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 @@ -642,6 +670,7 @@ public: 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 @@ -693,6 +722,10 @@ public: #ifdef wxSTD_STRING_COMPATIBILITY // std::string compatibility functions + // standard types + typedef wxChar value_type; + typedef const value_type *const_iterator; + // an 'invalid' value for string index static const size_t npos; @@ -714,11 +747,13 @@ public: // return the maximum size of the string size_t max_size() const { return wxSTRING_MAXLEN; } // resize the string, filling the space with c if c != 0 - void resize(size_t nSize, wxChar ch = _T('\0')); + void resize(size_t nSize, wxChar ch = wxT('\0')); // delete the contents of the string 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 size) { Alloc(size); } // lib.string.access // return the character at position n @@ -726,6 +761,11 @@ public: // returns the writable character at position n wxChar& at(size_t n) { return GetWritableChar(n); } + // first valid index position + const_iterator begin() const { return wx_str(); } + // position one after the last valid one + const_iterator end() const { return wx_str() + length(); } + // lib.string.modifiers // append a string wxString& append(const wxString& str) @@ -816,32 +856,37 @@ public: // find first/last occurence of any character in the set - // - size_t find_first_of(const wxString& str, size_t nStart = 0) const; - // + // as strpbrk() but starts at nStart, returns npos if not found + size_t find_first_of(const wxString& str, size_t nStart = 0) const + { return find_first_of(str.c_str(), nStart); } + // same as above size_t find_first_of(const wxChar* sz, size_t nStart = 0) const; // same as find(char, size_t) - size_t find_first_of(wxChar c, size_t nStart = 0) const; - // - size_t find_last_of (const wxString& str, size_t nStart = npos) const; - // - size_t find_last_of (const wxChar* s, size_t nStart = npos) const; - // same as rfind(char, size_t) - size_t find_last_of (wxChar c, size_t nStart = npos) const; + size_t find_first_of(wxChar c, size_t nStart = 0) const + { 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 + { return find_last_of(str.c_str(), nStart); } + // same as above + size_t find_last_of (const wxChar* sz, size_t nStart = npos) const; + // same as above + size_t find_last_of(wxChar c, size_t nStart = npos) const + { return rfind(c, nStart); } // find first/last occurence of any character not in the set - // - size_t find_first_not_of(const wxString& str, size_t nStart = 0) const; - // - size_t find_first_not_of(const wxChar* s, size_t nStart = 0) const; - // + // as strspn() (starting from nStart), returns npos on failure + size_t find_first_not_of(const wxString& str, size_t nStart = 0) const + { return find_first_not_of(str.c_str(), nStart); } + // same as above + size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const; + // 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 wxChar* s, size_t nStart = npos) const; - // + // same as above + size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const; + // same as above size_t find_last_not_of(wxChar ch, size_t nStart = npos) const; // All compare functions return -1, 0 or 1 if the [sub]string is less, @@ -861,7 +906,8 @@ public: const wxChar* sz, size_t nCount = npos) const; // 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 }; @@ -879,6 +925,7 @@ public: // so the original string may be safely deleted. When a string is retrieved // from the array (operator[] or Item() method), a reference is returned. // ---------------------------------------------------------------------------- + class WXDLLEXPORT wxArrayString { public: @@ -887,8 +934,9 @@ public: const wxString& second); // constructors and destructor - // default ctor - wxArrayString(); + // default ctor: if autoSort is TRUE, the array is always sorted (in + // alphabetical order) + wxArrayString(bool autoSort = FALSE); // copy ctor wxArrayString(const wxArrayString& array); // assignment operator @@ -929,8 +977,9 @@ public: // 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 - void Add(const wxString& str); + // add new element at the end (if the array is not sorted), return its + // index + size_t Add(const wxString& str); // add new element at given position void Insert(const wxString& str, size_t uiIndex); // remove first item matching this value @@ -945,21 +994,36 @@ public: // sort array elements using specified comparaison function void Sort(CompareFunction compareFunction); +protected: + void Copy(const wxArrayString& src); // copies the contents of another array + private: - void Grow(); // makes array bigger if needed - void Free(); // free the string stored + void Grow(); // makes array bigger if needed + void Free(); // free all the strings stored - void DoSort(); // common part of all Sort() variants + 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 + wxChar **m_pItems; // pointer to data + + bool m_autoSort; // if TRUE, keep the array always sorted +}; + +class WXDLLEXPORT wxSortedArrayString : public wxArrayString +{ +public: + wxSortedArrayString() : wxArrayString(TRUE) + { } + wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE) + { Copy(array); } }; // --------------------------------------------------------------------------- // wxString comparison functions: operator versions are always case sensitive // --------------------------------------------------------------------------- + // inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); } // @@ -997,28 +1061,54 @@ inline bool operator>=(const wxString& s1, const wxChar * s2) { return (s1.Cmp( // 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); } +inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); } +inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); } +inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); } + +#if wxUSE_UNICODE +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 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 + 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); #if wxUSE_UNICODE -wxString WXDLLEXPORT operator+(const wxString& string, const wxWCharBuffer buf) -{ return string + (const wchar_t *)buf; } +inline wxString WXDLLEXPORT operator+(const wxString& string, const wxWCharBuffer& buf) + { return string + (const wchar_t *)buf; } +inline wxString WXDLLEXPORT operator+(const wxWCharBuffer& buf, const wxString& string) + { return (const wchar_t *)buf + string; } #else -wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer buf) -{ return string + (const char *)buf; } +inline wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer& buf) + { return string + (const char *)buf; } +inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& string) + { return (const char *)buf + string; } #endif // --------------------------------------------------------------------------- // Implementation only from here until the end of file // --------------------------------------------------------------------------- -#ifdef wxSTD_STRING_COMPATIBILITY +// don't pollute the library user's name space +#undef ASSERT_VALID_INDEX + +#if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM #include "wx/ioswrap.h" -WXDLLEXPORT istream& operator>>(istream& is, wxString& str); +WXDLLEXPORT istream& operator>>(istream&, wxString&); +WXDLLEXPORT ostream& operator<<(ostream&, const wxString&); #endif // wxSTD_STRING_COMPATIBILITY