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