1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxString class
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
13 Efficient string class [more or less] compatible with MFC CString,
14 wxWidgets version 1 wxString and std::string and some handy functions
15 missing from string.h.
18 #ifndef _WX_WXSTRING_H__
19 #define _WX_WXSTRING_H__
21 // ----------------------------------------------------------------------------
23 // ----------------------------------------------------------------------------
25 #include "wx/defs.h" // everybody should include this
27 #if defined(__WXMAC__) || defined(__VISAGECPP__)
31 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
32 // problem in VACPP V4 with including stdlib.h multiple times
33 // strconv includes it anyway
46 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
47 #include <strings.h> // for strcasecmp()
48 #endif // HAVE_STRCASECMP_IN_STRINGS_H
51 #include <StringMgr.h>
54 #include "wx/wxcrt.h" // for wxChar, wxStrlen() etc.
55 #include "wx/strvararg.h"
56 #include "wx/buffer.h" // for wxCharBuffer
57 #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
58 #include "wx/stringimpl.h"
59 #include "wx/stringops.h"
60 #include "wx/unichar.h"
62 class WXDLLIMPEXP_BASE wxString
;
64 // unless this symbol is predefined to disable the compatibility functions, do
66 #ifndef WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
67 #define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1
70 // ---------------------------------------------------------------------------
72 // ---------------------------------------------------------------------------
74 // casts [unfortunately!] needed to call some broken functions which require
75 // "char *" instead of "const char *"
76 #define WXSTRINGCAST (wxChar *)(const wxChar *)
77 #define wxCSTRINGCAST (wxChar *)(const wxChar *)
78 #define wxMBSTRINGCAST (char *)(const char *)
79 #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
81 // ----------------------------------------------------------------------------
83 // ----------------------------------------------------------------------------
85 #if WXWIN_COMPATIBILITY_2_6
87 // deprecated in favour of wxString::npos, don't use in new code
89 // maximum possible length for a string means "take all string" everywhere
90 #define wxSTRING_MAXLEN wxString::npos
92 #endif // WXWIN_COMPATIBILITY_2_6
94 // ---------------------------------------------------------------------------
95 // global functions complementing standard C string library replacements for
96 // strlen() and portable strcasecmp()
97 //---------------------------------------------------------------------------
99 #if WXWIN_COMPATIBILITY_2_8
100 // Use wxXXX() functions from wxcrt.h instead! These functions are for
101 // backwards compatibility only.
103 // checks whether the passed in pointer is NULL and if the string is empty
104 wxDEPRECATED( inline bool IsEmpty(const char *p
) );
105 inline bool IsEmpty(const char *p
) { return (!p
|| !*p
); }
107 // safe version of strlen() (returns 0 if passed NULL pointer)
108 wxDEPRECATED( inline size_t Strlen(const char *psz
) );
109 inline size_t Strlen(const char *psz
)
110 { return psz
? strlen(psz
) : 0; }
112 // portable strcasecmp/_stricmp
113 wxDEPRECATED( inline int Stricmp(const char *psz1
, const char *psz2
) );
114 inline int Stricmp(const char *psz1
, const char *psz2
)
116 #if defined(__VISUALC__) && defined(__WXWINCE__)
117 register char c1
, c2
;
119 c1
= tolower(*psz1
++);
120 c2
= tolower(*psz2
++);
121 } while ( c1
&& (c1
== c2
) );
124 #elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
125 return _stricmp(psz1
, psz2
);
126 #elif defined(__SC__)
127 return _stricmp(psz1
, psz2
);
128 #elif defined(__SALFORDC__)
129 return stricmp(psz1
, psz2
);
130 #elif defined(__BORLANDC__)
131 return stricmp(psz1
, psz2
);
132 #elif defined(__WATCOMC__)
133 return stricmp(psz1
, psz2
);
134 #elif defined(__DJGPP__)
135 return stricmp(psz1
, psz2
);
136 #elif defined(__EMX__)
137 return stricmp(psz1
, psz2
);
138 #elif defined(__WXPM__)
139 return stricmp(psz1
, psz2
);
140 #elif defined(__WXPALMOS__) || \
141 defined(HAVE_STRCASECMP_IN_STRING_H) || \
142 defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
143 defined(__GNUWIN32__)
144 return strcasecmp(psz1
, psz2
);
145 #elif defined(__MWERKS__) && !defined(__INTEL__)
146 register char c1
, c2
;
148 c1
= tolower(*psz1
++);
149 c2
= tolower(*psz2
++);
150 } while ( c1
&& (c1
== c2
) );
154 // almost all compilers/libraries provide this function (unfortunately under
155 // different names), that's why we don't implement our own which will surely
156 // be more efficient than this code (uncomment to use):
158 register char c1, c2;
160 c1 = tolower(*psz1++);
161 c2 = tolower(*psz2++);
162 } while ( c1 && (c1 == c2) );
167 #error "Please define string case-insensitive compare for your OS/compiler"
168 #endif // OS/compiler
171 #endif // WXWIN_COMPATIBILITY_2_8
173 // ----------------------------------------------------------------------------
175 // ----------------------------------------------------------------------------
177 // Lightweight object returned by wxString::c_str() and implicitly convertible
178 // to either const char* or const wchar_t*.
179 class WXDLLIMPEXP_BASE wxCStrData
182 // Ctors; for internal use by wxString and wxCStrData only
183 wxCStrData(const wxString
*str
, size_t offset
= 0, bool owned
= false)
184 : m_str(str
), m_offset(offset
), m_owned(owned
) {}
187 // Ctor constructs the object from char literal; they are needed to make
188 // operator?: compile and they intentionally take char*, not const char*
189 inline wxCStrData(char *buf
);
190 inline wxCStrData(wchar_t *buf
);
191 inline wxCStrData(const wxCStrData
& data
);
193 inline ~wxCStrData();
195 // methods defined inline below must be declared inline or mingw32 3.4.5
196 // warns about "<symbol> defined locally after being referenced with
197 // dllimport linkage"
198 #if wxUSE_UNICODE_WCHAR
201 const wchar_t* AsWChar() const;
202 operator const wchar_t*() const { return AsWChar(); }
204 #if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
207 const char* AsChar() const;
208 const unsigned char* AsUnsignedChar() const
209 { return (const unsigned char *) AsChar(); }
210 operator const char*() const { return AsChar(); }
211 operator const unsigned char*() const { return AsUnsignedChar(); }
213 operator const void*() const { return AsChar(); }
215 inline const wxCharBuffer
AsCharBuf() const;
216 inline const wxWCharBuffer
AsWCharBuf() const;
218 inline wxString
AsString() const;
220 // returns the value as C string in internal representation (equivalent
221 // to AsString().wx_str(), but more efficient)
222 const wxStringCharType
*AsInternal() const;
224 // allow expressions like "c_str()[0]":
225 inline wxUniChar
operator[](size_t n
) const;
226 wxUniChar
operator[](int n
) const { return operator[](size_t(n
)); }
227 wxUniChar
operator[](long n
) const { return operator[](size_t(n
)); }
228 #ifndef wxSIZE_T_IS_UINT
229 wxUniChar
operator[](unsigned int n
) const { return operator[](size_t(n
)); }
230 #endif // size_t != unsigned int
232 // these operators are needed to emulate the pointer semantics of c_str():
233 // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
234 // (we need both versions to resolve ambiguities):
235 wxCStrData
operator+(int n
) const
236 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
237 wxCStrData
operator+(long n
) const
238 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
239 wxCStrData
operator+(size_t n
) const
240 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
242 // and these for "str.c_str() + n - 2":
243 wxCStrData
operator-(int n
) const
245 wxASSERT_MSG( n
<= (int)m_offset
,
246 _T("attempt to construct address before the beginning of the string") );
247 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
249 wxCStrData
operator-(long n
) const
251 wxASSERT_MSG( n
<= (int)m_offset
,
252 _T("attempt to construct address before the beginning of the string") );
253 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
255 wxCStrData
operator-(size_t n
) const
257 wxASSERT_MSG( n
<= m_offset
,
258 _T("attempt to construct address before the beginning of the string") );
259 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
262 // this operator is needed to make expressions like "*c_str()" or
263 // "*(c_str() + 2)" work
264 inline wxUniChar
operator*() const;
267 const wxString
*m_str
;
271 friend class WXDLLIMPEXP_BASE wxString
;
274 // ----------------------------------------------------------------------------
275 // wxStringPrintfMixin
276 // ---------------------------------------------------------------------------
278 // NB: VC6 has a bug that causes linker errors if you have template methods
279 // in a class using __declspec(dllimport). The solution is to split such
280 // class into two classes, one that contains the template methods and does
281 // *not* use WXDLLIMPEXP_BASE and another class that contains the rest
282 // (with DLL linkage).
284 // We only do this for VC6 here, because the code is less efficient
285 // (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler
286 // cannot compile this code.
288 #if defined(__VISUALC__) && __VISUALC__ < 1300
289 #define wxNEEDS_WXSTRING_PRINTF_MIXIN
292 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
293 // this class contains implementation of wxString's vararg methods, it's
294 // exported from wxBase DLL
295 class WXDLLIMPEXP_BASE wxStringPrintfMixinBase
298 wxStringPrintfMixinBase() {}
300 #if !wxUSE_UTF8_LOCALE_ONLY
301 int DoPrintfWchar(const wxChar
*format
, ...);
302 static wxString
DoFormatWchar(const wxChar
*format
, ...);
304 #if wxUSE_UNICODE_UTF8
305 int DoPrintfUtf8(const char *format
, ...);
306 static wxString
DoFormatUtf8(const char *format
, ...);
310 // this class contains template wrappers for wxString's vararg methods, it's
311 // intentionally *not* exported from the DLL in order to fix the VC6 bug
313 class wxStringPrintfMixin
: public wxStringPrintfMixinBase
316 // to further complicate things, we can't return wxString from
317 // wxStringPrintfMixin::Format() because wxString is not yet declared at
318 // this point; the solution is to use this fake type trait template - this
319 // way the compiler won't know the return type until Format() is used
320 // (this doesn't compile with Watcom, but VC6 compiles it just fine):
321 template<typename T
> struct StringReturnType
323 typedef wxString type
;
327 // these are duplicated wxString methods, they're also declared below
328 // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
330 // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1;
331 WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType
<T1
>::type
,
332 Format
, 1, (const wxString
&),
333 DoFormatWchar
, DoFormatUtf8
)
334 // We have to implement the version without template arguments manually
335 // because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC
336 // normally does it itself. It has to be a template so that we can use
337 // the hack, even though there's no real template parameter:
338 struct FormatDummyArg
{} ;
341 inline static typename StringReturnType
<T
>::type
342 Format(const wxString
& fmt
, FormatDummyArg dummy
= FormatDummyArg())
344 return DoFormat(fmt
);
347 // int Printf(const wxString& format, ...);
348 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wxString
&),
349 DoPrintfWchar
, DoPrintfUtf8
)
350 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
351 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wxString
&),
352 DoPrintfWchar
, DoPrintfUtf8
)
355 wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
357 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
360 // ----------------------------------------------------------------------------
361 // wxString: string class trying to be compatible with std::string, MFC
362 // CString and wxWindows 1.x wxString all at once
363 // ---------------------------------------------------------------------------
365 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
366 // "non dll-interface class 'wxStringPrintfMixin' used as base interface
367 // for dll-interface class 'wxString'" -- this is OK in our case
368 #pragma warning (disable:4275)
371 class WXDLLIMPEXP_BASE wxString
372 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
373 : public wxStringPrintfMixin
376 // NB: special care was taken in arranging the member functions in such order
377 // that all inline functions can be effectively inlined, verify that all
378 // performance critical functions are still inlined if you change order!
380 // an 'invalid' value for string index, moved to this place due to a CW bug
381 static const size_t npos
;
384 // if we hadn't made these operators private, it would be possible to
385 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
386 // converted to char in C and we do have operator=(char)
388 // NB: we don't need other versions (short/long and unsigned) as attempt
389 // to assign another numeric type to wxString will now result in
390 // ambiguity between operator=(char) and operator=(int)
391 wxString
& operator=(int);
393 // these methods are not implemented - there is _no_ conversion from int to
394 // string, you're doing something wrong if the compiler wants to call it!
396 // try `s << i' or `s.Printf("%d", i)' instead
400 // buffer for holding temporary substring when using any of the methods
401 // that take (char*,size_t) or (wchar_t*,size_t) arguments:
403 struct SubstrBufFromType
408 SubstrBufFromType(const T
& data_
, size_t len_
)
409 : data(data_
), len(len_
) {}
412 #if wxUSE_UNICODE_UTF8
413 // even char* -> char* needs conversion, from locale charset to UTF-8
414 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
415 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromMB
;
416 #elif wxUSE_UNICODE_WCHAR
417 typedef SubstrBufFromType
<const wchar_t*> SubstrBufFromWC
;
418 typedef SubstrBufFromType
<wxWCharBuffer
> SubstrBufFromMB
;
420 typedef SubstrBufFromType
<const char*> SubstrBufFromMB
;
421 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
425 // Functions implementing primitive operations on string data; wxString
426 // methods and iterators are implemented in terms of it. The differences
427 // between UTF-8 and wchar_t* representations of the string are mostly
430 #if wxUSE_UNICODE_UTF8
431 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
432 const wxMBConv
& conv
);
433 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
434 const wxMBConv
& conv
);
435 #elif wxUSE_UNICODE_WCHAR
436 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
437 const wxMBConv
& conv
);
439 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
440 const wxMBConv
& conv
);
443 #if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE
444 // returns C string encoded as the implementation expects:
446 static const wchar_t* ImplStr(const wchar_t* str
)
447 { return str
? str
: wxT(""); }
448 static const SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
449 { return SubstrBufFromWC(str
, (str
&& n
== npos
) ? wxWcslen(str
) : n
); }
450 static wxWCharBuffer
ImplStr(const char* str
,
451 const wxMBConv
& conv
= wxConvLibc
)
452 { return ConvertStr(str
, npos
, conv
).data
; }
453 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
454 const wxMBConv
& conv
= wxConvLibc
)
455 { return ConvertStr(str
, n
, conv
); }
457 static const char* ImplStr(const char* str
,
458 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
459 { return str
? str
: ""; }
460 static const SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
461 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
462 { return SubstrBufFromMB(str
, (str
&& n
== npos
) ? wxStrlen(str
) : n
); }
463 static wxCharBuffer
ImplStr(const wchar_t* str
)
464 { return ConvertStr(str
, npos
, wxConvLibc
).data
; }
465 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
466 { return ConvertStr(str
, n
, wxConvLibc
); }
469 // translates position index in wxString to/from index in underlying
471 static size_t PosToImpl(size_t pos
) { return pos
; }
472 static void PosLenToImpl(size_t pos
, size_t len
,
473 size_t *implPos
, size_t *implLen
)
474 { *implPos
= pos
; *implLen
= len
; }
475 static size_t LenToImpl(size_t len
) { return len
; }
476 static size_t PosFromImpl(size_t pos
) { return pos
; }
478 #else // wxUSE_UNICODE_UTF8
480 static wxCharBuffer
ImplStr(const char* str
,
481 const wxMBConv
& conv
= wxConvLibc
)
482 { return ConvertStr(str
, npos
, conv
).data
; }
483 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
484 const wxMBConv
& conv
= wxConvLibc
)
485 { return ConvertStr(str
, n
, conv
); }
487 static wxCharBuffer
ImplStr(const wchar_t* str
)
488 { return ConvertStr(str
, npos
, wxConvUTF8
).data
; }
489 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
490 { return ConvertStr(str
, n
, wxConvUTF8
); }
492 size_t PosToImpl(size_t pos
) const
494 if ( pos
== 0 || pos
== npos
)
497 return (begin() + pos
).impl() - m_impl
.begin();
500 void PosLenToImpl(size_t pos
, size_t len
, size_t *implPos
, size_t *implLen
) const;
502 size_t LenToImpl(size_t len
) const
505 PosLenToImpl(0, len
, &pos
, &len2
);
509 size_t PosFromImpl(size_t pos
) const
511 if ( pos
== 0 || pos
== npos
)
514 return const_iterator(m_impl
.begin() + pos
) - begin();
516 #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
520 typedef wxUniChar value_type
;
521 typedef wxUniChar char_type
;
522 typedef wxUniCharRef reference
;
523 typedef wxChar
* pointer
;
524 typedef const wxChar
* const_pointer
;
526 typedef size_t size_type
;
527 typedef wxUniChar const_reference
;
530 #if wxUSE_UNICODE_UTF8
531 // random access is not O(1), as required by Random Access Iterator
532 #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
534 #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
537 #define WX_STR_ITERATOR_TAG void /* dummy type */
540 #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \
541 reference_type, reference_ctor) \
543 typedef wxStringImpl::iterator_name underlying_iterator; \
545 typedef WX_STR_ITERATOR_TAG iterator_category; \
546 typedef wxUniChar value_type; \
547 typedef int difference_type; \
548 typedef reference_type reference; \
549 typedef pointer_type pointer; \
551 reference operator*() const { return reference_ctor; } \
552 reference operator[](size_t n) const { return *(*this + n); } \
554 iterator_name& operator++() \
555 { wxStringOperations::IncIter(m_cur); return *this; } \
556 iterator_name& operator--() \
557 { wxStringOperations::DecIter(m_cur); return *this; } \
558 iterator_name operator++(int) \
560 iterator_name tmp = *this; \
561 wxStringOperations::IncIter(m_cur); \
564 iterator_name operator--(int) \
566 iterator_name tmp = *this; \
567 wxStringOperations::DecIter(m_cur); \
571 iterator_name& operator+=(int n) \
573 m_cur = wxStringOperations::AddToIter(m_cur, n); \
576 iterator_name& operator+=(size_t n) \
578 m_cur = wxStringOperations::AddToIter(m_cur, (int)n); \
581 iterator_name& operator-=(int n) \
583 m_cur = wxStringOperations::AddToIter(m_cur, -n); \
586 iterator_name& operator-=(size_t n) \
588 m_cur = wxStringOperations::AddToIter(m_cur, -(int)n); \
592 difference_type operator-(const iterator_name& i) const \
593 { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \
595 bool operator==(const iterator_name& i) const \
596 { return m_cur == i.m_cur; } \
597 bool operator!=(const iterator_name& i) const \
598 { return m_cur != i.m_cur; } \
600 bool operator<(const iterator_name& i) const \
601 { return m_cur < i.m_cur; } \
602 bool operator>(const iterator_name& i) const \
603 { return m_cur > i.m_cur; } \
604 bool operator<=(const iterator_name& i) const \
605 { return m_cur <= i.m_cur; } \
606 bool operator>=(const iterator_name& i) const \
607 { return m_cur >= i.m_cur; } \
610 /* for internal wxString use only: */ \
611 underlying_iterator impl() const { return m_cur; } \
613 friend class WXDLLIMPEXP_BASE wxString; \
614 friend class WXDLLIMPEXP_BASE wxCStrData; \
617 underlying_iterator m_cur
619 class const_iterator
;
621 #if wxUSE_UNICODE_UTF8
624 // NB: In UTF-8 build, (non-const) iterator needs to keep reference
625 // to the underlying wxStringImpl, because UTF-8 is variable-length
626 // encoding and changing the value pointer to by an iterator using
627 // its operator* requires calling wxStringImpl::replace() if the old
628 // and new values differ in their encoding's length.
630 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
,
631 wxUniCharRef::CreateForString(m_str
, m_cur
));
634 iterator(const iterator
& i
) : m_cur(i
.m_cur
), m_str(i
.m_str
) {}
636 iterator
operator+(int n
) const
637 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, n
)); }
638 iterator
operator+(size_t n
) const
639 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, (int)n
)); }
640 iterator
operator-(int n
) const
641 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, -n
)); }
642 iterator
operator-(size_t n
) const
643 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
646 iterator(wxString
*str
, underlying_iterator ptr
)
647 : m_cur(ptr
), m_str(str
->m_impl
) {}
648 iterator(wxStringImpl
& str
, underlying_iterator ptr
)
649 : m_cur(ptr
), m_str(str
) {}
653 friend class const_iterator
;
656 size_t IterToImplPos(wxString::iterator i
) const
657 { return wxStringImpl::const_iterator(i
.impl()) - m_impl
.begin(); }
659 #else // !wxUSE_UNICODE_UTF8
663 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
,
664 wxUniCharRef::CreateForString(m_cur
));
667 iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
669 iterator
operator+(int n
) const
670 { return iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
671 iterator
operator+(size_t n
) const
672 { return iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
673 iterator
operator-(int n
) const
674 { return iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
675 iterator
operator-(size_t n
) const
676 { return iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
679 // for internal wxString use only:
680 iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
681 iterator(wxString
*WXUNUSED(str
), underlying_iterator ptr
) : m_cur(ptr
) {}
683 friend class const_iterator
;
685 #endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
689 // NB: reference_type is intentionally value, not reference, the character
690 // may be encoded differently in wxString data:
691 WX_STR_ITERATOR_IMPL(const_iterator
, const wxChar
*, wxUniChar
,
692 wxStringOperations::DecodeChar(m_cur
));
695 const_iterator(const const_iterator
& i
) : m_cur(i
.m_cur
) {}
696 const_iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
698 const_iterator
operator+(int n
) const
699 { return const_iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
700 const_iterator
operator+(size_t n
) const
701 { return const_iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
702 const_iterator
operator-(int n
) const
703 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
704 const_iterator
operator-(size_t n
) const
705 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
708 // for internal wxString use only:
709 const_iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
712 #undef WX_STR_ITERATOR_TAG
713 #undef WX_STR_ITERATOR_IMPL
715 friend class iterator
;
716 friend class const_iterator
;
718 template <typename T
>
719 class reverse_iterator_impl
722 typedef T iterator_type
;
724 typedef typename
T::iterator_category iterator_category
;
725 typedef typename
T::value_type value_type
;
726 typedef typename
T::difference_type difference_type
;
727 typedef typename
T::reference reference
;
728 typedef typename
T::pointer
*pointer
;
730 reverse_iterator_impl(iterator_type i
) : m_cur(i
) {}
731 reverse_iterator_impl(const reverse_iterator_impl
& ri
)
734 iterator_type
base() const { return m_cur
; }
736 reference
operator*() const { return *(m_cur
-1); }
737 reference
operator[](size_t n
) const { return *(*this + n
); }
739 reverse_iterator_impl
& operator++()
740 { --m_cur
; return *this; }
741 reverse_iterator_impl
operator++(int)
742 { reverse_iterator_impl tmp
= *this; --m_cur
; return tmp
; }
743 reverse_iterator_impl
& operator--()
744 { ++m_cur
; return *this; }
745 reverse_iterator_impl
operator--(int)
746 { reverse_iterator_impl tmp
= *this; ++m_cur
; return tmp
; }
748 // NB: explicit <T> in the functions below is to keep BCC 5.5 happy
749 reverse_iterator_impl
operator+(int n
) const
750 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
751 reverse_iterator_impl
operator+(size_t n
) const
752 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
753 reverse_iterator_impl
operator-(int n
) const
754 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
755 reverse_iterator_impl
operator-(size_t n
) const
756 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
757 reverse_iterator_impl
operator+=(int n
)
758 { m_cur
-= n
; return *this; }
759 reverse_iterator_impl
operator+=(size_t n
)
760 { m_cur
-= n
; return *this; }
761 reverse_iterator_impl
operator-=(int n
)
762 { m_cur
+= n
; return *this; }
763 reverse_iterator_impl
operator-=(size_t n
)
764 { m_cur
+= n
; return *this; }
766 unsigned operator-(const reverse_iterator_impl
& i
) const
767 { return i
.m_cur
- m_cur
; }
769 bool operator==(const reverse_iterator_impl
& ri
) const
770 { return m_cur
== ri
.m_cur
; }
771 bool operator!=(const reverse_iterator_impl
& ri
) const
772 { return !(*this == ri
); }
774 bool operator<(const reverse_iterator_impl
& i
) const
775 { return m_cur
> i
.m_cur
; }
776 bool operator>(const reverse_iterator_impl
& i
) const
777 { return m_cur
< i
.m_cur
; }
778 bool operator<=(const reverse_iterator_impl
& i
) const
779 { return m_cur
>= i
.m_cur
; }
780 bool operator>=(const reverse_iterator_impl
& i
) const
781 { return m_cur
<= i
.m_cur
; }
787 typedef reverse_iterator_impl
<iterator
> reverse_iterator
;
788 typedef reverse_iterator_impl
<const_iterator
> const_reverse_iterator
;
791 // used to transform an expression built using c_str() (and hence of type
792 // wxCStrData) to an iterator into the string
793 static const_iterator
CreateConstIterator(const wxCStrData
& data
)
795 return const_iterator(data
.m_str
->begin() + data
.m_offset
);
798 // in UTF-8 STL build, creation from std::string requires conversion under
799 // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor;
800 // instead we define dummy type that lets us have wxString ctor for creation
801 // from wxStringImpl that couldn't be used by user code (in all other builds,
802 // "standard" ctors can be used):
803 #if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING
804 struct CtorFromStringImplTag
{};
806 wxString(CtorFromStringImplTag
* WXUNUSED(dummy
), const wxStringImpl
& src
)
809 static wxString
FromImpl(const wxStringImpl
& src
)
810 { return wxString((CtorFromStringImplTag
*)NULL
, src
); }
812 #if !wxUSE_STL_BASED_WXSTRING
813 wxString(const wxStringImpl
& src
) : m_impl(src
) { }
814 // else: already defined as wxString(wxStdString) below
816 static wxString
FromImpl(const wxStringImpl
& src
) { return wxString(src
); }
820 // constructors and destructor
821 // ctor for an empty string
825 wxString(const wxString
& stringSrc
) : m_impl(stringSrc
.m_impl
) { }
827 // string containing nRepeat copies of ch
828 wxString(wxUniChar ch
, size_t nRepeat
= 1)
829 { assign(nRepeat
, ch
); }
830 wxString(size_t nRepeat
, wxUniChar ch
)
831 { assign(nRepeat
, ch
); }
832 wxString(wxUniCharRef ch
, size_t nRepeat
= 1)
833 { assign(nRepeat
, ch
); }
834 wxString(size_t nRepeat
, wxUniCharRef ch
)
835 { assign(nRepeat
, ch
); }
836 wxString(char ch
, size_t nRepeat
= 1)
837 { assign(nRepeat
, ch
); }
838 wxString(size_t nRepeat
, char ch
)
839 { assign(nRepeat
, ch
); }
840 wxString(wchar_t ch
, size_t nRepeat
= 1)
841 { assign(nRepeat
, ch
); }
842 wxString(size_t nRepeat
, wchar_t ch
)
843 { assign(nRepeat
, ch
); }
845 // ctors from char* strings:
846 wxString(const char *psz
)
847 : m_impl(ImplStr(psz
)) {}
848 wxString(const char *psz
, const wxMBConv
& conv
)
849 : m_impl(ImplStr(psz
, conv
)) {}
850 wxString(const char *psz
, size_t nLength
)
851 { assign(psz
, nLength
); }
852 wxString(const char *psz
, const wxMBConv
& conv
, size_t nLength
)
854 SubstrBufFromMB
str(ImplStr(psz
, nLength
, conv
));
855 m_impl
.assign(str
.data
, str
.len
);
858 // and unsigned char*:
859 wxString(const unsigned char *psz
)
860 : m_impl(ImplStr((const char*)psz
)) {}
861 wxString(const unsigned char *psz
, const wxMBConv
& conv
)
862 : m_impl(ImplStr((const char*)psz
, conv
)) {}
863 wxString(const unsigned char *psz
, size_t nLength
)
864 { assign((const char*)psz
, nLength
); }
865 wxString(const unsigned char *psz
, const wxMBConv
& conv
, size_t nLength
)
867 SubstrBufFromMB
str(ImplStr((const char*)psz
, nLength
, conv
));
868 m_impl
.assign(str
.data
, str
.len
);
871 // ctors from wchar_t* strings:
872 wxString(const wchar_t *pwz
)
873 : m_impl(ImplStr(pwz
)) {}
874 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
))
875 : m_impl(ImplStr(pwz
)) {}
876 wxString(const wchar_t *pwz
, size_t nLength
)
877 { assign(pwz
, nLength
); }
878 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
), size_t nLength
)
879 { assign(pwz
, nLength
); }
881 wxString(const wxCharBuffer
& buf
)
882 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
883 wxString(const wxWCharBuffer
& buf
)
884 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
886 wxString(const wxCStrData
& cstr
)
887 : m_impl(cstr
.AsString().m_impl
) { }
889 // as we provide both ctors with this signature for both char and unsigned
890 // char string, we need to provide one for wxCStrData to resolve ambiguity
891 wxString(const wxCStrData
& cstr
, size_t nLength
)
892 : m_impl(cstr
.AsString().Mid(0, nLength
).m_impl
) {}
894 // and because wxString is convertible to wxCStrData and const wxChar *
895 // we also need to provide this one
896 wxString(const wxString
& str
, size_t nLength
)
897 : m_impl(str
.Mid(0, nLength
).m_impl
) {}
899 // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
900 // implicit conversions from std::string to wxString and vice verse as this
901 // allows to use the same strings in non-GUI and GUI code, however we don't
902 // want to unconditionally add this ctor as it would make wx lib dependent on
903 // libstdc++ on some Linux versions which is bad, so instead we ask the
904 // client code to define this wxUSE_STD_STRING symbol if they need it
906 #if wxUSE_UNICODE_WCHAR
907 wxString(const wxStdWideString
& str
) : m_impl(str
) {}
908 #else // UTF-8 or ANSI
909 wxString(const wxStdWideString
& str
)
910 { assign(str
.c_str(), str
.length()); }
913 #if !wxUSE_UNICODE // ANSI build
914 // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
915 wxString(const std::string
& str
) : m_impl(str
) {}
917 wxString(const std::string
& str
)
918 { assign(str
.c_str(), str
.length()); }
921 #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
922 // wxStringImpl is std::string in the encoding we want
923 operator const wxStdWideString
&() const { return m_impl
; }
925 // wxStringImpl is either not std::string or needs conversion
926 operator wxStdWideString() const
927 // FIXME-UTF8: broken for embedded NULs
928 { return wxStdWideString(wc_str()); }
931 #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
932 // wxStringImpl is std::string in the encoding we want
933 operator const std::string
&() const { return m_impl
; }
935 // wxStringImpl is either not std::string or needs conversion
936 operator std::string() const
937 // FIXME-UTF8: broken for embedded NULs
938 { return std::string(mb_str()); }
942 // first valid index position
943 const_iterator
begin() const { return const_iterator(m_impl
.begin()); }
944 iterator
begin() { return iterator(this, m_impl
.begin()); }
945 // position one after the last valid one
946 const_iterator
end() const { return const_iterator(m_impl
.end()); }
947 iterator
end() { return iterator(this, m_impl
.end()); }
949 // first element of the reversed string
950 const_reverse_iterator
rbegin() const
951 { return const_reverse_iterator(end()); }
952 reverse_iterator
rbegin()
953 { return reverse_iterator(end()); }
954 // one beyond the end of the reversed string
955 const_reverse_iterator
rend() const
956 { return const_reverse_iterator(begin()); }
957 reverse_iterator
rend()
958 { return reverse_iterator(begin()); }
960 // std::string methods:
961 #if wxUSE_UNICODE_UTF8
962 size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
964 size_t length() const { return m_impl
.length(); }
967 size_type
size() const { return length(); }
968 size_type
max_size() const { return npos
; }
970 bool empty() const { return m_impl
.empty(); }
972 size_type
capacity() const { return m_impl
.capacity(); } // FIXME-UTF8
973 void reserve(size_t sz
) { m_impl
.reserve(sz
); } // FIXME-UTF8
975 void resize(size_t nSize
, wxUniChar ch
= wxT('\0'))
977 #if wxUSE_UNICODE_UTF8
980 size_t len
= length();
983 else if ( nSize
< len
)
986 append(nSize
- len
, ch
);
990 m_impl
.resize(nSize
, (wxStringCharType
)ch
);
993 wxString
substr(size_t nStart
= 0, size_t nLen
= npos
) const
996 PosLenToImpl(nStart
, nLen
, &pos
, &len
);
997 return FromImpl(m_impl
.substr(pos
, len
));
1000 // generic attributes & operations
1001 // as standard strlen()
1002 size_t Len() const { return length(); }
1003 // string contains any characters?
1004 bool IsEmpty() const { return empty(); }
1005 // empty string is "false", so !str will return true
1006 bool operator!() const { return empty(); }
1007 // truncate the string to given length
1008 wxString
& Truncate(size_t uiLen
);
1009 // empty string contents
1014 wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
1016 // empty the string and free memory
1019 wxString
tmp(wxEmptyString
);
1024 // Is an ascii value
1025 bool IsAscii() const;
1027 bool IsNumber() const;
1029 bool IsWord() const;
1031 // data access (all indexes are 0 based)
1033 wxUniChar
at(size_t n
) const
1034 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1035 wxUniChar
GetChar(size_t n
) const
1037 // read/write access
1038 wxUniCharRef
at(size_t n
)
1039 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1040 wxUniCharRef
GetWritableChar(size_t n
)
1043 void SetChar(size_t n
, wxUniChar ch
)
1046 // get last character
1047 wxUniChar
Last() const
1049 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1051 return at(length() - 1);
1054 // get writable last character
1057 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1058 return at(length() - 1);
1062 Note that we we must define all of the overloads below to avoid
1063 ambiguity when using str[0].
1065 wxUniChar
operator[](int n
) const
1067 wxUniChar
operator[](long n
) const
1069 wxUniChar
operator[](size_t n
) const
1071 #ifndef wxSIZE_T_IS_UINT
1072 wxUniChar
operator[](unsigned int n
) const
1074 #endif // size_t != unsigned int
1076 // operator versions of GetWriteableChar()
1077 wxUniCharRef
operator[](int n
)
1079 wxUniCharRef
operator[](long n
)
1081 wxUniCharRef
operator[](size_t n
)
1083 #ifndef wxSIZE_T_IS_UINT
1084 wxUniCharRef
operator[](unsigned int n
)
1086 #endif // size_t != unsigned int
1088 // explicit conversion to C string (use this with printf()!)
1089 wxCStrData
c_str() const { return wxCStrData(this); }
1090 wxCStrData
data() const { return c_str(); }
1092 // implicit conversion to C string
1093 operator wxCStrData() const { return c_str(); }
1094 operator const char*() const { return c_str(); }
1095 operator const wchar_t*() const { return c_str(); }
1097 // implicit conversion to untyped pointer for compatibility with previous
1098 // wxWidgets versions: this is the same as conversion to const char * so it
1100 operator const void*() const { return c_str(); }
1102 // identical to c_str(), for MFC compatibility
1103 const wxCStrData
GetData() const { return c_str(); }
1105 // explicit conversion to C string in internal representation (char*,
1106 // wchar_t*, UTF-8-encoded char*, depending on the build):
1107 const wxStringCharType
*wx_str() const { return m_impl
.c_str(); }
1109 // conversion to *non-const* multibyte or widestring buffer; modifying
1110 // returned buffer won't affect the string, these methods are only useful
1111 // for passing values to const-incorrect functions
1112 wxWritableCharBuffer
char_str(const wxMBConv
& conv
= wxConvLibc
) const
1113 { return mb_str(conv
); }
1114 wxWritableWCharBuffer
wchar_str() const { return wc_str(); }
1116 // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
1117 // converting numbers or strings which are certain not to contain special
1118 // chars (typically system functions, X atoms, environment variables etc.)
1120 // the behaviour of these functions with the strings containing anything
1121 // else than 7 bit ASCII characters is undefined, use at your own risk.
1123 static wxString
FromAscii(const char *ascii
); // string
1124 static wxString
FromAscii(const char ascii
); // char
1125 const wxCharBuffer
ToAscii() const;
1127 static wxString
FromAscii(const char *ascii
) { return wxString( ascii
); }
1128 static wxString
FromAscii(const char ascii
) { return wxString( ascii
); }
1129 const char *ToAscii() const { return c_str(); }
1130 #endif // Unicode/!Unicode
1132 // functions for storing binary data in wxString:
1134 static wxString
From8BitData(const char *data
, size_t len
)
1135 { return wxString(data
, wxConvISO8859_1
, len
); }
1136 // version for NUL-terminated data:
1137 static wxString
From8BitData(const char *data
)
1138 { return wxString(data
, wxConvISO8859_1
); }
1139 const wxCharBuffer
To8BitData() const { return mb_str(wxConvISO8859_1
); }
1141 static wxString
From8BitData(const char *data
, size_t len
)
1142 { return wxString(data
, len
); }
1143 // version for NUL-terminated data:
1144 static wxString
From8BitData(const char *data
)
1145 { return wxString(data
); }
1146 const char *To8BitData() const { return c_str(); }
1147 #endif // Unicode/ANSI
1149 // conversions with (possible) format conversions: have to return a
1150 // buffer with temporary data
1152 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
1153 // return an ANSI (multibyte) string, wc_str() to return a wide string and
1154 // fn_str() to return a string which should be used with the OS APIs
1155 // accepting the file names. The return value is always the same, but the
1156 // type differs because a function may either return pointer to the buffer
1157 // directly or have to use intermediate buffer for translation.
1160 #if wxUSE_UTF8_LOCALE_ONLY
1161 const char* mb_str() const { return wx_str(); }
1162 const wxCharBuffer
mb_str(const wxMBConv
& conv
) const;
1164 const wxCharBuffer
mb_str(const wxMBConv
& conv
= wxConvLibc
) const;
1167 const wxWX2MBbuf
mbc_str() const { return mb_str(*wxConvCurrent
); }
1169 #if wxUSE_UNICODE_WCHAR
1170 const wxChar
* wc_str() const { return wx_str(); }
1171 #elif wxUSE_UNICODE_UTF8
1172 const wxWCharBuffer
wc_str() const;
1174 // for compatibility with !wxUSE_UNICODE version
1175 const wxWX2WCbuf
wc_str(const wxMBConv
& WXUNUSED(conv
)) const
1176 { return wc_str(); }
1179 const wxCharBuffer
fn_str() const { return mb_str(wxConvFile
); }
1181 const wxWX2WCbuf
fn_str() const { return wc_str(); }
1182 #endif // wxMBFILES/!wxMBFILES
1185 const wxChar
* mb_str() const { return wx_str(); }
1187 // for compatibility with wxUSE_UNICODE version
1188 const wxChar
* mb_str(const wxMBConv
& WXUNUSED(conv
)) const { return wx_str(); }
1190 const wxWX2MBbuf
mbc_str() const { return mb_str(); }
1193 const wxWCharBuffer
wc_str(const wxMBConv
& conv
= wxConvLibc
) const;
1194 #endif // wxUSE_WCHAR_T
1196 const wxCharBuffer
fn_str() const { return wxConvFile
.cWC2WX( wc_str( wxConvLocal
) ); }
1198 const wxChar
* fn_str() const { return c_str(); }
1200 #endif // Unicode/ANSI
1202 // overloaded assignment
1203 // from another wxString
1204 wxString
& operator=(const wxString
& stringSrc
)
1205 { m_impl
= stringSrc
.m_impl
; return *this; }
1206 wxString
& operator=(const wxCStrData
& cstr
)
1207 { return *this = cstr
.AsString(); }
1209 wxString
& operator=(wxUniChar ch
)
1210 { m_impl
= wxStringOperations::EncodeChar(ch
); return *this; }
1211 wxString
& operator=(wxUniCharRef ch
)
1212 { return operator=((wxUniChar
)ch
); }
1213 wxString
& operator=(char ch
)
1214 { return operator=(wxUniChar(ch
)); }
1215 wxString
& operator=(unsigned char ch
)
1216 { return operator=(wxUniChar(ch
)); }
1217 wxString
& operator=(wchar_t ch
)
1218 { return operator=(wxUniChar(ch
)); }
1219 // from a C string - STL probably will crash on NULL,
1220 // so we need to compensate in that case
1221 #if wxUSE_STL_BASED_WXSTRING
1222 wxString
& operator=(const char *psz
)
1223 { if (psz
) m_impl
= ImplStr(psz
); else Clear(); return *this; }
1224 wxString
& operator=(const wchar_t *pwz
)
1225 { if (pwz
) m_impl
= ImplStr(pwz
); else Clear(); return *this; }
1227 wxString
& operator=(const char *psz
)
1228 { m_impl
= ImplStr(psz
); return *this; }
1229 wxString
& operator=(const wchar_t *pwz
)
1230 { m_impl
= ImplStr(pwz
); return *this; }
1232 wxString
& operator=(const unsigned char *psz
)
1233 { return operator=((const char*)psz
); }
1235 // from wxWCharBuffer
1236 wxString
& operator=(const wxWCharBuffer
& s
)
1237 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1238 // from wxCharBuffer
1239 wxString
& operator=(const wxCharBuffer
& s
)
1240 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1242 // string concatenation
1243 // in place concatenation
1245 Concatenate and return the result. Note that the left to right
1246 associativity of << allows to write things like "str << str1 << str2
1247 << ..." (unlike with +=)
1250 wxString
& operator<<(const wxString
& s
)
1252 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1253 wxASSERT_MSG( s
.IsValid(),
1254 _T("did you forget to call UngetWriteBuf()?") );
1260 // string += C string
1261 wxString
& operator<<(const char *psz
)
1262 { append(psz
); return *this; }
1263 wxString
& operator<<(const wchar_t *pwz
)
1264 { append(pwz
); return *this; }
1265 wxString
& operator<<(const wxCStrData
& psz
)
1266 { append(psz
.AsString()); return *this; }
1268 wxString
& operator<<(wxUniChar ch
) { append(1, ch
); return *this; }
1269 wxString
& operator<<(wxUniCharRef ch
) { append(1, ch
); return *this; }
1270 wxString
& operator<<(char ch
) { append(1, ch
); return *this; }
1271 wxString
& operator<<(unsigned char ch
) { append(1, ch
); return *this; }
1272 wxString
& operator<<(wchar_t ch
) { append(1, ch
); return *this; }
1274 // string += buffer (i.e. from wxGetString)
1275 wxString
& operator<<(const wxWCharBuffer
& s
)
1276 { return operator<<((const wchar_t *)s
); }
1277 wxString
& operator<<(const wxCharBuffer
& s
)
1278 { return operator<<((const char *)s
); }
1280 // string += C string
1281 wxString
& Append(const wxString
& s
)
1283 // test for empty() to share the string if possible
1290 wxString
& Append(const char* psz
)
1291 { append(psz
); return *this; }
1292 wxString
& Append(const wchar_t* pwz
)
1293 { append(pwz
); return *this; }
1294 wxString
& Append(const wxCStrData
& psz
)
1295 { append(psz
); return *this; }
1296 wxString
& Append(const wxCharBuffer
& psz
)
1297 { append(psz
); return *this; }
1298 wxString
& Append(const wxWCharBuffer
& psz
)
1299 { append(psz
); return *this; }
1300 // append count copies of given character
1301 wxString
& Append(wxUniChar ch
, size_t count
= 1u)
1302 { append(count
, ch
); return *this; }
1303 wxString
& Append(wxUniCharRef ch
, size_t count
= 1u)
1304 { append(count
, ch
); return *this; }
1305 wxString
& Append(char ch
, size_t count
= 1u)
1306 { append(count
, ch
); return *this; }
1307 wxString
& Append(unsigned char ch
, size_t count
= 1u)
1308 { append(count
, ch
); return *this; }
1309 wxString
& Append(wchar_t ch
, size_t count
= 1u)
1310 { append(count
, ch
); return *this; }
1311 wxString
& Append(const char* psz
, size_t nLen
)
1312 { append(psz
, nLen
); return *this; }
1313 wxString
& Append(const wchar_t* pwz
, size_t nLen
)
1314 { append(pwz
, nLen
); return *this; }
1316 // prepend a string, return the string itself
1317 wxString
& Prepend(const wxString
& str
)
1318 { *this = str
+ *this; return *this; }
1320 // non-destructive concatenation
1322 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
,
1323 const wxString
& string2
);
1324 // string with a single char
1325 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
1326 // char with a string
1327 friend wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
1328 // string with C string
1329 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1331 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1332 const wchar_t *pwz
);
1333 // C string with string
1334 friend wxString WXDLLIMPEXP_BASE
operator+(const char *psz
,
1335 const wxString
& string
);
1336 friend wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
,
1337 const wxString
& string
);
1339 // stream-like functions
1340 // insert an int into string
1341 wxString
& operator<<(int i
)
1342 { return (*this) << Format(_T("%d"), i
); }
1343 // insert an unsigned int into string
1344 wxString
& operator<<(unsigned int ui
)
1345 { return (*this) << Format(_T("%u"), ui
); }
1346 // insert a long into string
1347 wxString
& operator<<(long l
)
1348 { return (*this) << Format(_T("%ld"), l
); }
1349 // insert an unsigned long into string
1350 wxString
& operator<<(unsigned long ul
)
1351 { return (*this) << Format(_T("%lu"), ul
); }
1352 #if defined wxLongLong_t && !defined wxLongLongIsLong
1353 // insert a long long if they exist and aren't longs
1354 wxString
& operator<<(wxLongLong_t ll
)
1356 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("d");
1357 return (*this) << Format(fmt
, ll
);
1359 // insert an unsigned long long
1360 wxString
& operator<<(wxULongLong_t ull
)
1362 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("u");
1363 return (*this) << Format(fmt
, ull
);
1366 // insert a float into string
1367 wxString
& operator<<(float f
)
1368 { return (*this) << Format(_T("%f"), f
); }
1369 // insert a double into string
1370 wxString
& operator<<(double d
)
1371 { return (*this) << Format(_T("%g"), d
); }
1373 // string comparison
1374 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
1375 int Cmp(const char *psz
) const
1376 { return compare(psz
); }
1377 int Cmp(const wchar_t *pwz
) const
1378 { return compare(pwz
); }
1379 int Cmp(const wxString
& s
) const
1380 { return compare(s
); }
1381 int Cmp(const wxCStrData
& s
) const
1382 { return compare(s
); }
1383 int Cmp(const wxCharBuffer
& s
) const
1384 { return compare(s
); }
1385 int Cmp(const wxWCharBuffer
& s
) const
1386 { return compare(s
); }
1387 // same as Cmp() but not case-sensitive
1388 int CmpNoCase(const wxString
& s
) const;
1389 // test for the string equality, either considering case or not
1390 // (if compareWithCase then the case matters)
1391 bool IsSameAs(const wxString
& str
, bool compareWithCase
= true) const
1392 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1393 bool IsSameAs(const char *str
, bool compareWithCase
= true) const
1394 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1395 bool IsSameAs(const wchar_t *str
, bool compareWithCase
= true) const
1396 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1397 bool IsSameAs(const wxCStrData
& str
, bool compareWithCase
= true) const
1398 { return IsSameAs(str
.AsString(), compareWithCase
); }
1399 bool IsSameAs(const wxCharBuffer
& str
, bool compareWithCase
= true) const
1400 { return IsSameAs(str
.data(), compareWithCase
); }
1401 bool IsSameAs(const wxWCharBuffer
& str
, bool compareWithCase
= true) const
1402 { return IsSameAs(str
.data(), compareWithCase
); }
1403 // comparison with a single character: returns true if equal
1404 bool IsSameAs(wxUniChar c
, bool compareWithCase
= true) const
1406 return (length() == 1) && (compareWithCase
? GetChar(0u) == c
1407 : wxToupper(GetChar(0u)) == wxToupper(c
));
1409 // FIXME-UTF8: remove these overloads
1410 bool IsSameAs(wxUniCharRef c
, bool compareWithCase
= true) const
1411 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1412 bool IsSameAs(char c
, bool compareWithCase
= true) const
1413 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1414 bool IsSameAs(unsigned char c
, bool compareWithCase
= true) const
1415 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1416 bool IsSameAs(wchar_t c
, bool compareWithCase
= true) const
1417 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1418 bool IsSameAs(int c
, bool compareWithCase
= true) const
1419 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1421 // simple sub-string extraction
1422 // return substring starting at nFirst of length nCount (or till the end
1423 // if nCount = default value)
1424 wxString
Mid(size_t nFirst
, size_t nCount
= npos
) const;
1426 // operator version of Mid()
1427 wxString
operator()(size_t start
, size_t len
) const
1428 { return Mid(start
, len
); }
1430 // check if the string starts with the given prefix and return the rest
1431 // of the string in the provided pointer if it is not NULL; otherwise
1433 bool StartsWith(const wxChar
*prefix
, wxString
*rest
= NULL
) const;
1434 // check if the string ends with the given suffix and return the
1435 // beginning of the string before the suffix in the provided pointer if
1436 // it is not NULL; otherwise return false
1437 bool EndsWith(const wxChar
*suffix
, wxString
*rest
= NULL
) const;
1439 // get first nCount characters
1440 wxString
Left(size_t nCount
) const;
1441 // get last nCount characters
1442 wxString
Right(size_t nCount
) const;
1443 // get all characters before the first occurance of ch
1444 // (returns the whole string if ch not found)
1445 wxString
BeforeFirst(wxUniChar ch
) const;
1446 // get all characters before the last occurence of ch
1447 // (returns empty string if ch not found)
1448 wxString
BeforeLast(wxUniChar ch
) const;
1449 // get all characters after the first occurence of ch
1450 // (returns empty string if ch not found)
1451 wxString
AfterFirst(wxUniChar ch
) const;
1452 // get all characters after the last occurence of ch
1453 // (returns the whole string if ch not found)
1454 wxString
AfterLast(wxUniChar ch
) const;
1456 // for compatibility only, use more explicitly named functions above
1457 wxString
Before(wxUniChar ch
) const { return BeforeLast(ch
); }
1458 wxString
After(wxUniChar ch
) const { return AfterFirst(ch
); }
1461 // convert to upper case in place, return the string itself
1462 wxString
& MakeUpper();
1463 // convert to upper case, return the copy of the string
1464 // Here's something to remember: BC++ doesn't like returns in inlines.
1465 wxString
Upper() const ;
1466 // convert to lower case in place, return the string itself
1467 wxString
& MakeLower();
1468 // convert to lower case, return the copy of the string
1469 wxString
Lower() const ;
1471 // trimming/padding whitespace (either side) and truncating
1472 // remove spaces from left or from right (default) side
1473 wxString
& Trim(bool bFromRight
= true);
1474 // add nCount copies chPad in the beginning or at the end (default)
1475 wxString
& Pad(size_t nCount
, wxUniChar chPad
= wxT(' '), bool bFromRight
= true);
1477 // searching and replacing
1478 // searching (return starting index, or -1 if not found)
1479 int Find(wxUniChar ch
, bool bFromEnd
= false) const; // like strchr/strrchr
1480 int Find(wxUniCharRef ch
, bool bFromEnd
= false) const
1481 { return Find(wxUniChar(ch
), bFromEnd
); }
1482 int Find(char ch
, bool bFromEnd
= false) const
1483 { return Find(wxUniChar(ch
), bFromEnd
); }
1484 int Find(unsigned char ch
, bool bFromEnd
= false) const
1485 { return Find(wxUniChar(ch
), bFromEnd
); }
1486 int Find(wchar_t ch
, bool bFromEnd
= false) const
1487 { return Find(wxUniChar(ch
), bFromEnd
); }
1488 // searching (return starting index, or -1 if not found)
1489 int Find(const wxString
& sub
) const // like strstr
1491 size_type idx
= find(sub
);
1492 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1494 int Find(const char *sub
) const // like strstr
1496 size_type idx
= find(sub
);
1497 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1499 int Find(const wchar_t *sub
) const // like strstr
1501 size_type idx
= find(sub
);
1502 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1505 int Find(const wxCStrData
& sub
) const
1506 { return Find(sub
.AsString()); }
1507 int Find(const wxCharBuffer
& sub
) const
1508 { return Find(sub
.data()); }
1509 int Find(const wxWCharBuffer
& sub
) const
1510 { return Find(sub
.data()); }
1512 // replace first (or all of bReplaceAll) occurences of substring with
1513 // another string, returns the number of replacements made
1514 size_t Replace(const wxString
& strOld
,
1515 const wxString
& strNew
,
1516 bool bReplaceAll
= true);
1518 // check if the string contents matches a mask containing '*' and '?'
1519 bool Matches(const wxString
& mask
) const;
1521 // conversion to numbers: all functions return true only if the whole
1522 // string is a number and put the value of this number into the pointer
1523 // provided, the base is the numeric base in which the conversion should be
1524 // done and must be comprised between 2 and 36 or be 0 in which case the
1525 // standard C rules apply (leading '0' => octal, "0x" => hex)
1526 // convert to a signed integer
1527 bool ToLong(long *val
, int base
= 10) const;
1528 // convert to an unsigned integer
1529 bool ToULong(unsigned long *val
, int base
= 10) const;
1530 // convert to wxLongLong
1531 #if defined(wxLongLong_t)
1532 bool ToLongLong(wxLongLong_t
*val
, int base
= 10) const;
1533 // convert to wxULongLong
1534 bool ToULongLong(wxULongLong_t
*val
, int base
= 10) const;
1535 #endif // wxLongLong_t
1536 // convert to a double
1537 bool ToDouble(double *val
) const;
1540 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1541 // formatted input/output
1542 // as sprintf(), returns the number of characters written or < 0 on error
1543 // (take 'this' into account in attribute parameter count)
1544 // int Printf(const wxString& format, ...);
1545 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wxString
&),
1546 DoPrintfWchar
, DoPrintfUtf8
)
1548 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const char*)
1549 DoPrintfWchar
, DoPrintfUtf8
)
1550 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wchar_t*)
1551 DoPrintfWchar
, DoPrintfUtf8
)
1552 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wxCStrData
&)
1553 DoPrintfWchar
, DoPrintfUtf8
)
1555 #endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
1556 // as vprintf(), returns the number of characters written or < 0 on error
1557 int PrintfV(const wxString
& format
, va_list argptr
);
1559 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1560 // returns the string containing the result of Printf() to it
1561 // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1;
1562 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, 1, (const wxString
&),
1563 DoFormatWchar
, DoFormatUtf8
)
1565 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1566 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, 1, (const char*),
1567 DoFormatWchar
, DoFormatUtf8
)
1568 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, 1, (const wchar_t*),
1569 DoFormatWchar
, DoFormatUtf8
)
1570 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, 1, (const wxCStrData
&),
1571 DoFormatWchar
, DoFormatUtf8
)
1574 // the same as above, but takes a va_list
1575 static wxString
FormatV(const wxString
& format
, va_list argptr
);
1577 // raw access to string memory
1578 // ensure that string has space for at least nLen characters
1579 // only works if the data of this string is not shared
1580 bool Alloc(size_t nLen
) { reserve(nLen
); /*return capacity() >= nLen;*/ return true; }
1581 // minimize the string's memory
1582 // only works if the data of this string is not shared
1584 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1585 // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
1587 // get writable buffer of at least nLen bytes. Unget() *must* be called
1588 // a.s.a.p. to put string back in a reasonable state!
1589 wxDEPRECATED( wxStringCharType
*GetWriteBuf(size_t nLen
) );
1590 // call this immediately after GetWriteBuf() has been used
1591 wxDEPRECATED( void UngetWriteBuf() );
1592 wxDEPRECATED( void UngetWriteBuf(size_t nLen
) );
1593 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && wxUSE_UNICODE_UTF8
1595 // wxWidgets version 1 compatibility functions
1598 wxString
SubString(size_t from
, size_t to
) const
1599 { return Mid(from
, (to
- from
+ 1)); }
1600 // values for second parameter of CompareTo function
1601 enum caseCompare
{exact
, ignoreCase
};
1602 // values for first parameter of Strip function
1603 enum stripType
{leading
= 0x1, trailing
= 0x2, both
= 0x3};
1605 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1607 // (take 'this' into account in attribute parameter count)
1608 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
1609 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wxString
&),
1610 DoPrintfWchar
, DoPrintfUtf8
)
1612 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1613 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const char*),
1614 DoPrintfWchar
, DoPrintfUtf8
)
1615 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wchar_t*),
1616 DoPrintfWchar
, DoPrintfUtf8
)
1617 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wxCStrData
&),
1618 DoPrintfWchar
, DoPrintfUtf8
)
1620 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
1623 inline int CompareTo(const wxChar
* psz
, caseCompare cmp
= exact
) const
1624 { return cmp
== exact
? Cmp(psz
) : CmpNoCase(psz
); }
1627 size_t Length() const { return length(); }
1628 // Count the number of characters
1629 int Freq(wxUniChar ch
) const;
1631 void LowerCase() { MakeLower(); }
1633 void UpperCase() { MakeUpper(); }
1634 // use Trim except that it doesn't change this string
1635 wxString
Strip(stripType w
= trailing
) const;
1637 // use Find (more general variants not yet supported)
1638 size_t Index(const wxChar
* psz
) const { return Find(psz
); }
1639 size_t Index(wxUniChar ch
) const { return Find(ch
); }
1641 wxString
& Remove(size_t pos
) { return Truncate(pos
); }
1642 wxString
& RemoveLast(size_t n
= 1) { return Truncate(length() - n
); }
1644 wxString
& Remove(size_t nStart
, size_t nLen
)
1645 { return (wxString
&)erase( nStart
, nLen
); }
1648 int First( wxUniChar ch
) const { return Find(ch
); }
1649 int First( wxUniCharRef ch
) const { return Find(ch
); }
1650 int First( char ch
) const { return Find(ch
); }
1651 int First( unsigned char ch
) const { return Find(ch
); }
1652 int First( wchar_t ch
) const { return Find(ch
); }
1653 int First( const wxString
& str
) const { return Find(str
); }
1654 int Last( wxUniChar ch
) const { return Find(ch
, true); }
1655 bool Contains(const wxString
& str
) const { return Find(str
) != wxNOT_FOUND
; }
1658 bool IsNull() const { return empty(); }
1660 // std::string compatibility functions
1662 // take nLen chars starting at nPos
1663 wxString(const wxString
& str
, size_t nPos
, size_t nLen
)
1664 : m_impl(str
.m_impl
, nPos
, nLen
) { }
1665 // take all characters from first to last
1666 wxString(const_iterator first
, const_iterator last
)
1667 : m_impl(first
.impl(), last
.impl()) { }
1668 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1669 // the 2 overloads below are for compatibility with the existing code using
1670 // pointers instead of iterators
1671 wxString(const char *first
, const char *last
)
1673 SubstrBufFromMB
str(ImplStr(first
, last
- first
));
1674 m_impl
.assign(str
.data
, str
.len
);
1676 wxString(const wchar_t *first
, const wchar_t *last
)
1678 SubstrBufFromWC
str(ImplStr(first
, last
- first
));
1679 m_impl
.assign(str
.data
, str
.len
);
1681 // and this one is needed to compile code adding offsets to c_str() result
1682 wxString(const wxCStrData
& first
, const wxCStrData
& last
)
1683 : m_impl(CreateConstIterator(first
).impl(),
1684 CreateConstIterator(last
).impl())
1686 wxASSERT_MSG( first
.m_str
== last
.m_str
,
1687 _T("pointers must be into the same string") );
1689 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1691 // lib.string.modifiers
1692 // append elements str[pos], ..., str[pos+n]
1693 wxString
& append(const wxString
& str
, size_t pos
, size_t n
)
1696 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1697 m_impl
.append(str
.m_impl
, from
, len
);
1701 wxString
& append(const wxString
& str
)
1702 { m_impl
.append(str
.m_impl
); return *this; }
1703 // append first n (or all if n == npos) characters of sz
1704 wxString
& append(const char *sz
)
1705 { m_impl
.append(ImplStr(sz
)); return *this; }
1706 wxString
& append(const wchar_t *sz
)
1707 { m_impl
.append(ImplStr(sz
)); return *this; }
1708 wxString
& append(const char *sz
, size_t n
)
1710 SubstrBufFromMB
str(ImplStr(sz
, n
));
1711 m_impl
.append(str
.data
, str
.len
);
1714 wxString
& append(const wchar_t *sz
, size_t n
)
1716 SubstrBufFromWC
str(ImplStr(sz
, n
));
1717 m_impl
.append(str
.data
, str
.len
);
1721 wxString
& append(const wxCStrData
& str
)
1722 { return append(str
.AsString()); }
1723 wxString
& append(const wxCharBuffer
& str
)
1724 { return append(str
.data()); }
1725 wxString
& append(const wxWCharBuffer
& str
)
1726 { return append(str
.data()); }
1728 // append n copies of ch
1729 wxString
& append(size_t n
, wxUniChar ch
)
1731 #if wxUSE_UNICODE_UTF8
1732 if ( !ch
.IsAscii() )
1733 m_impl
.append(wxStringOperations::EncodeNChars(n
, ch
));
1736 m_impl
.append(n
, (wxStringCharType
)ch
);
1739 // append from first to last
1740 wxString
& append(const_iterator first
, const_iterator last
)
1741 { m_impl
.append(first
.impl(), last
.impl()); return *this; }
1742 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1743 wxString
& append(const char *first
, const char *last
)
1744 { return append(first
, last
- first
); }
1745 wxString
& append(const wchar_t *first
, const wchar_t *last
)
1746 { return append(first
, last
- first
); }
1747 wxString
& append(const wxCStrData
& first
, const wxCStrData
& last
)
1748 { return append(CreateConstIterator(first
), CreateConstIterator(last
)); }
1749 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1751 // same as `this_string = str'
1752 wxString
& assign(const wxString
& str
)
1753 { m_impl
= str
.m_impl
; return *this; }
1754 wxString
& assign(const wxString
& str
, size_t len
)
1756 m_impl
.assign(str
.m_impl
, 0, str
.LenToImpl(len
));
1759 // same as ` = str[pos..pos + n]
1760 wxString
& assign(const wxString
& str
, size_t pos
, size_t n
)
1763 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1764 m_impl
.assign(str
.m_impl
, from
, len
);
1767 // same as `= first n (or all if n == npos) characters of sz'
1768 wxString
& assign(const char *sz
)
1769 { m_impl
.assign(ImplStr(sz
)); return *this; }
1770 wxString
& assign(const wchar_t *sz
)
1771 { m_impl
.assign(ImplStr(sz
)); return *this; }
1772 wxString
& assign(const char *sz
, size_t n
)
1774 SubstrBufFromMB
str(ImplStr(sz
, n
));
1775 m_impl
.assign(str
.data
, str
.len
);
1778 wxString
& assign(const wchar_t *sz
, size_t n
)
1780 SubstrBufFromWC
str(ImplStr(sz
, n
));
1781 m_impl
.assign(str
.data
, str
.len
);
1785 wxString
& assign(const wxCStrData
& str
)
1786 { return assign(str
.AsString()); }
1787 wxString
& assign(const wxCharBuffer
& str
)
1788 { return assign(str
.data()); }
1789 wxString
& assign(const wxWCharBuffer
& str
)
1790 { return assign(str
.data()); }
1791 wxString
& assign(const wxCStrData
& str
, size_t len
)
1792 { return assign(str
.AsString(), len
); }
1793 wxString
& assign(const wxCharBuffer
& str
, size_t len
)
1794 { return assign(str
.data(), len
); }
1795 wxString
& assign(const wxWCharBuffer
& str
, size_t len
)
1796 { return assign(str
.data(), len
); }
1798 // same as `= n copies of ch'
1799 wxString
& assign(size_t n
, wxUniChar ch
)
1801 #if wxUSE_UNICODE_UTF8
1802 if ( !ch
.IsAscii() )
1803 m_impl
.assign(wxStringOperations::EncodeNChars(n
, ch
));
1806 m_impl
.assign(n
, (wxStringCharType
)ch
);
1810 wxString
& assign(size_t n
, wxUniCharRef ch
)
1811 { return assign(n
, wxUniChar(ch
)); }
1812 wxString
& assign(size_t n
, char ch
)
1813 { return assign(n
, wxUniChar(ch
)); }
1814 wxString
& assign(size_t n
, unsigned char ch
)
1815 { return assign(n
, wxUniChar(ch
)); }
1816 wxString
& assign(size_t n
, wchar_t ch
)
1817 { return assign(n
, wxUniChar(ch
)); }
1819 // assign from first to last
1820 wxString
& assign(const_iterator first
, const_iterator last
)
1821 { m_impl
.assign(first
.impl(), last
.impl()); return *this; }
1822 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1823 wxString
& assign(const char *first
, const char *last
)
1824 { return assign(first
, last
- first
); }
1825 wxString
& assign(const wchar_t *first
, const wchar_t *last
)
1826 { return assign(first
, last
- first
); }
1827 wxString
& assign(const wxCStrData
& first
, const wxCStrData
& last
)
1828 { return assign(CreateConstIterator(first
), CreateConstIterator(last
)); }
1829 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1831 // string comparison
1832 int compare(const wxString
& str
) const;
1833 int compare(const char* sz
) const;
1834 int compare(const wchar_t* sz
) const;
1835 int compare(const wxCStrData
& str
) const
1836 { return compare(str
.AsString()); }
1837 int compare(const wxCharBuffer
& str
) const
1838 { return compare(str
.data()); }
1839 int compare(const wxWCharBuffer
& str
) const
1840 { return compare(str
.data()); }
1841 // comparison with a substring
1842 int compare(size_t nStart
, size_t nLen
, const wxString
& str
) const;
1843 // comparison of 2 substrings
1844 int compare(size_t nStart
, size_t nLen
,
1845 const wxString
& str
, size_t nStart2
, size_t nLen2
) const;
1846 // substring comparison with first nCount characters of sz
1847 int compare(size_t nStart
, size_t nLen
,
1848 const char* sz
, size_t nCount
= npos
) const;
1849 int compare(size_t nStart
, size_t nLen
,
1850 const wchar_t* sz
, size_t nCount
= npos
) const;
1852 // insert another string
1853 wxString
& insert(size_t nPos
, const wxString
& str
)
1854 { insert(begin() + nPos
, str
.begin(), str
.end()); return *this; }
1855 // insert n chars of str starting at nStart (in str)
1856 wxString
& insert(size_t nPos
, const wxString
& str
, size_t nStart
, size_t n
)
1859 str
.PosLenToImpl(nStart
, n
, &from
, &len
);
1860 m_impl
.insert(PosToImpl(nPos
), str
.m_impl
, from
, len
);
1863 // insert first n (or all if n == npos) characters of sz
1864 wxString
& insert(size_t nPos
, const char *sz
)
1865 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
1866 wxString
& insert(size_t nPos
, const wchar_t *sz
)
1867 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
1868 wxString
& insert(size_t nPos
, const char *sz
, size_t n
)
1870 SubstrBufFromMB
str(ImplStr(sz
, n
));
1871 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
1874 wxString
& insert(size_t nPos
, const wchar_t *sz
, size_t n
)
1876 SubstrBufFromWC
str(ImplStr(sz
, n
));
1877 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
1880 // insert n copies of ch
1881 wxString
& insert(size_t nPos
, size_t n
, wxUniChar ch
)
1883 #if wxUSE_UNICODE_UTF8
1884 if ( !ch
.IsAscii() )
1885 m_impl
.insert(PosToImpl(nPos
), wxStringOperations::EncodeNChars(n
, ch
));
1888 m_impl
.insert(PosToImpl(nPos
), n
, (wxStringCharType
)ch
);
1891 iterator
insert(iterator it
, wxUniChar ch
)
1893 #if wxUSE_UNICODE_UTF8
1894 if ( !ch
.IsAscii() )
1896 size_t pos
= IterToImplPos(it
);
1897 m_impl
.insert(pos
, wxStringOperations::EncodeChar(ch
));
1898 return iterator(this, m_impl
.begin() + pos
);
1902 return iterator(this, m_impl
.insert(it
.impl(), (wxStringCharType
)ch
));
1904 void insert(iterator it
, const_iterator first
, const_iterator last
)
1905 { m_impl
.insert(it
.impl(), first
.impl(), last
.impl()); }
1906 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1907 void insert(iterator it
, const char *first
, const char *last
)
1908 { insert(it
- begin(), first
, last
- first
); }
1909 void insert(iterator it
, const wchar_t *first
, const wchar_t *last
)
1910 { insert(it
- begin(), first
, last
- first
); }
1911 void insert(iterator it
, const wxCStrData
& first
, const wxCStrData
& last
)
1912 { insert(it
, CreateConstIterator(first
), CreateConstIterator(last
)); }
1913 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1915 void insert(iterator it
, size_type n
, wxUniChar ch
)
1917 #if wxUSE_UNICODE_UTF8
1918 if ( !ch
.IsAscii() )
1919 m_impl
.insert(IterToImplPos(it
), wxStringOperations::EncodeNChars(n
, ch
));
1922 m_impl
.insert(it
.impl(), n
, (wxStringCharType
)ch
);
1925 // delete characters from nStart to nStart + nLen
1926 wxString
& erase(size_type pos
= 0, size_type n
= npos
)
1929 PosLenToImpl(pos
, n
, &from
, &len
);
1930 m_impl
.erase(from
, len
);
1933 // delete characters from first up to last
1934 iterator
erase(iterator first
, iterator last
)
1935 { return iterator(this, m_impl
.erase(first
.impl(), last
.impl())); }
1936 iterator
erase(iterator first
)
1937 { return iterator(this, m_impl
.erase(first
.impl())); }
1939 #ifdef wxSTRING_BASE_HASNT_CLEAR
1940 void clear() { erase(); }
1942 void clear() { m_impl
.clear(); }
1945 // replaces the substring of length nLen starting at nStart
1946 wxString
& replace(size_t nStart
, size_t nLen
, const char* sz
)
1949 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1950 m_impl
.replace(from
, len
, ImplStr(sz
));
1953 wxString
& replace(size_t nStart
, size_t nLen
, const wchar_t* sz
)
1956 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1957 m_impl
.replace(from
, len
, ImplStr(sz
));
1960 // replaces the substring of length nLen starting at nStart
1961 wxString
& replace(size_t nStart
, size_t nLen
, const wxString
& str
)
1964 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1965 m_impl
.replace(from
, len
, str
.m_impl
);
1968 // replaces the substring with nCount copies of ch
1969 wxString
& replace(size_t nStart
, size_t nLen
, size_t nCount
, wxUniChar ch
)
1972 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1973 #if wxUSE_UNICODE_UTF8
1974 if ( !ch
.IsAscii() )
1975 m_impl
.replace(from
, len
, wxStringOperations::EncodeNChars(nCount
, ch
));
1978 m_impl
.replace(from
, len
, nCount
, (wxStringCharType
)ch
);
1981 // replaces a substring with another substring
1982 wxString
& replace(size_t nStart
, size_t nLen
,
1983 const wxString
& str
, size_t nStart2
, size_t nLen2
)
1986 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1989 str
.PosLenToImpl(nStart2
, nLen2
, &from2
, &len2
);
1991 m_impl
.replace(from
, len
, str
.m_impl
, from2
, len2
);
1994 // replaces the substring with first nCount chars of sz
1995 wxString
& replace(size_t nStart
, size_t nLen
,
1996 const char* sz
, size_t nCount
)
1999 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2001 SubstrBufFromMB
str(ImplStr(sz
, nCount
));
2003 m_impl
.replace(from
, len
, str
.data
, str
.len
);
2006 wxString
& replace(size_t nStart
, size_t nLen
,
2007 const wchar_t* sz
, size_t nCount
)
2010 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2012 SubstrBufFromWC
str(ImplStr(sz
, nCount
));
2014 m_impl
.replace(from
, len
, str
.data
, str
.len
);
2017 wxString
& replace(size_t nStart
, size_t nLen
,
2018 const wxString
& s
, size_t nCount
)
2021 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2022 m_impl
.replace(from
, len
, s
.m_impl
.c_str(), s
.LenToImpl(nCount
));
2026 wxString
& replace(iterator first
, iterator last
, const char* s
)
2027 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
2028 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
)
2029 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
2030 wxString
& replace(iterator first
, iterator last
, const char* s
, size_type n
)
2032 SubstrBufFromMB
str(ImplStr(s
, n
));
2033 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
2036 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
, size_type n
)
2038 SubstrBufFromWC
str(ImplStr(s
, n
));
2039 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
2042 wxString
& replace(iterator first
, iterator last
, const wxString
& s
)
2043 { m_impl
.replace(first
.impl(), last
.impl(), s
.m_impl
); return *this; }
2044 wxString
& replace(iterator first
, iterator last
, size_type n
, wxUniChar ch
)
2046 #if wxUSE_UNICODE_UTF8
2047 if ( !ch
.IsAscii() )
2048 m_impl
.replace(first
.impl(), last
.impl(),
2049 wxStringOperations::EncodeNChars(n
, ch
));
2052 m_impl
.replace(first
.impl(), last
.impl(), n
, (wxStringCharType
)ch
);
2055 wxString
& replace(iterator first
, iterator last
,
2056 const_iterator first1
, const_iterator last1
)
2058 m_impl
.replace(first
.impl(), last
.impl(), first1
.impl(), last1
.impl());
2061 wxString
& replace(iterator first
, iterator last
,
2062 const char *first1
, const char *last1
)
2063 { replace(first
, last
, first1
, last1
- first1
); return *this; }
2064 wxString
& replace(iterator first
, iterator last
,
2065 const wchar_t *first1
, const wchar_t *last1
)
2066 { replace(first
, last
, first1
, last1
- first1
); return *this; }
2069 void swap(wxString
& str
)
2070 { m_impl
.swap(str
.m_impl
); }
2073 size_t find(const wxString
& str
, size_t nStart
= 0) const
2074 { return PosFromImpl(m_impl
.find(str
.m_impl
, PosToImpl(nStart
))); }
2076 // find first n characters of sz
2077 size_t find(const char* sz
, size_t nStart
= 0, size_t n
= npos
) const
2079 SubstrBufFromMB
str(ImplStr(sz
, n
));
2080 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
2082 size_t find(const wchar_t* sz
, size_t nStart
= 0, size_t n
= npos
) const
2084 SubstrBufFromWC
str(ImplStr(sz
, n
));
2085 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
2087 size_t find(const wxCharBuffer
& s
, size_t nStart
= 0, size_t n
= npos
) const
2088 { return find(s
.data(), nStart
, n
); }
2089 size_t find(const wxWCharBuffer
& s
, size_t nStart
= 0, size_t n
= npos
) const
2090 { return find(s
.data(), nStart
, n
); }
2091 size_t find(const wxCStrData
& s
, size_t nStart
= 0, size_t n
= npos
) const
2092 { return find(s
.AsWChar(), nStart
, n
); }
2094 // find the first occurence of character ch after nStart
2095 size_t find(wxUniChar ch
, size_t nStart
= 0) const
2097 return PosFromImpl(m_impl
.find(wxStringOperations::EncodeChar(ch
),
2098 PosToImpl(nStart
)));
2100 size_t find(wxUniCharRef ch
, size_t nStart
= 0) const
2101 { return find(wxUniChar(ch
), nStart
); }
2102 size_t find(char ch
, size_t nStart
= 0) const
2103 { return find(wxUniChar(ch
), nStart
); }
2104 size_t find(unsigned char ch
, size_t nStart
= 0) const
2105 { return find(wxUniChar(ch
), nStart
); }
2106 size_t find(wchar_t ch
, size_t nStart
= 0) const
2107 { return find(wxUniChar(ch
), nStart
); }
2109 // rfind() family is exactly like find() but works right to left
2111 // as find, but from the end
2112 size_t rfind(const wxString
& str
, size_t nStart
= npos
) const
2113 { return PosFromImpl(m_impl
.rfind(str
.m_impl
, PosToImpl(nStart
))); }
2115 // as find, but from the end
2116 size_t rfind(const char* sz
, size_t nStart
= npos
, size_t n
= npos
) const
2118 SubstrBufFromMB
str(ImplStr(sz
, n
));
2119 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2121 size_t rfind(const wchar_t* sz
, size_t nStart
= npos
, size_t n
= npos
) const
2123 SubstrBufFromWC
str(ImplStr(sz
, n
));
2124 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2126 size_t rfind(const wxCharBuffer
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2127 { return rfind(s
.data(), nStart
, n
); }
2128 size_t rfind(const wxWCharBuffer
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2129 { return rfind(s
.data(), nStart
, n
); }
2130 size_t rfind(const wxCStrData
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2131 { return rfind(s
.AsWChar(), nStart
, n
); }
2132 // as find, but from the end
2133 size_t rfind(wxUniChar ch
, size_t nStart
= npos
) const
2135 return PosFromImpl(m_impl
.rfind(wxStringOperations::EncodeChar(ch
),
2136 PosToImpl(nStart
)));
2138 size_t rfind(wxUniCharRef ch
, size_t nStart
= npos
) const
2139 { return rfind(wxUniChar(ch
), nStart
); }
2140 size_t rfind(char ch
, size_t nStart
= npos
) const
2141 { return rfind(wxUniChar(ch
), nStart
); }
2142 size_t rfind(unsigned char ch
, size_t nStart
= npos
) const
2143 { return rfind(wxUniChar(ch
), nStart
); }
2144 size_t rfind(wchar_t ch
, size_t nStart
= npos
) const
2145 { return rfind(wxUniChar(ch
), nStart
); }
2147 // find first/last occurence of any character (not) in the set:
2148 #if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2149 // FIXME-UTF8: this is not entirely correct, because it doesn't work if
2150 // sizeof(wchar_t)==2 and surrogates are present in the string;
2151 // should we care? Probably not.
2152 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2153 { return m_impl
.find_first_of(str
.m_impl
, nStart
); }
2154 size_t find_first_of(const char* sz
, size_t nStart
= 0) const
2155 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2156 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const
2157 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2158 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const
2159 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2160 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2161 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2162 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2163 { return m_impl
.find_first_of((wxChar
)c
, nStart
); }
2165 size_t find_last_of(const wxString
& str
, size_t nStart
= npos
) const
2166 { return m_impl
.find_last_of(str
.m_impl
, nStart
); }
2167 size_t find_last_of(const char* sz
, size_t nStart
= npos
) const
2168 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2169 size_t find_last_of(const wchar_t* sz
, size_t nStart
= npos
) const
2170 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2171 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const
2172 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2173 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2174 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2175 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2176 { return m_impl
.find_last_of((wxChar
)c
, nStart
); }
2178 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2179 { return m_impl
.find_first_not_of(str
.m_impl
, nStart
); }
2180 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const
2181 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2182 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const
2183 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2184 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const
2185 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2186 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2187 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2188 size_t find_first_not_of(wxUniChar c
, size_t nStart
= 0) const
2189 { return m_impl
.find_first_not_of((wxChar
)c
, nStart
); }
2191 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2192 { return m_impl
.find_last_not_of(str
.m_impl
, nStart
); }
2193 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const
2194 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2195 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const
2196 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2197 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const
2198 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2199 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2200 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2201 size_t find_last_not_of(wxUniChar c
, size_t nStart
= npos
) const
2202 { return m_impl
.find_last_not_of((wxChar
)c
, nStart
); }
2204 // we can't use std::string implementation in UTF-8 build, because the
2205 // character sets would be interpreted wrongly:
2207 // as strpbrk() but starts at nStart, returns npos if not found
2208 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2209 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2210 { return find_first_of(str
.wc_str(), nStart
); }
2212 { return find_first_of(str
.mb_str(), nStart
); }
2215 size_t find_first_of(const char* sz
, size_t nStart
= 0) const;
2216 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const;
2217 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const;
2218 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2219 // same as find(char, size_t)
2220 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2221 { return find(c
, nStart
); }
2222 // find the last (starting from nStart) char from str in this string
2223 size_t find_last_of (const wxString
& str
, size_t nStart
= npos
) const
2224 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2225 { return find_last_of(str
.wc_str(), nStart
); }
2227 { return find_last_of(str
.mb_str(), nStart
); }
2230 size_t find_last_of (const char* sz
, size_t nStart
= npos
) const;
2231 size_t find_last_of (const wchar_t* sz
, size_t nStart
= npos
) const;
2232 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const;
2233 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2235 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2236 { return rfind(c
, nStart
); }
2238 // find first/last occurence of any character not in the set
2240 // as strspn() (starting from nStart), returns npos on failure
2241 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2242 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2243 { return find_first_not_of(str
.wc_str(), nStart
); }
2245 { return find_first_not_of(str
.mb_str(), nStart
); }
2248 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const;
2249 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const;
2250 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2251 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2253 size_t find_first_not_of(wxUniChar ch
, size_t nStart
= 0) const;
2255 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2256 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2257 { return find_last_not_of(str
.wc_str(), nStart
); }
2259 { return find_last_not_of(str
.mb_str(), nStart
); }
2262 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const;
2263 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const;
2264 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2265 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2267 size_t find_last_not_of(wxUniChar ch
, size_t nStart
= npos
) const;
2268 #endif // wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 or not
2270 // provide char/wchar_t/wxUniCharRef overloads for char-finding functions
2271 // above to resolve ambiguities:
2272 size_t find_first_of(wxUniCharRef ch
, size_t nStart
= 0) const
2273 { return find_first_of(wxUniChar(ch
), nStart
); }
2274 size_t find_first_of(char ch
, size_t nStart
= 0) const
2275 { return find_first_of(wxUniChar(ch
), nStart
); }
2276 size_t find_first_of(unsigned char ch
, size_t nStart
= 0) const
2277 { return find_first_of(wxUniChar(ch
), nStart
); }
2278 size_t find_first_of(wchar_t ch
, size_t nStart
= 0) const
2279 { return find_first_of(wxUniChar(ch
), nStart
); }
2280 size_t find_last_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2281 { return find_last_of(wxUniChar(ch
), nStart
); }
2282 size_t find_last_of(char ch
, size_t nStart
= npos
) const
2283 { return find_last_of(wxUniChar(ch
), nStart
); }
2284 size_t find_last_of(unsigned char ch
, size_t nStart
= npos
) const
2285 { return find_last_of(wxUniChar(ch
), nStart
); }
2286 size_t find_last_of(wchar_t ch
, size_t nStart
= npos
) const
2287 { return find_last_of(wxUniChar(ch
), nStart
); }
2288 size_t find_first_not_of(wxUniCharRef ch
, size_t nStart
= 0) const
2289 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2290 size_t find_first_not_of(char ch
, size_t nStart
= 0) const
2291 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2292 size_t find_first_not_of(unsigned char ch
, size_t nStart
= 0) const
2293 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2294 size_t find_first_not_of(wchar_t ch
, size_t nStart
= 0) const
2295 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2296 size_t find_last_not_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2297 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2298 size_t find_last_not_of(char ch
, size_t nStart
= npos
) const
2299 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2300 size_t find_last_not_of(unsigned char ch
, size_t nStart
= npos
) const
2301 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2302 size_t find_last_not_of(wchar_t ch
, size_t nStart
= npos
) const
2303 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2305 // and additional overloads for the versions taking strings:
2306 size_t find_first_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2307 { return find_first_of(sz
.AsString(), nStart
); }
2308 size_t find_first_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2309 { return find_first_of(sz
.data(), nStart
); }
2310 size_t find_first_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2311 { return find_first_of(sz
.data(), nStart
); }
2312 size_t find_first_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2313 { return find_first_of(sz
.AsWChar(), nStart
, n
); }
2314 size_t find_first_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2315 { return find_first_of(sz
.data(), nStart
, n
); }
2316 size_t find_first_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2317 { return find_first_of(sz
.data(), nStart
, n
); }
2319 size_t find_last_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2320 { return find_last_of(sz
.AsString(), nStart
); }
2321 size_t find_last_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2322 { return find_last_of(sz
.data(), nStart
); }
2323 size_t find_last_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2324 { return find_last_of(sz
.data(), nStart
); }
2325 size_t find_last_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2326 { return find_last_of(sz
.AsWChar(), nStart
, n
); }
2327 size_t find_last_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2328 { return find_last_of(sz
.data(), nStart
, n
); }
2329 size_t find_last_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2330 { return find_last_of(sz
.data(), nStart
, n
); }
2332 size_t find_first_not_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2333 { return find_first_not_of(sz
.AsString(), nStart
); }
2334 size_t find_first_not_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2335 { return find_first_not_of(sz
.data(), nStart
); }
2336 size_t find_first_not_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2337 { return find_first_not_of(sz
.data(), nStart
); }
2338 size_t find_first_not_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2339 { return find_first_not_of(sz
.AsWChar(), nStart
, n
); }
2340 size_t find_first_not_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2341 { return find_first_not_of(sz
.data(), nStart
, n
); }
2342 size_t find_first_not_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2343 { return find_first_not_of(sz
.data(), nStart
, n
); }
2345 size_t find_last_not_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2346 { return find_last_not_of(sz
.AsString(), nStart
); }
2347 size_t find_last_not_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2348 { return find_last_not_of(sz
.data(), nStart
); }
2349 size_t find_last_not_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2350 { return find_last_not_of(sz
.data(), nStart
); }
2351 size_t find_last_not_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2352 { return find_last_not_of(sz
.AsWChar(), nStart
, n
); }
2353 size_t find_last_not_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2354 { return find_last_not_of(sz
.data(), nStart
, n
); }
2355 size_t find_last_not_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2356 { return find_last_not_of(sz
.data(), nStart
, n
); }
2359 wxString
& operator+=(const wxString
& s
)
2360 { m_impl
+= s
.m_impl
; return *this; }
2361 // string += C string
2362 wxString
& operator+=(const char *psz
)
2363 { m_impl
+= ImplStr(psz
); return *this; }
2364 wxString
& operator+=(const wchar_t *pwz
)
2365 { m_impl
+= ImplStr(pwz
); return *this; }
2366 wxString
& operator+=(const wxCStrData
& s
)
2367 { m_impl
+= s
.AsString().m_impl
; return *this; }
2368 wxString
& operator+=(const wxCharBuffer
& s
)
2369 { return operator+=(s
.data()); }
2370 wxString
& operator+=(const wxWCharBuffer
& s
)
2371 { return operator+=(s
.data()); }
2373 wxString
& operator+=(wxUniChar ch
)
2374 { m_impl
+= wxStringOperations::EncodeChar(ch
); return *this; }
2375 wxString
& operator+=(wxUniCharRef ch
) { return *this += wxUniChar(ch
); }
2376 wxString
& operator+=(int ch
) { return *this += wxUniChar(ch
); }
2377 wxString
& operator+=(char ch
) { return *this += wxUniChar(ch
); }
2378 wxString
& operator+=(unsigned char ch
) { return *this += wxUniChar(ch
); }
2379 wxString
& operator+=(wchar_t ch
) { return *this += wxUniChar(ch
); }
2382 #if !wxUSE_STL_BASED_WXSTRING
2383 // helpers for wxStringBuffer and wxStringBufferLength
2384 wxStringCharType
*DoGetWriteBuf(size_t nLen
)
2385 { return m_impl
.DoGetWriteBuf(nLen
); }
2386 void DoUngetWriteBuf()
2387 { m_impl
.DoUngetWriteBuf(); }
2388 void DoUngetWriteBuf(size_t nLen
)
2389 { m_impl
.DoUngetWriteBuf(nLen
); }
2390 #endif // !wxUSE_STL_BASED_WXSTRING
2392 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
2393 #if !wxUSE_UTF8_LOCALE_ONLY
2394 int DoPrintfWchar(const wxChar
*format
, ...);
2395 static wxString
DoFormatWchar(const wxChar
*format
, ...);
2397 #if wxUSE_UNICODE_UTF8
2398 int DoPrintfUtf8(const char *format
, ...);
2399 static wxString
DoFormatUtf8(const char *format
, ...);
2403 #if !wxUSE_STL_BASED_WXSTRING
2404 // check string's data validity
2405 bool IsValid() const { return m_impl
.GetStringData()->IsValid(); }
2409 wxStringImpl m_impl
;
2411 // buffers for compatibility conversion from (char*)c_str() and
2412 // (wchar_t*)c_str():
2413 // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
2414 template<typename T
>
2415 struct ConvertedBuffer
2417 ConvertedBuffer() : m_buf(NULL
) {}
2421 operator T
*() const { return m_buf
; }
2423 ConvertedBuffer
& operator=(T
*str
)
2432 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
2433 ConvertedBuffer
<char> m_convertedToChar
;
2435 #if !wxUSE_UNICODE_WCHAR
2436 ConvertedBuffer
<wchar_t> m_convertedToWChar
;
2439 friend class WXDLLIMPEXP_BASE wxCStrData
;
2440 friend class wxImplStringBuffer
;
2441 friend class wxImplStringBufferLength
;
2444 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
2445 #pragma warning (default:4275)
2448 // string iterator operators that satisfy STL Random Access Iterator
2450 inline wxString::iterator
operator+(int n
, wxString::iterator i
)
2452 inline wxString::iterator
operator+(size_t n
, wxString::iterator i
)
2454 inline wxString::const_iterator
operator+(int n
, wxString::const_iterator i
)
2456 inline wxString::const_iterator
operator+(size_t n
, wxString::const_iterator i
)
2458 inline wxString::reverse_iterator
operator+(int n
, wxString::reverse_iterator i
)
2460 inline wxString::reverse_iterator
operator+(size_t n
, wxString::reverse_iterator i
)
2462 inline wxString::const_reverse_iterator
operator+(int n
, wxString::const_reverse_iterator i
)
2464 inline wxString::const_reverse_iterator
operator+(size_t n
, wxString::const_reverse_iterator i
)
2467 // notice that even though for many compilers the friend declarations above are
2468 // enough, from the point of view of C++ standard we must have the declarations
2469 // here as friend ones are not injected in the enclosing namespace and without
2470 // them the code fails to compile with conforming compilers such as xlC or g++4
2471 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
, const wxString
& string2
);
2472 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const char *psz
);
2473 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const wchar_t *pwz
);
2474 wxString WXDLLIMPEXP_BASE
operator+(const char *psz
, const wxString
& string
);
2475 wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
, const wxString
& string
);
2477 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
2478 wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
2480 inline wxString
operator+(const wxString
& string
, wxUniCharRef ch
)
2481 { return string
+ (wxUniChar
)ch
; }
2482 inline wxString
operator+(const wxString
& string
, char ch
)
2483 { return string
+ wxUniChar(ch
); }
2484 inline wxString
operator+(const wxString
& string
, wchar_t ch
)
2485 { return string
+ wxUniChar(ch
); }
2486 inline wxString
operator+(wxUniCharRef ch
, const wxString
& string
)
2487 { return (wxUniChar
)ch
+ string
; }
2488 inline wxString
operator+(char ch
, const wxString
& string
)
2489 { return wxUniChar(ch
) + string
; }
2490 inline wxString
operator+(wchar_t ch
, const wxString
& string
)
2491 { return wxUniChar(ch
) + string
; }
2494 #if wxUSE_STL_BASED_WXSTRING
2495 // return an empty wxString (not very useful with wxUSE_STL == 1)
2496 inline const wxString
wxGetEmptyString() { return wxString(); }
2497 #else // !wxUSE_STL_BASED_WXSTRING
2498 // return an empty wxString (more efficient than wxString() here)
2499 inline const wxString
& wxGetEmptyString()
2501 return *(wxString
*)&wxEmptyString
;
2503 #endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
2505 // ----------------------------------------------------------------------------
2506 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
2507 // ----------------------------------------------------------------------------
2509 #if !wxUSE_STL_BASED_WXSTRING
2510 // string buffer for direct access to string data in their native
2512 class wxImplStringBuffer
2515 typedef wxStringCharType CharType
;
2517 wxImplStringBuffer(wxString
& str
, size_t lenWanted
= 1024)
2518 : m_str(str
), m_buf(NULL
)
2519 { m_buf
= m_str
.DoGetWriteBuf(lenWanted
); }
2521 ~wxImplStringBuffer() { m_str
.DoUngetWriteBuf(); }
2523 operator wxStringCharType
*() const { return m_buf
; }
2527 wxStringCharType
*m_buf
;
2529 DECLARE_NO_COPY_CLASS(wxImplStringBuffer
)
2532 class wxImplStringBufferLength
2535 typedef wxStringCharType CharType
;
2537 wxImplStringBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2538 : m_str(str
), m_buf(NULL
), m_len(0), m_lenSet(false)
2540 m_buf
= m_str
.DoGetWriteBuf(lenWanted
);
2541 wxASSERT(m_buf
!= NULL
);
2544 ~wxImplStringBufferLength()
2547 m_str
.DoUngetWriteBuf(m_len
);
2550 operator wxStringCharType
*() const { return m_buf
; }
2551 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2555 wxStringCharType
*m_buf
;
2559 DECLARE_NO_COPY_CLASS(wxImplStringBufferLength
)
2562 #endif // !wxUSE_STL_BASED_WXSTRING
2564 template<typename T
>
2565 class wxStringTypeBufferBase
2570 wxStringTypeBufferBase(wxString
& str
, size_t lenWanted
= 1024)
2571 : m_str(str
), m_buf(lenWanted
)
2575 operator CharType
*() { return m_buf
.data(); }
2579 wxCharTypeBuffer
<CharType
> m_buf
;
2582 template<typename T
>
2583 class wxStringTypeBufferLengthBase
2588 wxStringTypeBufferLengthBase(wxString
& str
, size_t lenWanted
= 1024)
2589 : m_str(str
), m_buf(lenWanted
), m_len(0), m_lenSet(false)
2592 ~wxStringTypeBufferLengthBase()
2595 m_str
.assign(m_buf
.data(), m_len
);
2598 operator CharType
*() { return m_buf
.data(); }
2599 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2603 wxCharTypeBuffer
<CharType
> m_buf
;
2608 template<typename T
>
2609 class wxStringTypeBuffer
: public wxStringTypeBufferBase
<T
>
2612 wxStringTypeBuffer(wxString
& str
, size_t lenWanted
= 1024)
2613 : wxStringTypeBufferBase
<T
>(str
, lenWanted
) {}
2614 ~wxStringTypeBuffer()
2616 this->m_str
.assign(this->m_buf
.data());
2619 DECLARE_NO_COPY_CLASS(wxStringTypeBuffer
)
2622 template<typename T
>
2623 class wxStringTypeBufferLength
: public wxStringTypeBufferLengthBase
<T
>
2626 wxStringTypeBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2627 : wxStringTypeBufferLengthBase
<T
>(str
, lenWanted
) {}
2629 ~wxStringTypeBufferLength()
2631 wxASSERT(this->m_lenSet
);
2632 this->m_str
.assign(this->m_buf
.data(), this->m_len
);
2635 DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength
)
2638 #if wxUSE_STL_BASED_WXSTRING
2639 class wxImplStringBuffer
: public wxStringTypeBufferBase
<wxStringCharType
>
2642 wxImplStringBuffer(wxString
& str
, size_t lenWanted
= 1024)
2643 : wxStringTypeBufferBase
<wxStringCharType
>(str
, lenWanted
) {}
2644 ~wxImplStringBuffer()
2645 { m_str
.m_impl
.assign(m_buf
.data()); }
2647 DECLARE_NO_COPY_CLASS(wxImplStringBuffer
)
2650 class wxImplStringBufferLength
: public wxStringTypeBufferLengthBase
<wxStringCharType
>
2653 wxImplStringBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2654 : wxStringTypeBufferLengthBase
<wxStringCharType
>(str
, lenWanted
) {}
2656 ~wxImplStringBufferLength()
2659 m_str
.m_impl
.assign(m_buf
.data(), m_len
);
2662 DECLARE_NO_COPY_CLASS(wxImplStringBufferLength
)
2664 #endif // wxUSE_STL_BASED_WXSTRING
2667 #if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
2668 typedef wxStringTypeBuffer
<wxChar
> wxStringBuffer
;
2669 typedef wxStringTypeBufferLength
<wxChar
> wxStringBufferLength
;
2670 #else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2671 typedef wxImplStringBuffer wxStringBuffer
;
2672 typedef wxImplStringBufferLength wxStringBufferLength
;
2673 #endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2675 // ---------------------------------------------------------------------------
2676 // wxString comparison functions: operator versions are always case sensitive
2677 // ---------------------------------------------------------------------------
2679 #define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p)
2681 wxDEFINE_ALL_COMPARISONS(const wxChar
*, const wxString
&, wxCMP_WXCHAR_STRING
)
2683 #undef wxCMP_WXCHAR_STRING
2685 // note that there is an optimization in operator==() and !=(): we (quickly)
2686 // checks the strings length first, before comparing their data
2687 inline bool operator==(const wxString
& s1
, const wxString
& s2
)
2688 { return (s1
.Len() == s2
.Len()) && (s1
.Cmp(s2
) == 0); }
2689 inline bool operator!=(const wxString
& s1
, const wxString
& s2
)
2690 { return (s1
.Len() != s2
.Len()) || (s1
.Cmp(s2
) != 0); }
2691 inline bool operator< (const wxString
& s1
, const wxString
& s2
)
2692 { return s1
.Cmp(s2
) < 0; }
2693 inline bool operator> (const wxString
& s1
, const wxString
& s2
)
2694 { return s1
.Cmp(s2
) > 0; }
2695 inline bool operator<=(const wxString
& s1
, const wxString
& s2
)
2696 { return s1
.Cmp(s2
) <= 0; }
2697 inline bool operator>=(const wxString
& s1
, const wxString
& s2
)
2698 { return s1
.Cmp(s2
) >= 0; }
2701 inline bool operator==(const wxString
& s1
, const wxWCharBuffer
& s2
)
2702 { return (s1
.Cmp((const wchar_t *)s2
) == 0); }
2703 inline bool operator==(const wxWCharBuffer
& s1
, const wxString
& s2
)
2704 { return (s2
.Cmp((const wchar_t *)s1
) == 0); }
2705 inline bool operator!=(const wxString
& s1
, const wxWCharBuffer
& s2
)
2706 { return (s1
.Cmp((const wchar_t *)s2
) != 0); }
2707 inline bool operator!=(const wxWCharBuffer
& s1
, const wxString
& s2
)
2708 { return (s2
.Cmp((const wchar_t *)s1
) != 0); }
2709 #else // !wxUSE_UNICODE
2710 inline bool operator==(const wxString
& s1
, const wxCharBuffer
& s2
)
2711 { return (s1
.Cmp((const char *)s2
) == 0); }
2712 inline bool operator==(const wxCharBuffer
& s1
, const wxString
& s2
)
2713 { return (s2
.Cmp((const char *)s1
) == 0); }
2714 inline bool operator!=(const wxString
& s1
, const wxCharBuffer
& s2
)
2715 { return (s1
.Cmp((const char *)s2
) != 0); }
2716 inline bool operator!=(const wxCharBuffer
& s1
, const wxString
& s2
)
2717 { return (s2
.Cmp((const char *)s1
) != 0); }
2718 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2721 inline wxString
operator+(const wxString
& string
, const wxWCharBuffer
& buf
)
2722 { return string
+ (const wchar_t *)buf
; }
2723 inline wxString
operator+(const wxWCharBuffer
& buf
, const wxString
& string
)
2724 { return (const wchar_t *)buf
+ string
; }
2725 #else // !wxUSE_UNICODE
2726 inline wxString
operator+(const wxString
& string
, const wxCharBuffer
& buf
)
2727 { return string
+ (const char *)buf
; }
2728 inline wxString
operator+(const wxCharBuffer
& buf
, const wxString
& string
)
2729 { return (const char *)buf
+ string
; }
2730 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2732 // comparison with char
2733 inline bool operator==(const wxUniChar
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2734 inline bool operator==(const wxUniCharRef
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2735 inline bool operator==(char c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2736 inline bool operator==(wchar_t c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2737 inline bool operator==(int c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2738 inline bool operator==(const wxString
& s
, const wxUniChar
& c
) { return s
.IsSameAs(c
); }
2739 inline bool operator==(const wxString
& s
, const wxUniCharRef
& c
) { return s
.IsSameAs(c
); }
2740 inline bool operator==(const wxString
& s
, char c
) { return s
.IsSameAs(c
); }
2741 inline bool operator==(const wxString
& s
, wchar_t c
) { return s
.IsSameAs(c
); }
2742 inline bool operator!=(const wxUniChar
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2743 inline bool operator!=(const wxUniCharRef
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2744 inline bool operator!=(char c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2745 inline bool operator!=(wchar_t c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2746 inline bool operator!=(int c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2747 inline bool operator!=(const wxString
& s
, const wxUniChar
& c
) { return !s
.IsSameAs(c
); }
2748 inline bool operator!=(const wxString
& s
, const wxUniCharRef
& c
) { return !s
.IsSameAs(c
); }
2749 inline bool operator!=(const wxString
& s
, char c
) { return !s
.IsSameAs(c
); }
2750 inline bool operator!=(const wxString
& s
, wchar_t c
) { return !s
.IsSameAs(c
); }
2752 // comparison with C string in Unicode build
2755 #define wxCMP_CHAR_STRING(p, s, op) wxString(p) op s
2757 wxDEFINE_ALL_COMPARISONS(const char *, const wxString
&, wxCMP_CHAR_STRING
)
2759 #undef wxCMP_CHAR_STRING
2761 #endif // wxUSE_UNICODE
2763 // we also need to provide the operators for comparison with wxCStrData to
2764 // resolve ambiguity between operator(const wxChar *,const wxString &) and
2765 // operator(const wxChar *, const wxChar *) for "p == s.c_str()"
2767 // notice that these are (shallow) pointer comparisons, not (deep) string ones
2768 #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
2769 #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
2771 wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData
&, wxCMP_WCHAR_CSTRDATA
)
2772 wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData
&, wxCMP_CHAR_CSTRDATA
)
2774 #undef wxCMP_CHAR_CSTRDATA
2775 #undef wxCMP_WCHAR_CSTRDATA
2777 // ---------------------------------------------------------------------------
2778 // Implementation only from here until the end of file
2779 // ---------------------------------------------------------------------------
2781 #if wxUSE_STD_IOSTREAM
2783 #include "wx/iosfwrap.h"
2785 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxString
&);
2786 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCStrData
&);
2787 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCharBuffer
&);
2788 #ifndef __BORLANDC__
2789 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxWCharBuffer
&);
2792 #endif // wxSTD_STRING_COMPATIBILITY
2794 // ---------------------------------------------------------------------------
2795 // wxCStrData implementation
2796 // ---------------------------------------------------------------------------
2798 inline wxCStrData::wxCStrData(char *buf
)
2799 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
2800 inline wxCStrData::wxCStrData(wchar_t *buf
)
2801 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
2803 inline wxCStrData::wxCStrData(const wxCStrData
& data
)
2804 : m_str(data
.m_owned
? new wxString(*data
.m_str
) : data
.m_str
),
2805 m_offset(data
.m_offset
),
2806 m_owned(data
.m_owned
)
2810 inline wxCStrData::~wxCStrData()
2816 // simple cases for AsChar() and AsWChar(), the complicated ones are
2818 #if wxUSE_UNICODE_WCHAR
2819 inline const wchar_t* wxCStrData::AsWChar() const
2821 return m_str
->wx_str() + m_offset
;
2823 #endif // wxUSE_UNICODE_WCHAR
2825 #if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
2826 inline const char* wxCStrData::AsChar() const
2828 return wxStringOperations::AddToIter(m_str
->wx_str(), m_offset
);
2830 #endif // !wxUSE_UNICODE
2832 inline const wxCharBuffer
wxCStrData::AsCharBuf() const
2835 return wxCharBuffer::CreateNonOwned(AsChar());
2837 return AsString().mb_str();
2841 inline const wxWCharBuffer
wxCStrData::AsWCharBuf() const
2843 #if wxUSE_UNICODE_WCHAR
2844 return wxWCharBuffer::CreateNonOwned(AsWChar());
2846 return AsString().wc_str();
2850 inline wxString
wxCStrData::AsString() const
2852 if ( m_offset
== 0 )
2855 return m_str
->Mid(m_offset
);
2858 inline const wxStringCharType
*wxCStrData::AsInternal() const
2860 return wxStringOperations::AddToIter(m_str
->wx_str(), m_offset
);
2863 inline wxUniChar
wxCStrData::operator*() const
2865 if ( m_str
->empty() )
2866 return wxUniChar(_T('\0'));
2868 return (*m_str
)[m_offset
];
2871 inline wxUniChar
wxCStrData::operator[](size_t n
) const
2873 // NB: we intentionally use operator[] and not at() here because the former
2874 // works for the terminating NUL while the latter does not
2875 return (*m_str
)[m_offset
+ n
];
2878 // ----------------------------------------------------------------------------
2879 // more wxCStrData operators
2880 // ----------------------------------------------------------------------------
2882 // we need to define those to allow "size_t pos = p - s.c_str()" where p is
2883 // some pointer into the string
2884 inline size_t operator-(const char *p
, const wxCStrData
& cs
)
2886 return p
- cs
.AsChar();
2889 inline size_t operator-(const wchar_t *p
, const wxCStrData
& cs
)
2891 return p
- cs
.AsWChar();
2894 // ----------------------------------------------------------------------------
2895 // implementation of wx[W]CharBuffer inline methods using wxCStrData
2896 // ----------------------------------------------------------------------------
2898 // FIXME-UTF8: move this to buffer.h
2899 inline wxCharBuffer::wxCharBuffer(const wxCStrData
& cstr
)
2900 : wxCharTypeBufferBase(cstr
.AsCharBuf())
2904 inline wxWCharBuffer::wxWCharBuffer(const wxCStrData
& cstr
)
2905 : wxCharTypeBufferBase(cstr
.AsWCharBuf())
2909 #if WXWIN_COMPATIBILITY_2_8
2910 // lot of code out there doesn't explicitly include wx/wxchar.h, but uses
2911 // CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h,
2912 // so let's include this header now that wxString is defined and it's safe
2914 #include "wx/wxchar.h"
2917 #endif // _WX_WXSTRING_H_