]> git.saurik.com Git - wxWidgets.git/blob - include/wx/string.h
projects / wxWidgets.git / blob
? search:


af6c1ab17f76a2f55751fb60cdd3d5f63c5e86ed
[wxWidgets.git] / include / wx / string.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: string.h
3 // Purpose: wxString and wxArrayString classes
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 /*
13 Efficient string class [more or less] compatible with MFC CString,
14 wxWindows version 1 wxString and std::string and some handy functions
15 missing from string.h.
16 */
17
18 #ifndef _WX_WXSTRINGH__
19 #define _WX_WXSTRINGH__
20
21 #ifdef __GNUG__
22 #pragma interface "string.h"
23 #endif
24
25 // ----------------------------------------------------------------------------
26 // conditinal compilation
27 // ----------------------------------------------------------------------------
28
29 // compile the std::string compatibility functions if defined
30 #define wxSTD_STRING_COMPATIBILITY
31
32 // ----------------------------------------------------------------------------
33 // headers
34 // ----------------------------------------------------------------------------
35
36 #include "wx/defs.h" // everybody should include this
37
38 #if defined(__WXMAC__) || defined(__VISAGECPP__)
39 #include <ctype.h>
40 #endif
41
42 #ifdef __EMX__
43 #include <std.h>
44 #endif
45
46 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
47 // problem in VACPP V4 with including stdlib.h multiple times
48 // strconv includes it anyway
49 # include <stdio.h>
50 # include <string.h>
51 # include <stdarg.h>
52 # include <limits.h>
53 #else
54 # include <string.h>
55 # include <stdio.h>
56 # include <stdarg.h>
57 # include <limits.h>
58 # include <stdlib.h>
59 #endif
60
61 #ifdef HAVE_STRINGS_H
62 #include <strings.h> // for strcasecmp()
63 #endif // HAVE_STRINGS_H
64
65 #include "wx/wxchar.h" // for wxChar
66 #include "wx/buffer.h" // for wxCharBuffer
67 #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
68
69 // ---------------------------------------------------------------------------
70 // macros
71 // ---------------------------------------------------------------------------
72
73 // casts [unfortunately!] needed to call some broken functions which require
74 // "char *" instead of "const char *"
75 #define WXSTRINGCAST (wxChar *)(const wxChar *)
76 #define wxCSTRINGCAST (wxChar *)(const wxChar *)
77 #define wxMBSTRINGCAST (char *)(const char *)
78 #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
79
80 // implementation only
81 #define wxASSERT_VALID_INDEX(i) \
82 wxASSERT_MSG( (size_t)(i) <= Len(), _T("invalid index in wxString") )
83
84 // ----------------------------------------------------------------------------
85 // constants
86 // ----------------------------------------------------------------------------
87
88 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
89 // must define this static for VA or else you get multiply defined symbols everywhere
90 extern const unsigned int wxSTRING_MAXLEN;
91
92 #else
93 // maximum possible length for a string means "take all string" everywhere
94 // (as sizeof(StringData) is unknown here, we substract 100)
95 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
96
97 #endif
98
99 // ----------------------------------------------------------------------------
100 // global data
101 // ----------------------------------------------------------------------------
102
103 // global pointer to empty string
104 WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
105
106 // ---------------------------------------------------------------------------
107 // global functions complementing standard C string library replacements for
108 // strlen() and portable strcasecmp()
109 //---------------------------------------------------------------------------
110
111 // Use wxXXX() functions from wxchar.h instead! These functions are for
112 // backwards compatibility only.
113
114 // checks whether the passed in pointer is NULL and if the string is empty
115 inline bool IsEmpty(const char *p) { return (!p || !*p); }
116
117 // safe version of strlen() (returns 0 if passed NULL pointer)
118 inline size_t Strlen(const char *psz)
119 { return psz ? strlen(psz) : 0; }
120
121 // portable strcasecmp/_stricmp
122 inline int Stricmp(const char *psz1, const char *psz2)
123 {
124 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
125 return _stricmp(psz1, psz2);
126 #elif defined(__SC__)
127 return _stricmp(psz1, psz2);
128 #elif defined(__SALFORDC__)
129 return stricmp(psz1, psz2);
130 #elif defined(__BORLANDC__)
131 return stricmp(psz1, psz2);
132 #elif defined(__WATCOMC__)
133 return stricmp(psz1, psz2);
134 #elif defined(__DJGPP__)
135 return stricmp(psz1, psz2);
136 #elif defined(__EMX__)
137 return stricmp(psz1, psz2);
138 #elif defined(__WXPM__)
139 return stricmp(psz1, psz2);
140 #elif defined(__UNIX__) || defined(__GNUWIN32__)
141 return strcasecmp(psz1, psz2);
142 #elif defined(__MWERKS__) && !defined(__INTEL__)
143 register char c1, c2;
144 do {
145 c1 = tolower(*psz1++);
146 c2 = tolower(*psz2++);
147 } while ( c1 && (c1 == c2) );
148
149 return c1 - c2;
150 #else
151 // almost all compilers/libraries provide this function (unfortunately under
152 // different names), that's why we don't implement our own which will surely
153 // be more efficient than this code (uncomment to use):
154 /*
155 register char c1, c2;
156 do {
157 c1 = tolower(*psz1++);
158 c2 = tolower(*psz2++);
159 } while ( c1 && (c1 == c2) );
160
161 return c1 - c2;
162 */
163
164 #error "Please define string case-insensitive compare for your OS/compiler"
165 #endif // OS/compiler
166 }
167
168 // wxSnprintf() is like snprintf() if it's available and sprintf() (always
169 // available, but dangerous!) if not
170 extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
171 const wxChar *format, ...);
172
173 // and wxVsnprintf() is like vsnprintf() or vsprintf()
174 extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
175 const wxChar *format, va_list argptr);
176
177 // return an empty wxString
178 class WXDLLEXPORT wxString; // not yet defined
179 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
180
181 // ---------------------------------------------------------------------------
182 // string data prepended with some housekeeping info (used by wxString class),
183 // is never used directly (but had to be put here to allow inlining)
184 // ---------------------------------------------------------------------------
185
186 struct WXDLLEXPORT wxStringData
187 {
188 int nRefs; // reference count
189 size_t nDataLength, // actual string length
190 nAllocLength; // allocated memory size
191
192 // mimics declaration 'wxChar data[nAllocLength]'
193 wxChar* data() const { return (wxChar*)(this + 1); }
194
195 // empty string has a special ref count so it's never deleted
196 bool IsEmpty() const { return (nRefs == -1); }
197 bool IsShared() const { return (nRefs > 1); }
198
199 // lock/unlock
200 void Lock() { if ( !IsEmpty() ) nRefs++; }
201
202 // VC++ will refuse to inline this function but profiling shows that it
203 // is wrong
204 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
205 __forceinline
206 #endif
207 void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); }
208
209 // if we had taken control over string memory (GetWriteBuf), it's
210 // intentionally put in invalid state
211 void Validate(bool b) { nRefs = (b ? 1 : 0); }
212 bool IsValid() const { return (nRefs != 0); }
213 };
214
215 // ---------------------------------------------------------------------------
216 // This is (yet another one) String class for C++ programmers. It doesn't use
217 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
218 // thus you should be able to compile it with practicaly any C++ compiler.
219 // This class uses copy-on-write technique, i.e. identical strings share the
220 // same memory as long as neither of them is changed.
221 //
222 // This class aims to be as compatible as possible with the new standard
223 // std::string class, but adds some additional functions and should be at
224 // least as efficient than the standard implementation.
225 //
226 // Performance note: it's more efficient to write functions which take "const
227 // String&" arguments than "const char *" if you assign the argument to
228 // another string.
229 //
230 // It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
231 //
232 // To do:
233 // - ressource support (string tables in ressources)
234 // - more wide character (UNICODE) support
235 // - regular expressions support
236 // ---------------------------------------------------------------------------
237
238 class WXDLLEXPORT wxString
239 {
240 friend class WXDLLEXPORT wxArrayString;
241
242 // NB: special care was taken in arranging the member functions in such order
243 // that all inline functions can be effectively inlined, verify that all
244 // performace critical functions are still inlined if you change order!
245 private:
246 // points to data preceded by wxStringData structure with ref count info
247 wxChar *m_pchData;
248
249 // accessor to string data
250 wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
251
252 // string (re)initialization functions
253 // initializes the string to the empty value (must be called only from
254 // ctors, use Reinit() otherwise)
255 void Init() { m_pchData = (wxChar *)wxEmptyString; }
256 // initializaes the string with (a part of) C-string
257 void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = wxSTRING_MAXLEN);
258 // as Init, but also frees old data
259 void Reinit() { GetStringData()->Unlock(); Init(); }
260
261 // memory allocation
262 // allocates memory for string of length nLen
263 bool AllocBuffer(size_t nLen);
264 // copies data to another string
265 bool AllocCopy(wxString&, int, int) const;
266 // effectively copies data to string
267 bool AssignCopy(size_t, const wxChar *);
268
269 // append a (sub)string
270 bool ConcatSelf(int nLen, const wxChar *src);
271
272 // functions called before writing to the string: they copy it if there
273 // are other references to our data (should be the only owner when writing)
274 bool CopyBeforeWrite();
275 bool AllocBeforeWrite(size_t);
276
277 // if we hadn't made these operators private, it would be possible to
278 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
279 // converted to char in C and we do have operator=(char)
280 //
281 // NB: we don't need other versions (short/long and unsigned) as attempt
282 // to assign another numeric type to wxString will now result in
283 // ambiguity between operator=(char) and operator=(int)
284 wxString& operator=(int);
285
286 // these methods are not implemented - there is _no_ conversion from int to
287 // string, you're doing something wrong if the compiler wants to call it!
288 //
289 // try `s << i' or `s.Printf("%d", i)' instead
290 wxString(int);
291
292 public:
293 // constructors and destructor
294 // ctor for an empty string
295 wxString() : m_pchData(NULL) { Init(); }
296 // copy ctor
297 wxString(const wxString& stringSrc) : m_pchData(NULL)
298 {
299 wxASSERT_MSG( stringSrc.GetStringData()->IsValid(),
300 _T("did you forget to call UngetWriteBuf()?") );
301
302 if ( stringSrc.IsEmpty() ) {
303 // nothing to do for an empty string
304 Init();
305 }
306 else {
307 m_pchData = stringSrc.m_pchData; // share same data
308 GetStringData()->Lock(); // => one more copy
309 }
310 }
311 // string containing nRepeat copies of ch
312 wxString(wxChar ch, size_t nRepeat = 1);
313 // ctor takes first nLength characters from C string
314 // (default value of wxSTRING_MAXLEN means take all the string)
315 wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
316 : m_pchData(NULL)
317 { InitWith(psz, 0, nLength); }
318 wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
319 : m_pchData(NULL)
320 { InitWith(psz, 0, nLength); }
321
322 #if wxUSE_UNICODE
323 // from multibyte string
324 // (NB: nLength is right now number of Unicode characters, not
325 // characters in psz! So try not to use it yet!)
326 wxString(const char *psz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);
327 // from wxWCharBuffer (i.e. return from wxGetString)
328 wxString(const wxWCharBuffer& psz)
329 { InitWith(psz, 0, wxSTRING_MAXLEN); }
330 #else // ANSI
331 // from C string (for compilers using unsigned char)
332 wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
333 : m_pchData(NULL)
334 { InitWith((const char*)psz, 0, nLength); }
335
336 #if wxUSE_WCHAR_T
337 // from wide (Unicode) string
338 wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);
339 #endif // !wxUSE_WCHAR_T
340
341 // from wxCharBuffer
342 wxString(const wxCharBuffer& psz)
343 : m_pchData(NULL)
344 { InitWith(psz, 0, wxSTRING_MAXLEN); }
345 #endif // Unicode/ANSI
346
347 // dtor is not virtual, this class must not be inherited from!
348 ~wxString() { GetStringData()->Unlock(); }
349
350 // generic attributes & operations
351 // as standard strlen()
352 size_t Len() const { return GetStringData()->nDataLength; }
353 // string contains any characters?
354 bool IsEmpty() const { return Len() == 0; }
355 // empty string is "FALSE", so !str will return TRUE
356 bool operator!() const { return IsEmpty(); }
357 // truncate the string to given length
358 wxString& Truncate(size_t uiLen);
359 // empty string contents
360 void Empty()
361 {
362 Truncate(0);
363
364 wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );
365 }
366 // empty the string and free memory
367 void Clear()
368 {
369 if ( !GetStringData()->IsEmpty() )
370 Reinit();
371
372 wxASSERT_MSG( !GetStringData()->nDataLength &&
373 !GetStringData()->nAllocLength,
374 _T("string should be empty after Clear()") );
375 }
376
377 // contents test
378 // Is an ascii value
379 bool IsAscii() const;
380 // Is a number
381 bool IsNumber() const;
382 // Is a word
383 bool IsWord() const;
384
385 // data access (all indexes are 0 based)
386 // read access
387 wxChar GetChar(size_t n) const
388 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
389 // read/write access
390 wxChar& GetWritableChar(size_t n)
391 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
392 // write access
393 void SetChar(size_t n, wxChar ch)
394 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }
395
396 // get last character
397 wxChar Last() const
398 {
399 wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
400
401 return m_pchData[Len() - 1];
402 }
403
404 // get writable last character
405 wxChar& Last()
406 {
407 wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
408 CopyBeforeWrite();
409 return m_pchData[Len()-1];
410 }
411
412 /*
413 So why do we have all these overloaded operator[]s? A bit of history:
414 initially there was only one of them, taking size_t. Then people
415 started complaining because they wanted to use ints as indices (I
416 wonder why) and compilers were giving warnings about it, so we had to
417 add the operator[](int). Then it became apparent that you couldn't
418 write str[0] any longer because there was ambiguity between two
419 overloads and so you now had to write str[0u] (or, of course, use the
420 explicit casts to either int or size_t but nobody did this).
421
422 Finally, someone decided to compile wxWin on an Alpha machine and got
423 a surprize: str[0u] didn't compile there because it is of type
424 unsigned int and size_t is unsigned _long_ on Alpha and so there was
425 ambiguity between converting uint to int or ulong. To fix this one we
426 now add operator[](uint) for the machines where size_t is not already
427 the same as unsigned int - hopefully this fixes the problem (for some
428 time)
429
430 The only real fix is, of course, to remove all versions but the one
431 taking size_t...
432 */
433
434 // operator version of GetChar
435 wxChar operator[](size_t n) const
436 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
437
438 // operator version of GetChar
439 wxChar operator[](int n) const
440 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
441
442 // operator version of GetWriteableChar
443 wxChar& operator[](size_t n)
444 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
445
446 #ifndef wxSIZE_T_IS_UINT
447 // operator version of GetChar
448 wxChar operator[](unsigned int n) const
449 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
450
451 // operator version of GetWriteableChar
452 wxChar& operator[](unsigned int n)
453 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
454 #endif // size_t != unsigned int
455
456 // implicit conversion to C string
457 operator const wxChar*() const { return m_pchData; }
458 // explicit conversion to C string (use this with printf()!)
459 const wxChar* c_str() const { return m_pchData; }
460 // identical to c_str()
461 const wxChar* wx_str() const { return m_pchData; }
462 // identical to c_str()
463 const wxChar* GetData() const { return m_pchData; }
464
465 // conversions with (possible) format convertions: have to return a
466 // buffer with temporary data
467 //
468 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
469 // return an ANSI (multibyte) string, wc_str() to return a wide string and
470 // fn_str() to return a string which should be used with the OS APIs
471 // accepting the file names. The return value is always the same, but the
472 // type differs because a function may either return pointer to the buffer
473 // directly or have to use intermediate buffer for translation.
474 #if wxUSE_UNICODE
475 const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
476 { return conv.cWC2MB(m_pchData); }
477
478 const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
479
480 const wxChar* wc_str() const { return m_pchData; }
481
482 // for compatibility with !wxUSE_UNICODE version
483 const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
484
485 #if wxMBFILES
486 const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
487 #else // !wxMBFILES
488 const wxChar* fn_str() const { return m_pchData; }
489 #endif // wxMBFILES/!wxMBFILES
490 #else // ANSI
491 const wxChar* mb_str() const { return m_pchData; }
492
493 // for compatibility with wxUSE_UNICODE version
494 const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
495
496 const wxWX2MBbuf mbc_str() const { return mb_str(); }
497
498 #if wxUSE_WCHAR_T
499 const wxWCharBuffer wc_str(wxMBConv& conv) const
500 { return conv.cMB2WC(m_pchData); }
501 #endif // wxUSE_WCHAR_T
502
503 const wxChar* fn_str() const { return m_pchData; }
504 #endif // Unicode/ANSI
505
506 // overloaded assignment
507 // from another wxString
508 wxString& operator=(const wxString& stringSrc);
509 // from a character
510 wxString& operator=(wxChar ch);
511 // from a C string
512 wxString& operator=(const wxChar *psz);
513 #if wxUSE_UNICODE
514 // from wxWCharBuffer
515 wxString& operator=(const wxWCharBuffer& psz)
516 { (void) operator=((const wchar_t *)psz); return *this; }
517 #else // ANSI
518 // from another kind of C string
519 wxString& operator=(const unsigned char* psz);
520 #if wxUSE_WCHAR_T
521 // from a wide string
522 wxString& operator=(const wchar_t *pwz);
523 #endif
524 // from wxCharBuffer
525 wxString& operator=(const wxCharBuffer& psz)
526 { (void) operator=((const char *)psz); return *this; }
527 #endif // Unicode/ANSI
528
529 // string concatenation
530 // in place concatenation
531 /*
532 Concatenate and return the result. Note that the left to right
533 associativity of << allows to write things like "str << str1 << str2
534 << ..." (unlike with +=)
535 */
536 // string += string
537 wxString& operator<<(const wxString& s)
538 {
539 wxASSERT_MSG( s.GetStringData()->IsValid(),
540 _T("did you forget to call UngetWriteBuf()?") );
541
542 ConcatSelf(s.Len(), s);
543 return *this;
544 }
545 // string += C string
546 wxString& operator<<(const wxChar *psz)
547 { ConcatSelf(wxStrlen(psz), psz); return *this; }
548 // string += char
549 wxString& operator<<(wxChar ch) { ConcatSelf(1, &ch); return *this; }
550
551 // string += string
552 void operator+=(const wxString& s) { (void)operator<<(s); }
553 // string += C string
554 void operator+=(const wxChar *psz) { (void)operator<<(psz); }
555 // string += char
556 void operator+=(wxChar ch) { (void)operator<<(ch); }
557
558 // string += buffer (i.e. from wxGetString)
559 #if wxUSE_UNICODE
560 wxString& operator<<(const wxWCharBuffer& s)
561 { (void)operator<<((const wchar_t *)s); return *this; }
562 void operator+=(const wxWCharBuffer& s)
563 { (void)operator<<((const wchar_t *)s); }
564 #else // !wxUSE_UNICODE
565 wxString& operator<<(const wxCharBuffer& s)
566 { (void)operator<<((const char *)s); return *this; }
567 void operator+=(const wxCharBuffer& s)
568 { (void)operator<<((const char *)s); }
569 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
570
571 // string += C string
572 wxString& Append(const wxString& s)
573 {
574 // test for IsEmpty() to share the string if possible
575 if ( IsEmpty() )
576 *this = s;
577 else
578 ConcatSelf(s.Length(), s.c_str());
579 return *this;
580 }
581 wxString& Append(const wxChar* psz)
582 { ConcatSelf(wxStrlen(psz), psz); return *this; }
583 // append count copies of given character
584 wxString& Append(wxChar ch, size_t count = 1u)
585 { wxString str(ch, count); return *this << str; }
586 wxString& Append(const wxChar* psz, size_t nLen)
587 { ConcatSelf(nLen, psz); return *this; }
588
589 // prepend a string, return the string itself
590 wxString& Prepend(const wxString& str)
591 { *this = str + *this; return *this; }
592
593 // non-destructive concatenation
594 //
595 friend wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2);
596 //
597 friend wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
598 //
599 friend wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
600 //
601 friend wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
602 //
603 friend wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
604
605 // stream-like functions
606 // insert an int into string
607 wxString& operator<<(int i)
608 { return (*this) << Format(_T("%d"), i); }
609 // insert an unsigned int into string
610 wxString& operator<<(unsigned int ui)
611 { return (*this) << Format(_T("%u"), ui); }
612 // insert a long into string
613 wxString& operator<<(long l)
614 { return (*this) << Format(_T("%ld"), l); }
615 // insert an unsigned long into string
616 wxString& operator<<(unsigned long ul)
617 { return (*this) << Format(_T("%lu"), ul); }
618 // insert a float into string
619 wxString& operator<<(float f)
620 { return (*this) << Format(_T("%f"), f); }
621 // insert a double into string
622 wxString& operator<<(double d)
623 { return (*this) << Format(_T("%g"), d); }
624
625 // string comparison
626 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
627 int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
628 // same as Cmp() but not case-sensitive
629 int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
630 // test for the string equality, either considering case or not
631 // (if compareWithCase then the case matters)
632 bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
633 { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
634 // comparison with a signle character: returns TRUE if equal
635 bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
636 {
637 return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
638 : wxToupper(GetChar(0u)) == wxToupper(c));
639 }
640
641 // simple sub-string extraction
642 // return substring starting at nFirst of length nCount (or till the end
643 // if nCount = default value)
644 wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
645
646 // operator version of Mid()
647 wxString operator()(size_t start, size_t len) const
648 { return Mid(start, len); }
649
650 // check that the string starts with prefix and return the rest of the
651 // string in the provided pointer if it is not NULL, otherwise return
652 // FALSE
653 bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
654
655 // get first nCount characters
656 wxString Left(size_t nCount) const;
657 // get last nCount characters
658 wxString Right(size_t nCount) const;
659 // get all characters before the first occurance of ch
660 // (returns the whole string if ch not found)
661 wxString BeforeFirst(wxChar ch) const;
662 // get all characters before the last occurence of ch
663 // (returns empty string if ch not found)
664 wxString BeforeLast(wxChar ch) const;
665 // get all characters after the first occurence of ch
666 // (returns empty string if ch not found)
667 wxString AfterFirst(wxChar ch) const;
668 // get all characters after the last occurence of ch
669 // (returns the whole string if ch not found)
670 wxString AfterLast(wxChar ch) const;
671
672 // for compatibility only, use more explicitly named functions above
673 wxString Before(wxChar ch) const { return BeforeLast(ch); }
674 wxString After(wxChar ch) const { return AfterFirst(ch); }
675
676 // case conversion
677 // convert to upper case in place, return the string itself
678 wxString& MakeUpper();
679 // convert to upper case, return the copy of the string
680 // Here's something to remember: BC++ doesn't like returns in inlines.
681 wxString Upper() const ;
682 // convert to lower case in place, return the string itself
683 wxString& MakeLower();
684 // convert to lower case, return the copy of the string
685 wxString Lower() const ;
686
687 // trimming/padding whitespace (either side) and truncating
688 // remove spaces from left or from right (default) side
689 wxString& Trim(bool bFromRight = TRUE);
690 // add nCount copies chPad in the beginning or at the end (default)
691 wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
692
693 // searching and replacing
694 // searching (return starting index, or -1 if not found)
695 int Find(wxChar ch, bool bFromEnd = FALSE) const; // like strchr/strrchr
696 // searching (return starting index, or -1 if not found)
697 int Find(const wxChar *pszSub) const; // like strstr
698 // replace first (or all of bReplaceAll) occurences of substring with
699 // another string, returns the number of replacements made
700 size_t Replace(const wxChar *szOld,
701 const wxChar *szNew,
702 bool bReplaceAll = TRUE);
703
704 // check if the string contents matches a mask containing '*' and '?'
705 bool Matches(const wxChar *szMask) const;
706
707 // conversion to numbers: all functions return TRUE only if the whole
708 // string is a number and put the value of this number into the pointer
709 // provided, the base is the numeric base in which the conversion should be
710 // done and must be comprised between 2 and 36 or be 0 in which case the
711 // standard C rules apply (leading '0' => octal, "0x" => hex)
712 // convert to a signed integer
713 bool ToLong(long *val, int base = 10) const;
714 // convert to an unsigned integer
715 bool ToULong(unsigned long *val, int base = 10) const;
716 // convert to a double
717 bool ToDouble(double *val) const;
718
719 // formated input/output
720 // as sprintf(), returns the number of characters written or < 0 on error
721 int Printf(const wxChar *pszFormat, ...);
722 // as vprintf(), returns the number of characters written or < 0 on error
723 int PrintfV(const wxChar* pszFormat, va_list argptr);
724
725 // returns the string containing the result of Printf() to it
726 static wxString Format(const wxChar *pszFormat, ...);
727 // the same as above, but takes a va_list
728 static wxString FormatV(const wxChar *pszFormat, va_list argptr);
729
730 // raw access to string memory
731 // ensure that string has space for at least nLen characters
732 // only works if the data of this string is not shared
733 bool Alloc(size_t nLen);
734 // minimize the string's memory
735 // only works if the data of this string is not shared
736 bool Shrink();
737 // get writable buffer of at least nLen bytes. Unget() *must* be called
738 // a.s.a.p. to put string back in a reasonable state!
739 wxChar *GetWriteBuf(size_t nLen);
740 // call this immediately after GetWriteBuf() has been used
741 void UngetWriteBuf();
742 void UngetWriteBuf(size_t nLen);
743
744 // wxWindows version 1 compatibility functions
745
746 // use Mid()
747 wxString SubString(size_t from, size_t to) const
748 { return Mid(from, (to - from + 1)); }
749 // values for second parameter of CompareTo function
750 enum caseCompare {exact, ignoreCase};
751 // values for first parameter of Strip function
752 enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
753
754 // use Printf()
755 int sprintf(const wxChar *pszFormat, ...);
756
757 // use Cmp()
758 inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
759 { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
760
761 // use Len
762 size_t Length() const { return Len(); }
763 // Count the number of characters
764 int Freq(wxChar ch) const;
765 // use MakeLower
766 void LowerCase() { MakeLower(); }
767 // use MakeUpper
768 void UpperCase() { MakeUpper(); }
769 // use Trim except that it doesn't change this string
770 wxString Strip(stripType w = trailing) const;
771
772 // use Find (more general variants not yet supported)
773 size_t Index(const wxChar* psz) const { return Find(psz); }
774 size_t Index(wxChar ch) const { return Find(ch); }
775 // use Truncate
776 wxString& Remove(size_t pos) { return Truncate(pos); }
777 wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }
778
779 wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
780
781 // use Find()
782 int First( const wxChar ch ) const { return Find(ch); }
783 int First( const wxChar* psz ) const { return Find(psz); }
784 int First( const wxString &str ) const { return Find(str); }
785 int Last( const wxChar ch ) const { return Find(ch, TRUE); }
786 bool Contains(const wxString& str) const { return Find(str) != -1; }
787
788 // use IsEmpty()
789 bool IsNull() const { return IsEmpty(); }
790
791 #ifdef wxSTD_STRING_COMPATIBILITY
792 // std::string compatibility functions
793
794 // standard types
795 typedef wxChar value_type;
796 typedef const value_type *const_iterator;
797
798 // an 'invalid' value for string index
799 static const size_t npos;
800
801 // constructors
802 // take nLen chars starting at nPos
803 wxString(const wxString& str, size_t nPos, size_t nLen)
804 : m_pchData(NULL)
805 {
806 wxASSERT_MSG( str.GetStringData()->IsValid(),
807 _T("did you forget to call UngetWriteBuf()?") );
808
809 InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
810 }
811 // take all characters from pStart to pEnd
812 wxString(const void *pStart, const void *pEnd);
813
814 // lib.string.capacity
815 // return the length of the string
816 size_t size() const { return Len(); }
817 // return the length of the string
818 size_t length() const { return Len(); }
819 // return the maximum size of the string
820 size_t max_size() const { return wxSTRING_MAXLEN; }
821 // resize the string, filling the space with c if c != 0
822 void resize(size_t nSize, wxChar ch = wxT('\0'));
823 // delete the contents of the string
824 void clear() { Empty(); }
825 // returns true if the string is empty
826 bool empty() const { return IsEmpty(); }
827 // inform string about planned change in size
828 void reserve(size_t size) { Alloc(size); }
829
830 // lib.string.access
831 // return the character at position n
832 wxChar at(size_t n) const { return GetChar(n); }
833 // returns the writable character at position n
834 wxChar& at(size_t n) { return GetWritableChar(n); }
835
836 // first valid index position
837 const_iterator begin() const { return wx_str(); }
838 // position one after the last valid one
839 const_iterator end() const { return wx_str() + length(); }
840
841 // lib.string.modifiers
842 // append a string
843 wxString& append(const wxString& str)
844 { *this += str; return *this; }
845 // append elements str[pos], ..., str[pos+n]
846 wxString& append(const wxString& str, size_t pos, size_t n)
847 { ConcatSelf(n, str.c_str() + pos); return *this; }
848 // append first n (or all if n == npos) characters of sz
849 wxString& append(const wxChar *sz, size_t n = npos)
850 { ConcatSelf(n == npos ? wxStrlen(sz) : n, sz); return *this; }
851
852 // append n copies of ch
853 wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
854
855 // same as `this_string = str'
856 wxString& assign(const wxString& str)
857 { return *this = str; }
858 // same as ` = str[pos..pos + n]
859 wxString& assign(const wxString& str, size_t pos, size_t n)
860 { Empty(); return Append(str.c_str() + pos, n); }
861 // same as `= first n (or all if n == npos) characters of sz'
862 wxString& assign(const wxChar *sz, size_t n = npos)
863 { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }
864 // same as `= n copies of ch'
865 wxString& assign(size_t n, wxChar ch)
866 { Empty(); return Append(ch, n); }
867
868 // insert another string
869 wxString& insert(size_t nPos, const wxString& str);
870 // insert n chars of str starting at nStart (in str)
871 wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
872 { return insert(nPos, wxString((const wxChar *)str + nStart, n)); }
873
874 // insert first n (or all if n == npos) characters of sz
875 wxString& insert(size_t nPos, const wxChar *sz, size_t n = npos)
876 { return insert(nPos, wxString(sz, n)); }
877 // insert n copies of ch
878 wxString& insert(size_t nPos, size_t n, wxChar ch)
879 { return insert(nPos, wxString(ch, n)); }
880
881 // delete characters from nStart to nStart + nLen
882 wxString& erase(size_t nStart = 0, size_t nLen = npos);
883
884 // replaces the substring of length nLen starting at nStart
885 wxString& replace(size_t nStart, size_t nLen, const wxChar* sz);
886 // replaces the substring with nCount copies of ch
887 wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);
888 // replaces a substring with another substring
889 wxString& replace(size_t nStart, size_t nLen,
890 const wxString& str, size_t nStart2, size_t nLen2);
891 // replaces the substring with first nCount chars of sz
892 wxString& replace(size_t nStart, size_t nLen,
893 const wxChar* sz, size_t nCount);
894
895 // swap two strings
896 void swap(wxString& str);
897
898 // All find() functions take the nStart argument which specifies the
899 // position to start the search on, the default value is 0. All functions
900 // return npos if there were no match.
901
902 // find a substring
903 size_t find(const wxString& str, size_t nStart = 0) const;
904
905 // VC++ 1.5 can't cope with this syntax.
906 #if !defined(__VISUALC__) || defined(__WIN32__)
907 // find first n characters of sz
908 size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
909 #endif // VC++ 1.5
910
911 // Gives a duplicate symbol (presumably a case-insensitivity problem)
912 #if !defined(__BORLANDC__)
913 // find the first occurence of character ch after nStart
914 size_t find(wxChar ch, size_t nStart = 0) const;
915 #endif
916 // rfind() family is exactly like find() but works right to left
917
918 // as find, but from the end
919 size_t rfind(const wxString& str, size_t nStart = npos) const;
920
921 // VC++ 1.5 can't cope with this syntax.
922 #if !defined(__VISUALC__) || defined(__WIN32__)
923 // as find, but from the end
924 size_t rfind(const wxChar* sz, size_t nStart = npos,
925 size_t n = npos) const;
926 // as find, but from the end
927 size_t rfind(wxChar ch, size_t nStart = npos) const;
928 #endif // VC++ 1.5
929
930 // find first/last occurence of any character in the set
931
932 // as strpbrk() but starts at nStart, returns npos if not found
933 size_t find_first_of(const wxString& str, size_t nStart = 0) const
934 { return find_first_of(str.c_str(), nStart); }
935 // same as above
936 size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
937 // same as find(char, size_t)
938 size_t find_first_of(wxChar c, size_t nStart = 0) const
939 { return find(c, nStart); }
940 // find the last (starting from nStart) char from str in this string
941 size_t find_last_of (const wxString& str, size_t nStart = npos) const
942 { return find_last_of(str.c_str(), nStart); }
943 // same as above
944 size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
945 // same as above
946 size_t find_last_of(wxChar c, size_t nStart = npos) const
947 { return rfind(c, nStart); }
948
949 // find first/last occurence of any character not in the set
950
951 // as strspn() (starting from nStart), returns npos on failure
952 size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
953 { return find_first_not_of(str.c_str(), nStart); }
954 // same as above
955 size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
956 // same as above
957 size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
958 // as strcspn()
959 size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
960 { return find_first_not_of(str.c_str(), nStart); }
961 // same as above
962 size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
963 // same as above
964 size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
965
966 // All compare functions return -1, 0 or 1 if the [sub]string is less,
967 // equal or greater than the compare() argument.
968
969 // just like strcmp()
970 int compare(const wxString& str) const { return Cmp(str); }
971 // comparison with a substring
972 int compare(size_t nStart, size_t nLen, const wxString& str) const
973 { return Mid(nStart, nLen).Cmp(str); }
974 // comparison of 2 substrings
975 int compare(size_t nStart, size_t nLen,
976 const wxString& str, size_t nStart2, size_t nLen2) const
977 { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }
978 // just like strcmp()
979 int compare(const wxChar* sz) const { return Cmp(sz); }
980 // substring comparison with first nCount characters of sz
981 int compare(size_t nStart, size_t nLen,
982 const wxChar* sz, size_t nCount = npos) const
983 { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }
984
985 // substring extraction
986 wxString substr(size_t nStart = 0, size_t nLen = npos) const
987 { return Mid(nStart, nLen); }
988 #endif // wxSTD_STRING_COMPATIBILITY
989 };
990
991 // ----------------------------------------------------------------------------
992 // The string array uses it's knowledge of internal structure of the wxString
993 // class to optimize string storage. Normally, we would store pointers to
994 // string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is
995 // sizeof(char *)) we store these pointers instead. The cast to "wxString *" is
996 // really all we need to turn such pointer into a string!
997 //
998 // Of course, it can be called a dirty hack, but we use twice less memory and
999 // this approach is also more speed efficient, so it's probably worth it.
1000 //
1001 // Usage notes: when a string is added/inserted, a new copy of it is created,
1002 // so the original string may be safely deleted. When a string is retrieved
1003 // from the array (operator[] or Item() method), a reference is returned.
1004 // ----------------------------------------------------------------------------
1005
1006 class WXDLLEXPORT wxArrayString
1007 {
1008 public:
1009 // type of function used by wxArrayString::Sort()
1010 typedef int (*CompareFunction)(const wxString& first,
1011 const wxString& second);
1012
1013 // constructors and destructor
1014 // default ctor
1015 wxArrayString()
1016 : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
1017 { Init(FALSE); }
1018 // if autoSort is TRUE, the array is always sorted (in alphabetical order)
1019 //
1020 // NB: the reason for using int and not bool is that like this we can avoid
1021 // using this ctor for implicit conversions from "const char *" (which
1022 // we'd like to be implicitly converted to wxString instead!)
1023 //
1024 // of course, using explicit would be even better - if all compilers
1025 // supported it...
1026 wxArrayString(int autoSort)
1027 : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
1028 { Init(autoSort != 0); }
1029 // copy ctor
1030 wxArrayString(const wxArrayString& array);
1031 // assignment operator
1032 wxArrayString& operator=(const wxArrayString& src);
1033 // not virtual, this class should not be derived from
1034 ~wxArrayString();
1035
1036 // memory management
1037 // empties the list, but doesn't release memory
1038 void Empty();
1039 // empties the list and releases memory
1040 void Clear();
1041 // preallocates memory for given number of items
1042 void Alloc(size_t nCount);
1043 // minimzes the memory usage (by freeing all extra memory)
1044 void Shrink();
1045
1046 // simple accessors
1047 // number of elements in the array
1048 size_t GetCount() const { return m_nCount; }
1049 // is it empty?
1050 bool IsEmpty() const { return m_nCount == 0; }
1051 // number of elements in the array (GetCount is preferred API)
1052 size_t Count() const { return m_nCount; }
1053
1054 // items access (range checking is done in debug version)
1055 // get item at position uiIndex
1056 wxString& Item(size_t nIndex) const
1057 {
1058 wxASSERT_MSG( nIndex < m_nCount,
1059 _T("wxArrayString: index out of bounds") );
1060
1061 return *(wxString *)&(m_pItems[nIndex]);
1062 }
1063
1064 // same as Item()
1065 wxString& operator[](size_t nIndex) const { return Item(nIndex); }
1066 // get last item
1067 wxString& Last() const
1068 {
1069 wxASSERT_MSG( !IsEmpty(),
1070 _T("wxArrayString: index out of bounds") );
1071 return Item(Count() - 1);
1072 }
1073
1074 // return a wxString[], useful for the controls which
1075 // take one in their ctor. You must delete[] it yourself
1076 // once you are done with it. Will return NULL if the
1077 // ArrayString was empty.
1078 wxString* GetStringArray() const;
1079
1080 // item management
1081 // Search the element in the array, starting from the beginning if
1082 // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
1083 // sensitive (default). Returns index of the first item matched or
1084 // wxNOT_FOUND
1085 int Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
1086 // add new element at the end (if the array is not sorted), return its
1087 // index
1088 size_t Add(const wxString& str, size_t nInsert = 1);
1089 // add new element at given position
1090 void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1);
1091 // expand the array to have count elements
1092 void SetCount(size_t count);
1093 // remove first item matching this value
1094 void Remove(const wxChar *sz);
1095 // remove item by index
1096 void Remove(size_t nIndex, size_t nRemove = 1);
1097 void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); }
1098
1099 // sorting
1100 // sort array elements in alphabetical order (or reversed alphabetical
1101 // order if reverseOrder parameter is TRUE)
1102 void Sort(bool reverseOrder = FALSE);
1103 // sort array elements using specified comparaison function
1104 void Sort(CompareFunction compareFunction);
1105
1106 // comparison
1107 // compare two arrays case sensitively
1108 bool operator==(const wxArrayString& a) const;
1109 // compare two arrays case sensitively
1110 bool operator!=(const wxArrayString& a) const { return !(*this == a); }
1111
1112 protected:
1113 void Init(bool autoSort); // common part of all ctors
1114 void Copy(const wxArrayString& src); // copies the contents of another array
1115
1116 private:
1117 void Grow(size_t nIncrement = 0); // makes array bigger if needed
1118 void Free(); // free all the strings stored
1119
1120 void DoSort(); // common part of all Sort() variants
1121
1122 size_t m_nSize, // current size of the array
1123 m_nCount; // current number of elements
1124
1125 wxChar **m_pItems; // pointer to data
1126
1127 bool m_autoSort; // if TRUE, keep the array always sorted
1128 };
1129
1130 class WXDLLEXPORT wxSortedArrayString : public wxArrayString
1131 {
1132 public:
1133 wxSortedArrayString() : wxArrayString(TRUE)
1134 { }
1135 wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE)
1136 { Copy(array); }
1137 };
1138
1139 // ----------------------------------------------------------------------------
1140 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
1141 // ----------------------------------------------------------------------------
1142
1143 class WXDLLEXPORT wxStringBuffer
1144 {
1145 DECLARE_NO_COPY_CLASS(wxStringBuffer)
1146
1147 public:
1148 wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1149 : m_str(str), m_buf(NULL)
1150 { m_buf = m_str.GetWriteBuf(lenWanted); }
1151
1152 ~wxStringBuffer() { m_str.UngetWriteBuf(); }
1153
1154 operator wxChar*() const { return m_buf; }
1155
1156 private:
1157 wxString& m_str;
1158 wxChar *m_buf;
1159 };
1160
1161 // ---------------------------------------------------------------------------
1162 // wxString comparison functions: operator versions are always case sensitive
1163 // ---------------------------------------------------------------------------
1164
1165 inline bool operator==(const wxString& s1, const wxString& s2)
1166 { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
1167 inline bool operator==(const wxString& s1, const wxChar * s2)
1168 { return s1.Cmp(s2) == 0; }
1169 inline bool operator==(const wxChar * s1, const wxString& s2)
1170 { return s2.Cmp(s1) == 0; }
1171 inline bool operator!=(const wxString& s1, const wxString& s2)
1172 { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
1173 inline bool operator!=(const wxString& s1, const wxChar * s2)
1174 { return s1.Cmp(s2) != 0; }
1175 inline bool operator!=(const wxChar * s1, const wxString& s2)
1176 { return s2.Cmp(s1) != 0; }
1177 inline bool operator< (const wxString& s1, const wxString& s2)
1178 { return s1.Cmp(s2) < 0; }
1179 inline bool operator< (const wxString& s1, const wxChar * s2)
1180 { return s1.Cmp(s2) < 0; }
1181 inline bool operator< (const wxChar * s1, const wxString& s2)
1182 { return s2.Cmp(s1) > 0; }
1183 inline bool operator> (const wxString& s1, const wxString& s2)
1184 { return s1.Cmp(s2) > 0; }
1185 inline bool operator> (const wxString& s1, const wxChar * s2)
1186 { return s1.Cmp(s2) > 0; }
1187 inline bool operator> (const wxChar * s1, const wxString& s2)
1188 { return s2.Cmp(s1) < 0; }
1189 inline bool operator<=(const wxString& s1, const wxString& s2)
1190 { return s1.Cmp(s2) <= 0; }
1191 inline bool operator<=(const wxString& s1, const wxChar * s2)
1192 { return s1.Cmp(s2) <= 0; }
1193 inline bool operator<=(const wxChar * s1, const wxString& s2)
1194 { return s2.Cmp(s1) >= 0; }
1195 inline bool operator>=(const wxString& s1, const wxString& s2)
1196 { return s1.Cmp(s2) >= 0; }
1197 inline bool operator>=(const wxString& s1, const wxChar * s2)
1198 { return s1.Cmp(s2) >= 0; }
1199 inline bool operator>=(const wxChar * s1, const wxString& s2)
1200 { return s2.Cmp(s1) <= 0; }
1201
1202 // comparison with char
1203 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
1204 inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
1205 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
1206 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
1207
1208 #if wxUSE_UNICODE
1209 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
1210 { return (s1.Cmp((const wchar_t *)s2) == 0); }
1211 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
1212 { return (s2.Cmp((const wchar_t *)s1) == 0); }
1213 inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
1214 { return (s1.Cmp((const wchar_t *)s2) != 0); }
1215 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
1216 { return (s2.Cmp((const wchar_t *)s1) != 0); }
1217 #else // !wxUSE_UNICODE
1218 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
1219 { return (s1.Cmp((const char *)s2) == 0); }
1220 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
1221 { return (s2.Cmp((const char *)s1) == 0); }
1222 inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
1223 { return (s1.Cmp((const char *)s2) != 0); }
1224 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
1225 { return (s2.Cmp((const char *)s1) != 0); }
1226 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1227
1228 wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2);
1229 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
1230 wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
1231 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
1232 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
1233 #if wxUSE_UNICODE
1234 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
1235 { return string + (const wchar_t *)buf; }
1236 inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
1237 { return (const wchar_t *)buf + string; }
1238 #else // !wxUSE_UNICODE
1239 inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
1240 { return string + (const char *)buf; }
1241 inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
1242 { return (const char *)buf + string; }
1243 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1244
1245 // ---------------------------------------------------------------------------
1246 // Implementation only from here until the end of file
1247 // ---------------------------------------------------------------------------
1248
1249 // don't pollute the library user's name space
1250 #undef wxASSERT_VALID_INDEX
1251
1252 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
1253
1254 #include "wx/ioswrap.h"
1255
1256 WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
1257 WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
1258
1259 #endif // wxSTD_STRING_COMPATIBILITY
1260
1261 #endif // _WX_WXSTRINGH__
wxWidgets (Impactor)