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