]> git.saurik.com Git - wxWidgets.git/blame - include/wx/string.h
disable report view mode under Mac as it hangs the native wxListCtrl implementation...
[wxWidgets.git] / include / wx / string.h
CommitLineData
3c67202d 1///////////////////////////////////////////////////////////////////////////////
1c2d1459 2// Name: wx/string.h
a7ea63e2 3// Purpose: wxString class
c801d85f
KB
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>
65571936 9// Licence: wxWindows licence
3c67202d 10///////////////////////////////////////////////////////////////////////////////
c801d85f 11
e90c1d2a
VZ
12/*
13 Efficient string class [more or less] compatible with MFC CString,
77ffb593 14 wxWidgets version 1 wxString and std::string and some handy functions
e90c1d2a
VZ
15 missing from string.h.
16*/
17
a7ea63e2
VS
18#ifndef _WX_WXSTRING_H__
19#define _WX_WXSTRING_H__
c801d85f 20
e90c1d2a
VZ
21// ----------------------------------------------------------------------------
22// headers
23// ----------------------------------------------------------------------------
24
5737d05f
VZ
25#include "wx/defs.h" // everybody should include this
26
9b4da627 27#ifndef __WXPALMOS5__
9dea36ef 28#if defined(__WXMAC__) || defined(__VISAGECPP__)
3f4a0c5b 29 #include <ctype.h>
17dff81c 30#endif
3f4a0c5b 31
9dea36ef
DW
32#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
33 // problem in VACPP V4 with including stdlib.h multiple times
34 // strconv includes it anyway
35# include <stdio.h>
36# include <string.h>
37# include <stdarg.h>
38# include <limits.h>
39#else
40# include <string.h>
41# include <stdio.h>
42# include <stdarg.h>
43# include <limits.h>
44# include <stdlib.h>
45#endif
c801d85f 46
1c2d1459 47#ifdef HAVE_STRCASECMP_IN_STRINGS_H
1bfcb0b6 48 #include <strings.h> // for strcasecmp()
1c2d1459 49#endif // HAVE_STRCASECMP_IN_STRINGS_H
9b4da627 50#endif // ! __WXPALMOS5__
ffecfa5a 51
52de37c7 52#include "wx/wxcrtbase.h" // for wxChar, wxStrlen() etc.
c9f78968 53#include "wx/strvararg.h"
e90c1d2a
VZ
54#include "wx/buffer.h" // for wxCharBuffer
55#include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
a7ea63e2 56#include "wx/stringimpl.h"
467175ab 57#include "wx/stringops.h"
a7ea63e2 58#include "wx/unichar.h"
3f4a0c5b 59
b5dbe15d 60class WXDLLIMPEXP_FWD_BASE wxString;
fb3c9042 61
67cff9dc
VZ
62// unless this symbol is predefined to disable the compatibility functions, do
63// use them
64#ifndef WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
65 #define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1
66#endif
67
062dc5fc
VZ
68namespace wxPrivate
69{
70 template <typename T> struct wxStringAsBufHelper;
71}
72
c801d85f
KB
73// ---------------------------------------------------------------------------
74// macros
75// ---------------------------------------------------------------------------
76
5737d05f
VZ
77// casts [unfortunately!] needed to call some broken functions which require
78// "char *" instead of "const char *"
2bb67b80 79#define WXSTRINGCAST (wxChar *)(const wxChar *)
e90c1d2a
VZ
80#define wxCSTRINGCAST (wxChar *)(const wxChar *)
81#define wxMBSTRINGCAST (char *)(const char *)
82#define wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
c801d85f 83
e90c1d2a
VZ
84// ----------------------------------------------------------------------------
85// constants
86// ----------------------------------------------------------------------------
87
13874b5c
VZ
88#if WXWIN_COMPATIBILITY_2_6
89
90// deprecated in favour of wxString::npos, don't use in new code
91//
e90c1d2a 92// maximum possible length for a string means "take all string" everywhere
8f93a29f 93#define wxSTRING_MAXLEN wxString::npos
66b6b045 94
13874b5c
VZ
95#endif // WXWIN_COMPATIBILITY_2_6
96
c801d85f 97// ---------------------------------------------------------------------------
e90c1d2a 98// global functions complementing standard C string library replacements for
3c67202d
VZ
99// strlen() and portable strcasecmp()
100//---------------------------------------------------------------------------
e90c1d2a 101
c7554da8 102#if WXWIN_COMPATIBILITY_2_8
e3f6cbd9 103// Use wxXXX() functions from wxcrt.h instead! These functions are for
e90c1d2a 104// backwards compatibility only.
88150e60 105
3c67202d 106// checks whether the passed in pointer is NULL and if the string is empty
c7554da8 107wxDEPRECATED( inline bool IsEmpty(const char *p) );
6d56eb5c 108inline bool IsEmpty(const char *p) { return (!p || !*p); }
c801d85f 109
3c67202d 110// safe version of strlen() (returns 0 if passed NULL pointer)
c7554da8 111wxDEPRECATED( inline size_t Strlen(const char *psz) );
6d56eb5c 112inline size_t Strlen(const char *psz)
c801d85f
KB
113 { return psz ? strlen(psz) : 0; }
114
3c67202d 115// portable strcasecmp/_stricmp
c7554da8 116wxDEPRECATED( inline int Stricmp(const char *psz1, const char *psz2) );
6d56eb5c 117inline int Stricmp(const char *psz1, const char *psz2)
dd1eaa89 118{
7f0586ef
JS
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__) )
dd1eaa89 128 return _stricmp(psz1, psz2);
91b8de8d 129#elif defined(__SC__)
2432b92d 130 return _stricmp(psz1, psz2);
dd1eaa89
VZ
131#elif defined(__BORLANDC__)
132 return stricmp(psz1, psz2);
7be1f0d9
JS
133#elif defined(__WATCOMC__)
134 return stricmp(psz1, psz2);
14704334
VS
135#elif defined(__DJGPP__)
136 return stricmp(psz1, psz2);
91b8de8d
RR
137#elif defined(__EMX__)
138 return stricmp(psz1, psz2);
e2c87f4c 139#elif defined(__WXPM__)
1777b9bb 140 return stricmp(psz1, psz2);
a0be6908
WS
141#elif defined(__WXPALMOS__) || \
142 defined(HAVE_STRCASECMP_IN_STRING_H) || \
1c2d1459
VZ
143 defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
144 defined(__GNUWIN32__)
dd1eaa89 145 return strcasecmp(psz1, psz2);
8be97d65 146#elif defined(__MWERKS__) && !defined(__INTEL__)
17dff81c
SC
147 register char c1, c2;
148 do {
149 c1 = tolower(*psz1++);
150 c2 = tolower(*psz2++);
151 } while ( c1 && (c1 == c2) );
152
153 return c1 - c2;
dd1eaa89
VZ
154#else
155 // almost all compilers/libraries provide this function (unfortunately under
156 // different names), that's why we don't implement our own which will surely
157 // be more efficient than this code (uncomment to use):
158 /*
159 register char c1, c2;
160 do {
161 c1 = tolower(*psz1++);
162 c2 = tolower(*psz2++);
163 } while ( c1 && (c1 == c2) );
164
165 return c1 - c2;
166 */
167
168 #error "Please define string case-insensitive compare for your OS/compiler"
169#endif // OS/compiler
170}
c801d85f 171
c7554da8
VS
172#endif // WXWIN_COMPATIBILITY_2_8
173
c9f78968
VS
174// ----------------------------------------------------------------------------
175// wxCStrData
176// ----------------------------------------------------------------------------
177
178// Lightweight object returned by wxString::c_str() and implicitly convertible
179// to either const char* or const wchar_t*.
9aee0061 180class WXDLLIMPEXP_BASE wxCStrData
c9f78968
VS
181{
182private:
183 // Ctors; for internal use by wxString and wxCStrData only
184 wxCStrData(const wxString *str, size_t offset = 0, bool owned = false)
185 : m_str(str), m_offset(offset), m_owned(owned) {}
186
187public:
188 // Ctor constructs the object from char literal; they are needed to make
189 // operator?: compile and they intentionally take char*, not const char*
92a17abc
VS
190 inline wxCStrData(char *buf);
191 inline wxCStrData(wchar_t *buf);
192 inline wxCStrData(const wxCStrData& data);
c9f78968 193
9aee0061 194 inline ~wxCStrData();
c9f78968 195
9aee0061
VZ
196 // methods defined inline below must be declared inline or mingw32 3.4.5
197 // warns about "<symbol> defined locally after being referenced with
198 // dllimport linkage"
199#if wxUSE_UNICODE_WCHAR
200 inline
201#endif
c9f78968
VS
202 const wchar_t* AsWChar() const;
203 operator const wchar_t*() const { return AsWChar(); }
11aac4ba 204
111d9948 205#if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
9aee0061
VZ
206 inline
207#endif
c9f78968 208 const char* AsChar() const;
dbea442a
VZ
209 const unsigned char* AsUnsignedChar() const
210 { return (const unsigned char *) AsChar(); }
c9f78968 211 operator const char*() const { return AsChar(); }
dbea442a 212 operator const unsigned char*() const { return AsUnsignedChar(); }
11aac4ba
VS
213
214 operator const void*() const { return AsChar(); }
c9f78968 215
681e4412
VS
216 inline const wxCharBuffer AsCharBuf() const;
217 inline const wxWCharBuffer AsWCharBuf() const;
218
9aee0061 219 inline wxString AsString() const;
c9f78968 220
2523e9b7
VS
221 // returns the value as C string in internal representation (equivalent
222 // to AsString().wx_str(), but more efficient)
223 const wxStringCharType *AsInternal() const;
224
c9f78968 225 // allow expressions like "c_str()[0]":
9aee0061 226 inline wxUniChar operator[](size_t n) const;
c9f78968 227 wxUniChar operator[](int n) const { return operator[](size_t(n)); }
c1df0a3b 228 wxUniChar operator[](long n) const { return operator[](size_t(n)); }
c9f78968
VS
229#ifndef wxSIZE_T_IS_UINT
230 wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
231#endif // size_t != unsigned int
232
acf0c9ac 233 // these operators are needed to emulate the pointer semantics of c_str():
c9f78968
VS
234 // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
235 // (we need both versions to resolve ambiguities):
236 wxCStrData operator+(int n) const
237 { return wxCStrData(m_str, m_offset + n, m_owned); }
acf0c9ac
VZ
238 wxCStrData operator+(long n) const
239 { return wxCStrData(m_str, m_offset + n, m_owned); }
c9f78968
VS
240 wxCStrData operator+(size_t n) const
241 { return wxCStrData(m_str, m_offset + n, m_owned); }
242
b5343e06
VZ
243 // and these for "str.c_str() + (p2 - p1)" (it also works for any integer
244 // expression but it must be ptrdiff_t and not e.g. int to work in this
245 // example):
246 wxCStrData operator-(ptrdiff_t n) const
f4c90fdf 247 {
b5343e06 248 wxASSERT_MSG( n <= (ptrdiff_t)m_offset,
f4c90fdf
VS
249 _T("attempt to construct address before the beginning of the string") );
250 return wxCStrData(m_str, m_offset - n, m_owned);
251 }
252
b77afb41 253 // this operator is needed to make expressions like "*c_str()" or
c9f78968 254 // "*(c_str() + 2)" work
9aee0061 255 inline wxUniChar operator*() const;
c9f78968
VS
256
257private:
258 const wxString *m_str;
259 size_t m_offset;
260 bool m_owned;
261
b5dbe15d 262 friend class WXDLLIMPEXP_FWD_BASE wxString;
c9f78968
VS
263};
264
265// ----------------------------------------------------------------------------
266// wxStringPrintfMixin
267// ---------------------------------------------------------------------------
268
269// NB: VC6 has a bug that causes linker errors if you have template methods
270// in a class using __declspec(dllimport). The solution is to split such
271// class into two classes, one that contains the template methods and does
272// *not* use WXDLLIMPEXP_BASE and another class that contains the rest
273// (with DLL linkage).
274//
275// We only do this for VC6 here, because the code is less efficient
276// (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler
277// cannot compile this code.
278
279#if defined(__VISUALC__) && __VISUALC__ < 1300
280 #define wxNEEDS_WXSTRING_PRINTF_MIXIN
281#endif
282
283#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
284// this class contains implementation of wxString's vararg methods, it's
285// exported from wxBase DLL
286class WXDLLIMPEXP_BASE wxStringPrintfMixinBase
287{
288protected:
289 wxStringPrintfMixinBase() {}
290
d1f6e2cf
VS
291#if !wxUSE_UTF8_LOCALE_ONLY
292 int DoPrintfWchar(const wxChar *format, ...);
293 static wxString DoFormatWchar(const wxChar *format, ...);
294#endif
295#if wxUSE_UNICODE_UTF8
296 int DoPrintfUtf8(const char *format, ...);
297 static wxString DoFormatUtf8(const char *format, ...);
298#endif
c9f78968
VS
299};
300
301// this class contains template wrappers for wxString's vararg methods, it's
302// intentionally *not* exported from the DLL in order to fix the VC6 bug
303// described above
304class wxStringPrintfMixin : public wxStringPrintfMixinBase
305{
306private:
307 // to further complicate things, we can't return wxString from
308 // wxStringPrintfMixin::Format() because wxString is not yet declared at
309 // this point; the solution is to use this fake type trait template - this
310 // way the compiler won't know the return type until Format() is used
311 // (this doesn't compile with Watcom, but VC6 compiles it just fine):
312 template<typename T> struct StringReturnType
313 {
314 typedef wxString type;
315 };
316
317public:
318 // these are duplicated wxString methods, they're also declared below
319 // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
320
2523e9b7 321 // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1;
d1f6e2cf 322 WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType<T1>::type,
1528e0b8 323 Format, 1, (const wxFormatString&),
d1f6e2cf 324 DoFormatWchar, DoFormatUtf8)
2523e9b7
VS
325 // We have to implement the version without template arguments manually
326 // because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC
327 // normally does it itself. It has to be a template so that we can use
81051829
VS
328 // the hack, even though there's no real template parameter. We can't move
329 // it to wxStrig, because it would shadow these versions of Format() then.
2523e9b7
VS
330 template<typename T>
331 inline static typename StringReturnType<T>::type
81051829 332 Format(const T& fmt)
2523e9b7 333 {
81051829
VS
334 // NB: this doesn't compile if T is not (some form of) a string;
335 // this makes Format's prototype equivalent to
336 // Format(const wxFormatString& fmt)
337 return DoFormatWchar(wxFormatString(fmt));
2523e9b7
VS
338 }
339
340 // int Printf(const wxString& format, ...);
1528e0b8 341 WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&),
d1f6e2cf 342 DoPrintfWchar, DoPrintfUtf8)
2523e9b7 343 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
1528e0b8 344 WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
d1f6e2cf 345 DoPrintfWchar, DoPrintfUtf8)
c9f78968
VS
346
347protected:
348 wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
349};
350#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
351
352
b6339dde
VZ
353// ----------------------------------------------------------------------------
354// wxString: string class trying to be compatible with std::string, MFC
355// CString and wxWindows 1.x wxString all at once
e87b7833
MB
356// ---------------------------------------------------------------------------
357
c9f78968
VS
358#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
359 // "non dll-interface class 'wxStringPrintfMixin' used as base interface
360 // for dll-interface class 'wxString'" -- this is OK in our case
361 #pragma warning (disable:4275)
e87b7833
MB
362#endif
363
b0c4d5d7
VS
364#if wxUSE_UNICODE_UTF8
365// see the comment near wxString::iterator for why we need this
326a863a 366class WXDLLIMPEXP_BASE wxStringIteratorNode
b0c4d5d7 367{
326a863a 368public:
39c20230
VS
369 wxStringIteratorNode()
370 : m_str(NULL), m_citer(NULL), m_iter(NULL), m_prev(NULL), m_next(NULL) {}
371 wxStringIteratorNode(const wxString *str,
372 wxStringImpl::const_iterator *citer)
373 { DoSet(str, citer, NULL); }
374 wxStringIteratorNode(const wxString *str, wxStringImpl::iterator *iter)
375 { DoSet(str, NULL, iter); }
376 ~wxStringIteratorNode()
377 { clear(); }
378
379 inline void set(const wxString *str, wxStringImpl::const_iterator *citer)
380 { clear(); DoSet(str, citer, NULL); }
381 inline void set(const wxString *str, wxStringImpl::iterator *iter)
382 { clear(); DoSet(str, NULL, iter); }
b0c4d5d7
VS
383
384 const wxString *m_str;
385 wxStringImpl::const_iterator *m_citer;
386 wxStringImpl::iterator *m_iter;
387 wxStringIteratorNode *m_prev, *m_next;
300b44a9 388
39c20230
VS
389private:
390 inline void clear();
391 inline void DoSet(const wxString *str,
392 wxStringImpl::const_iterator *citer,
393 wxStringImpl::iterator *iter);
394
300b44a9
VS
395 // the node belongs to a particular iterator instance, it's not copied
396 // when a copy of the iterator is made
397 DECLARE_NO_COPY_CLASS(wxStringIteratorNode)
b0c4d5d7
VS
398};
399#endif // wxUSE_UNICODE_UTF8
400
8f93a29f 401class WXDLLIMPEXP_BASE wxString
c9f78968 402#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
8f93a29f 403 : public wxStringPrintfMixin
c9f78968
VS
404#endif
405{
e87b7833
MB
406 // NB: special care was taken in arranging the member functions in such order
407 // that all inline functions can be effectively inlined, verify that all
20aa779e 408 // performance critical functions are still inlined if you change order!
8f93a29f 409public:
8f93a29f
VS
410 // an 'invalid' value for string index, moved to this place due to a CW bug
411 static const size_t npos;
8f93a29f 412
e87b7833
MB
413private:
414 // if we hadn't made these operators private, it would be possible to
415 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
416 // converted to char in C and we do have operator=(char)
417 //
418 // NB: we don't need other versions (short/long and unsigned) as attempt
419 // to assign another numeric type to wxString will now result in
420 // ambiguity between operator=(char) and operator=(int)
421 wxString& operator=(int);
422
8f93a29f
VS
423 // these methods are not implemented - there is _no_ conversion from int to
424 // string, you're doing something wrong if the compiler wants to call it!
425 //
426 // try `s << i' or `s.Printf("%d", i)' instead
427 wxString(int);
428
429
430 // buffer for holding temporary substring when using any of the methods
431 // that take (char*,size_t) or (wchar_t*,size_t) arguments:
8f93a29f
VS
432 template<typename T>
433 struct SubstrBufFromType
434 {
435 T data;
436 size_t len;
437
8f93a29f 438 SubstrBufFromType(const T& data_, size_t len_)
9ef1ad0d
VZ
439 : data(data_), len(len_)
440 {
441 wxASSERT_MSG( len != npos, "must have real length" );
442 }
8f93a29f
VS
443 };
444
445#if wxUSE_UNICODE_UTF8
81727065
VS
446 // even char* -> char* needs conversion, from locale charset to UTF-8
447 typedef SubstrBufFromType<wxCharBuffer> SubstrBufFromWC;
448 typedef SubstrBufFromType<wxCharBuffer> SubstrBufFromMB;
8f93a29f
VS
449#elif wxUSE_UNICODE_WCHAR
450 typedef SubstrBufFromType<const wchar_t*> SubstrBufFromWC;
451 typedef SubstrBufFromType<wxWCharBuffer> SubstrBufFromMB;
8f93a29f
VS
452#else
453 typedef SubstrBufFromType<const char*> SubstrBufFromMB;
454 typedef SubstrBufFromType<wxCharBuffer> SubstrBufFromWC;
8f93a29f
VS
455#endif
456
457
458 // Functions implementing primitive operations on string data; wxString
459 // methods and iterators are implemented in terms of it. The differences
460 // between UTF-8 and wchar_t* representations of the string are mostly
461 // contained here.
462
81727065
VS
463#if wxUSE_UNICODE_UTF8
464 static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength,
465 const wxMBConv& conv);
466 static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength,
467 const wxMBConv& conv);
468#elif wxUSE_UNICODE_WCHAR
8f93a29f 469 static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength,
a962cdf4 470 const wxMBConv& conv);
8f93a29f
VS
471#else
472 static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength,
a962cdf4 473 const wxMBConv& conv);
8f93a29f
VS
474#endif
475
476#if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE
a962cdf4 477 // returns C string encoded as the implementation expects:
8f93a29f 478 #if wxUSE_UNICODE
a962cdf4 479 static const wchar_t* ImplStr(const wchar_t* str)
e8f59039 480 { return str ? str : wxT(""); }
a962cdf4 481 static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
e8f59039
VS
482 { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); }
483 static wxWCharBuffer ImplStr(const char* str,
484 const wxMBConv& conv = wxConvLibc)
485 { return ConvertStr(str, npos, conv).data; }
486 static SubstrBufFromMB ImplStr(const char* str, size_t n,
487 const wxMBConv& conv = wxConvLibc)
488 { return ConvertStr(str, n, conv); }
8f93a29f 489 #else
e8f59039
VS
490 static const char* ImplStr(const char* str,
491 const wxMBConv& WXUNUSED(conv) = wxConvLibc)
492 { return str ? str : ""; }
493 static const SubstrBufFromMB ImplStr(const char* str, size_t n,
494 const wxMBConv& WXUNUSED(conv) = wxConvLibc)
495 { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); }
8f93a29f
VS
496 static wxCharBuffer ImplStr(const wchar_t* str)
497 { return ConvertStr(str, npos, wxConvLibc).data; }
498 static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
499 { return ConvertStr(str, n, wxConvLibc); }
500 #endif
501
8f93a29f
VS
502 // translates position index in wxString to/from index in underlying
503 // wxStringImpl:
504 static size_t PosToImpl(size_t pos) { return pos; }
505 static void PosLenToImpl(size_t pos, size_t len,
506 size_t *implPos, size_t *implLen)
507 { *implPos = pos; *implLen = len; }
11aac4ba 508 static size_t LenToImpl(size_t len) { return len; }
8f93a29f
VS
509 static size_t PosFromImpl(size_t pos) { return pos; }
510
511#else // wxUSE_UNICODE_UTF8
512
467175ab
VS
513 static wxCharBuffer ImplStr(const char* str,
514 const wxMBConv& conv = wxConvLibc)
515 { return ConvertStr(str, npos, conv).data; }
516 static SubstrBufFromMB ImplStr(const char* str, size_t n,
517 const wxMBConv& conv = wxConvLibc)
518 { return ConvertStr(str, n, conv); }
81727065 519
467175ab 520 static wxCharBuffer ImplStr(const wchar_t* str)
5487ff0f 521 { return ConvertStr(str, npos, wxMBConvUTF8()).data; }
467175ab 522 static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
5487ff0f 523 { return ConvertStr(str, n, wxMBConvUTF8()); }
81727065 524
8f93a29f
VS
525 size_t PosToImpl(size_t pos) const
526 {
527 if ( pos == 0 || pos == npos )
528 return pos;
529 else
cf9a878b 530 return (begin() + pos).impl() - m_impl.begin();
8f93a29f
VS
531 }
532
81727065
VS
533 void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const;
534
535 size_t LenToImpl(size_t len) const
536 {
537 size_t pos, len2;
538 PosLenToImpl(0, len, &pos, &len2);
539 return len2;
540 }
541
8f93a29f
VS
542 size_t PosFromImpl(size_t pos) const
543 {
544 if ( pos == 0 || pos == npos )
545 return pos;
546 else
b0c4d5d7 547 return const_iterator(this, m_impl.begin() + pos) - begin();
8f93a29f 548 }
8f93a29f
VS
549#endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
550
8f93a29f
VS
551public:
552 // standard types
553 typedef wxUniChar value_type;
554 typedef wxUniChar char_type;
555 typedef wxUniCharRef reference;
556 typedef wxChar* pointer;
557 typedef const wxChar* const_pointer;
558
559 typedef size_t size_type;
560 typedef wxUniChar const_reference;
561
a962cdf4 562#if wxUSE_STL
81727065
VS
563 #if wxUSE_UNICODE_UTF8
564 // random access is not O(1), as required by Random Access Iterator
565 #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
566 #else
567 #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
568 #endif
a962cdf4
VS
569#else
570 #define WX_STR_ITERATOR_TAG void /* dummy type */
571#endif
572
b0c4d5d7 573 #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
8f93a29f
VS
574 private: \
575 typedef wxStringImpl::iterator_name underlying_iterator; \
576 public: \
a962cdf4 577 typedef WX_STR_ITERATOR_TAG iterator_category; \
8f93a29f 578 typedef wxUniChar value_type; \
a962cdf4 579 typedef int difference_type; \
8f93a29f
VS
580 typedef reference_type reference; \
581 typedef pointer_type pointer; \
582 \
a962cdf4 583 reference operator[](size_t n) const { return *(*this + n); } \
8f93a29f
VS
584 \
585 iterator_name& operator++() \
467175ab 586 { wxStringOperations::IncIter(m_cur); return *this; } \
8f93a29f 587 iterator_name& operator--() \
467175ab 588 { wxStringOperations::DecIter(m_cur); return *this; } \
8f93a29f
VS
589 iterator_name operator++(int) \
590 { \
591 iterator_name tmp = *this; \
467175ab 592 wxStringOperations::IncIter(m_cur); \
8f93a29f
VS
593 return tmp; \
594 } \
595 iterator_name operator--(int) \
596 { \
597 iterator_name tmp = *this; \
467175ab 598 wxStringOperations::DecIter(m_cur); \
8f93a29f
VS
599 return tmp; \
600 } \
601 \
b5343e06 602 iterator_name& operator+=(ptrdiff_t n) \
467175ab
VS
603 { \
604 m_cur = wxStringOperations::AddToIter(m_cur, n); \
605 return *this; \
606 } \
b5343e06 607 iterator_name& operator-=(ptrdiff_t n) \
467175ab
VS
608 { \
609 m_cur = wxStringOperations::AddToIter(m_cur, -n); \
610 return *this; \
467175ab 611 } \
8f93a29f 612 \
89360a8c 613 difference_type operator-(const iterator_name& i) const \
467175ab 614 { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \
8f93a29f 615 \
f2a1b1bd 616 bool operator==(const iterator_name& i) const \
8f93a29f
VS
617 { return m_cur == i.m_cur; } \
618 bool operator!=(const iterator_name& i) const \
619 { return m_cur != i.m_cur; } \
620 \
621 bool operator<(const iterator_name& i) const \
622 { return m_cur < i.m_cur; } \
623 bool operator>(const iterator_name& i) const \
624 { return m_cur > i.m_cur; } \
625 bool operator<=(const iterator_name& i) const \
626 { return m_cur <= i.m_cur; } \
627 bool operator>=(const iterator_name& i) const \
628 { return m_cur >= i.m_cur; } \
629 \
630 private: \
631 /* for internal wxString use only: */ \
cf9a878b 632 underlying_iterator impl() const { return m_cur; } \
8f93a29f 633 \
b5dbe15d
VS
634 friend class wxString; \
635 friend class wxCStrData; \
8f93a29f
VS
636 \
637 private: \
89360a8c 638 underlying_iterator m_cur
8f93a29f 639
b5dbe15d 640 class WXDLLIMPEXP_FWD_BASE const_iterator;
8f93a29f 641
81727065 642#if wxUSE_UNICODE_UTF8
b0c4d5d7
VS
643 // NB: In UTF-8 build, (non-const) iterator needs to keep reference
644 // to the underlying wxStringImpl, because UTF-8 is variable-length
645 // encoding and changing the value pointer to by an iterator (using
646 // its operator*) requires calling wxStringImpl::replace() if the old
647 // and new values differ in their encoding's length.
648 //
649 // Furthermore, the replace() call may invalid all iterators for the
650 // string, so we have to keep track of outstanding iterators and update
651 // them if replace() happens.
652 //
653 // This is implemented by maintaining linked list of iterators for every
654 // string and traversing it in wxUniCharRef::operator=(). Head of the
655 // list is stored in wxString. (FIXME-UTF8)
656
541aa821 657 class WXDLLIMPEXP_BASE iterator
81727065 658 {
b0c4d5d7 659 WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
c7dc0057 660
c67b782d 661 public:
39c20230 662 iterator() {}
b0c4d5d7
VS
663 iterator(const iterator& i)
664 : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
300b44a9 665 iterator& operator=(const iterator& i)
162e998c
PC
666 {
667 if (&i != this)
668 {
669 m_cur = i.m_cur;
670 m_node.set(i.str(), &m_cur);
671 }
672 return *this;
673 }
b0c4d5d7
VS
674
675 reference operator*()
676 { return wxUniCharRef::CreateForString(m_node, m_cur); }
81727065 677
b5343e06 678 iterator operator+(ptrdiff_t n) const
b0c4d5d7 679 { return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
b5343e06 680 iterator operator-(ptrdiff_t n) const
b0c4d5d7 681 { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
81727065
VS
682
683 private:
684 iterator(wxString *str, underlying_iterator ptr)
b0c4d5d7 685 : m_cur(ptr), m_node(str, &m_cur) {}
c7dc0057 686
b0c4d5d7
VS
687 wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); }
688
689 wxStringIteratorNode m_node;
81727065
VS
690
691 friend class const_iterator;
692 };
cf9a878b 693
541aa821 694 class WXDLLIMPEXP_BASE const_iterator
b0c4d5d7
VS
695 {
696 // NB: reference_type is intentionally value, not reference, the character
697 // may be encoded differently in wxString data:
698 WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar);
699
700 public:
39c20230 701 const_iterator() {}
b0c4d5d7
VS
702 const_iterator(const const_iterator& i)
703 : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
704 const_iterator(const iterator& i)
705 : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
706
300b44a9 707 const_iterator& operator=(const const_iterator& i)
162e998c
PC
708 {
709 if (&i != this)
710 {
711 m_cur = i.m_cur;
712 m_node.set(i.str(), &m_cur);
713 }
714 return *this;
715 }
300b44a9 716 const_iterator& operator=(const iterator& i)
39c20230 717 { m_cur = i.m_cur; m_node.set(i.str(), &m_cur); return *this; }
300b44a9 718
b0c4d5d7
VS
719 reference operator*() const
720 { return wxStringOperations::DecodeChar(m_cur); }
721
b5343e06 722 const_iterator operator+(ptrdiff_t n) const
b0c4d5d7 723 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
b5343e06 724 const_iterator operator-(ptrdiff_t n) const
b0c4d5d7 725 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
b0c4d5d7
VS
726
727 private:
728 // for internal wxString use only:
729 const_iterator(const wxString *str, underlying_iterator ptr)
730 : m_cur(ptr), m_node(str, &m_cur) {}
b0c4d5d7
VS
731
732 const wxString* str() const { return m_node.m_str; }
733
734 wxStringIteratorNode m_node;
735 };
736
cf9a878b
VS
737 size_t IterToImplPos(wxString::iterator i) const
738 { return wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); }
739
81727065 740#else // !wxUSE_UNICODE_UTF8
cf9a878b 741
541aa821 742 class WXDLLIMPEXP_BASE iterator
8f93a29f 743 {
b0c4d5d7 744 WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
8f93a29f 745
81727065 746 public:
39c20230 747 iterator() {}
81727065
VS
748 iterator(const iterator& i) : m_cur(i.m_cur) {}
749
b0c4d5d7
VS
750 reference operator*()
751 { return wxUniCharRef::CreateForString(m_cur); }
752
b5343e06 753 iterator operator+(ptrdiff_t n) const
467175ab 754 { return iterator(wxStringOperations::AddToIter(m_cur, n)); }
b5343e06 755 iterator operator-(ptrdiff_t n) const
467175ab 756 { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
81727065
VS
757
758 private:
759 // for internal wxString use only:
760 iterator(underlying_iterator ptr) : m_cur(ptr) {}
761 iterator(wxString *WXUNUSED(str), underlying_iterator ptr) : m_cur(ptr) {}
762
8f93a29f
VS
763 friend class const_iterator;
764 };
765
541aa821 766 class WXDLLIMPEXP_BASE const_iterator
8f93a29f
VS
767 {
768 // NB: reference_type is intentionally value, not reference, the character
769 // may be encoded differently in wxString data:
b0c4d5d7 770 WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar);
8f93a29f
VS
771
772 public:
39c20230 773 const_iterator() {}
81727065 774 const_iterator(const const_iterator& i) : m_cur(i.m_cur) {}
8f93a29f 775 const_iterator(const iterator& i) : m_cur(i.m_cur) {}
81727065 776
b0c4d5d7
VS
777 reference operator*() const
778 { return wxStringOperations::DecodeChar(m_cur); }
779
b5343e06 780 const_iterator operator+(ptrdiff_t n) const
467175ab 781 { return const_iterator(wxStringOperations::AddToIter(m_cur, n)); }
b5343e06 782 const_iterator operator-(ptrdiff_t n) const
467175ab 783 { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
81727065
VS
784
785 private:
786 // for internal wxString use only:
787 const_iterator(underlying_iterator ptr) : m_cur(ptr) {}
b0c4d5d7
VS
788 const_iterator(const wxString *WXUNUSED(str), underlying_iterator ptr)
789 : m_cur(ptr) {}
8f93a29f 790 };
b0c4d5d7 791#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
8f93a29f 792
a962cdf4 793 #undef WX_STR_ITERATOR_TAG
8f93a29f
VS
794 #undef WX_STR_ITERATOR_IMPL
795
796 friend class iterator;
797 friend class const_iterator;
798
799 template <typename T>
800 class reverse_iterator_impl
801 {
802 public:
803 typedef T iterator_type;
a962cdf4
VS
804
805 typedef typename T::iterator_category iterator_category;
8f93a29f 806 typedef typename T::value_type value_type;
a962cdf4 807 typedef typename T::difference_type difference_type;
8f93a29f
VS
808 typedef typename T::reference reference;
809 typedef typename T::pointer *pointer;
810
39c20230 811 reverse_iterator_impl() {}
8f93a29f
VS
812 reverse_iterator_impl(iterator_type i) : m_cur(i) {}
813 reverse_iterator_impl(const reverse_iterator_impl& ri)
814 : m_cur(ri.m_cur) {}
815
816 iterator_type base() const { return m_cur; }
817
818 reference operator*() const { return *(m_cur-1); }
a962cdf4 819 reference operator[](size_t n) const { return *(*this + n); }
8f93a29f
VS
820
821 reverse_iterator_impl& operator++()
822 { --m_cur; return *this; }
823 reverse_iterator_impl operator++(int)
824 { reverse_iterator_impl tmp = *this; --m_cur; return tmp; }
825 reverse_iterator_impl& operator--()
826 { ++m_cur; return *this; }
827 reverse_iterator_impl operator--(int)
828 { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; }
829
50eeb96f 830 // NB: explicit <T> in the functions below is to keep BCC 5.5 happy
b5343e06 831 reverse_iterator_impl operator+(ptrdiff_t n) const
50eeb96f 832 { return reverse_iterator_impl<T>(m_cur - n); }
b5343e06 833 reverse_iterator_impl operator-(ptrdiff_t n) const
50eeb96f 834 { return reverse_iterator_impl<T>(m_cur + n); }
b5343e06 835 reverse_iterator_impl operator+=(ptrdiff_t n)
8f93a29f 836 { m_cur -= n; return *this; }
b5343e06 837 reverse_iterator_impl operator-=(ptrdiff_t n)
8f93a29f
VS
838 { m_cur += n; return *this; }
839
840 unsigned operator-(const reverse_iterator_impl& i) const
841 { return i.m_cur - m_cur; }
842
843 bool operator==(const reverse_iterator_impl& ri) const
844 { return m_cur == ri.m_cur; }
845 bool operator!=(const reverse_iterator_impl& ri) const
846 { return !(*this == ri); }
847
848 bool operator<(const reverse_iterator_impl& i) const
849 { return m_cur > i.m_cur; }
850 bool operator>(const reverse_iterator_impl& i) const
851 { return m_cur < i.m_cur; }
852 bool operator<=(const reverse_iterator_impl& i) const
853 { return m_cur >= i.m_cur; }
854 bool operator>=(const reverse_iterator_impl& i) const
855 { return m_cur <= i.m_cur; }
856
857 private:
858 iterator_type m_cur;
859 };
e87b7833 860
8f93a29f
VS
861 typedef reverse_iterator_impl<iterator> reverse_iterator;
862 typedef reverse_iterator_impl<const_iterator> const_reverse_iterator;
e90c1d2a 863
67cff9dc
VZ
864private:
865 // used to transform an expression built using c_str() (and hence of type
866 // wxCStrData) to an iterator into the string
867 static const_iterator CreateConstIterator(const wxCStrData& data)
868 {
b0c4d5d7
VS
869 return const_iterator(data.m_str,
870 (data.m_str->begin() + data.m_offset).impl());
67cff9dc
VZ
871 }
872
59953bf4
VS
873 // in UTF-8 STL build, creation from std::string requires conversion under
874 // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor;
875 // instead we define dummy type that lets us have wxString ctor for creation
876 // from wxStringImpl that couldn't be used by user code (in all other builds,
877 // "standard" ctors can be used):
878#if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING
879 struct CtorFromStringImplTag {};
880
881 wxString(CtorFromStringImplTag* WXUNUSED(dummy), const wxStringImpl& src)
882 : m_impl(src) {}
883
884 static wxString FromImpl(const wxStringImpl& src)
885 { return wxString((CtorFromStringImplTag*)NULL, src); }
886#else
82a99c69 887 #if !wxUSE_STL_BASED_WXSTRING
59953bf4 888 wxString(const wxStringImpl& src) : m_impl(src) { }
82a99c69
VS
889 // else: already defined as wxString(wxStdString) below
890 #endif
59953bf4
VS
891 static wxString FromImpl(const wxStringImpl& src) { return wxString(src); }
892#endif
893
67cff9dc
VZ
894public:
895 // constructors and destructor
896 // ctor for an empty string
897 wxString() {}
898
899 // copy ctor
67cff9dc
VZ
900 wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
901
902 // string containing nRepeat copies of ch
623633ee 903 wxString(wxUniChar ch, size_t nRepeat = 1 )
67cff9dc
VZ
904 { assign(nRepeat, ch); }
905 wxString(size_t nRepeat, wxUniChar ch)
906 { assign(nRepeat, ch); }
907 wxString(wxUniCharRef ch, size_t nRepeat = 1)
908 { assign(nRepeat, ch); }
909 wxString(size_t nRepeat, wxUniCharRef ch)
910 { assign(nRepeat, ch); }
911 wxString(char ch, size_t nRepeat = 1)
912 { assign(nRepeat, ch); }
913 wxString(size_t nRepeat, char ch)
914 { assign(nRepeat, ch); }
915 wxString(wchar_t ch, size_t nRepeat = 1)
916 { assign(nRepeat, ch); }
917 wxString(size_t nRepeat, wchar_t ch)
918 { assign(nRepeat, ch); }
919
920 // ctors from char* strings:
921 wxString(const char *psz)
922 : m_impl(ImplStr(psz)) {}
923 wxString(const char *psz, const wxMBConv& conv)
924 : m_impl(ImplStr(psz, conv)) {}
925 wxString(const char *psz, size_t nLength)
926 { assign(psz, nLength); }
927 wxString(const char *psz, const wxMBConv& conv, size_t nLength)
928 {
929 SubstrBufFromMB str(ImplStr(psz, nLength, conv));
930 m_impl.assign(str.data, str.len);
931 }
932
933 // and unsigned char*:
934 wxString(const unsigned char *psz)
935 : m_impl(ImplStr((const char*)psz)) {}
936 wxString(const unsigned char *psz, const wxMBConv& conv)
937 : m_impl(ImplStr((const char*)psz, conv)) {}
938 wxString(const unsigned char *psz, size_t nLength)
939 { assign((const char*)psz, nLength); }
940 wxString(const unsigned char *psz, const wxMBConv& conv, size_t nLength)
941 {
942 SubstrBufFromMB str(ImplStr((const char*)psz, nLength, conv));
943 m_impl.assign(str.data, str.len);
944 }
945
946 // ctors from wchar_t* strings:
947 wxString(const wchar_t *pwz)
948 : m_impl(ImplStr(pwz)) {}
949 wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv))
950 : m_impl(ImplStr(pwz)) {}
951 wxString(const wchar_t *pwz, size_t nLength)
952 { assign(pwz, nLength); }
953 wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength)
954 { assign(pwz, nLength); }
955
956 wxString(const wxCharBuffer& buf)
957 { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
958 wxString(const wxWCharBuffer& buf)
959 { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
960
06e9cf13
VS
961 // NB: this version uses m_impl.c_str() to force making a copy of the
962 // string, so that "wxString(str.c_str())" idiom for passing strings
963 // between threads works
67cff9dc 964 wxString(const wxCStrData& cstr)
06e9cf13 965 : m_impl(cstr.AsString().m_impl.c_str()) { }
67cff9dc
VZ
966
967 // as we provide both ctors with this signature for both char and unsigned
968 // char string, we need to provide one for wxCStrData to resolve ambiguity
969 wxString(const wxCStrData& cstr, size_t nLength)
970 : m_impl(cstr.AsString().Mid(0, nLength).m_impl) {}
971
972 // and because wxString is convertible to wxCStrData and const wxChar *
973 // we also need to provide this one
974 wxString(const wxString& str, size_t nLength)
1545d942 975 { assign(str, nLength); }
67cff9dc
VZ
976
977 // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
59953bf4
VS
978 // implicit conversions from std::string to wxString and vice verse as this
979 // allows to use the same strings in non-GUI and GUI code, however we don't
980 // want to unconditionally add this ctor as it would make wx lib dependent on
67cff9dc
VZ
981 // libstdc++ on some Linux versions which is bad, so instead we ask the
982 // client code to define this wxUSE_STD_STRING symbol if they need it
59953bf4 983#if wxUSE_STD_STRING
59953bf4
VS
984 #if wxUSE_UNICODE_WCHAR
985 wxString(const wxStdWideString& str) : m_impl(str) {}
986 #else // UTF-8 or ANSI
987 wxString(const wxStdWideString& str)
988 { assign(str.c_str(), str.length()); }
989 #endif
990
991 #if !wxUSE_UNICODE // ANSI build
992 // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
993 wxString(const std::string& str) : m_impl(str) {}
994 #else // Unicode
995 wxString(const std::string& str)
996 { assign(str.c_str(), str.length()); }
997 #endif
7978bc72 998#endif // wxUSE_STD_STRING
59953bf4 999
7978bc72
VS
1000 // Unlike ctor from std::string, we provide conversion to std::string only
1001 // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default),
1002 // because it conflicts with operator const char/wchar_t*:
1003#if wxUSE_STL
59953bf4
VS
1004 #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
1005 // wxStringImpl is std::string in the encoding we want
1006 operator const wxStdWideString&() const { return m_impl; }
1007 #else
1008 // wxStringImpl is either not std::string or needs conversion
1009 operator wxStdWideString() const
1010 // FIXME-UTF8: broken for embedded NULs
1011 { return wxStdWideString(wc_str()); }
1012 #endif
1013
111d9948 1014 #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
59953bf4
VS
1015 // wxStringImpl is std::string in the encoding we want
1016 operator const std::string&() const { return m_impl; }
1017 #else
1018 // wxStringImpl is either not std::string or needs conversion
1019 operator std::string() const
1020 // FIXME-UTF8: broken for embedded NULs
1021 { return std::string(mb_str()); }
1022 #endif
111d9948 1023#endif // wxUSE_STL
67cff9dc 1024
06e9cf13
VS
1025 wxString Clone() const
1026 {
1027 // make a deep copy of the string, i.e. the returned string will have
1028 // ref count = 1 with refcounted implementation
1029 return wxString::FromImpl(wxStringImpl(m_impl.c_str(), m_impl.length()));
1030 }
1031
8f93a29f 1032 // first valid index position
b0c4d5d7 1033 const_iterator begin() const { return const_iterator(this, m_impl.begin()); }
81727065 1034 iterator begin() { return iterator(this, m_impl.begin()); }
8f93a29f 1035 // position one after the last valid one
b0c4d5d7 1036 const_iterator end() const { return const_iterator(this, m_impl.end()); }
81727065 1037 iterator end() { return iterator(this, m_impl.end()); }
8f93a29f
VS
1038
1039 // first element of the reversed string
1040 const_reverse_iterator rbegin() const
1041 { return const_reverse_iterator(end()); }
1042 reverse_iterator rbegin()
1043 { return reverse_iterator(end()); }
1044 // one beyond the end of the reversed string
1045 const_reverse_iterator rend() const
1046 { return const_reverse_iterator(begin()); }
1047 reverse_iterator rend()
1048 { return reverse_iterator(begin()); }
1049
1050 // std::string methods:
1051#if wxUSE_UNICODE_UTF8
1052 size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
1053#else
1054 size_t length() const { return m_impl.length(); }
1055#endif
ce76f779 1056
8f93a29f
VS
1057 size_type size() const { return length(); }
1058 size_type max_size() const { return npos; }
e90c1d2a 1059
8f93a29f 1060 bool empty() const { return m_impl.empty(); }
b77afb41 1061
8f93a29f
VS
1062 size_type capacity() const { return m_impl.capacity(); } // FIXME-UTF8
1063 void reserve(size_t sz) { m_impl.reserve(sz); } // FIXME-UTF8
b77afb41 1064
8f93a29f
VS
1065 void resize(size_t nSize, wxUniChar ch = wxT('\0'))
1066 {
fe1b98f5
VZ
1067 const size_t len = length();
1068 if ( nSize == len)
1069 return;
1070
8f93a29f 1071#if wxUSE_UNICODE_UTF8
fe1b98f5 1072 if ( nSize < len )
8f93a29f 1073 {
fe1b98f5
VZ
1074 // we can't use wxStringImpl::resize() for truncating the string as it
1075 // counts in bytes, not characters
1076 erase(nSize);
1077 return;
8f93a29f 1078 }
fe1b98f5
VZ
1079
1080 // we also can't use (presumably more efficient) resize() if we have to
1081 // append characters taking more than one byte
1082 if ( !ch.IsAscii() )
1083 append(nSize - len, ch);
8f93a29f 1084 else
fe1b98f5 1085#endif // wxUSE_UNICODE_UTF8
8f93a29f
VS
1086 m_impl.resize(nSize, (wxStringCharType)ch);
1087 }
e90c1d2a 1088
8f93a29f
VS
1089 wxString substr(size_t nStart = 0, size_t nLen = npos) const
1090 {
1091 size_t pos, len;
1092 PosLenToImpl(nStart, nLen, &pos, &len);
59953bf4 1093 return FromImpl(m_impl.substr(pos, len));
8f93a29f 1094 }
e90c1d2a 1095
3c67202d
VZ
1096 // generic attributes & operations
1097 // as standard strlen()
e87b7833 1098 size_t Len() const { return length(); }
3c67202d 1099 // string contains any characters?
e87b7833 1100 bool IsEmpty() const { return empty(); }
d775fa82 1101 // empty string is "false", so !str will return true
20aa779e 1102 bool operator!() const { return empty(); }
735d1db6
VZ
1103 // truncate the string to given length
1104 wxString& Truncate(size_t uiLen);
3c67202d 1105 // empty string contents
dd1eaa89
VZ
1106 void Empty()
1107 {
735d1db6 1108 Truncate(0);
dd1eaa89 1109
5a8231ef 1110 wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
7be07660 1111 }
3c67202d 1112 // empty the string and free memory
7be07660
VZ
1113 void Clear()
1114 {
e87b7833
MB
1115 wxString tmp(wxEmptyString);
1116 swap(tmp);
dd1eaa89
VZ
1117 }
1118
3c67202d
VZ
1119 // contents test
1120 // Is an ascii value
c801d85f 1121 bool IsAscii() const;
3c67202d 1122 // Is a number
c801d85f 1123 bool IsNumber() const;
3c67202d 1124 // Is a word
c801d85f 1125 bool IsWord() const;
c801d85f 1126
3c67202d
VZ
1127 // data access (all indexes are 0 based)
1128 // read access
8f93a29f
VS
1129 wxUniChar at(size_t n) const
1130 { return *(begin() + n); } // FIXME-UTF8: optimize?
c9f78968 1131 wxUniChar GetChar(size_t n) const
9d9ad673 1132 { return at(n); }
3c67202d 1133 // read/write access
8f93a29f
VS
1134 wxUniCharRef at(size_t n)
1135 { return *(begin() + n); } // FIXME-UTF8: optimize?
c9f78968 1136 wxUniCharRef GetWritableChar(size_t n)
9d9ad673 1137 { return at(n); }
3c67202d 1138 // write access
c9f78968 1139 void SetChar(size_t n, wxUniChar ch)
9d9ad673 1140 { at(n) = ch; }
c801d85f 1141
3c67202d 1142 // get last character
8f93a29f 1143 wxUniChar Last() const
564ab31a
VS
1144 {
1145 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1146 return *rbegin();
1147 }
09443a26 1148
3c67202d 1149 // get writable last character
c9f78968 1150 wxUniCharRef Last()
564ab31a
VS
1151 {
1152 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1153 return *rbegin();
1154 }
c801d85f 1155
d836ee96 1156 /*
9d9ad673 1157 Note that we we must define all of the overloads below to avoid
c9f78968 1158 ambiguity when using str[0].
d836ee96 1159 */
c9f78968 1160 wxUniChar operator[](int n) const
8f93a29f 1161 { return at(n); }
c1df0a3b 1162 wxUniChar operator[](long n) const
8f93a29f 1163 { return at(n); }
c9f78968 1164 wxUniChar operator[](size_t n) const
8f93a29f 1165 { return at(n); }
01398433 1166#ifndef wxSIZE_T_IS_UINT
c9f78968 1167 wxUniChar operator[](unsigned int n) const
8f93a29f 1168 { return at(n); }
01398433 1169#endif // size_t != unsigned int
01398433 1170
9d9ad673 1171 // operator versions of GetWriteableChar()
c9f78968 1172 wxUniCharRef operator[](int n)
8f93a29f 1173 { return at(n); }
c1df0a3b 1174 wxUniCharRef operator[](long n)
8f93a29f 1175 { return at(n); }
c9f78968 1176 wxUniCharRef operator[](size_t n)
8f93a29f 1177 { return at(n); }
d836ee96 1178#ifndef wxSIZE_T_IS_UINT
c9f78968 1179 wxUniCharRef operator[](unsigned int n)
8f93a29f 1180 { return at(n); }
d836ee96 1181#endif // size_t != unsigned int
c801d85f 1182
c9f78968
VS
1183 // explicit conversion to C string (use this with printf()!)
1184 wxCStrData c_str() const { return wxCStrData(this); }
8f93a29f 1185 wxCStrData data() const { return c_str(); }
c9f78968 1186
3c67202d 1187 // implicit conversion to C string
c9f78968 1188 operator wxCStrData() const { return c_str(); }
7978bc72 1189
4f167b46
VZ
1190 // the first two operators conflict with operators for conversion to
1191 // std::string and they must be disabled in STL build; the next one only
1192 // makes sense if conversions to char* are also defined and not defining it
1193 // in STL build also helps us to get more clear error messages for the code
1194 // which relies on implicit conversion to char* in STL build
7978bc72 1195#if !wxUSE_STL
11aac4ba
VS
1196 operator const char*() const { return c_str(); }
1197 operator const wchar_t*() const { return c_str(); }
e015c2a3 1198
353a4edc
VZ
1199 // implicit conversion to untyped pointer for compatibility with previous
1200 // wxWidgets versions: this is the same as conversion to const char * so it
1201 // may fail!
1202 operator const void*() const { return c_str(); }
4f167b46 1203#endif // wxUSE_STL
353a4edc 1204
e015c2a3 1205 // identical to c_str(), for MFC compatibility
c9f78968
VS
1206 const wxCStrData GetData() const { return c_str(); }
1207
1208 // explicit conversion to C string in internal representation (char*,
1209 // wchar_t*, UTF-8-encoded char*, depending on the build):
81727065 1210 const wxStringCharType *wx_str() const { return m_impl.c_str(); }
e90c1d2a 1211
ef0f1387 1212 // conversion to *non-const* multibyte or widestring buffer; modifying
c67b782d
VS
1213 // returned buffer won't affect the string, these methods are only useful
1214 // for passing values to const-incorrect functions
8060b0be 1215 wxWritableCharBuffer char_str(const wxMBConv& conv = wxConvLibc) const
c67b782d
VS
1216 { return mb_str(conv); }
1217 wxWritableWCharBuffer wchar_str() const { return wc_str(); }
ef0f1387 1218
062dc5fc
VZ
1219 // conversion to the buffer of the given type T (= char or wchar_t) and
1220 // also optionally return the buffer length
1221 //
1222 // this is mostly/only useful for the template functions
1223 //
1224 // FIXME-VC6: the second argument only exists for VC6 which doesn't support
1225 // explicit template function selection, do not use it unless
1226 // you must support VC6!
1227 template <typename T>
1228 wxCharTypeBuffer<T> tchar_str(size_t *len = NULL,
1229 T * WXUNUSED(dummy) = NULL) const
1230 {
1231#if wxUSE_UNICODE
1232 // we need a helper dispatcher depending on type
1233 return wxPrivate::wxStringAsBufHelper<T>::Get(*this, len);
1234#else // ANSI
1235 // T can only be char in ANSI build
1236 if ( len )
1237 *len = length();
1238
1239 return wxCharTypeBuffer<T>::CreateNonOwned(wx_str());
1240#endif // Unicode build kind
1241 }
1242
e015c2a3
VZ
1243 // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
1244 // converting numbers or strings which are certain not to contain special
1245 // chars (typically system functions, X atoms, environment variables etc.)
1246 //
1247 // the behaviour of these functions with the strings containing anything
1248 // else than 7 bit ASCII characters is undefined, use at your own risk.
b1ac3b56 1249#if wxUSE_UNICODE
628f9e95
VZ
1250 static wxString FromAscii(const char *ascii, size_t len);
1251 static wxString FromAscii(const char *ascii);
1252 static wxString FromAscii(char ascii);
b1ac3b56 1253 const wxCharBuffer ToAscii() const;
e015c2a3
VZ
1254#else // ANSI
1255 static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
e6310bbc
VS
1256 static wxString FromAscii(const char *ascii, size_t len)
1257 { return wxString( ascii, len ); }
628f9e95 1258 static wxString FromAscii(char ascii) { return wxString( ascii ); }
e015c2a3
VZ
1259 const char *ToAscii() const { return c_str(); }
1260#endif // Unicode/!Unicode
b1ac3b56 1261
628f9e95
VZ
1262 // also provide unsigned char overloads as signed/unsigned doesn't matter
1263 // for 7 bit ASCII characters
1264 static wxString FromAscii(const unsigned char *ascii)
1265 { return FromAscii((const char *)ascii); }
1266 static wxString FromAscii(const unsigned char *ascii, size_t len)
1267 { return FromAscii((const char *)ascii, len); }
1268
5f167b77
VS
1269 // conversion to/from UTF-8:
1270#if wxUSE_UNICODE_UTF8
1271 static wxString FromUTF8(const char *utf8)
1272 {
f966a73d
VS
1273 if ( !utf8 )
1274 return wxEmptyString;
1275
5f167b77
VS
1276 wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
1277 return FromImpl(wxStringImpl(utf8));
1278 }
1279 static wxString FromUTF8(const char *utf8, size_t len)
1280 {
f966a73d
VS
1281 if ( !utf8 )
1282 return wxEmptyString;
1283 if ( len == npos )
1284 return FromUTF8(utf8);
1285
5f167b77
VS
1286 wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
1287 return FromImpl(wxStringImpl(utf8, len));
1288 }
1289 const char* utf8_str() const { return wx_str(); }
1290 const char* ToUTF8() const { return wx_str(); }
062dc5fc
VZ
1291
1292 // this function exists in UTF-8 build only and returns the length of the
1293 // internal UTF-8 representation
1294 size_t utf8_length() const { return m_impl.length(); }
5f167b77
VS
1295#elif wxUSE_UNICODE_WCHAR
1296 static wxString FromUTF8(const char *utf8)
5487ff0f 1297 { return wxString(utf8, wxMBConvUTF8()); }
5f167b77 1298 static wxString FromUTF8(const char *utf8, size_t len)
5487ff0f
VS
1299 { return wxString(utf8, wxMBConvUTF8(), len); }
1300 const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
5f167b77
VS
1301 const wxCharBuffer ToUTF8() const { return utf8_str(); }
1302#else // ANSI
1303 static wxString FromUTF8(const char *utf8)
5487ff0f 1304 { return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
5f167b77 1305 static wxString FromUTF8(const char *utf8, size_t len)
06c73b98
VS
1306 {
1307 size_t wlen;
5487ff0f 1308 wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
06c73b98
VS
1309 return wxString(buf.data(), wlen);
1310 }
5487ff0f
VS
1311 const wxCharBuffer utf8_str() const
1312 { return wxMBConvUTF8().cWC2MB(wc_str()); }
5f167b77
VS
1313 const wxCharBuffer ToUTF8() const { return utf8_str(); }
1314#endif
1315
cb2f2135
VS
1316 // functions for storing binary data in wxString:
1317#if wxUSE_UNICODE
1318 static wxString From8BitData(const char *data, size_t len)
1319 { return wxString(data, wxConvISO8859_1, len); }
1320 // version for NUL-terminated data:
1321 static wxString From8BitData(const char *data)
1322 { return wxString(data, wxConvISO8859_1); }
1323 const wxCharBuffer To8BitData() const { return mb_str(wxConvISO8859_1); }
1324#else // ANSI
1325 static wxString From8BitData(const char *data, size_t len)
1326 { return wxString(data, len); }
1327 // version for NUL-terminated data:
1328 static wxString From8BitData(const char *data)
1329 { return wxString(data); }
1330 const char *To8BitData() const { return c_str(); }
1331#endif // Unicode/ANSI
1332
2b5f62a0 1333 // conversions with (possible) format conversions: have to return a
e90c1d2a 1334 // buffer with temporary data
f6bcfd97
BP
1335 //
1336 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
1337 // return an ANSI (multibyte) string, wc_str() to return a wide string and
1338 // fn_str() to return a string which should be used with the OS APIs
1339 // accepting the file names. The return value is always the same, but the
1340 // type differs because a function may either return pointer to the buffer
1341 // directly or have to use intermediate buffer for translation.
2bb67b80 1342#if wxUSE_UNICODE
111d9948
VS
1343
1344#if wxUSE_UTF8_LOCALE_ONLY
1345 const char* mb_str() const { return wx_str(); }
1346 const wxCharBuffer mb_str(const wxMBConv& conv) const;
1347#else
830f8f11 1348 const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;
111d9948 1349#endif
f6bcfd97 1350
e90c1d2a
VZ
1351 const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
1352
81727065
VS
1353#if wxUSE_UNICODE_WCHAR
1354 const wxChar* wc_str() const { return wx_str(); }
1355#elif wxUSE_UNICODE_UTF8
1356 const wxWCharBuffer wc_str() const;
1357#endif
f6bcfd97 1358 // for compatibility with !wxUSE_UNICODE version
81727065
VS
1359 const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const
1360 { return wc_str(); }
e90c1d2a 1361
2bb67b80 1362#if wxMBFILES
5f709e67 1363 const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
e90c1d2a 1364#else // !wxMBFILES
81727065 1365 const wxWX2WCbuf fn_str() const { return wc_str(); }
e90c1d2a 1366#endif // wxMBFILES/!wxMBFILES
81727065 1367
e90c1d2a 1368#else // ANSI
81727065 1369 const wxChar* mb_str() const { return wx_str(); }
f6bcfd97
BP
1370
1371 // for compatibility with wxUSE_UNICODE version
81727065 1372 const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
f6bcfd97 1373
e90c1d2a 1374 const wxWX2MBbuf mbc_str() const { return mb_str(); }
f6bcfd97 1375
6f841509 1376#if wxUSE_WCHAR_T
ef0f1387 1377 const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) const;
e90c1d2a 1378#endif // wxUSE_WCHAR_T
c47e732c 1379 const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
e90c1d2a 1380#endif // Unicode/ANSI
c801d85f 1381
3c67202d
VZ
1382 // overloaded assignment
1383 // from another wxString
04abe4bc 1384 wxString& operator=(const wxString& stringSrc)
162e998c 1385 { if (&stringSrc != this) m_impl = stringSrc.m_impl; return *this; }
8f93a29f
VS
1386 wxString& operator=(const wxCStrData& cstr)
1387 { return *this = cstr.AsString(); }
3c67202d 1388 // from a character
c9f78968 1389 wxString& operator=(wxUniChar ch)
84d2877f
VS
1390 {
1391#if wxUSE_UNICODE_UTF8
1392 if ( !ch.IsAscii() )
1393 m_impl = wxStringOperations::EncodeChar(ch);
1394 else
1395#endif
1396 m_impl = (wxStringCharType)ch;
1397 return *this;
1398 }
c9f78968 1399 wxString& operator=(wxUniCharRef ch)
8f93a29f 1400 { return operator=((wxUniChar)ch); }
c9f78968 1401 wxString& operator=(char ch)
8f93a29f 1402 { return operator=(wxUniChar(ch)); }
50e02008
VS
1403 wxString& operator=(unsigned char ch)
1404 { return operator=(wxUniChar(ch)); }
c9f78968 1405 wxString& operator=(wchar_t ch)
8f93a29f 1406 { return operator=(wxUniChar(ch)); }
c57e3bd5
RN
1407 // from a C string - STL probably will crash on NULL,
1408 // so we need to compensate in that case
992527a5 1409#if wxUSE_STL_BASED_WXSTRING
04abe4bc
VS
1410 wxString& operator=(const char *psz)
1411 { if (psz) m_impl = ImplStr(psz); else Clear(); return *this; }
1412 wxString& operator=(const wchar_t *pwz)
1413 { if (pwz) m_impl = ImplStr(pwz); else Clear(); return *this; }
c57e3bd5 1414#else
04abe4bc
VS
1415 wxString& operator=(const char *psz)
1416 { m_impl = ImplStr(psz); return *this; }
1417 wxString& operator=(const wchar_t *pwz)
1418 { m_impl = ImplStr(pwz); return *this; }
c57e3bd5 1419#endif
04abe4bc
VS
1420 wxString& operator=(const unsigned char *psz)
1421 { return operator=((const char*)psz); }
c57e3bd5 1422
111bb7f2 1423 // from wxWCharBuffer
8f93a29f 1424 wxString& operator=(const wxWCharBuffer& s)
04abe4bc 1425 { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
111bb7f2 1426 // from wxCharBuffer
04abe4bc
VS
1427 wxString& operator=(const wxCharBuffer& s)
1428 { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs
3c67202d
VZ
1429
1430 // string concatenation
1431 // in place concatenation
1432 /*
1433 Concatenate and return the result. Note that the left to right
1434 associativity of << allows to write things like "str << str1 << str2
1435 << ..." (unlike with +=)
1436 */
1437 // string += string
dd1eaa89
VZ
1438 wxString& operator<<(const wxString& s)
1439 {
8f93a29f
VS
1440#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1441 wxASSERT_MSG( s.IsValid(),
09443a26 1442 _T("did you forget to call UngetWriteBuf()?") );
e87b7833 1443#endif
dd1eaa89 1444
e87b7833 1445 append(s);
dd1eaa89
VZ
1446 return *this;
1447 }
3c67202d 1448 // string += C string
8f93a29f 1449 wxString& operator<<(const char *psz)
c9f78968 1450 { append(psz); return *this; }
8f93a29f
VS
1451 wxString& operator<<(const wchar_t *pwz)
1452 { append(pwz); return *this; }
c9f78968 1453 wxString& operator<<(const wxCStrData& psz)
8f93a29f 1454 { append(psz.AsString()); return *this; }
3c67202d 1455 // string += char
c9f78968
VS
1456 wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; }
1457 wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; }
1458 wxString& operator<<(char ch) { append(1, ch); return *this; }
50e02008 1459 wxString& operator<<(unsigned char ch) { append(1, ch); return *this; }
c9f78968 1460 wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
2bb67b80
OK
1461
1462 // string += buffer (i.e. from wxGetString)
09443a26 1463 wxString& operator<<(const wxWCharBuffer& s)
d7330233 1464 { return operator<<((const wchar_t *)s); }
09443a26 1465 wxString& operator<<(const wxCharBuffer& s)
d7330233 1466 { return operator<<((const char *)s); }
d7330233 1467
3c67202d 1468 // string += C string
09443a26
VZ
1469 wxString& Append(const wxString& s)
1470 {
5a8231ef
WS
1471 // test for empty() to share the string if possible
1472 if ( empty() )
09443a26
VZ
1473 *this = s;
1474 else
e87b7833 1475 append(s);
09443a26
VZ
1476 return *this;
1477 }
8f93a29f 1478 wxString& Append(const char* psz)
e87b7833 1479 { append(psz); return *this; }
8f93a29f
VS
1480 wxString& Append(const wchar_t* pwz)
1481 { append(pwz); return *this; }
d3cefe87
VS
1482 wxString& Append(const wxCStrData& psz)
1483 { append(psz); return *this; }
1484 wxString& Append(const wxCharBuffer& psz)
1485 { append(psz); return *this; }
1486 wxString& Append(const wxWCharBuffer& psz)
1487 { append(psz); return *this; }
f416695a
VS
1488 wxString& Append(const char* psz, size_t nLen)
1489 { append(psz, nLen); return *this; }
1490 wxString& Append(const wchar_t* pwz, size_t nLen)
1491 { append(pwz, nLen); return *this; }
1492 wxString& Append(const wxCStrData& psz, size_t nLen)
1493 { append(psz, nLen); return *this; }
1494 wxString& Append(const wxCharBuffer& psz, size_t nLen)
1495 { append(psz, nLen); return *this; }
1496 wxString& Append(const wxWCharBuffer& psz, size_t nLen)
1497 { append(psz, nLen); return *this; }
3c67202d 1498 // append count copies of given character
c9f78968
VS
1499 wxString& Append(wxUniChar ch, size_t count = 1u)
1500 { append(count, ch); return *this; }
1501 wxString& Append(wxUniCharRef ch, size_t count = 1u)
1502 { append(count, ch); return *this; }
1503 wxString& Append(char ch, size_t count = 1u)
1504 { append(count, ch); return *this; }
50e02008
VS
1505 wxString& Append(unsigned char ch, size_t count = 1u)
1506 { append(count, ch); return *this; }
c9f78968 1507 wxString& Append(wchar_t ch, size_t count = 1u)
e87b7833 1508 { append(count, ch); return *this; }
3c67202d
VZ
1509
1510 // prepend a string, return the string itself
1511 wxString& Prepend(const wxString& str)
1512 { *this = str + *this; return *this; }
1513
1514 // non-destructive concatenation
1fc8cfbd
VZ
1515 // two strings
1516 friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,
1517 const wxString& string2);
1518 // string with a single char
c9f78968 1519 friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch);
1fc8cfbd 1520 // char with a string
c9f78968 1521 friend wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string);
1fc8cfbd
VZ
1522 // string with C string
1523 friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
8f93a29f
VS
1524 const char *psz);
1525 friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
1526 const wchar_t *pwz);
1fc8cfbd 1527 // C string with string
8f93a29f
VS
1528 friend wxString WXDLLIMPEXP_BASE operator+(const char *psz,
1529 const wxString& string);
1530 friend wxString WXDLLIMPEXP_BASE operator+(const wchar_t *pwz,
1fc8cfbd 1531 const wxString& string);
3c67202d
VZ
1532
1533 // stream-like functions
1534 // insert an int into string
3ce65f6c
VZ
1535 wxString& operator<<(int i)
1536 { return (*this) << Format(_T("%d"), i); }
1537 // insert an unsigned int into string
1538 wxString& operator<<(unsigned int ui)
1539 { return (*this) << Format(_T("%u"), ui); }
1540 // insert a long into string
1541 wxString& operator<<(long l)
1542 { return (*this) << Format(_T("%ld"), l); }
1543 // insert an unsigned long into string
1544 wxString& operator<<(unsigned long ul)
1545 { return (*this) << Format(_T("%lu"), ul); }
3fc1adbd
MW
1546#if defined wxLongLong_t && !defined wxLongLongIsLong
1547 // insert a long long if they exist and aren't longs
1548 wxString& operator<<(wxLongLong_t ll)
b7859132
MW
1549 {
1550 const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
1551 return (*this) << Format(fmt, ll);
1552 }
3fc1adbd
MW
1553 // insert an unsigned long long
1554 wxString& operator<<(wxULongLong_t ull)
b7859132
MW
1555 {
1556 const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
1557 return (*this) << Format(fmt , ull);
1558 }
3fc1adbd 1559#endif
3c67202d 1560 // insert a float into string
3ce65f6c
VZ
1561 wxString& operator<<(float f)
1562 { return (*this) << Format(_T("%f"), f); }
3c67202d 1563 // insert a double into string
3ce65f6c
VZ
1564 wxString& operator<<(double d)
1565 { return (*this) << Format(_T("%g"), d); }
c84c52de 1566
3c67202d 1567 // string comparison
30b21f9a 1568 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
8f93a29f
VS
1569 int Cmp(const char *psz) const
1570 { return compare(psz); }
1571 int Cmp(const wchar_t *pwz) const
1572 { return compare(pwz); }
1573 int Cmp(const wxString& s) const
1574 { return compare(s); }
d3cefe87
VS
1575 int Cmp(const wxCStrData& s) const
1576 { return compare(s); }
1577 int Cmp(const wxCharBuffer& s) const
1578 { return compare(s); }
1579 int Cmp(const wxWCharBuffer& s) const
1580 { return compare(s); }
3c67202d 1581 // same as Cmp() but not case-sensitive
dcb68102 1582 int CmpNoCase(const wxString& s) const;
2712e317 1583
3c67202d
VZ
1584 // test for the string equality, either considering case or not
1585 // (if compareWithCase then the case matters)
11aac4ba 1586 bool IsSameAs(const wxString& str, bool compareWithCase = true) const
2712e317
VS
1587 {
1588#if !wxUSE_UNICODE_UTF8
1589 // in UTF-8 build, length() is O(n) and doing this would be _slower_
1590 if ( length() != str.length() )
1591 return false;
1592#endif
1593 return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0;
1594 }
11aac4ba
VS
1595 bool IsSameAs(const char *str, bool compareWithCase = true) const
1596 { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; }
1597 bool IsSameAs(const wchar_t *str, bool compareWithCase = true) const
1598 { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; }
2712e317 1599
d3cefe87
VS
1600 bool IsSameAs(const wxCStrData& str, bool compareWithCase = true) const
1601 { return IsSameAs(str.AsString(), compareWithCase); }
1602 bool IsSameAs(const wxCharBuffer& str, bool compareWithCase = true) const
1603 { return IsSameAs(str.data(), compareWithCase); }
1604 bool IsSameAs(const wxWCharBuffer& str, bool compareWithCase = true) const
1605 { return IsSameAs(str.data(), compareWithCase); }
20aa779e 1606 // comparison with a single character: returns true if equal
52de37c7 1607 bool IsSameAs(wxUniChar c, bool compareWithCase = true) const;
11aac4ba
VS
1608 // FIXME-UTF8: remove these overloads
1609 bool IsSameAs(wxUniCharRef c, bool compareWithCase = true) const
1610 { return IsSameAs(wxUniChar(c), compareWithCase); }
1611 bool IsSameAs(char c, bool compareWithCase = true) const
1612 { return IsSameAs(wxUniChar(c), compareWithCase); }
1613 bool IsSameAs(unsigned char c, bool compareWithCase = true) const
1614 { return IsSameAs(wxUniChar(c), compareWithCase); }
1615 bool IsSameAs(wchar_t c, bool compareWithCase = true) const
1616 { return IsSameAs(wxUniChar(c), compareWithCase); }
1617 bool IsSameAs(int c, bool compareWithCase = true) const
1618 { return IsSameAs(wxUniChar(c), compareWithCase); }
3c67202d
VZ
1619
1620 // simple sub-string extraction
1621 // return substring starting at nFirst of length nCount (or till the end
1622 // if nCount = default value)
e87b7833 1623 wxString Mid(size_t nFirst, size_t nCount = npos) const;
3c67202d 1624
f6bcfd97 1625 // operator version of Mid()
3c67202d
VZ
1626 wxString operator()(size_t start, size_t len) const
1627 { return Mid(start, len); }
1628
3affcd07
VZ
1629 // check if the string starts with the given prefix and return the rest
1630 // of the string in the provided pointer if it is not NULL; otherwise
1631 // return false
c5e7a7d7 1632 bool StartsWith(const wxString& prefix, wxString *rest = NULL) const;
3affcd07
VZ
1633 // check if the string ends with the given suffix and return the
1634 // beginning of the string before the suffix in the provided pointer if
1635 // it is not NULL; otherwise return false
c5e7a7d7 1636 bool EndsWith(const wxString& suffix, wxString *rest = NULL) const;
f6bcfd97 1637
3c67202d 1638 // get first nCount characters
c801d85f 1639 wxString Left(size_t nCount) const;
3c67202d 1640 // get last nCount characters
c801d85f 1641 wxString Right(size_t nCount) const;
c0881dc3 1642 // get all characters before the first occurance of ch
3c67202d 1643 // (returns the whole string if ch not found)
c9f78968 1644 wxString BeforeFirst(wxUniChar ch) const;
3c67202d
VZ
1645 // get all characters before the last occurence of ch
1646 // (returns empty string if ch not found)
c9f78968 1647 wxString BeforeLast(wxUniChar ch) const;
3c67202d
VZ
1648 // get all characters after the first occurence of ch
1649 // (returns empty string if ch not found)
c9f78968 1650 wxString AfterFirst(wxUniChar ch) const;
3c67202d
VZ
1651 // get all characters after the last occurence of ch
1652 // (returns the whole string if ch not found)
c9f78968 1653 wxString AfterLast(wxUniChar ch) const;
3c67202d
VZ
1654
1655 // for compatibility only, use more explicitly named functions above
c9f78968
VS
1656 wxString Before(wxUniChar ch) const { return BeforeLast(ch); }
1657 wxString After(wxUniChar ch) const { return AfterFirst(ch); }
3c67202d
VZ
1658
1659 // case conversion
c84c52de 1660 // convert to upper case in place, return the string itself
c801d85f 1661 wxString& MakeUpper();
c84c52de 1662 // convert to upper case, return the copy of the string
03ab016d
JS
1663 // Here's something to remember: BC++ doesn't like returns in inlines.
1664 wxString Upper() const ;
c84c52de 1665 // convert to lower case in place, return the string itself
c801d85f 1666 wxString& MakeLower();
c84c52de 1667 // convert to lower case, return the copy of the string
03ab016d 1668 wxString Lower() const ;
c801d85f 1669
3c67202d
VZ
1670 // trimming/padding whitespace (either side) and truncating
1671 // remove spaces from left or from right (default) side
d775fa82 1672 wxString& Trim(bool bFromRight = true);
3c67202d 1673 // add nCount copies chPad in the beginning or at the end (default)
c9f78968 1674 wxString& Pad(size_t nCount, wxUniChar chPad = wxT(' '), bool bFromRight = true);
dd1eaa89 1675
3c67202d
VZ
1676 // searching and replacing
1677 // searching (return starting index, or -1 if not found)
c9f78968 1678 int Find(wxUniChar ch, bool bFromEnd = false) const; // like strchr/strrchr
8a540c88
VS
1679 int Find(wxUniCharRef ch, bool bFromEnd = false) const
1680 { return Find(wxUniChar(ch), bFromEnd); }
1681 int Find(char ch, bool bFromEnd = false) const
1682 { return Find(wxUniChar(ch), bFromEnd); }
1683 int Find(unsigned char ch, bool bFromEnd = false) const
1684 { return Find(wxUniChar(ch), bFromEnd); }
1685 int Find(wchar_t ch, bool bFromEnd = false) const
1686 { return Find(wxUniChar(ch), bFromEnd); }
3c67202d 1687 // searching (return starting index, or -1 if not found)
8a540c88
VS
1688 int Find(const wxString& sub) const // like strstr
1689 {
1690 size_type idx = find(sub);
1691 return (idx == npos) ? wxNOT_FOUND : (int)idx;
1692 }
1693 int Find(const char *sub) const // like strstr
1694 {
1695 size_type idx = find(sub);
1696 return (idx == npos) ? wxNOT_FOUND : (int)idx;
1697 }
1698 int Find(const wchar_t *sub) const // like strstr
1699 {
1700 size_type idx = find(sub);
1701 return (idx == npos) ? wxNOT_FOUND : (int)idx;
1702 }
1703
d3cefe87
VS
1704 int Find(const wxCStrData& sub) const
1705 { return Find(sub.AsString()); }
1706 int Find(const wxCharBuffer& sub) const
1707 { return Find(sub.data()); }
1708 int Find(const wxWCharBuffer& sub) const
1709 { return Find(sub.data()); }
1710
3c67202d
VZ
1711 // replace first (or all of bReplaceAll) occurences of substring with
1712 // another string, returns the number of replacements made
8a540c88
VS
1713 size_t Replace(const wxString& strOld,
1714 const wxString& strNew,
d775fa82 1715 bool bReplaceAll = true);
3c67202d
VZ
1716
1717 // check if the string contents matches a mask containing '*' and '?'
8a540c88 1718 bool Matches(const wxString& mask) const;
c801d85f 1719
d775fa82 1720 // conversion to numbers: all functions return true only if the whole
538f35cc
VZ
1721 // string is a number and put the value of this number into the pointer
1722 // provided, the base is the numeric base in which the conversion should be
1723 // done and must be comprised between 2 and 36 or be 0 in which case the
1724 // standard C rules apply (leading '0' => octal, "0x" => hex)
cd0b1709 1725 // convert to a signed integer
538f35cc 1726 bool ToLong(long *val, int base = 10) const;
cd0b1709 1727 // convert to an unsigned integer
538f35cc 1728 bool ToULong(unsigned long *val, int base = 10) const;
d6718dd1
VZ
1729 // convert to wxLongLong
1730#if defined(wxLongLong_t)
1731 bool ToLongLong(wxLongLong_t *val, int base = 10) const;
1732 // convert to wxULongLong
1733 bool ToULongLong(wxULongLong_t *val, int base = 10) const;
1734#endif // wxLongLong_t
cd0b1709
VZ
1735 // convert to a double
1736 bool ToDouble(double *val) const;
1737
d6718dd1 1738
c9f78968 1739#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
90e572f1 1740 // formatted input/output
3c67202d 1741 // as sprintf(), returns the number of characters written or < 0 on error
7357f981 1742 // (take 'this' into account in attribute parameter count)
2523e9b7 1743 // int Printf(const wxString& format, ...);
1528e0b8 1744 WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxFormatString&),
d1f6e2cf 1745 DoPrintfWchar, DoPrintfUtf8)
2523e9b7 1746#ifdef __WATCOMC__
59a14f69
VS
1747 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1748 WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wxString&),
1749 (wxFormatString(f1)));
1750 WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wxCStrData&),
1751 (wxFormatString(f1)));
1752 WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const char*),
1753 (wxFormatString(f1)));
1754 WX_VARARG_WATCOM_WORKAROUND(int, Printf, 1, (const wchar_t*),
1755 (wxFormatString(f1)));
2523e9b7 1756#endif
c9f78968 1757#endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
3c67202d 1758 // as vprintf(), returns the number of characters written or < 0 on error
c9f78968 1759 int PrintfV(const wxString& format, va_list argptr);
dd1eaa89 1760
c9f78968 1761#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
341e7d28 1762 // returns the string containing the result of Printf() to it
2523e9b7 1763 // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1;
1528e0b8 1764 WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxFormatString&),
d1f6e2cf 1765 DoFormatWchar, DoFormatUtf8)
2523e9b7
VS
1766#ifdef __WATCOMC__
1767 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
59a14f69
VS
1768 WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wxString&),
1769 (wxFormatString(f1)));
1770 WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wxCStrData&),
1771 (wxFormatString(f1)));
1772 WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const char*),
1773 (wxFormatString(f1)));
1774 WX_VARARG_WATCOM_WORKAROUND(static wxString, Format, 1, (const wchar_t*),
1775 (wxFormatString(f1)));
2523e9b7 1776#endif
c9f78968 1777#endif
341e7d28 1778 // the same as above, but takes a va_list
c9f78968 1779 static wxString FormatV(const wxString& format, va_list argptr);
341e7d28 1780
3c67202d
VZ
1781 // raw access to string memory
1782 // ensure that string has space for at least nLen characters
dd1eaa89 1783 // only works if the data of this string is not shared
0367b928 1784 bool Alloc(size_t nLen) { reserve(nLen); return capacity() >= nLen; }
3c67202d 1785 // minimize the string's memory
dd1eaa89 1786 // only works if the data of this string is not shared
b1801e0e 1787 bool Shrink();
8f93a29f 1788#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
d8a4b666
VS
1789 // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
1790 //
3c67202d
VZ
1791 // get writable buffer of at least nLen bytes. Unget() *must* be called
1792 // a.s.a.p. to put string back in a reasonable state!
c87a0bc8 1793 wxDEPRECATED( wxStringCharType *GetWriteBuf(size_t nLen) );
3c67202d 1794 // call this immediately after GetWriteBuf() has been used
d8a4b666
VS
1795 wxDEPRECATED( void UngetWriteBuf() );
1796 wxDEPRECATED( void UngetWriteBuf(size_t nLen) );
8f93a29f 1797#endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && wxUSE_UNICODE_UTF8
c801d85f 1798
77ffb593 1799 // wxWidgets version 1 compatibility functions
3c67202d
VZ
1800
1801 // use Mid()
1802 wxString SubString(size_t from, size_t to) const
1803 { return Mid(from, (to - from + 1)); }
1804 // values for second parameter of CompareTo function
c801d85f 1805 enum caseCompare {exact, ignoreCase};
3c67202d 1806 // values for first parameter of Strip function
c801d85f 1807 enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
8870c26e 1808
c9f78968 1809#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
7357f981
GD
1810 // use Printf()
1811 // (take 'this' into account in attribute parameter count)
2523e9b7 1812 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
1528e0b8 1813 WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxFormatString&),
d1f6e2cf 1814 DoPrintfWchar, DoPrintfUtf8)
2523e9b7
VS
1815#ifdef __WATCOMC__
1816 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
59a14f69
VS
1817 WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wxString&),
1818 (wxFormatString(f1)));
1819 WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wxCStrData&),
1820 (wxFormatString(f1)));
1821 WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const char*),
1822 (wxFormatString(f1)));
1823 WX_VARARG_WATCOM_WORKAROUND(int, sprintf, 1, (const wchar_t*),
1824 (wxFormatString(f1)));
2523e9b7 1825#endif
c9f78968 1826#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
c801d85f 1827
3c67202d 1828 // use Cmp()
2bb67b80 1829 inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
6b95b20d 1830 { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
c801d85f 1831
8f93a29f 1832 // use length()
e87b7833 1833 size_t Length() const { return length(); }
3c67202d 1834 // Count the number of characters
c9f78968 1835 int Freq(wxUniChar ch) const;
3c67202d 1836 // use MakeLower
c801d85f 1837 void LowerCase() { MakeLower(); }
3c67202d 1838 // use MakeUpper
c801d85f 1839 void UpperCase() { MakeUpper(); }
3c67202d 1840 // use Trim except that it doesn't change this string
c801d85f
KB
1841 wxString Strip(stripType w = trailing) const;
1842
3c67202d 1843 // use Find (more general variants not yet supported)
2bb67b80 1844 size_t Index(const wxChar* psz) const { return Find(psz); }
c9f78968 1845 size_t Index(wxUniChar ch) const { return Find(ch); }
3c67202d 1846 // use Truncate
c801d85f 1847 wxString& Remove(size_t pos) { return Truncate(pos); }
e87b7833 1848 wxString& RemoveLast(size_t n = 1) { return Truncate(length() - n); }
c801d85f 1849
e87b7833
MB
1850 wxString& Remove(size_t nStart, size_t nLen)
1851 { return (wxString&)erase( nStart, nLen ); }
dd1eaa89 1852
3c67202d 1853 // use Find()
8f93a29f 1854 int First( wxUniChar ch ) const { return Find(ch); }
8a540c88 1855 int First( wxUniCharRef ch ) const { return Find(ch); }
c9f78968 1856 int First( char ch ) const { return Find(ch); }
50e02008 1857 int First( unsigned char ch ) const { return Find(ch); }
c9f78968 1858 int First( wchar_t ch ) const { return Find(ch); }
8a540c88 1859 int First( const wxString& str ) const { return Find(str); }
8f93a29f 1860 int Last( wxUniChar ch ) const { return Find(ch, true); }
d775fa82 1861 bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }
c801d85f 1862
5a8231ef
WS
1863 // use empty()
1864 bool IsNull() const { return empty(); }
c801d85f 1865
3c67202d 1866 // std::string compatibility functions
dd1eaa89 1867
3c67202d
VZ
1868 // take nLen chars starting at nPos
1869 wxString(const wxString& str, size_t nPos, size_t nLen)
1545d942 1870 { assign(str, nPos, nLen); }
f2a1b1bd 1871 // take all characters from first to last
e87b7833 1872 wxString(const_iterator first, const_iterator last)
cf9a878b 1873 : m_impl(first.impl(), last.impl()) { }
67cff9dc
VZ
1874#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1875 // the 2 overloads below are for compatibility with the existing code using
1876 // pointers instead of iterators
f2a1b1bd
VZ
1877 wxString(const char *first, const char *last)
1878 {
1879 SubstrBufFromMB str(ImplStr(first, last - first));
1880 m_impl.assign(str.data, str.len);
1881 }
1882 wxString(const wchar_t *first, const wchar_t *last)
1883 {
1884 SubstrBufFromWC str(ImplStr(first, last - first));
1885 m_impl.assign(str.data, str.len);
1886 }
67cff9dc
VZ
1887 // and this one is needed to compile code adding offsets to c_str() result
1888 wxString(const wxCStrData& first, const wxCStrData& last)
cf9a878b
VS
1889 : m_impl(CreateConstIterator(first).impl(),
1890 CreateConstIterator(last).impl())
67cff9dc
VZ
1891 {
1892 wxASSERT_MSG( first.m_str == last.m_str,
1893 _T("pointers must be into the same string") );
1894 }
1895#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
5460b9e3 1896
3c67202d 1897 // lib.string.modifiers
3c67202d
VZ
1898 // append elements str[pos], ..., str[pos+n]
1899 wxString& append(const wxString& str, size_t pos, size_t n)
8f93a29f
VS
1900 {
1901 size_t from, len;
04848a06 1902 str.PosLenToImpl(pos, n, &from, &len);
8f93a29f
VS
1903 m_impl.append(str.m_impl, from, len);
1904 return *this;
1905 }
e87b7833
MB
1906 // append a string
1907 wxString& append(const wxString& str)
8f93a29f 1908 { m_impl.append(str.m_impl); return *this; }
3c67202d 1909 // append first n (or all if n == npos) characters of sz
8f93a29f
VS
1910 wxString& append(const char *sz)
1911 { m_impl.append(ImplStr(sz)); return *this; }
1912 wxString& append(const wchar_t *sz)
1913 { m_impl.append(ImplStr(sz)); return *this; }
1914 wxString& append(const char *sz, size_t n)
1915 {
1916 SubstrBufFromMB str(ImplStr(sz, n));
1917 m_impl.append(str.data, str.len);
1918 return *this;
1919 }
1920 wxString& append(const wchar_t *sz, size_t n)
1921 {
1922 SubstrBufFromWC str(ImplStr(sz, n));
1923 m_impl.append(str.data, str.len);
1924 return *this;
1925 }
d3cefe87
VS
1926
1927 wxString& append(const wxCStrData& str)
1928 { return append(str.AsString()); }
1929 wxString& append(const wxCharBuffer& str)
1930 { return append(str.data()); }
1931 wxString& append(const wxWCharBuffer& str)
1932 { return append(str.data()); }
f416695a
VS
1933 wxString& append(const wxCStrData& str, size_t n)
1934 { return append(str.AsString(), 0, n); }
1935 wxString& append(const wxCharBuffer& str, size_t n)
1936 { return append(str.data(), n); }
1937 wxString& append(const wxWCharBuffer& str, size_t n)
1938 { return append(str.data(), n); }
d3cefe87 1939
3c67202d 1940 // append n copies of ch
c9f78968 1941 wxString& append(size_t n, wxUniChar ch)
8f93a29f
VS
1942 {
1943#if wxUSE_UNICODE_UTF8
1944 if ( !ch.IsAscii() )
467175ab 1945 m_impl.append(wxStringOperations::EncodeNChars(n, ch));
8f93a29f
VS
1946 else
1947#endif
1948 m_impl.append(n, (wxStringCharType)ch);
1949 return *this;
1950 }
f416695a
VS
1951 wxString& append(size_t n, wxUniCharRef ch)
1952 { return append(n, wxUniChar(ch)); }
1953 wxString& append(size_t n, char ch)
1954 { return append(n, wxUniChar(ch)); }
1955 wxString& append(size_t n, unsigned char ch)
1956 { return append(n, wxUniChar(ch)); }
1957 wxString& append(size_t n, wchar_t ch)
1958 { return append(n, wxUniChar(ch)); }
1959
e87b7833
MB
1960 // append from first to last
1961 wxString& append(const_iterator first, const_iterator last)
cf9a878b 1962 { m_impl.append(first.impl(), last.impl()); return *this; }
67cff9dc 1963#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
f2a1b1bd
VZ
1964 wxString& append(const char *first, const char *last)
1965 { return append(first, last - first); }
1966 wxString& append(const wchar_t *first, const wchar_t *last)
1967 { return append(first, last - first); }
67cff9dc
VZ
1968 wxString& append(const wxCStrData& first, const wxCStrData& last)
1969 { return append(CreateConstIterator(first), CreateConstIterator(last)); }
1970#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
3c67202d
VZ
1971
1972 // same as `this_string = str'
735d1db6 1973 wxString& assign(const wxString& str)
8f93a29f 1974 { m_impl = str.m_impl; return *this; }
11aac4ba
VS
1975 wxString& assign(const wxString& str, size_t len)
1976 {
1977 m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
1978 return *this;
1979 }
3c67202d
VZ
1980 // same as ` = str[pos..pos + n]
1981 wxString& assign(const wxString& str, size_t pos, size_t n)
8f93a29f
VS
1982 {
1983 size_t from, len;
04848a06 1984 str.PosLenToImpl(pos, n, &from, &len);
8f93a29f
VS
1985 m_impl.assign(str.m_impl, from, len);
1986 return *this;
1987 }
3c67202d 1988 // same as `= first n (or all if n == npos) characters of sz'
8f93a29f
VS
1989 wxString& assign(const char *sz)
1990 { m_impl.assign(ImplStr(sz)); return *this; }
1991 wxString& assign(const wchar_t *sz)
1992 { m_impl.assign(ImplStr(sz)); return *this; }
1993 wxString& assign(const char *sz, size_t n)
1994 {
1995 SubstrBufFromMB str(ImplStr(sz, n));
1996 m_impl.assign(str.data, str.len);
1997 return *this;
1998 }
1999 wxString& assign(const wchar_t *sz, size_t n)
2000 {
2001 SubstrBufFromWC str(ImplStr(sz, n));
2002 m_impl.assign(str.data, str.len);
2003 return *this;
2004 }
d3cefe87
VS
2005
2006 wxString& assign(const wxCStrData& str)
2007 { return assign(str.AsString()); }
2008 wxString& assign(const wxCharBuffer& str)
2009 { return assign(str.data()); }
2010 wxString& assign(const wxWCharBuffer& str)
2011 { return assign(str.data()); }
2012 wxString& assign(const wxCStrData& str, size_t len)
2013 { return assign(str.AsString(), len); }
2014 wxString& assign(const wxCharBuffer& str, size_t len)
2015 { return assign(str.data(), len); }
2016 wxString& assign(const wxWCharBuffer& str, size_t len)
2017 { return assign(str.data(), len); }
2018
3c67202d 2019 // same as `= n copies of ch'
c9f78968 2020 wxString& assign(size_t n, wxUniChar ch)
8f93a29f
VS
2021 {
2022#if wxUSE_UNICODE_UTF8
2023 if ( !ch.IsAscii() )
467175ab 2024 m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
8f93a29f
VS
2025 else
2026#endif
2027 m_impl.assign(n, (wxStringCharType)ch);
2028 return *this;
2029 }
11aac4ba
VS
2030
2031 wxString& assign(size_t n, wxUniCharRef ch)
2032 { return assign(n, wxUniChar(ch)); }
2033 wxString& assign(size_t n, char ch)
2034 { return assign(n, wxUniChar(ch)); }
2035 wxString& assign(size_t n, unsigned char ch)
2036 { return assign(n, wxUniChar(ch)); }
2037 wxString& assign(size_t n, wchar_t ch)
2038 { return assign(n, wxUniChar(ch)); }
2039
e87b7833
MB
2040 // assign from first to last
2041 wxString& assign(const_iterator first, const_iterator last)
cf9a878b 2042 { m_impl.assign(first.impl(), last.impl()); return *this; }
67cff9dc 2043#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
f2a1b1bd
VZ
2044 wxString& assign(const char *first, const char *last)
2045 { return assign(first, last - first); }
2046 wxString& assign(const wchar_t *first, const wchar_t *last)
2047 { return assign(first, last - first); }
67cff9dc
VZ
2048 wxString& assign(const wxCStrData& first, const wxCStrData& last)
2049 { return assign(CreateConstIterator(first), CreateConstIterator(last)); }
2050#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
e87b7833
MB
2051
2052 // string comparison
8f93a29f 2053 int compare(const wxString& str) const;
d3cefe87
VS
2054 int compare(const char* sz) const;
2055 int compare(const wchar_t* sz) const;
2056 int compare(const wxCStrData& str) const
2057 { return compare(str.AsString()); }
2058 int compare(const wxCharBuffer& str) const
2059 { return compare(str.data()); }
2060 int compare(const wxWCharBuffer& str) const
2061 { return compare(str.data()); }
e87b7833 2062 // comparison with a substring
8f93a29f 2063 int compare(size_t nStart, size_t nLen, const wxString& str) const;
e87b7833
MB
2064 // comparison of 2 substrings
2065 int compare(size_t nStart, size_t nLen,
8f93a29f 2066 const wxString& str, size_t nStart2, size_t nLen2) const;
e87b7833
MB
2067 // substring comparison with first nCount characters of sz
2068 int compare(size_t nStart, size_t nLen,
8f93a29f
VS
2069 const char* sz, size_t nCount = npos) const;
2070 int compare(size_t nStart, size_t nLen,
2071 const wchar_t* sz, size_t nCount = npos) const;
3c67202d
VZ
2072
2073 // insert another string
e87b7833 2074 wxString& insert(size_t nPos, const wxString& str)
8f93a29f 2075 { insert(begin() + nPos, str.begin(), str.end()); return *this; }
3c67202d
VZ
2076 // insert n chars of str starting at nStart (in str)
2077 wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
8f93a29f
VS
2078 {
2079 size_t from, len;
04848a06 2080 str.PosLenToImpl(nStart, n, &from, &len);
8f93a29f
VS
2081 m_impl.insert(PosToImpl(nPos), str.m_impl, from, len);
2082 return *this;
2083 }
3c67202d 2084 // insert first n (or all if n == npos) characters of sz
8f93a29f
VS
2085 wxString& insert(size_t nPos, const char *sz)
2086 { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
2087 wxString& insert(size_t nPos, const wchar_t *sz)
2088 { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
2089 wxString& insert(size_t nPos, const char *sz, size_t n)
2090 {
2091 SubstrBufFromMB str(ImplStr(sz, n));
2092 m_impl.insert(PosToImpl(nPos), str.data, str.len);
2093 return *this;
2094 }
2095 wxString& insert(size_t nPos, const wchar_t *sz, size_t n)
2096 {
2097 SubstrBufFromWC str(ImplStr(sz, n));
2098 m_impl.insert(PosToImpl(nPos), str.data, str.len);
2099 return *this;
2100 }
3c67202d 2101 // insert n copies of ch
c9f78968 2102 wxString& insert(size_t nPos, size_t n, wxUniChar ch)
8f93a29f
VS
2103 {
2104#if wxUSE_UNICODE_UTF8
2105 if ( !ch.IsAscii() )
467175ab 2106 m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
8f93a29f
VS
2107 else
2108#endif
81727065 2109 m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
8f93a29f
VS
2110 return *this;
2111 }
c9f78968 2112 iterator insert(iterator it, wxUniChar ch)
81727065
VS
2113 {
2114#if wxUSE_UNICODE_UTF8
2115 if ( !ch.IsAscii() )
2116 {
2117 size_t pos = IterToImplPos(it);
467175ab 2118 m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
81727065
VS
2119 return iterator(this, m_impl.begin() + pos);
2120 }
2121 else
2122#endif
cf9a878b 2123 return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch));
81727065 2124 }
e87b7833 2125 void insert(iterator it, const_iterator first, const_iterator last)
cf9a878b 2126 { m_impl.insert(it.impl(), first.impl(), last.impl()); }
67cff9dc 2127#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
f2a1b1bd
VZ
2128 void insert(iterator it, const char *first, const char *last)
2129 { insert(it - begin(), first, last - first); }
67cff9dc 2130 void insert(iterator it, const wchar_t *first, const wchar_t *last)
f2a1b1bd 2131 { insert(it - begin(), first, last - first); }
67cff9dc
VZ
2132 void insert(iterator it, const wxCStrData& first, const wxCStrData& last)
2133 { insert(it, CreateConstIterator(first), CreateConstIterator(last)); }
2134#endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
2135
c9f78968 2136 void insert(iterator it, size_type n, wxUniChar ch)
8f93a29f
VS
2137 {
2138#if wxUSE_UNICODE_UTF8
2139 if ( !ch.IsAscii() )
467175ab 2140 m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
8f93a29f
VS
2141 else
2142#endif
cf9a878b 2143 m_impl.insert(it.impl(), n, (wxStringCharType)ch);
8f93a29f 2144 }
3c67202d
VZ
2145
2146 // delete characters from nStart to nStart + nLen
e87b7833 2147 wxString& erase(size_type pos = 0, size_type n = npos)
8f93a29f
VS
2148 {
2149 size_t from, len;
2150 PosLenToImpl(pos, n, &from, &len);
2151 m_impl.erase(from, len);
2152 return *this;
2153 }
f2a1b1bd 2154 // delete characters from first up to last
e87b7833 2155 iterator erase(iterator first, iterator last)
cf9a878b 2156 { return iterator(this, m_impl.erase(first.impl(), last.impl())); }
e87b7833 2157 iterator erase(iterator first)
cf9a878b 2158 { return iterator(this, m_impl.erase(first.impl())); }
e87b7833
MB
2159
2160#ifdef wxSTRING_BASE_HASNT_CLEAR
2161 void clear() { erase(); }
8f93a29f
VS
2162#else
2163 void clear() { m_impl.clear(); }
e87b7833 2164#endif
3c67202d
VZ
2165
2166 // replaces the substring of length nLen starting at nStart
8f93a29f
VS
2167 wxString& replace(size_t nStart, size_t nLen, const char* sz)
2168 {
2169 size_t from, len;
2170 PosLenToImpl(nStart, nLen, &from, &len);
2171 m_impl.replace(from, len, ImplStr(sz));
2172 return *this;
2173 }
2174 wxString& replace(size_t nStart, size_t nLen, const wchar_t* sz)
2175 {
2176 size_t from, len;
2177 PosLenToImpl(nStart, nLen, &from, &len);
2178 m_impl.replace(from, len, ImplStr(sz));
2179 return *this;
2180 }
e87b7833
MB
2181 // replaces the substring of length nLen starting at nStart
2182 wxString& replace(size_t nStart, size_t nLen, const wxString& str)
8f93a29f
VS
2183 {
2184 size_t from, len;
2185 PosLenToImpl(nStart, nLen, &from, &len);
2186 m_impl.replace(from, len, str.m_impl);
2187 return *this;
2188 }
3c67202d 2189 // replaces the substring with nCount copies of ch
c9f78968 2190 wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch)
8f93a29f
VS
2191 {
2192 size_t from, len;
2193 PosLenToImpl(nStart, nLen, &from, &len);
2194#if wxUSE_UNICODE_UTF8
2195 if ( !ch.IsAscii() )
467175ab 2196 m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
8f93a29f
VS
2197 else
2198#endif
2199 m_impl.replace(from, len, nCount, (wxStringCharType)ch);
2200 return *this;
2201 }
3c67202d
VZ
2202 // replaces a substring with another substring
2203 wxString& replace(size_t nStart, size_t nLen,
e87b7833 2204 const wxString& str, size_t nStart2, size_t nLen2)
8f93a29f
VS
2205 {
2206 size_t from, len;
2207 PosLenToImpl(nStart, nLen, &from, &len);
2208
2209 size_t from2, len2;
04848a06 2210 str.PosLenToImpl(nStart2, nLen2, &from2, &len2);
8f93a29f
VS
2211
2212 m_impl.replace(from, len, str.m_impl, from2, len2);
2213 return *this;
2214 }
e87b7833 2215 // replaces the substring with first nCount chars of sz
fb20fa43 2216 wxString& replace(size_t nStart, size_t nLen,
8f93a29f
VS
2217 const char* sz, size_t nCount)
2218 {
2219 size_t from, len;
2220 PosLenToImpl(nStart, nLen, &from, &len);
2221
2222 SubstrBufFromMB str(ImplStr(sz, nCount));
2223
2224 m_impl.replace(from, len, str.data, str.len);
2225 return *this;
2226 }
2227 wxString& replace(size_t nStart, size_t nLen,
2228 const wchar_t* sz, size_t nCount)
2229 {
2230 size_t from, len;
2231 PosLenToImpl(nStart, nLen, &from, &len);
2232
2233 SubstrBufFromWC str(ImplStr(sz, nCount));
2234
2235 m_impl.replace(from, len, str.data, str.len);
2236 return *this;
2237 }
11aac4ba
VS
2238 wxString& replace(size_t nStart, size_t nLen,
2239 const wxString& s, size_t nCount)
2240 {
2241 size_t from, len;
2242 PosLenToImpl(nStart, nLen, &from, &len);
2243 m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
2244 return *this;
2245 }
2246
8f93a29f 2247 wxString& replace(iterator first, iterator last, const char* s)
cf9a878b 2248 { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
8f93a29f 2249 wxString& replace(iterator first, iterator last, const wchar_t* s)
cf9a878b 2250 { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
8f93a29f
VS
2251 wxString& replace(iterator first, iterator last, const char* s, size_type n)
2252 {
2253 SubstrBufFromMB str(ImplStr(s, n));
cf9a878b 2254 m_impl.replace(first.impl(), last.impl(), str.data, str.len);
8f93a29f
VS
2255 return *this;
2256 }
2257 wxString& replace(iterator first, iterator last, const wchar_t* s, size_type n)
2258 {
2259 SubstrBufFromWC str(ImplStr(s, n));
cf9a878b 2260 m_impl.replace(first.impl(), last.impl(), str.data, str.len);
8f93a29f
VS
2261 return *this;
2262 }
e87b7833 2263 wxString& replace(iterator first, iterator last, const wxString& s)
cf9a878b 2264 { m_impl.replace(first.impl(), last.impl(), s.m_impl); return *this; }
8f93a29f
VS
2265 wxString& replace(iterator first, iterator last, size_type n, wxUniChar ch)
2266 {
2267#if wxUSE_UNICODE_UTF8
2268 if ( !ch.IsAscii() )
467175ab
VS
2269 m_impl.replace(first.impl(), last.impl(),
2270 wxStringOperations::EncodeNChars(n, ch));
8f93a29f
VS
2271 else
2272#endif
cf9a878b 2273 m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
8f93a29f
VS
2274 return *this;
2275 }
e87b7833
MB
2276 wxString& replace(iterator first, iterator last,
2277 const_iterator first1, const_iterator last1)
cf9a878b
VS
2278 {
2279 m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl());
2280 return *this;
2281 }
f2a1b1bd
VZ
2282 wxString& replace(iterator first, iterator last,
2283 const char *first1, const char *last1)
2284 { replace(first, last, first1, last1 - first1); return *this; }
2285 wxString& replace(iterator first, iterator last,
2286 const wchar_t *first1, const wchar_t *last1)
2287 { replace(first, last, first1, last1 - first1); return *this; }
8f93a29f
VS
2288
2289 // swap two strings
2290 void swap(wxString& str)
2291 { m_impl.swap(str.m_impl); }
2292
2293 // find a substring
2294 size_t find(const wxString& str, size_t nStart = 0) const
2295 { return PosFromImpl(m_impl.find(str.m_impl, PosToImpl(nStart))); }
2296
2297 // find first n characters of sz
2298 size_t find(const char* sz, size_t nStart = 0, size_t n = npos) const
2299 {
2300 SubstrBufFromMB str(ImplStr(sz, n));
2301 return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len));
2302 }
2303 size_t find(const wchar_t* sz, size_t nStart = 0, size_t n = npos) const
2304 {
2305 SubstrBufFromWC str(ImplStr(sz, n));
2306 return PosFromImpl(m_impl.find(str.data, PosToImpl(nStart), str.len));
2307 }
d3cefe87
VS
2308 size_t find(const wxCharBuffer& s, size_t nStart = 0, size_t n = npos) const
2309 { return find(s.data(), nStart, n); }
2310 size_t find(const wxWCharBuffer& s, size_t nStart = 0, size_t n = npos) const
2311 { return find(s.data(), nStart, n); }
2312 size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const
2313 { return find(s.AsWChar(), nStart, n); }
8f93a29f
VS
2314
2315 // find the first occurence of character ch after nStart
2316 size_t find(wxUniChar ch, size_t nStart = 0) const
467175ab 2317 {
84d2877f
VS
2318#if wxUSE_UNICODE_UTF8
2319 if ( !ch.IsAscii() )
2320 return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
2321 PosToImpl(nStart)));
2322 else
2323#endif
2324 return PosFromImpl(m_impl.find((wxStringCharType)ch,
2325 PosToImpl(nStart)));
2326
467175ab 2327 }
8f93a29f
VS
2328 size_t find(wxUniCharRef ch, size_t nStart = 0) const
2329 { return find(wxUniChar(ch), nStart); }
2330 size_t find(char ch, size_t nStart = 0) const
2331 { return find(wxUniChar(ch), nStart); }
50e02008
VS
2332 size_t find(unsigned char ch, size_t nStart = 0) const
2333 { return find(wxUniChar(ch), nStart); }
8f93a29f
VS
2334 size_t find(wchar_t ch, size_t nStart = 0) const
2335 { return find(wxUniChar(ch), nStart); }
2336
2337 // rfind() family is exactly like find() but works right to left
2338
2339 // as find, but from the end
2340 size_t rfind(const wxString& str, size_t nStart = npos) const
2341 { return PosFromImpl(m_impl.rfind(str.m_impl, PosToImpl(nStart))); }
2342
2343 // as find, but from the end
2344 size_t rfind(const char* sz, size_t nStart = npos, size_t n = npos) const
2345 {
2346 SubstrBufFromMB str(ImplStr(sz, n));
2347 return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len));
2348 }
2349 size_t rfind(const wchar_t* sz, size_t nStart = npos, size_t n = npos) const
2350 {
2351 SubstrBufFromWC str(ImplStr(sz, n));
2352 return PosFromImpl(m_impl.rfind(str.data, PosToImpl(nStart), str.len));
2353 }
d3cefe87
VS
2354 size_t rfind(const wxCharBuffer& s, size_t nStart = npos, size_t n = npos) const
2355 { return rfind(s.data(), nStart, n); }
2356 size_t rfind(const wxWCharBuffer& s, size_t nStart = npos, size_t n = npos) const
2357 { return rfind(s.data(), nStart, n); }
2358 size_t rfind(const wxCStrData& s, size_t nStart = npos, size_t n = npos) const
2359 { return rfind(s.AsWChar(), nStart, n); }
8f93a29f
VS
2360 // as find, but from the end
2361 size_t rfind(wxUniChar ch, size_t nStart = npos) const
467175ab 2362 {
84d2877f
VS
2363#if wxUSE_UNICODE_UTF8
2364 if ( !ch.IsAscii() )
2365 return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
2366 PosToImpl(nStart)));
2367 else
2368#endif
2369 return PosFromImpl(m_impl.rfind((wxStringCharType)ch,
2370 PosToImpl(nStart)));
467175ab 2371 }
8f93a29f
VS
2372 size_t rfind(wxUniCharRef ch, size_t nStart = npos) const
2373 { return rfind(wxUniChar(ch), nStart); }
2374 size_t rfind(char ch, size_t nStart = npos) const
2375 { return rfind(wxUniChar(ch), nStart); }
50e02008
VS
2376 size_t rfind(unsigned char ch, size_t nStart = npos) const
2377 { return rfind(wxUniChar(ch), nStart); }
8f93a29f
VS
2378 size_t rfind(wchar_t ch, size_t nStart = npos) const
2379 { return rfind(wxUniChar(ch), nStart); }
2380
2381 // find first/last occurence of any character (not) in the set:
2382#if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2383 // FIXME-UTF8: this is not entirely correct, because it doesn't work if
2384 // sizeof(wchar_t)==2 and surrogates are present in the string;
2385 // should we care? Probably not.
2386 size_t find_first_of(const wxString& str, size_t nStart = 0) const
a962cdf4 2387 { return m_impl.find_first_of(str.m_impl, nStart); }
8f93a29f
VS
2388 size_t find_first_of(const char* sz, size_t nStart = 0) const
2389 { return m_impl.find_first_of(ImplStr(sz), nStart); }
2390 size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const
2391 { return m_impl.find_first_of(ImplStr(sz), nStart); }
a962cdf4 2392 size_t find_first_of(const char* sz, size_t nStart, size_t n) const
8f93a29f 2393 { return m_impl.find_first_of(ImplStr(sz), nStart, n); }
a962cdf4 2394 size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const
8f93a29f
VS
2395 { return m_impl.find_first_of(ImplStr(sz), nStart, n); }
2396 size_t find_first_of(wxUniChar c, size_t nStart = 0) const
2397 { return m_impl.find_first_of((wxChar)c, nStart); }
2398
a962cdf4
VS
2399 size_t find_last_of(const wxString& str, size_t nStart = npos) const
2400 { return m_impl.find_last_of(str.m_impl, nStart); }
8f93a29f
VS
2401 size_t find_last_of(const char* sz, size_t nStart = npos) const
2402 { return m_impl.find_last_of(ImplStr(sz), nStart); }
2403 size_t find_last_of(const wchar_t* sz, size_t nStart = npos) const
2404 { return m_impl.find_last_of(ImplStr(sz), nStart); }
2405 size_t find_last_of(const char* sz, size_t nStart, size_t n) const
2406 { return m_impl.find_last_of(ImplStr(sz), nStart, n); }
2407 size_t find_last_of(const wchar_t* sz, size_t nStart, size_t n) const
2408 { return m_impl.find_last_of(ImplStr(sz), nStart, n); }
2409 size_t find_last_of(wxUniChar c, size_t nStart = npos) const
2410 { return m_impl.find_last_of((wxChar)c, nStart); }
2411
a962cdf4 2412 size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
8f93a29f 2413 { return m_impl.find_first_not_of(str.m_impl, nStart); }
a962cdf4 2414 size_t find_first_not_of(const char* sz, size_t nStart = 0) const
8f93a29f 2415 { return m_impl.find_first_not_of(ImplStr(sz), nStart); }
a962cdf4 2416 size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const
8f93a29f 2417 { return m_impl.find_first_not_of(ImplStr(sz), nStart); }
a962cdf4 2418 size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const
8f93a29f 2419 { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); }
a962cdf4 2420 size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const
8f93a29f 2421 { return m_impl.find_first_not_of(ImplStr(sz), nStart, n); }
a962cdf4 2422 size_t find_first_not_of(wxUniChar c, size_t nStart = 0) const
8f93a29f
VS
2423 { return m_impl.find_first_not_of((wxChar)c, nStart); }
2424
a962cdf4 2425 size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
8f93a29f 2426 { return m_impl.find_last_not_of(str.m_impl, nStart); }
a962cdf4 2427 size_t find_last_not_of(const char* sz, size_t nStart = npos) const
8f93a29f 2428 { return m_impl.find_last_not_of(ImplStr(sz), nStart); }
a962cdf4 2429 size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const
8f93a29f 2430 { return m_impl.find_last_not_of(ImplStr(sz), nStart); }
a962cdf4 2431 size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const
8f93a29f 2432 { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); }
a962cdf4 2433 size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const
8f93a29f 2434 { return m_impl.find_last_not_of(ImplStr(sz), nStart, n); }
a962cdf4 2435 size_t find_last_not_of(wxUniChar c, size_t nStart = npos) const
8f93a29f
VS
2436 { return m_impl.find_last_not_of((wxChar)c, nStart); }
2437#else
2438 // we can't use std::string implementation in UTF-8 build, because the
2439 // character sets would be interpreted wrongly:
2440
2441 // as strpbrk() but starts at nStart, returns npos if not found
2442 size_t find_first_of(const wxString& str, size_t nStart = 0) const
81727065 2443#if wxUSE_UNICODE // FIXME-UTF8: temporary
d3cefe87 2444 { return find_first_of(str.wc_str(), nStart); }
81727065 2445#else
d3cefe87 2446 { return find_first_of(str.mb_str(), nStart); }
81727065 2447#endif
8f93a29f
VS
2448 // same as above
2449 size_t find_first_of(const char* sz, size_t nStart = 0) const;
2450 size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const;
2451 size_t find_first_of(const char* sz, size_t nStart, size_t n) const;
2452 size_t find_first_of(const wchar_t* sz, size_t nStart, size_t n) const;
2453 // same as find(char, size_t)
2454 size_t find_first_of(wxUniChar c, size_t nStart = 0) const
2455 { return find(c, nStart); }
2456 // find the last (starting from nStart) char from str in this string
2457 size_t find_last_of (const wxString& str, size_t nStart = npos) const
81727065 2458#if wxUSE_UNICODE // FIXME-UTF8: temporary
d3cefe87 2459 { return find_last_of(str.wc_str(), nStart); }
81727065 2460#else
d3cefe87 2461 { return find_last_of(str.mb_str(), nStart); }
81727065 2462#endif
8f93a29f
VS
2463 // same as above
2464 size_t find_last_of (const char* sz, size_t nStart = npos) const;
2465 size_t find_last_of (const wchar_t* sz, size_t nStart = npos) const;
2466 size_t find_last_of(const char* sz, size_t nStart, size_t n) const;
2467 size_t find_last_of(const wchar_t* sz, size_t nStart, size_t n) const;
2468 // same as above
2469 size_t find_last_of(wxUniChar c, size_t nStart = npos) const
2470 { return rfind(c, nStart); }
2471
2472 // find first/last occurence of any character not in the set
2473
2474 // as strspn() (starting from nStart), returns npos on failure
2475 size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
81727065 2476#if wxUSE_UNICODE // FIXME-UTF8: temporary
d3cefe87 2477 { return find_first_not_of(str.wc_str(), nStart); }
81727065 2478#else
d3cefe87 2479 { return find_first_not_of(str.mb_str(), nStart); }
81727065 2480#endif
8f93a29f
VS
2481 // same as above
2482 size_t find_first_not_of(const char* sz, size_t nStart = 0) const;
2483 size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const;
2484 size_t find_first_not_of(const char* sz, size_t nStart, size_t n) const;
2485 size_t find_first_not_of(const wchar_t* sz, size_t nStart, size_t n) const;
2486 // same as above
2487 size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const;
2488 // as strcspn()
2489 size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
81727065 2490#if wxUSE_UNICODE // FIXME-UTF8: temporary
d3cefe87 2491 { return find_last_not_of(str.wc_str(), nStart); }
81727065 2492#else
d3cefe87 2493 { return find_last_not_of(str.mb_str(), nStart); }
81727065 2494#endif
8f93a29f
VS
2495 // same as above
2496 size_t find_last_not_of(const char* sz, size_t nStart = npos) const;
2497 size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const;
2498 size_t find_last_not_of(const char* sz, size_t nStart, size_t n) const;
2499 size_t find_last_not_of(const wchar_t* sz, size_t nStart, size_t n) const;
2500 // same as above
2501 size_t find_last_not_of(wxUniChar ch, size_t nStart = npos) const;
2502#endif // wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 or not
2503
2504 // provide char/wchar_t/wxUniCharRef overloads for char-finding functions
2505 // above to resolve ambiguities:
2506 size_t find_first_of(wxUniCharRef ch, size_t nStart = 0) const
2507 { return find_first_of(wxUniChar(ch), nStart); }
2508 size_t find_first_of(char ch, size_t nStart = 0) const
2509 { return find_first_of(wxUniChar(ch), nStart); }
50e02008
VS
2510 size_t find_first_of(unsigned char ch, size_t nStart = 0) const
2511 { return find_first_of(wxUniChar(ch), nStart); }
8f93a29f
VS
2512 size_t find_first_of(wchar_t ch, size_t nStart = 0) const
2513 { return find_first_of(wxUniChar(ch), nStart); }
2514 size_t find_last_of(wxUniCharRef ch, size_t nStart = npos) const
2515 { return find_last_of(wxUniChar(ch), nStart); }
2516 size_t find_last_of(char ch, size_t nStart = npos) const
2517 { return find_last_of(wxUniChar(ch), nStart); }
50e02008
VS
2518 size_t find_last_of(unsigned char ch, size_t nStart = npos) const
2519 { return find_last_of(wxUniChar(ch), nStart); }
8f93a29f
VS
2520 size_t find_last_of(wchar_t ch, size_t nStart = npos) const
2521 { return find_last_of(wxUniChar(ch), nStart); }
2522 size_t find_first_not_of(wxUniCharRef ch, size_t nStart = 0) const
2523 { return find_first_not_of(wxUniChar(ch), nStart); }
2524 size_t find_first_not_of(char ch, size_t nStart = 0) const
2525 { return find_first_not_of(wxUniChar(ch), nStart); }
50e02008
VS
2526 size_t find_first_not_of(unsigned char ch, size_t nStart = 0) const
2527 { return find_first_not_of(wxUniChar(ch), nStart); }
8f93a29f
VS
2528 size_t find_first_not_of(wchar_t ch, size_t nStart = 0) const
2529 { return find_first_not_of(wxUniChar(ch), nStart); }
2530 size_t find_last_not_of(wxUniCharRef ch, size_t nStart = npos) const
2531 { return find_last_not_of(wxUniChar(ch), nStart); }
2532 size_t find_last_not_of(char ch, size_t nStart = npos) const
2533 { return find_last_not_of(wxUniChar(ch), nStart); }
50e02008
VS
2534 size_t find_last_not_of(unsigned char ch, size_t nStart = npos) const
2535 { return find_last_not_of(wxUniChar(ch), nStart); }
8f93a29f
VS
2536 size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const
2537 { return find_last_not_of(wxUniChar(ch), nStart); }
3c67202d 2538
d3cefe87
VS
2539 // and additional overloads for the versions taking strings:
2540 size_t find_first_of(const wxCStrData& sz, size_t nStart = 0) const
2541 { return find_first_of(sz.AsString(), nStart); }
2542 size_t find_first_of(const wxCharBuffer& sz, size_t nStart = 0) const
2543 { return find_first_of(sz.data(), nStart); }
2544 size_t find_first_of(const wxWCharBuffer& sz, size_t nStart = 0) const
2545 { return find_first_of(sz.data(), nStart); }
2546 size_t find_first_of(const wxCStrData& sz, size_t nStart, size_t n) const
2547 { return find_first_of(sz.AsWChar(), nStart, n); }
2548 size_t find_first_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
2549 { return find_first_of(sz.data(), nStart, n); }
2550 size_t find_first_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
2551 { return find_first_of(sz.data(), nStart, n); }
2552
2553 size_t find_last_of(const wxCStrData& sz, size_t nStart = 0) const
2554 { return find_last_of(sz.AsString(), nStart); }
2555 size_t find_last_of(const wxCharBuffer& sz, size_t nStart = 0) const
2556 { return find_last_of(sz.data(), nStart); }
2557 size_t find_last_of(const wxWCharBuffer& sz, size_t nStart = 0) const
2558 { return find_last_of(sz.data(), nStart); }
2559 size_t find_last_of(const wxCStrData& sz, size_t nStart, size_t n) const
2560 { return find_last_of(sz.AsWChar(), nStart, n); }
2561 size_t find_last_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
2562 { return find_last_of(sz.data(), nStart, n); }
2563 size_t find_last_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
2564 { return find_last_of(sz.data(), nStart, n); }
2565
2566 size_t find_first_not_of(const wxCStrData& sz, size_t nStart = 0) const
2567 { return find_first_not_of(sz.AsString(), nStart); }
2568 size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart = 0) const
2569 { return find_first_not_of(sz.data(), nStart); }
2570 size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const
2571 { return find_first_not_of(sz.data(), nStart); }
2572 size_t find_first_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
2573 { return find_first_not_of(sz.AsWChar(), nStart, n); }
2574 size_t find_first_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
2575 { return find_first_not_of(sz.data(), nStart, n); }
2576 size_t find_first_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
2577 { return find_first_not_of(sz.data(), nStart, n); }
2578
2579 size_t find_last_not_of(const wxCStrData& sz, size_t nStart = 0) const
2580 { return find_last_not_of(sz.AsString(), nStart); }
2581 size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart = 0) const
2582 { return find_last_not_of(sz.data(), nStart); }
2583 size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart = 0) const
2584 { return find_last_not_of(sz.data(), nStart); }
2585 size_t find_last_not_of(const wxCStrData& sz, size_t nStart, size_t n) const
2586 { return find_last_not_of(sz.AsWChar(), nStart, n); }
2587 size_t find_last_not_of(const wxCharBuffer& sz, size_t nStart, size_t n) const
2588 { return find_last_not_of(sz.data(), nStart, n); }
2589 size_t find_last_not_of(const wxWCharBuffer& sz, size_t nStart, size_t n) const
2590 { return find_last_not_of(sz.data(), nStart, n); }
2591
e87b7833
MB
2592 // string += string
2593 wxString& operator+=(const wxString& s)
8f93a29f 2594 { m_impl += s.m_impl; return *this; }
e87b7833 2595 // string += C string
8f93a29f
VS
2596 wxString& operator+=(const char *psz)
2597 { m_impl += ImplStr(psz); return *this; }
2598 wxString& operator+=(const wchar_t *pwz)
2599 { m_impl += ImplStr(pwz); return *this; }
c9f78968 2600 wxString& operator+=(const wxCStrData& s)
8f93a29f 2601 { m_impl += s.AsString().m_impl; return *this; }
d3cefe87
VS
2602 wxString& operator+=(const wxCharBuffer& s)
2603 { return operator+=(s.data()); }
2604 wxString& operator+=(const wxWCharBuffer& s)
2605 { return operator+=(s.data()); }
e87b7833 2606 // string += char
c9f78968 2607 wxString& operator+=(wxUniChar ch)
84d2877f
VS
2608 {
2609#if wxUSE_UNICODE_UTF8
2610 if ( !ch.IsAscii() )
2611 m_impl += wxStringOperations::EncodeChar(ch);
2612 else
2613#endif
2614 m_impl += (wxStringCharType)ch;
2615 return *this;
2616 }
c9f78968 2617 wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
b7d40341 2618 wxString& operator+=(int ch) { return *this += wxUniChar(ch); }
c9f78968 2619 wxString& operator+=(char ch) { return *this += wxUniChar(ch); }
b77afb41 2620 wxString& operator+=(unsigned char ch) { return *this += wxUniChar(ch); }
c9f78968 2621 wxString& operator+=(wchar_t ch) { return *this += wxUniChar(ch); }
d8a4b666
VS
2622
2623private:
2523e9b7 2624#if !wxUSE_STL_BASED_WXSTRING
d8a4b666 2625 // helpers for wxStringBuffer and wxStringBufferLength
8f93a29f
VS
2626 wxStringCharType *DoGetWriteBuf(size_t nLen)
2627 { return m_impl.DoGetWriteBuf(nLen); }
2628 void DoUngetWriteBuf()
2629 { m_impl.DoUngetWriteBuf(); }
2630 void DoUngetWriteBuf(size_t nLen)
2631 { m_impl.DoUngetWriteBuf(nLen); }
2523e9b7 2632#endif // !wxUSE_STL_BASED_WXSTRING
c9f78968
VS
2633
2634#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
d1f6e2cf
VS
2635 #if !wxUSE_UTF8_LOCALE_ONLY
2636 int DoPrintfWchar(const wxChar *format, ...);
2637 static wxString DoFormatWchar(const wxChar *format, ...);
2638 #endif
2639 #if wxUSE_UNICODE_UTF8
2640 int DoPrintfUtf8(const char *format, ...);
2641 static wxString DoFormatUtf8(const char *format, ...);
2642 #endif
c9f78968 2643#endif
8f93a29f
VS
2644
2645#if !wxUSE_STL_BASED_WXSTRING
2646 // check string's data validity
2647 bool IsValid() const { return m_impl.GetStringData()->IsValid(); }
2648#endif
2649
2650private:
2651 wxStringImpl m_impl;
132276cf
VS
2652
2653 // buffers for compatibility conversion from (char*)c_str() and
2654 // (wchar_t*)c_str():
2655 // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
2656 template<typename T>
2657 struct ConvertedBuffer
2658 {
2659 ConvertedBuffer() : m_buf(NULL) {}
2660 ~ConvertedBuffer()
2661 { free(m_buf); }
2662
05f32fc3 2663 operator T*() const { return m_buf; }
132276cf
VS
2664
2665 ConvertedBuffer& operator=(T *str)
2666 {
2667 free(m_buf);
2668 m_buf = str;
2669 return *this;
2670 }
2671
2672 T *m_buf;
2673 };
111d9948 2674#if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
132276cf
VS
2675 ConvertedBuffer<char> m_convertedToChar;
2676#endif
2677#if !wxUSE_UNICODE_WCHAR
2678 ConvertedBuffer<wchar_t> m_convertedToWChar;
2679#endif
2523e9b7 2680
b0c4d5d7
VS
2681#if wxUSE_UNICODE_UTF8
2682 // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently
2683 // assigning to character pointer to by wxString::interator may
2684 // change the underlying wxStringImpl iterator, so we have to
2685 // keep track of all iterators and update them as necessary:
2686 struct wxStringIteratorNodeHead
2687 {
2688 wxStringIteratorNodeHead() : ptr(NULL) {}
2689 wxStringIteratorNode *ptr;
300b44a9
VS
2690
2691 // copying is disallowed as it would result in more than one pointer into
2692 // the same linked list
2693 DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead)
b0c4d5d7
VS
2694 };
2695
2696 wxStringIteratorNodeHead m_iterators;
2697
b5dbe15d
VS
2698 friend class WXDLLIMPEXP_FWD_BASE wxStringIteratorNode;
2699 friend class WXDLLIMPEXP_FWD_BASE wxUniCharRef;
b0c4d5d7
VS
2700#endif // wxUSE_UNICODE_UTF8
2701
b5dbe15d 2702 friend class WXDLLIMPEXP_FWD_BASE wxCStrData;
6798451b
VS
2703 friend class wxStringInternalBuffer;
2704 friend class wxStringInternalBufferLength;
c801d85f
KB
2705};
2706
c9f78968
VS
2707#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
2708 #pragma warning (default:4275)
2709#endif
2710
a962cdf4
VS
2711// string iterator operators that satisfy STL Random Access Iterator
2712// requirements:
b5343e06 2713inline wxString::iterator operator+(ptrdiff_t n, wxString::iterator i)
a962cdf4 2714 { return i + n; }
b5343e06 2715inline wxString::const_iterator operator+(ptrdiff_t n, wxString::const_iterator i)
a962cdf4 2716 { return i + n; }
b5343e06 2717inline wxString::reverse_iterator operator+(ptrdiff_t n, wxString::reverse_iterator i)
a962cdf4 2718 { return i + n; }
b5343e06 2719inline wxString::const_reverse_iterator operator+(ptrdiff_t n, wxString::const_reverse_iterator i)
a962cdf4
VS
2720 { return i + n; }
2721
1fc8cfbd
VZ
2722// notice that even though for many compilers the friend declarations above are
2723// enough, from the point of view of C++ standard we must have the declarations
2724// here as friend ones are not injected in the enclosing namespace and without
2725// them the code fails to compile with conforming compilers such as xlC or g++4
c9f78968 2726wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
8f93a29f
VS
2727wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const char *psz);
2728wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wchar_t *pwz);
2729wxString WXDLLIMPEXP_BASE operator+(const char *psz, const wxString& string);
2730wxString WXDLLIMPEXP_BASE operator+(const wchar_t *pwz, const wxString& string);
1fc8cfbd 2731
c9f78968
VS
2732wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch);
2733wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string);
2734
2735inline wxString operator+(const wxString& string, wxUniCharRef ch)
2736 { return string + (wxUniChar)ch; }
2737inline wxString operator+(const wxString& string, char ch)
2738 { return string + wxUniChar(ch); }
2739inline wxString operator+(const wxString& string, wchar_t ch)
2740 { return string + wxUniChar(ch); }
2741inline wxString operator+(wxUniCharRef ch, const wxString& string)
2742 { return (wxUniChar)ch + string; }
2743inline wxString operator+(char ch, const wxString& string)
2744 { return wxUniChar(ch) + string; }
2745inline wxString operator+(wchar_t ch, const wxString& string)
2746 { return wxUniChar(ch) + string; }
2747
b7146cbe 2748
a0f63de9 2749#define wxGetEmptyString() wxString()
07170120 2750
062dc5fc
VZ
2751// ----------------------------------------------------------------------------
2752// helper functions which couldn't be defined inline
2753// ----------------------------------------------------------------------------
2754
2755namespace wxPrivate
2756{
2757
2758#if wxUSE_UNICODE_WCHAR
2759
2760template <>
2761struct wxStringAsBufHelper<char>
2762{
2763 static wxCharBuffer Get(const wxString& s, size_t *len)
2764 {
2765 wxCharBuffer buf(s.mb_str());
2766 if ( len )
2767 *len = buf ? strlen(buf) : 0;
2768 return buf;
2769 }
2770};
2771
2772template <>
2773struct wxStringAsBufHelper<wchar_t>
2774{
2775 static wxWCharBuffer Get(const wxString& s, size_t *len)
2776 {
2777 if ( len )
2778 *len = s.length();
2779 return wxWCharBuffer::CreateNonOwned(s.wx_str());
2780 }
2781};
2782
2783#elif wxUSE_UNICODE_UTF8
2784
2785template <>
2786struct wxStringAsBufHelper<char>
2787{
2788 static wxCharBuffer Get(const wxString& s, size_t *len)
2789 {
2790 if ( len )
2791 *len = s.utf8_length();
2792 return wxCharBuffer::CreateNonOwned(s.wx_str());
2793 }
2794};
2795
2796template <>
2797struct wxStringAsBufHelper<wchar_t>
2798{
2799 static wxWCharBuffer Get(const wxString& s, size_t *len)
2800 {
2801 wxWCharBuffer wbuf(s.wc_str());
2802 if ( len )
2803 *len = wxWcslen(wbuf);
2804 return wbuf;
2805 }
2806};
2807
2808#endif // Unicode build kind
2809
2810} // namespace wxPrivate
2811
1d218550
VZ
2812// ----------------------------------------------------------------------------
2813// wxStringBuffer: a tiny class allowing to get a writable pointer into string
2814// ----------------------------------------------------------------------------
2815
2523e9b7
VS
2816#if !wxUSE_STL_BASED_WXSTRING
2817// string buffer for direct access to string data in their native
2818// representation:
6798451b 2819class wxStringInternalBuffer
2523e9b7
VS
2820{
2821public:
2822 typedef wxStringCharType CharType;
2823
6798451b 2824 wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024)
2523e9b7
VS
2825 : m_str(str), m_buf(NULL)
2826 { m_buf = m_str.DoGetWriteBuf(lenWanted); }
2827
6798451b 2828 ~wxStringInternalBuffer() { m_str.DoUngetWriteBuf(); }
2523e9b7
VS
2829
2830 operator wxStringCharType*() const { return m_buf; }
941b78cc 2831
2523e9b7
VS
2832private:
2833 wxString& m_str;
2834 wxStringCharType *m_buf;
2835
6798451b 2836 DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
2523e9b7
VS
2837};
2838
6798451b 2839class wxStringInternalBufferLength
941b78cc
MB
2840{
2841public:
2523e9b7
VS
2842 typedef wxStringCharType CharType;
2843
6798451b 2844 wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024)
2523e9b7
VS
2845 : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
2846 {
2847 m_buf = m_str.DoGetWriteBuf(lenWanted);
2848 wxASSERT(m_buf != NULL);
2849 }
2850
6798451b 2851 ~wxStringInternalBufferLength()
2523e9b7
VS
2852 {
2853 wxASSERT(m_lenSet);
2854 m_str.DoUngetWriteBuf(m_len);
2855 }
2856
2857 operator wxStringCharType*() const { return m_buf; }
2858 void SetLength(size_t length) { m_len = length; m_lenSet = true; }
2859
2860private:
2861 wxString& m_str;
2862 wxStringCharType *m_buf;
2863 size_t m_len;
2864 bool m_lenSet;
2865
6798451b 2866 DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
2523e9b7
VS
2867};
2868
2869#endif // !wxUSE_STL_BASED_WXSTRING
2870
2871template<typename T>
4ec4d861 2872class WXDLLIMPEXP_BASE wxStringTypeBufferBase
2523e9b7
VS
2873{
2874public:
2875 typedef T CharType;
2876
2877 wxStringTypeBufferBase(wxString& str, size_t lenWanted = 1024)
e87b7833 2878 : m_str(str), m_buf(lenWanted)
062dc5fc
VZ
2879 {
2880 // for compatibility with old wxStringBuffer which provided direct
2881 // access to wxString internal buffer, initialize ourselves with the
2882 // string initial contents
2883
2884 // FIXME-VC6: remove the ugly (CharType *)NULL and use normal
2885 // tchar_str<CharType>
2886 size_t len;
2887 const wxCharTypeBuffer<CharType> buf(str.tchar_str(&len, (CharType *)NULL));
2888 if ( buf )
2889 {
2890 if ( len > lenWanted )
2891 {
2892 // in this case there is not enough space for terminating NUL,
2893 // ensure that we still put it there
2894 m_buf.data()[lenWanted] = 0;
2895 len = lenWanted - 1;
2896 }
2897
39329d2e 2898 memcpy(m_buf.data(), buf, (len + 1)*sizeof(CharType));
062dc5fc
VZ
2899 }
2900 //else: conversion failed, this can happen when trying to get Unicode
2901 // string contents into a char string
2902 }
941b78cc 2903
2523e9b7 2904 operator CharType*() { return m_buf.data(); }
941b78cc 2905
2523e9b7 2906protected:
941b78cc 2907 wxString& m_str;
2523e9b7 2908 wxCharTypeBuffer<CharType> m_buf;
941b78cc
MB
2909};
2910
2523e9b7 2911template<typename T>
4ec4d861 2912class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
062dc5fc 2913 : public wxStringTypeBufferBase<T>
941b78cc
MB
2914{
2915public:
2523e9b7 2916 wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)
062dc5fc
VZ
2917 : wxStringTypeBufferBase<T>(str, lenWanted),
2918 m_len(0),
2919 m_lenSet(false)
941b78cc
MB
2920 { }
2921
062dc5fc
VZ
2922 ~wxStringTypeBufferLengthBase()
2923 {
2924 wxASSERT_MSG( this->m_lenSet, "forgot to call SetLength()" );
2925 }
2926
941b78cc
MB
2927 void SetLength(size_t length) { m_len = length; m_lenSet = true; }
2928
2523e9b7 2929protected:
062dc5fc
VZ
2930 size_t m_len;
2931 bool m_lenSet;
941b78cc
MB
2932};
2933
2523e9b7
VS
2934template<typename T>
2935class wxStringTypeBuffer : public wxStringTypeBufferBase<T>
2936{
2937public:
2938 wxStringTypeBuffer(wxString& str, size_t lenWanted = 1024)
062dc5fc
VZ
2939 : wxStringTypeBufferBase<T>(str, lenWanted)
2940 { }
2941
2523e9b7
VS
2942 ~wxStringTypeBuffer()
2943 {
2944 this->m_str.assign(this->m_buf.data());
2945 }
941b78cc 2946
2523e9b7
VS
2947 DECLARE_NO_COPY_CLASS(wxStringTypeBuffer)
2948};
2949
2950template<typename T>
2951class wxStringTypeBufferLength : public wxStringTypeBufferLengthBase<T>
1d218550
VZ
2952{
2953public:
2523e9b7 2954 wxStringTypeBufferLength(wxString& str, size_t lenWanted = 1024)
062dc5fc
VZ
2955 : wxStringTypeBufferLengthBase<T>(str, lenWanted)
2956 { }
e015c2a3 2957
2523e9b7
VS
2958 ~wxStringTypeBufferLength()
2959 {
2523e9b7
VS
2960 this->m_str.assign(this->m_buf.data(), this->m_len);
2961 }
e015c2a3 2962
2523e9b7
VS
2963 DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength)
2964};
e015c2a3 2965
2523e9b7 2966#if wxUSE_STL_BASED_WXSTRING
7c77f334
VZ
2967
2968WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<wxStringCharType> )
2969
6798451b 2970class wxStringInternalBuffer : public wxStringTypeBufferBase<wxStringCharType>
2523e9b7
VS
2971{
2972public:
6798451b 2973 wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024)
2523e9b7 2974 : wxStringTypeBufferBase<wxStringCharType>(str, lenWanted) {}
6798451b 2975 ~wxStringInternalBuffer()
2523e9b7 2976 { m_str.m_impl.assign(m_buf.data()); }
e015c2a3 2977
6798451b 2978 DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
1d218550
VZ
2979};
2980
7c77f334
VZ
2981WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
2982 wxStringTypeBufferLengthBase<wxStringCharType> )
2983
2984class wxStringInternalBufferLength
2985 : public wxStringTypeBufferLengthBase<wxStringCharType>
941b78cc
MB
2986{
2987public:
6798451b 2988 wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024)
2523e9b7 2989 : wxStringTypeBufferLengthBase<wxStringCharType>(str, lenWanted) {}
941b78cc 2990
6798451b 2991 ~wxStringInternalBufferLength()
941b78cc 2992 {
2523e9b7 2993 m_str.m_impl.assign(m_buf.data(), m_len);
941b78cc
MB
2994 }
2995
6798451b 2996 DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
941b78cc 2997};
062dc5fc 2998
2523e9b7
VS
2999#endif // wxUSE_STL_BASED_WXSTRING
3000
941b78cc 3001
2523e9b7
VS
3002#if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
3003typedef wxStringTypeBuffer<wxChar> wxStringBuffer;
3004typedef wxStringTypeBufferLength<wxChar> wxStringBufferLength;
3005#else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
6798451b
VS
3006typedef wxStringInternalBuffer wxStringBuffer;
3007typedef wxStringInternalBufferLength wxStringBufferLength;
8f93a29f 3008#endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
941b78cc 3009
7d46f92b 3010#if wxUSE_UNICODE_UTF8
628f87da
VS
3011typedef wxStringInternalBuffer wxUTF8StringBuffer;
3012typedef wxStringInternalBufferLength wxUTF8StringBufferLength;
7d46f92b 3013#elif wxUSE_UNICODE_WCHAR
7c77f334
VZ
3014
3015WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<char> )
3016
628f87da
VS
3017class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase<char>
3018{
3019public:
3020 wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024)
3021 : wxStringTypeBufferBase<char>(str, lenWanted) {}
3022 ~wxUTF8StringBuffer();
3023
3024 DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
3025};
3026
7c77f334
VZ
3027WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
3028
628f87da
VS
3029class WXDLLIMPEXP_BASE wxUTF8StringBufferLength
3030 : public wxStringTypeBufferLengthBase<char>
3031{
3032public:
3033 wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024)
3034 : wxStringTypeBufferLengthBase<char>(str, lenWanted) {}
3035 ~wxUTF8StringBufferLength();
3036
3037 DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
3038};
7d46f92b 3039#endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
628f87da
VS
3040
3041
c801d85f 3042// ---------------------------------------------------------------------------
3c67202d 3043// wxString comparison functions: operator versions are always case sensitive
c801d85f 3044// ---------------------------------------------------------------------------
f33fee2a 3045
831faf97 3046#define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p)
fb52c2b6
VZ
3047
3048wxDEFINE_ALL_COMPARISONS(const wxChar *, const wxString&, wxCMP_WXCHAR_STRING)
3049
3050#undef wxCMP_WXCHAR_STRING
3051
0cbe5ee3 3052inline bool operator==(const wxString& s1, const wxString& s2)
2712e317 3053 { return s1.IsSameAs(s2); }
0cbe5ee3 3054inline bool operator!=(const wxString& s1, const wxString& s2)
2712e317 3055 { return !s1.IsSameAs(s2); }
0cbe5ee3
VZ
3056inline bool operator< (const wxString& s1, const wxString& s2)
3057 { return s1.Cmp(s2) < 0; }
0cbe5ee3
VZ
3058inline bool operator> (const wxString& s1, const wxString& s2)
3059 { return s1.Cmp(s2) > 0; }
0cbe5ee3
VZ
3060inline bool operator<=(const wxString& s1, const wxString& s2)
3061 { return s1.Cmp(s2) <= 0; }
0cbe5ee3
VZ
3062inline bool operator>=(const wxString& s1, const wxString& s2)
3063 { return s1.Cmp(s2) >= 0; }
3c67202d 3064
5d0fac27
VS
3065inline bool operator==(const wxString& s1, const wxCStrData& s2)
3066 { return s1 == s2.AsString(); }
3067inline bool operator==(const wxCStrData& s1, const wxString& s2)
3068 { return s1.AsString() == s2; }
3069inline bool operator!=(const wxString& s1, const wxCStrData& s2)
3070 { return s1 != s2.AsString(); }
3071inline bool operator!=(const wxCStrData& s1, const wxString& s2)
3072 { return s1.AsString() != s2; }
3073
5ca07d0f 3074inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
f33fee2a 3075 { return (s1.Cmp((const wchar_t *)s2) == 0); }
5ca07d0f 3076inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
f33fee2a 3077 { return (s2.Cmp((const wchar_t *)s1) == 0); }
f6bcfd97
BP
3078inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
3079 { return (s1.Cmp((const wchar_t *)s2) != 0); }
3080inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
3081 { return (s2.Cmp((const wchar_t *)s1) != 0); }
be39d6f5 3082
5ca07d0f 3083inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
f33fee2a 3084 { return (s1.Cmp((const char *)s2) == 0); }
5ca07d0f 3085inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
f33fee2a 3086 { return (s2.Cmp((const char *)s1) == 0); }
f6bcfd97
BP
3087inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
3088 { return (s1.Cmp((const char *)s2) != 0); }
3089inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
3090 { return (s2.Cmp((const char *)s1) != 0); }
5ca07d0f 3091
6d56eb5c 3092inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
e90c1d2a 3093 { return string + (const wchar_t *)buf; }
6d56eb5c 3094inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
e90c1d2a 3095 { return (const wchar_t *)buf + string; }
be39d6f5 3096
6d56eb5c 3097inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
e90c1d2a 3098 { return string + (const char *)buf; }
6d56eb5c 3099inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
e90c1d2a 3100 { return (const char *)buf + string; }
f04f3991 3101
a962cdf4 3102// comparison with char
c9f78968
VS
3103inline bool operator==(const wxUniChar& c, const wxString& s) { return s.IsSameAs(c); }
3104inline bool operator==(const wxUniCharRef& c, const wxString& s) { return s.IsSameAs(c); }
3105inline bool operator==(char c, const wxString& s) { return s.IsSameAs(c); }
3106inline bool operator==(wchar_t c, const wxString& s) { return s.IsSameAs(c); }
3107inline bool operator==(int c, const wxString& s) { return s.IsSameAs(c); }
3108inline bool operator==(const wxString& s, const wxUniChar& c) { return s.IsSameAs(c); }
3109inline bool operator==(const wxString& s, const wxUniCharRef& c) { return s.IsSameAs(c); }
3110inline bool operator==(const wxString& s, char c) { return s.IsSameAs(c); }
3111inline bool operator==(const wxString& s, wchar_t c) { return s.IsSameAs(c); }
3112inline bool operator!=(const wxUniChar& c, const wxString& s) { return !s.IsSameAs(c); }
3113inline bool operator!=(const wxUniCharRef& c, const wxString& s) { return !s.IsSameAs(c); }
3114inline bool operator!=(char c, const wxString& s) { return !s.IsSameAs(c); }
3115inline bool operator!=(wchar_t c, const wxString& s) { return !s.IsSameAs(c); }
3116inline bool operator!=(int c, const wxString& s) { return !s.IsSameAs(c); }
3117inline bool operator!=(const wxString& s, const wxUniChar& c) { return !s.IsSameAs(c); }
3118inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsSameAs(c); }
3119inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
3120inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
e51b17a1 3121
d7330233
VS
3122// comparison with C string in Unicode build
3123#if wxUSE_UNICODE
fb52c2b6
VZ
3124
3125#define wxCMP_CHAR_STRING(p, s, op) wxString(p) op s
3126
3127wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING)
3128
3129#undef wxCMP_CHAR_STRING
3130
d7330233
VS
3131#endif // wxUSE_UNICODE
3132
fb52c2b6
VZ
3133// we also need to provide the operators for comparison with wxCStrData to
3134// resolve ambiguity between operator(const wxChar *,const wxString &) and
3135// operator(const wxChar *, const wxChar *) for "p == s.c_str()"
3136//
3137// notice that these are (shallow) pointer comparisons, not (deep) string ones
3138#define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
3139#define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
3140
11aac4ba
VS
3141wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA)
3142wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA)
fb52c2b6
VZ
3143
3144#undef wxCMP_CHAR_CSTRDATA
3145#undef wxCMP_WCHAR_CSTRDATA
3146
c801d85f 3147// ---------------------------------------------------------------------------
3c67202d 3148// Implementation only from here until the end of file
c801d85f
KB
3149// ---------------------------------------------------------------------------
3150
e87b7833 3151#if wxUSE_STD_IOSTREAM
c801d85f 3152
65f19af1 3153#include "wx/iosfwrap.h"
c801d85f 3154
bddd7a8d 3155WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
c9f78968 3156WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);
04abe4bc
VS
3157WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&);
3158#ifndef __BORLANDC__
3159WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&);
3160#endif
c801d85f 3161
6a6ea041 3162#if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
6b61b594
VZ
3163
3164WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&);
3165WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&);
3166WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxWCharBuffer&);
3167
6a6ea041 3168#endif // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
6b61b594 3169
7a906e1a 3170#endif // wxUSE_STD_IOSTREAM
c801d85f 3171
c9f78968
VS
3172// ---------------------------------------------------------------------------
3173// wxCStrData implementation
3174// ---------------------------------------------------------------------------
3175
3176inline wxCStrData::wxCStrData(char *buf)
3177 : m_str(new wxString(buf)), m_offset(0), m_owned(true) {}
3178inline wxCStrData::wxCStrData(wchar_t *buf)
3179 : m_str(new wxString(buf)), m_offset(0), m_owned(true) {}
3180
92a17abc
VS
3181inline wxCStrData::wxCStrData(const wxCStrData& data)
3182 : m_str(data.m_owned ? new wxString(*data.m_str) : data.m_str),
3183 m_offset(data.m_offset),
3184 m_owned(data.m_owned)
3185{
3186}
3187
c9f78968
VS
3188inline wxCStrData::~wxCStrData()
3189{
3190 if ( m_owned )
b052a864 3191 delete wx_const_cast(wxString*, m_str); // cast to silence warnings
c9f78968
VS
3192}
3193
11aac4ba
VS
3194// simple cases for AsChar() and AsWChar(), the complicated ones are
3195// in string.cpp
3196#if wxUSE_UNICODE_WCHAR
c9f78968 3197inline const wchar_t* wxCStrData::AsWChar() const
11aac4ba
VS
3198{
3199 return m_str->wx_str() + m_offset;
3200}
3201#endif // wxUSE_UNICODE_WCHAR
3202
bfb6847d 3203#if !wxUSE_UNICODE
c9f78968 3204inline const char* wxCStrData::AsChar() const
c9f78968 3205{
bfb6847d 3206 return m_str->wx_str() + m_offset;
c9f78968 3207}
11aac4ba 3208#endif // !wxUSE_UNICODE
c9f78968 3209
bfb6847d
VS
3210#if wxUSE_UTF8_LOCALE_ONLY
3211inline const char* wxCStrData::AsChar() const
3212{
3213 return wxStringOperations::AddToIter(m_str->wx_str(), m_offset);
3214}
3215#endif // wxUSE_UTF8_LOCALE_ONLY
3216
681e4412
VS
3217inline const wxCharBuffer wxCStrData::AsCharBuf() const
3218{
3219#if !wxUSE_UNICODE
3220 return wxCharBuffer::CreateNonOwned(AsChar());
3221#else
3222 return AsString().mb_str();
3223#endif
3224}
3225
3226inline const wxWCharBuffer wxCStrData::AsWCharBuf() const
3227{
3228#if wxUSE_UNICODE_WCHAR
3229 return wxWCharBuffer::CreateNonOwned(AsWChar());
3230#else
3231 return AsString().wc_str();
3232#endif
3233}
3234
c9f78968
VS
3235inline wxString wxCStrData::AsString() const
3236{
3237 if ( m_offset == 0 )
3238 return *m_str;
3239 else
3240 return m_str->Mid(m_offset);
3241}
3242
2523e9b7
VS
3243inline const wxStringCharType *wxCStrData::AsInternal() const
3244{
bfb6847d 3245#if wxUSE_UNICODE_UTF8
2523e9b7 3246 return wxStringOperations::AddToIter(m_str->wx_str(), m_offset);
bfb6847d
VS
3247#else
3248 return m_str->wx_str() + m_offset;
3249#endif
2523e9b7
VS
3250}
3251
c9f78968
VS
3252inline wxUniChar wxCStrData::operator*() const
3253{
3254 if ( m_str->empty() )
3255 return wxUniChar(_T('\0'));
3256 else
3257 return (*m_str)[m_offset];
3258}
3259
3260inline wxUniChar wxCStrData::operator[](size_t n) const
3261{
378964d4
VS
3262 // NB: we intentionally use operator[] and not at() here because the former
3263 // works for the terminating NUL while the latter does not
3264 return (*m_str)[m_offset + n];
c9f78968
VS
3265}
3266
cc5bd48e
VZ
3267// ----------------------------------------------------------------------------
3268// more wxCStrData operators
3269// ----------------------------------------------------------------------------
3270
3271// we need to define those to allow "size_t pos = p - s.c_str()" where p is
3272// some pointer into the string
3273inline size_t operator-(const char *p, const wxCStrData& cs)
3274{
3275 return p - cs.AsChar();
3276}
3277
3278inline size_t operator-(const wchar_t *p, const wxCStrData& cs)
3279{
3280 return p - cs.AsWChar();
3281}
3282
414b7b40
VZ
3283// ----------------------------------------------------------------------------
3284// implementation of wx[W]CharBuffer inline methods using wxCStrData
3285// ----------------------------------------------------------------------------
3286
11aac4ba
VS
3287// FIXME-UTF8: move this to buffer.h
3288inline wxCharBuffer::wxCharBuffer(const wxCStrData& cstr)
681e4412 3289 : wxCharTypeBufferBase(cstr.AsCharBuf())
11aac4ba
VS
3290{
3291}
3292
3293inline wxWCharBuffer::wxWCharBuffer(const wxCStrData& cstr)
681e4412 3294 : wxCharTypeBufferBase(cstr.AsWCharBuf())
414b7b40
VZ
3295{
3296}
3297
b0c4d5d7
VS
3298#if wxUSE_UNICODE_UTF8
3299// ----------------------------------------------------------------------------
3300// implementation of wxStringIteratorNode inline methods
3301// ----------------------------------------------------------------------------
3302
39c20230
VS
3303void wxStringIteratorNode::DoSet(const wxString *str,
3304 wxStringImpl::const_iterator *citer,
3305 wxStringImpl::iterator *iter)
b0c4d5d7 3306{
42fc0309 3307 m_prev = NULL;
39c20230
VS
3308 m_iter = iter;
3309 m_citer = citer;
3310 m_str = str;
3311 if ( str )
3312 {
3313 m_next = str->m_iterators.ptr;
3314 wx_const_cast(wxString*, m_str)->m_iterators.ptr = this;
3315 if ( m_next )
3316 m_next->m_prev = this;
3317 }
42fc0309
VS
3318 else
3319 {
3320 m_next = NULL;
3321 }
b0c4d5d7
VS
3322}
3323
39c20230 3324void wxStringIteratorNode::clear()
b0c4d5d7
VS
3325{
3326 if ( m_next )
3327 m_next->m_prev = m_prev;
3328 if ( m_prev )
3329 m_prev->m_next = m_next;
39c20230 3330 else if ( m_str ) // first in the list
b0c4d5d7 3331 wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next;
39c20230
VS
3332
3333 m_next = m_prev = NULL;
3334 m_citer = NULL;
3335 m_iter = NULL;
3336 m_str = NULL;
b0c4d5d7
VS
3337}
3338#endif // wxUSE_UNICODE_UTF8
3339
e3e8e3c0 3340#if WXWIN_COMPATIBILITY_2_8
3a3dde0d 3341 // lot of code out there doesn't explicitly include wx/crt.h, but uses
e3e8e3c0
VS
3342 // CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h,
3343 // so let's include this header now that wxString is defined and it's safe
3344 // to do it:
3a3dde0d 3345 #include "wx/crt.h"
e3e8e3c0
VS
3346#endif
3347
11aac4ba 3348#endif // _WX_WXSTRING_H_