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