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