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