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/wxchar.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 wxCStrData(char *buf
);
190 wxCStrData(wchar_t *buf
);
192 inline ~wxCStrData();
194 // methods defined inline below must be declared inline or mingw32 3.4.5
195 // warns about "<symbol> defined locally after being referenced with
196 // dllimport linkage"
197 #if wxUSE_UNICODE_WCHAR
200 const wchar_t* AsWChar() const;
201 operator const wchar_t*() const { return AsWChar(); }
203 inline operator bool() const;
208 const char* AsChar() const;
209 const unsigned char* AsUnsignedChar() const
210 { return (const unsigned char *) AsChar(); }
211 operator const char*() const { return AsChar(); }
212 operator const unsigned char*() const { return AsUnsignedChar(); }
214 operator const void*() const { return AsChar(); }
216 inline const wxCharBuffer
AsCharBuf() const;
217 inline const wxWCharBuffer
AsWCharBuf() const;
219 inline wxString
AsString() const;
221 // allow expressions like "c_str()[0]":
222 inline wxUniChar
operator[](size_t n
) const;
223 wxUniChar
operator[](int n
) const { return operator[](size_t(n
)); }
224 wxUniChar
operator[](long n
) const { return operator[](size_t(n
)); }
225 #ifndef wxSIZE_T_IS_UINT
226 wxUniChar
operator[](unsigned int n
) const { return operator[](size_t(n
)); }
227 #endif // size_t != unsigned int
229 // these operators are needed to emulate the pointer semantics of c_str():
230 // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
231 // (we need both versions to resolve ambiguities):
232 wxCStrData
operator+(int n
) const
233 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
234 wxCStrData
operator+(long n
) const
235 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
236 wxCStrData
operator+(size_t n
) const
237 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
239 // and these for "str.c_str() + n - 2":
240 wxCStrData
operator-(int n
) const
242 wxASSERT_MSG( n
<= (int)m_offset
,
243 _T("attempt to construct address before the beginning of the string") );
244 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
246 wxCStrData
operator-(long n
) const
248 wxASSERT_MSG( n
<= (int)m_offset
,
249 _T("attempt to construct address before the beginning of the string") );
250 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
252 wxCStrData
operator-(size_t n
) const
254 wxASSERT_MSG( n
<= m_offset
,
255 _T("attempt to construct address before the beginning of the string") );
256 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
259 // this operator is needed to make expressions like "*c_str()" or
260 // "*(c_str() + 2)" work
261 inline wxUniChar
operator*() const;
264 const wxString
*m_str
;
268 friend class WXDLLIMPEXP_BASE wxString
;
271 // ----------------------------------------------------------------------------
272 // wxStringPrintfMixin
273 // ---------------------------------------------------------------------------
275 // NB: VC6 has a bug that causes linker errors if you have template methods
276 // in a class using __declspec(dllimport). The solution is to split such
277 // class into two classes, one that contains the template methods and does
278 // *not* use WXDLLIMPEXP_BASE and another class that contains the rest
279 // (with DLL linkage).
281 // We only do this for VC6 here, because the code is less efficient
282 // (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler
283 // cannot compile this code.
285 #if defined(__VISUALC__) && __VISUALC__ < 1300
286 #define wxNEEDS_WXSTRING_PRINTF_MIXIN
289 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
290 // this class contains implementation of wxString's vararg methods, it's
291 // exported from wxBase DLL
292 class WXDLLIMPEXP_BASE wxStringPrintfMixinBase
295 wxStringPrintfMixinBase() {}
297 int DoPrintf(const wxChar
*format
, ...) ATTRIBUTE_PRINTF_2
;
298 static wxString
DoFormat(const wxChar
*format
, ...) ATTRIBUTE_PRINTF_1
;
301 // this class contains template wrappers for wxString's vararg methods, it's
302 // intentionally *not* exported from the DLL in order to fix the VC6 bug
304 class wxStringPrintfMixin
: public wxStringPrintfMixinBase
307 // to further complicate things, we can't return wxString from
308 // wxStringPrintfMixin::Format() because wxString is not yet declared at
309 // this point; the solution is to use this fake type trait template - this
310 // way the compiler won't know the return type until Format() is used
311 // (this doesn't compile with Watcom, but VC6 compiles it just fine):
312 template<typename T
> struct StringReturnType
314 typedef wxString type
;
318 // these are duplicated wxString methods, they're also declared below
319 // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
321 // int Printf(const wxChar *pszFormat, ...);
322 WX_DEFINE_VARARG_FUNC(int, Printf
, DoPrintf
)
323 // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
324 WX_DEFINE_VARARG_FUNC(static typename StringReturnType
<T1
>::type
,
326 // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
327 WX_DEFINE_VARARG_FUNC(int, sprintf
, DoPrintf
)
330 wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
332 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
335 // ----------------------------------------------------------------------------
336 // wxString: string class trying to be compatible with std::string, MFC
337 // CString and wxWindows 1.x wxString all at once
338 // ---------------------------------------------------------------------------
340 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
341 // "non dll-interface class 'wxStringPrintfMixin' used as base interface
342 // for dll-interface class 'wxString'" -- this is OK in our case
343 #pragma warning (disable:4275)
346 class WXDLLIMPEXP_BASE wxString
347 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
348 : public wxStringPrintfMixin
351 // NB: special care was taken in arranging the member functions in such order
352 // that all inline functions can be effectively inlined, verify that all
353 // performance critical functions are still inlined if you change order!
355 // an 'invalid' value for string index, moved to this place due to a CW bug
356 static const size_t npos
;
359 // if we hadn't made these operators private, it would be possible to
360 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
361 // converted to char in C and we do have operator=(char)
363 // NB: we don't need other versions (short/long and unsigned) as attempt
364 // to assign another numeric type to wxString will now result in
365 // ambiguity between operator=(char) and operator=(int)
366 wxString
& operator=(int);
368 // these methods are not implemented - there is _no_ conversion from int to
369 // string, you're doing something wrong if the compiler wants to call it!
371 // try `s << i' or `s.Printf("%d", i)' instead
375 // buffer for holding temporary substring when using any of the methods
376 // that take (char*,size_t) or (wchar_t*,size_t) arguments:
378 struct SubstrBufFromType
383 SubstrBufFromType(const T
& data_
, size_t len_
)
384 : data(data_
), len(len_
) {}
387 #if wxUSE_UNICODE_UTF8
388 // even char* -> char* needs conversion, from locale charset to UTF-8
389 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
390 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromMB
;
391 #elif wxUSE_UNICODE_WCHAR
392 typedef SubstrBufFromType
<const wchar_t*> SubstrBufFromWC
;
393 typedef SubstrBufFromType
<wxWCharBuffer
> SubstrBufFromMB
;
395 typedef SubstrBufFromType
<const char*> SubstrBufFromMB
;
396 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
400 // Functions implementing primitive operations on string data; wxString
401 // methods and iterators are implemented in terms of it. The differences
402 // between UTF-8 and wchar_t* representations of the string are mostly
405 #if wxUSE_UNICODE_UTF8
406 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
407 const wxMBConv
& conv
);
408 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
409 const wxMBConv
& conv
);
410 #elif wxUSE_UNICODE_WCHAR
411 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
412 const wxMBConv
& conv
);
414 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
415 const wxMBConv
& conv
);
418 #if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE
419 // returns C string encoded as the implementation expects:
421 static const wchar_t* ImplStr(const wchar_t* str
)
422 { return str
? str
: wxT(""); }
423 static const SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
424 { return SubstrBufFromWC(str
, (str
&& n
== npos
) ? wxWcslen(str
) : n
); }
425 static wxWCharBuffer
ImplStr(const char* str
,
426 const wxMBConv
& conv
= wxConvLibc
)
427 { return ConvertStr(str
, npos
, conv
).data
; }
428 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
429 const wxMBConv
& conv
= wxConvLibc
)
430 { return ConvertStr(str
, n
, conv
); }
432 static const char* ImplStr(const char* str
,
433 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
434 { return str
? str
: ""; }
435 static const SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
436 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
437 { return SubstrBufFromMB(str
, (str
&& n
== npos
) ? wxStrlen(str
) : n
); }
438 static wxCharBuffer
ImplStr(const wchar_t* str
)
439 { return ConvertStr(str
, npos
, wxConvLibc
).data
; }
440 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
441 { return ConvertStr(str
, n
, wxConvLibc
); }
444 // translates position index in wxString to/from index in underlying
446 static size_t PosToImpl(size_t pos
) { return pos
; }
447 static void PosLenToImpl(size_t pos
, size_t len
,
448 size_t *implPos
, size_t *implLen
)
449 { *implPos
= pos
; *implLen
= len
; }
450 static size_t LenToImpl(size_t len
) { return len
; }
451 static size_t PosFromImpl(size_t pos
) { return pos
; }
453 #else // wxUSE_UNICODE_UTF8
455 // FIXME-UTF8: return as-is without copying under UTF8 locale, return
456 // converted string under other locales - needs wxCharBuffer
458 static wxCharBuffer
ImplStr(const char* str
,
459 const wxMBConv
& conv
= wxConvLibc
)
460 { return ConvertStr(str
, npos
, conv
).data
; }
461 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
462 const wxMBConv
& conv
= wxConvLibc
)
463 { return ConvertStr(str
, n
, conv
); }
465 static wxCharBuffer
ImplStr(const wchar_t* str
)
466 { return ConvertStr(str
, npos
, wxConvUTF8
).data
; }
467 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
468 { return ConvertStr(str
, n
, wxConvUTF8
); }
470 size_t PosToImpl(size_t pos
) const
472 if ( pos
== 0 || pos
== npos
)
475 return (begin() + pos
).impl() - m_impl
.begin();
478 void PosLenToImpl(size_t pos
, size_t len
, size_t *implPos
, size_t *implLen
) const;
480 size_t LenToImpl(size_t len
) const
483 PosLenToImpl(0, len
, &pos
, &len2
);
487 size_t PosFromImpl(size_t pos
) const
489 if ( pos
== 0 || pos
== npos
)
492 return const_iterator(m_impl
.begin() + pos
) - begin();
494 #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
498 typedef wxUniChar value_type
;
499 typedef wxUniChar char_type
;
500 typedef wxUniCharRef reference
;
501 typedef wxChar
* pointer
;
502 typedef const wxChar
* const_pointer
;
504 typedef size_t size_type
;
505 typedef wxUniChar const_reference
;
508 #if wxUSE_UNICODE_UTF8
509 // random access is not O(1), as required by Random Access Iterator
510 #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
512 #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
515 #define WX_STR_ITERATOR_TAG void /* dummy type */
518 #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \
519 reference_type, reference_ctor) \
521 typedef wxStringImpl::iterator_name underlying_iterator; \
523 typedef WX_STR_ITERATOR_TAG iterator_category; \
524 typedef wxUniChar value_type; \
525 typedef int difference_type; \
526 typedef reference_type reference; \
527 typedef pointer_type pointer; \
529 reference operator*() const { return reference_ctor; } \
530 reference operator[](size_t n) const { return *(*this + n); } \
532 iterator_name& operator++() \
533 { wxStringOperations::IncIter(m_cur); return *this; } \
534 iterator_name& operator--() \
535 { wxStringOperations::DecIter(m_cur); return *this; } \
536 iterator_name operator++(int) \
538 iterator_name tmp = *this; \
539 wxStringOperations::IncIter(m_cur); \
542 iterator_name operator--(int) \
544 iterator_name tmp = *this; \
545 wxStringOperations::DecIter(m_cur); \
549 iterator_name& operator+=(int n) \
551 m_cur = wxStringOperations::AddToIter(m_cur, n); \
554 iterator_name& operator+=(size_t n) \
556 m_cur = wxStringOperations::AddToIter(m_cur, (int)n); \
559 iterator_name& operator-=(int n) \
561 m_cur = wxStringOperations::AddToIter(m_cur, -n); \
564 iterator_name& operator-=(size_t n) \
566 m_cur = wxStringOperations::AddToIter(m_cur, -(int)n); \
570 difference_type operator-(const iterator_name& i) const \
571 { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \
573 bool operator==(const iterator_name& i) const \
574 { return m_cur == i.m_cur; } \
575 bool operator!=(const iterator_name& i) const \
576 { return m_cur != i.m_cur; } \
578 bool operator<(const iterator_name& i) const \
579 { return m_cur < i.m_cur; } \
580 bool operator>(const iterator_name& i) const \
581 { return m_cur > i.m_cur; } \
582 bool operator<=(const iterator_name& i) const \
583 { return m_cur <= i.m_cur; } \
584 bool operator>=(const iterator_name& i) const \
585 { return m_cur >= i.m_cur; } \
588 /* for internal wxString use only: */ \
589 underlying_iterator impl() const { return m_cur; } \
591 friend class WXDLLIMPEXP_BASE wxString; \
592 friend class WXDLLIMPEXP_BASE wxCStrData; \
595 underlying_iterator m_cur
597 class const_iterator
;
599 #if wxUSE_UNICODE_UTF8
602 // NB: In UTF-8 build, (non-const) iterator needs to keep reference
603 // to the underlying wxStringImpl, because UTF-8 is variable-length
604 // encoding and changing the value pointer to by an iterator using
605 // its operator* requires calling wxStringImpl::replace() if the old
606 // and new values differ in their encoding's length.
608 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
,
609 wxUniCharRef::CreateForString(m_str
, m_cur
));
612 iterator(const iterator
& i
) : m_cur(i
.m_cur
), m_str(i
.m_str
) {}
614 iterator
operator+(int n
) const
615 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, n
)); }
616 iterator
operator+(size_t n
) const
617 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, (int)n
)); }
618 iterator
operator-(int n
) const
619 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, -n
)); }
620 iterator
operator-(size_t n
) const
621 { return iterator(m_str
, wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
624 iterator(wxString
*str
, underlying_iterator ptr
)
625 : m_cur(ptr
), m_str(str
->m_impl
) {}
626 iterator(wxStringImpl
& str
, underlying_iterator ptr
)
627 : m_cur(ptr
), m_str(str
) {}
631 friend class const_iterator
;
634 size_t IterToImplPos(wxString::iterator i
) const
635 { return wxStringImpl::const_iterator(i
.impl()) - m_impl
.begin(); }
637 #else // !wxUSE_UNICODE_UTF8
641 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
,
642 wxUniCharRef::CreateForString(m_cur
));
645 iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
647 iterator
operator+(int n
) const
648 { return iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
649 iterator
operator+(size_t n
) const
650 { return iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
651 iterator
operator-(int n
) const
652 { return iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
653 iterator
operator-(size_t n
) const
654 { return iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
657 // for internal wxString use only:
658 iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
659 iterator(wxString
*WXUNUSED(str
), underlying_iterator ptr
) : m_cur(ptr
) {}
661 friend class const_iterator
;
663 #endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
667 // NB: reference_type is intentionally value, not reference, the character
668 // may be encoded differently in wxString data:
669 WX_STR_ITERATOR_IMPL(const_iterator
, const wxChar
*, wxUniChar
,
670 wxStringOperations::DecodeChar(m_cur
));
673 const_iterator(const const_iterator
& i
) : m_cur(i
.m_cur
) {}
674 const_iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
676 const_iterator
operator+(int n
) const
677 { return const_iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
678 const_iterator
operator+(size_t n
) const
679 { return const_iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
680 const_iterator
operator-(int n
) const
681 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
682 const_iterator
operator-(size_t n
) const
683 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
686 // for internal wxString use only:
687 const_iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
690 #undef WX_STR_ITERATOR_TAG
691 #undef WX_STR_ITERATOR_IMPL
693 friend class iterator
;
694 friend class const_iterator
;
696 template <typename T
>
697 class reverse_iterator_impl
700 typedef T iterator_type
;
702 typedef typename
T::iterator_category iterator_category
;
703 typedef typename
T::value_type value_type
;
704 typedef typename
T::difference_type difference_type
;
705 typedef typename
T::reference reference
;
706 typedef typename
T::pointer
*pointer
;
708 reverse_iterator_impl(iterator_type i
) : m_cur(i
) {}
709 reverse_iterator_impl(const reverse_iterator_impl
& ri
)
712 iterator_type
base() const { return m_cur
; }
714 reference
operator*() const { return *(m_cur
-1); }
715 reference
operator[](size_t n
) const { return *(*this + n
); }
717 reverse_iterator_impl
& operator++()
718 { --m_cur
; return *this; }
719 reverse_iterator_impl
operator++(int)
720 { reverse_iterator_impl tmp
= *this; --m_cur
; return tmp
; }
721 reverse_iterator_impl
& operator--()
722 { ++m_cur
; return *this; }
723 reverse_iterator_impl
operator--(int)
724 { reverse_iterator_impl tmp
= *this; ++m_cur
; return tmp
; }
726 // NB: explicit <T> in the functions below is to keep BCC 5.5 happy
727 reverse_iterator_impl
operator+(int n
) const
728 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
729 reverse_iterator_impl
operator+(size_t n
) const
730 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
731 reverse_iterator_impl
operator-(int n
) const
732 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
733 reverse_iterator_impl
operator-(size_t n
) const
734 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
735 reverse_iterator_impl
operator+=(int n
)
736 { m_cur
-= n
; return *this; }
737 reverse_iterator_impl
operator+=(size_t n
)
738 { m_cur
-= n
; return *this; }
739 reverse_iterator_impl
operator-=(int n
)
740 { m_cur
+= n
; return *this; }
741 reverse_iterator_impl
operator-=(size_t n
)
742 { m_cur
+= n
; return *this; }
744 unsigned operator-(const reverse_iterator_impl
& i
) const
745 { return i
.m_cur
- m_cur
; }
747 bool operator==(const reverse_iterator_impl
& ri
) const
748 { return m_cur
== ri
.m_cur
; }
749 bool operator!=(const reverse_iterator_impl
& ri
) const
750 { return !(*this == ri
); }
752 bool operator<(const reverse_iterator_impl
& i
) const
753 { return m_cur
> i
.m_cur
; }
754 bool operator>(const reverse_iterator_impl
& i
) const
755 { return m_cur
< i
.m_cur
; }
756 bool operator<=(const reverse_iterator_impl
& i
) const
757 { return m_cur
>= i
.m_cur
; }
758 bool operator>=(const reverse_iterator_impl
& i
) const
759 { return m_cur
<= i
.m_cur
; }
765 typedef reverse_iterator_impl
<iterator
> reverse_iterator
;
766 typedef reverse_iterator_impl
<const_iterator
> const_reverse_iterator
;
769 // used to transform an expression built using c_str() (and hence of type
770 // wxCStrData) to an iterator into the string
771 static const_iterator
CreateConstIterator(const wxCStrData
& data
)
773 return const_iterator(data
.m_str
->begin() + data
.m_offset
);
776 // in UTF-8 STL build, creation from std::string requires conversion under
777 // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor;
778 // instead we define dummy type that lets us have wxString ctor for creation
779 // from wxStringImpl that couldn't be used by user code (in all other builds,
780 // "standard" ctors can be used):
781 #if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING
782 struct CtorFromStringImplTag
{};
784 wxString(CtorFromStringImplTag
* WXUNUSED(dummy
), const wxStringImpl
& src
)
787 static wxString
FromImpl(const wxStringImpl
& src
)
788 { return wxString((CtorFromStringImplTag
*)NULL
, src
); }
790 #if !wxUSE_STL_BASED_WXSTRING
791 wxString(const wxStringImpl
& src
) : m_impl(src
) { }
792 // else: already defined as wxString(wxStdString) below
794 static wxString
FromImpl(const wxStringImpl
& src
) { return wxString(src
); }
798 // constructors and destructor
799 // ctor for an empty string
803 wxString(const wxString
& stringSrc
) : m_impl(stringSrc
.m_impl
) { }
805 // string containing nRepeat copies of ch
806 wxString(wxUniChar ch
, size_t nRepeat
= 1)
807 { assign(nRepeat
, ch
); }
808 wxString(size_t nRepeat
, wxUniChar ch
)
809 { assign(nRepeat
, ch
); }
810 wxString(wxUniCharRef ch
, size_t nRepeat
= 1)
811 { assign(nRepeat
, ch
); }
812 wxString(size_t nRepeat
, wxUniCharRef ch
)
813 { assign(nRepeat
, ch
); }
814 wxString(char ch
, size_t nRepeat
= 1)
815 { assign(nRepeat
, ch
); }
816 wxString(size_t nRepeat
, char ch
)
817 { assign(nRepeat
, ch
); }
818 wxString(wchar_t ch
, size_t nRepeat
= 1)
819 { assign(nRepeat
, ch
); }
820 wxString(size_t nRepeat
, wchar_t ch
)
821 { assign(nRepeat
, ch
); }
823 // ctors from char* strings:
824 wxString(const char *psz
)
825 : m_impl(ImplStr(psz
)) {}
826 wxString(const char *psz
, const wxMBConv
& conv
)
827 : m_impl(ImplStr(psz
, conv
)) {}
828 wxString(const char *psz
, size_t nLength
)
829 { assign(psz
, nLength
); }
830 wxString(const char *psz
, const wxMBConv
& conv
, size_t nLength
)
832 SubstrBufFromMB
str(ImplStr(psz
, nLength
, conv
));
833 m_impl
.assign(str
.data
, str
.len
);
836 // and unsigned char*:
837 wxString(const unsigned char *psz
)
838 : m_impl(ImplStr((const char*)psz
)) {}
839 wxString(const unsigned char *psz
, const wxMBConv
& conv
)
840 : m_impl(ImplStr((const char*)psz
, conv
)) {}
841 wxString(const unsigned char *psz
, size_t nLength
)
842 { assign((const char*)psz
, nLength
); }
843 wxString(const unsigned char *psz
, const wxMBConv
& conv
, size_t nLength
)
845 SubstrBufFromMB
str(ImplStr((const char*)psz
, nLength
, conv
));
846 m_impl
.assign(str
.data
, str
.len
);
849 // ctors from wchar_t* strings:
850 wxString(const wchar_t *pwz
)
851 : m_impl(ImplStr(pwz
)) {}
852 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
))
853 : m_impl(ImplStr(pwz
)) {}
854 wxString(const wchar_t *pwz
, size_t nLength
)
855 { assign(pwz
, nLength
); }
856 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
), size_t nLength
)
857 { assign(pwz
, nLength
); }
859 wxString(const wxCharBuffer
& buf
)
860 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
861 wxString(const wxWCharBuffer
& buf
)
862 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
864 wxString(const wxCStrData
& cstr
)
865 : m_impl(cstr
.AsString().m_impl
) { }
867 // as we provide both ctors with this signature for both char and unsigned
868 // char string, we need to provide one for wxCStrData to resolve ambiguity
869 wxString(const wxCStrData
& cstr
, size_t nLength
)
870 : m_impl(cstr
.AsString().Mid(0, nLength
).m_impl
) {}
872 // and because wxString is convertible to wxCStrData and const wxChar *
873 // we also need to provide this one
874 wxString(const wxString
& str
, size_t nLength
)
875 : m_impl(str
.Mid(0, nLength
).m_impl
) {}
877 // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
878 // implicit conversions from std::string to wxString and vice verse as this
879 // allows to use the same strings in non-GUI and GUI code, however we don't
880 // want to unconditionally add this ctor as it would make wx lib dependent on
881 // libstdc++ on some Linux versions which is bad, so instead we ask the
882 // client code to define this wxUSE_STD_STRING symbol if they need it
885 #if wxUSE_UNICODE_WCHAR
886 wxString(const wxStdWideString
& str
) : m_impl(str
) {}
887 #else // UTF-8 or ANSI
888 wxString(const wxStdWideString
& str
)
889 { assign(str
.c_str(), str
.length()); }
892 #if !wxUSE_UNICODE // ANSI build
893 // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
894 wxString(const std::string
& str
) : m_impl(str
) {}
896 wxString(const std::string
& str
)
897 { assign(str
.c_str(), str
.length()); }
900 #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
901 // wxStringImpl is std::string in the encoding we want
902 operator const wxStdWideString
&() const { return m_impl
; }
904 // wxStringImpl is either not std::string or needs conversion
905 operator wxStdWideString() const
906 // FIXME-UTF8: broken for embedded NULs
907 { return wxStdWideString(wc_str()); }
910 #if !wxUSE_UNICODE && wxUSE_STL_BASED_WXSTRING
911 // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
912 // wxStringImpl is std::string in the encoding we want
913 operator const std::string
&() const { return m_impl
; }
915 // wxStringImpl is either not std::string or needs conversion
916 operator std::string() const
917 // FIXME-UTF8: broken for embedded NULs
918 { return std::string(mb_str()); }
921 #endif // wxUSE_STD_STRING
923 // first valid index position
924 const_iterator
begin() const { return const_iterator(m_impl
.begin()); }
925 iterator
begin() { return iterator(this, m_impl
.begin()); }
926 // position one after the last valid one
927 const_iterator
end() const { return const_iterator(m_impl
.end()); }
928 iterator
end() { return iterator(this, m_impl
.end()); }
930 // first element of the reversed string
931 const_reverse_iterator
rbegin() const
932 { return const_reverse_iterator(end()); }
933 reverse_iterator
rbegin()
934 { return reverse_iterator(end()); }
935 // one beyond the end of the reversed string
936 const_reverse_iterator
rend() const
937 { return const_reverse_iterator(begin()); }
938 reverse_iterator
rend()
939 { return reverse_iterator(begin()); }
941 // std::string methods:
942 #if wxUSE_UNICODE_UTF8
943 size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
945 size_t length() const { return m_impl
.length(); }
948 size_type
size() const { return length(); }
949 size_type
max_size() const { return npos
; }
951 bool empty() const { return m_impl
.empty(); }
953 size_type
capacity() const { return m_impl
.capacity(); } // FIXME-UTF8
954 void reserve(size_t sz
) { m_impl
.reserve(sz
); } // FIXME-UTF8
956 void resize(size_t nSize
, wxUniChar ch
= wxT('\0'))
958 #if wxUSE_UNICODE_UTF8
961 size_t len
= length();
964 else if ( nSize
< len
)
967 append(nSize
- len
, ch
);
971 m_impl
.resize(nSize
, (wxStringCharType
)ch
);
974 wxString
substr(size_t nStart
= 0, size_t nLen
= npos
) const
977 PosLenToImpl(nStart
, nLen
, &pos
, &len
);
978 return FromImpl(m_impl
.substr(pos
, len
));
981 // generic attributes & operations
982 // as standard strlen()
983 size_t Len() const { return length(); }
984 // string contains any characters?
985 bool IsEmpty() const { return empty(); }
986 // empty string is "false", so !str will return true
987 bool operator!() const { return empty(); }
988 // truncate the string to given length
989 wxString
& Truncate(size_t uiLen
);
990 // empty string contents
995 wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
997 // empty the string and free memory
1000 wxString
tmp(wxEmptyString
);
1005 // Is an ascii value
1006 bool IsAscii() const;
1008 bool IsNumber() const;
1010 bool IsWord() const;
1012 // data access (all indexes are 0 based)
1014 wxUniChar
at(size_t n
) const
1015 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1016 wxUniChar
GetChar(size_t n
) const
1018 // read/write access
1019 wxUniCharRef
at(size_t n
)
1020 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1021 wxUniCharRef
GetWritableChar(size_t n
)
1024 void SetChar(size_t n
, wxUniChar ch
)
1027 // get last character
1028 wxUniChar
Last() const
1030 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1032 return at(length() - 1);
1035 // get writable last character
1038 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1039 return at(length() - 1);
1043 Note that we we must define all of the overloads below to avoid
1044 ambiguity when using str[0].
1046 wxUniChar
operator[](int n
) const
1048 wxUniChar
operator[](long n
) const
1050 wxUniChar
operator[](size_t n
) const
1052 #ifndef wxSIZE_T_IS_UINT
1053 wxUniChar
operator[](unsigned int n
) const
1055 #endif // size_t != unsigned int
1057 // operator versions of GetWriteableChar()
1058 wxUniCharRef
operator[](int n
)
1060 wxUniCharRef
operator[](long n
)
1062 wxUniCharRef
operator[](size_t n
)
1064 #ifndef wxSIZE_T_IS_UINT
1065 wxUniCharRef
operator[](unsigned int n
)
1067 #endif // size_t != unsigned int
1069 // explicit conversion to C string (use this with printf()!)
1070 wxCStrData
c_str() const { return wxCStrData(this); }
1071 wxCStrData
data() const { return c_str(); }
1073 // implicit conversion to C string
1074 operator wxCStrData() const { return c_str(); }
1075 operator const char*() const { return c_str(); }
1076 operator const wchar_t*() const { return c_str(); }
1078 // identical to c_str(), for MFC compatibility
1079 const wxCStrData
GetData() const { return c_str(); }
1081 // explicit conversion to C string in internal representation (char*,
1082 // wchar_t*, UTF-8-encoded char*, depending on the build):
1083 const wxStringCharType
*wx_str() const { return m_impl
.c_str(); }
1085 // conversion to *non-const* multibyte or widestring buffer; modifying
1086 // returned buffer won't affect the string, these methods are only useful
1087 // for passing values to const-incorrect functions
1088 wxWritableCharBuffer
char_str(const wxMBConv
& conv
= wxConvLibc
) const
1089 { return mb_str(conv
); }
1090 wxWritableWCharBuffer
wchar_str() const { return wc_str(); }
1092 // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
1093 // converting numbers or strings which are certain not to contain special
1094 // chars (typically system functions, X atoms, environment variables etc.)
1096 // the behaviour of these functions with the strings containing anything
1097 // else than 7 bit ASCII characters is undefined, use at your own risk.
1099 static wxString
FromAscii(const char *ascii
); // string
1100 static wxString
FromAscii(const char ascii
); // char
1101 const wxCharBuffer
ToAscii() const;
1103 static wxString
FromAscii(const char *ascii
) { return wxString( ascii
); }
1104 static wxString
FromAscii(const char ascii
) { return wxString( ascii
); }
1105 const char *ToAscii() const { return c_str(); }
1106 #endif // Unicode/!Unicode
1108 // conversions with (possible) format conversions: have to return a
1109 // buffer with temporary data
1111 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
1112 // return an ANSI (multibyte) string, wc_str() to return a wide string and
1113 // fn_str() to return a string which should be used with the OS APIs
1114 // accepting the file names. The return value is always the same, but the
1115 // type differs because a function may either return pointer to the buffer
1116 // directly or have to use intermediate buffer for translation.
1118 const wxCharBuffer
mb_str(const wxMBConv
& conv
= wxConvLibc
) const;
1120 const wxWX2MBbuf
mbc_str() const { return mb_str(*wxConvCurrent
); }
1122 #if wxUSE_UNICODE_WCHAR
1123 const wxChar
* wc_str() const { return wx_str(); }
1124 #elif wxUSE_UNICODE_UTF8
1125 const wxWCharBuffer
wc_str() const;
1127 // for compatibility with !wxUSE_UNICODE version
1128 const wxWX2WCbuf
wc_str(const wxMBConv
& WXUNUSED(conv
)) const
1129 { return wc_str(); }
1132 const wxCharBuffer
fn_str() const { return mb_str(wxConvFile
); }
1134 const wxWX2WCbuf
fn_str() const { return wc_str(); }
1135 #endif // wxMBFILES/!wxMBFILES
1138 const wxChar
* mb_str() const { return wx_str(); }
1140 // for compatibility with wxUSE_UNICODE version
1141 const wxChar
* mb_str(const wxMBConv
& WXUNUSED(conv
)) const { return wx_str(); }
1143 const wxWX2MBbuf
mbc_str() const { return mb_str(); }
1146 const wxWCharBuffer
wc_str(const wxMBConv
& conv
= wxConvLibc
) const;
1147 #endif // wxUSE_WCHAR_T
1149 const wxCharBuffer
fn_str() const { return wxConvFile
.cWC2WX( wc_str( wxConvLocal
) ); }
1151 const wxChar
* fn_str() const { return c_str(); }
1153 #endif // Unicode/ANSI
1155 // overloaded assignment
1156 // from another wxString
1157 wxString
& operator=(const wxString
& stringSrc
)
1158 { m_impl
= stringSrc
.m_impl
; return *this; }
1159 wxString
& operator=(const wxCStrData
& cstr
)
1160 { return *this = cstr
.AsString(); }
1162 wxString
& operator=(wxUniChar ch
)
1163 { m_impl
= wxStringOperations::EncodeChar(ch
); return *this; }
1164 wxString
& operator=(wxUniCharRef ch
)
1165 { return operator=((wxUniChar
)ch
); }
1166 wxString
& operator=(char ch
)
1167 { return operator=(wxUniChar(ch
)); }
1168 wxString
& operator=(unsigned char ch
)
1169 { return operator=(wxUniChar(ch
)); }
1170 wxString
& operator=(wchar_t ch
)
1171 { return operator=(wxUniChar(ch
)); }
1172 // from a C string - STL probably will crash on NULL,
1173 // so we need to compensate in that case
1174 #if wxUSE_STL_BASED_WXSTRING
1175 wxString
& operator=(const char *psz
)
1176 { if (psz
) m_impl
= ImplStr(psz
); else Clear(); return *this; }
1177 wxString
& operator=(const wchar_t *pwz
)
1178 { if (pwz
) m_impl
= ImplStr(pwz
); else Clear(); return *this; }
1180 wxString
& operator=(const char *psz
)
1181 { m_impl
= ImplStr(psz
); return *this; }
1182 wxString
& operator=(const wchar_t *pwz
)
1183 { m_impl
= ImplStr(pwz
); return *this; }
1185 wxString
& operator=(const unsigned char *psz
)
1186 { return operator=((const char*)psz
); }
1188 // from wxWCharBuffer
1189 wxString
& operator=(const wxWCharBuffer
& s
)
1190 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1191 // from wxCharBuffer
1192 wxString
& operator=(const wxCharBuffer
& s
)
1193 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1195 // string concatenation
1196 // in place concatenation
1198 Concatenate and return the result. Note that the left to right
1199 associativity of << allows to write things like "str << str1 << str2
1200 << ..." (unlike with +=)
1203 wxString
& operator<<(const wxString
& s
)
1205 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1206 wxASSERT_MSG( s
.IsValid(),
1207 _T("did you forget to call UngetWriteBuf()?") );
1213 // string += C string
1214 wxString
& operator<<(const char *psz
)
1215 { append(psz
); return *this; }
1216 wxString
& operator<<(const wchar_t *pwz
)
1217 { append(pwz
); return *this; }
1218 wxString
& operator<<(const wxCStrData
& psz
)
1219 { append(psz
.AsString()); return *this; }
1221 wxString
& operator<<(wxUniChar ch
) { append(1, ch
); return *this; }
1222 wxString
& operator<<(wxUniCharRef ch
) { append(1, ch
); return *this; }
1223 wxString
& operator<<(char ch
) { append(1, ch
); return *this; }
1224 wxString
& operator<<(unsigned char ch
) { append(1, ch
); return *this; }
1225 wxString
& operator<<(wchar_t ch
) { append(1, ch
); return *this; }
1227 // string += buffer (i.e. from wxGetString)
1228 wxString
& operator<<(const wxWCharBuffer
& s
)
1229 { return operator<<((const wchar_t *)s
); }
1230 wxString
& operator+=(const wxWCharBuffer
& s
)
1231 { return operator<<((const wchar_t *)s
); }
1233 wxString
& operator<<(const wxCharBuffer
& s
)
1234 { return operator<<((const char *)s
); }
1235 wxString
& operator+=(const wxCharBuffer
& s
)
1236 { return operator<<((const char *)s
); }
1238 // string += C string
1239 wxString
& Append(const wxString
& s
)
1241 // test for empty() to share the string if possible
1248 wxString
& Append(const wxCStrData
& psz
)
1249 { append(psz
); return *this; }
1250 wxString
& Append(const char* psz
)
1251 { append(psz
); return *this; }
1252 wxString
& Append(const wchar_t* pwz
)
1253 { append(pwz
); return *this; }
1254 // append count copies of given character
1255 wxString
& Append(wxUniChar ch
, size_t count
= 1u)
1256 { append(count
, ch
); return *this; }
1257 wxString
& Append(wxUniCharRef ch
, size_t count
= 1u)
1258 { append(count
, ch
); return *this; }
1259 wxString
& Append(char ch
, size_t count
= 1u)
1260 { append(count
, ch
); return *this; }
1261 wxString
& Append(unsigned char ch
, size_t count
= 1u)
1262 { append(count
, ch
); return *this; }
1263 wxString
& Append(wchar_t ch
, size_t count
= 1u)
1264 { append(count
, ch
); return *this; }
1265 wxString
& Append(const char* psz
, size_t nLen
)
1266 { append(psz
, nLen
); return *this; }
1267 wxString
& Append(const wchar_t* pwz
, size_t nLen
)
1268 { append(pwz
, nLen
); return *this; }
1270 // prepend a string, return the string itself
1271 wxString
& Prepend(const wxString
& str
)
1272 { *this = str
+ *this; return *this; }
1274 // non-destructive concatenation
1276 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
,
1277 const wxString
& string2
);
1278 // string with a single char
1279 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
1280 // char with a string
1281 friend wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
1282 // string with C string
1283 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1285 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1286 const wchar_t *pwz
);
1287 // C string with string
1288 friend wxString WXDLLIMPEXP_BASE
operator+(const char *psz
,
1289 const wxString
& string
);
1290 friend wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
,
1291 const wxString
& string
);
1293 // stream-like functions
1294 // insert an int into string
1295 wxString
& operator<<(int i
)
1296 { return (*this) << Format(_T("%d"), i
); }
1297 // insert an unsigned int into string
1298 wxString
& operator<<(unsigned int ui
)
1299 { return (*this) << Format(_T("%u"), ui
); }
1300 // insert a long into string
1301 wxString
& operator<<(long l
)
1302 { return (*this) << Format(_T("%ld"), l
); }
1303 // insert an unsigned long into string
1304 wxString
& operator<<(unsigned long ul
)
1305 { return (*this) << Format(_T("%lu"), ul
); }
1306 #if defined wxLongLong_t && !defined wxLongLongIsLong
1307 // insert a long long if they exist and aren't longs
1308 wxString
& operator<<(wxLongLong_t ll
)
1310 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("d");
1311 return (*this) << Format(fmt
, ll
);
1313 // insert an unsigned long long
1314 wxString
& operator<<(wxULongLong_t ull
)
1316 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("u");
1317 return (*this) << Format(fmt
, ull
);
1320 // insert a float into string
1321 wxString
& operator<<(float f
)
1322 { return (*this) << Format(_T("%f"), f
); }
1323 // insert a double into string
1324 wxString
& operator<<(double d
)
1325 { return (*this) << Format(_T("%g"), d
); }
1327 // string comparison
1328 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
1329 int Cmp(const char *psz
) const
1330 { return compare(psz
); }
1331 int Cmp(const wchar_t *pwz
) const
1332 { return compare(pwz
); }
1333 int Cmp(const wxString
& s
) const
1334 { return compare(s
); }
1335 // same as Cmp() but not case-sensitive
1336 int CmpNoCase(const wxString
& s
) const;
1337 int CmpNoCase(const char *psz
) const
1338 { return CmpNoCase(wxString(psz
)); }
1339 int CmpNoCase(const wchar_t *pwz
) const
1340 { return CmpNoCase(wxString(pwz
)); }
1341 // test for the string equality, either considering case or not
1342 // (if compareWithCase then the case matters)
1343 bool IsSameAs(const wxString
& str
, bool compareWithCase
= true) const
1344 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1345 bool IsSameAs(const char *str
, bool compareWithCase
= true) const
1346 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1347 bool IsSameAs(const wchar_t *str
, bool compareWithCase
= true) const
1348 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1349 // comparison with a single character: returns true if equal
1350 bool IsSameAs(wxUniChar c
, bool compareWithCase
= true) const
1352 return (length() == 1) && (compareWithCase
? GetChar(0u) == c
1353 : wxToupper(GetChar(0u)) == wxToupper(c
));
1355 // FIXME-UTF8: remove these overloads
1356 bool IsSameAs(wxUniCharRef c
, bool compareWithCase
= true) const
1357 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1358 bool IsSameAs(char c
, bool compareWithCase
= true) const
1359 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1360 bool IsSameAs(unsigned char c
, bool compareWithCase
= true) const
1361 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1362 bool IsSameAs(wchar_t c
, bool compareWithCase
= true) const
1363 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1364 bool IsSameAs(int c
, bool compareWithCase
= true) const
1365 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1367 // simple sub-string extraction
1368 // return substring starting at nFirst of length nCount (or till the end
1369 // if nCount = default value)
1370 wxString
Mid(size_t nFirst
, size_t nCount
= npos
) const;
1372 // operator version of Mid()
1373 wxString
operator()(size_t start
, size_t len
) const
1374 { return Mid(start
, len
); }
1376 // check if the string starts with the given prefix and return the rest
1377 // of the string in the provided pointer if it is not NULL; otherwise
1379 bool StartsWith(const wxChar
*prefix
, wxString
*rest
= NULL
) const;
1380 // check if the string ends with the given suffix and return the
1381 // beginning of the string before the suffix in the provided pointer if
1382 // it is not NULL; otherwise return false
1383 bool EndsWith(const wxChar
*suffix
, wxString
*rest
= NULL
) const;
1385 // get first nCount characters
1386 wxString
Left(size_t nCount
) const;
1387 // get last nCount characters
1388 wxString
Right(size_t nCount
) const;
1389 // get all characters before the first occurance of ch
1390 // (returns the whole string if ch not found)
1391 wxString
BeforeFirst(wxUniChar ch
) const;
1392 // get all characters before the last occurence of ch
1393 // (returns empty string if ch not found)
1394 wxString
BeforeLast(wxUniChar ch
) const;
1395 // get all characters after the first occurence of ch
1396 // (returns empty string if ch not found)
1397 wxString
AfterFirst(wxUniChar ch
) const;
1398 // get all characters after the last occurence of ch
1399 // (returns the whole string if ch not found)
1400 wxString
AfterLast(wxUniChar ch
) const;
1402 // for compatibility only, use more explicitly named functions above
1403 wxString
Before(wxUniChar ch
) const { return BeforeLast(ch
); }
1404 wxString
After(wxUniChar ch
) const { return AfterFirst(ch
); }
1407 // convert to upper case in place, return the string itself
1408 wxString
& MakeUpper();
1409 // convert to upper case, return the copy of the string
1410 // Here's something to remember: BC++ doesn't like returns in inlines.
1411 wxString
Upper() const ;
1412 // convert to lower case in place, return the string itself
1413 wxString
& MakeLower();
1414 // convert to lower case, return the copy of the string
1415 wxString
Lower() const ;
1417 // trimming/padding whitespace (either side) and truncating
1418 // remove spaces from left or from right (default) side
1419 wxString
& Trim(bool bFromRight
= true);
1420 // add nCount copies chPad in the beginning or at the end (default)
1421 wxString
& Pad(size_t nCount
, wxUniChar chPad
= wxT(' '), bool bFromRight
= true);
1423 // searching and replacing
1424 // searching (return starting index, or -1 if not found)
1425 int Find(wxUniChar ch
, bool bFromEnd
= false) const; // like strchr/strrchr
1426 int Find(wxUniCharRef ch
, bool bFromEnd
= false) const
1427 { return Find(wxUniChar(ch
), bFromEnd
); }
1428 int Find(char ch
, bool bFromEnd
= false) const
1429 { return Find(wxUniChar(ch
), bFromEnd
); }
1430 int Find(unsigned char ch
, bool bFromEnd
= false) const
1431 { return Find(wxUniChar(ch
), bFromEnd
); }
1432 int Find(wchar_t ch
, bool bFromEnd
= false) const
1433 { return Find(wxUniChar(ch
), bFromEnd
); }
1434 // searching (return starting index, or -1 if not found)
1435 // FIXME-UTF8: keep wxString overload only
1436 int Find(const wxString
& sub
) const // like strstr
1438 size_type idx
= find(sub
);
1439 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1441 int Find(const char *sub
) const // like strstr
1443 size_type idx
= find(sub
);
1444 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1446 int Find(const wchar_t *sub
) const // like strstr
1448 size_type idx
= find(sub
);
1449 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1452 // replace first (or all of bReplaceAll) occurences of substring with
1453 // another string, returns the number of replacements made
1454 size_t Replace(const wxString
& strOld
,
1455 const wxString
& strNew
,
1456 bool bReplaceAll
= true);
1458 // check if the string contents matches a mask containing '*' and '?'
1459 bool Matches(const wxString
& mask
) const;
1461 // conversion to numbers: all functions return true only if the whole
1462 // string is a number and put the value of this number into the pointer
1463 // provided, the base is the numeric base in which the conversion should be
1464 // done and must be comprised between 2 and 36 or be 0 in which case the
1465 // standard C rules apply (leading '0' => octal, "0x" => hex)
1466 // convert to a signed integer
1467 bool ToLong(long *val
, int base
= 10) const;
1468 // convert to an unsigned integer
1469 bool ToULong(unsigned long *val
, int base
= 10) const;
1470 // convert to wxLongLong
1471 #if defined(wxLongLong_t)
1472 bool ToLongLong(wxLongLong_t
*val
, int base
= 10) const;
1473 // convert to wxULongLong
1474 bool ToULongLong(wxULongLong_t
*val
, int base
= 10) const;
1475 #endif // wxLongLong_t
1476 // convert to a double
1477 bool ToDouble(double *val
) const;
1480 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1481 // formatted input/output
1482 // as sprintf(), returns the number of characters written or < 0 on error
1483 // (take 'this' into account in attribute parameter count)
1484 // int Printf(const wxChar *pszFormat, ...);
1485 WX_DEFINE_VARARG_FUNC(int, Printf
, DoPrintf
)
1486 #endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
1487 // as vprintf(), returns the number of characters written or < 0 on error
1488 int PrintfV(const wxString
& format
, va_list argptr
);
1490 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1491 // returns the string containing the result of Printf() to it
1492 // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
1493 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, DoFormat
)
1495 // the same as above, but takes a va_list
1496 static wxString
FormatV(const wxString
& format
, va_list argptr
);
1498 // raw access to string memory
1499 // ensure that string has space for at least nLen characters
1500 // only works if the data of this string is not shared
1501 bool Alloc(size_t nLen
) { reserve(nLen
); /*return capacity() >= nLen;*/ return true; }
1502 // minimize the string's memory
1503 // only works if the data of this string is not shared
1505 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1506 // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
1508 // get writable buffer of at least nLen bytes. Unget() *must* be called
1509 // a.s.a.p. to put string back in a reasonable state!
1510 wxDEPRECATED( wxChar
*GetWriteBuf(size_t nLen
) );
1511 // call this immediately after GetWriteBuf() has been used
1512 wxDEPRECATED( void UngetWriteBuf() );
1513 wxDEPRECATED( void UngetWriteBuf(size_t nLen
) );
1514 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && wxUSE_UNICODE_UTF8
1516 // wxWidgets version 1 compatibility functions
1519 wxString
SubString(size_t from
, size_t to
) const
1520 { return Mid(from
, (to
- from
+ 1)); }
1521 // values for second parameter of CompareTo function
1522 enum caseCompare
{exact
, ignoreCase
};
1523 // values for first parameter of Strip function
1524 enum stripType
{leading
= 0x1, trailing
= 0x2, both
= 0x3};
1526 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1528 // (take 'this' into account in attribute parameter count)
1529 // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
1530 WX_DEFINE_VARARG_FUNC(int, sprintf
, DoPrintf
)
1531 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
1534 inline int CompareTo(const wxChar
* psz
, caseCompare cmp
= exact
) const
1535 { return cmp
== exact
? Cmp(psz
) : CmpNoCase(psz
); }
1538 size_t Length() const { return length(); }
1539 // Count the number of characters
1540 int Freq(wxUniChar ch
) const;
1542 void LowerCase() { MakeLower(); }
1544 void UpperCase() { MakeUpper(); }
1545 // use Trim except that it doesn't change this string
1546 wxString
Strip(stripType w
= trailing
) const;
1548 // use Find (more general variants not yet supported)
1549 size_t Index(const wxChar
* psz
) const { return Find(psz
); }
1550 size_t Index(wxUniChar ch
) const { return Find(ch
); }
1552 wxString
& Remove(size_t pos
) { return Truncate(pos
); }
1553 wxString
& RemoveLast(size_t n
= 1) { return Truncate(length() - n
); }
1555 wxString
& Remove(size_t nStart
, size_t nLen
)
1556 { return (wxString
&)erase( nStart
, nLen
); }
1559 int First( wxUniChar ch
) const { return Find(ch
); }
1560 int First( wxUniCharRef ch
) const { return Find(ch
); }
1561 int First( char ch
) const { return Find(ch
); }
1562 int First( unsigned char ch
) const { return Find(ch
); }
1563 int First( wchar_t ch
) const { return Find(ch
); }
1564 int First( const wxChar
* psz
) const { return Find(psz
); }
1565 int First( const wxString
& str
) const { return Find(str
); }
1566 int Last( wxUniChar ch
) const { return Find(ch
, true); }
1567 bool Contains(const wxString
& str
) const { return Find(str
) != wxNOT_FOUND
; }
1570 bool IsNull() const { return empty(); }
1572 // std::string compatibility functions
1574 // take nLen chars starting at nPos
1575 wxString(const wxString
& str
, size_t nPos
, size_t nLen
)
1576 : m_impl(str
.m_impl
, nPos
, nLen
) { }
1577 // take all characters from first to last
1578 wxString(const_iterator first
, const_iterator last
)
1579 : m_impl(first
.impl(), last
.impl()) { }
1580 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1581 // the 2 overloads below are for compatibility with the existing code using
1582 // pointers instead of iterators
1583 wxString(const char *first
, const char *last
)
1585 SubstrBufFromMB
str(ImplStr(first
, last
- first
));
1586 m_impl
.assign(str
.data
, str
.len
);
1588 wxString(const wchar_t *first
, const wchar_t *last
)
1590 SubstrBufFromWC
str(ImplStr(first
, last
- first
));
1591 m_impl
.assign(str
.data
, str
.len
);
1593 // and this one is needed to compile code adding offsets to c_str() result
1594 wxString(const wxCStrData
& first
, const wxCStrData
& last
)
1595 : m_impl(CreateConstIterator(first
).impl(),
1596 CreateConstIterator(last
).impl())
1598 wxASSERT_MSG( first
.m_str
== last
.m_str
,
1599 _T("pointers must be into the same string") );
1601 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1603 // lib.string.modifiers
1604 // append elements str[pos], ..., str[pos+n]
1605 wxString
& append(const wxString
& str
, size_t pos
, size_t n
)
1608 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1609 m_impl
.append(str
.m_impl
, from
, len
);
1613 wxString
& append(const wxString
& str
)
1614 { m_impl
.append(str
.m_impl
); return *this; }
1615 wxString
& append(const wxCStrData
& str
)
1616 { m_impl
.append(str
.AsString().m_impl
); return *this; }
1617 // append first n (or all if n == npos) characters of sz
1618 wxString
& append(const char *sz
)
1619 { m_impl
.append(ImplStr(sz
)); return *this; }
1620 wxString
& append(const wchar_t *sz
)
1621 { m_impl
.append(ImplStr(sz
)); return *this; }
1622 wxString
& append(const char *sz
, size_t n
)
1624 SubstrBufFromMB
str(ImplStr(sz
, n
));
1625 m_impl
.append(str
.data
, str
.len
);
1628 wxString
& append(const wchar_t *sz
, size_t n
)
1630 SubstrBufFromWC
str(ImplStr(sz
, n
));
1631 m_impl
.append(str
.data
, str
.len
);
1634 // append n copies of ch
1635 wxString
& append(size_t n
, wxUniChar ch
)
1637 #if wxUSE_UNICODE_UTF8
1638 if ( !ch
.IsAscii() )
1639 m_impl
.append(wxStringOperations::EncodeNChars(n
, ch
));
1642 m_impl
.append(n
, (wxStringCharType
)ch
);
1645 // append from first to last
1646 wxString
& append(const_iterator first
, const_iterator last
)
1647 { m_impl
.append(first
.impl(), last
.impl()); return *this; }
1648 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1649 wxString
& append(const char *first
, const char *last
)
1650 { return append(first
, last
- first
); }
1651 wxString
& append(const wchar_t *first
, const wchar_t *last
)
1652 { return append(first
, last
- first
); }
1653 wxString
& append(const wxCStrData
& first
, const wxCStrData
& last
)
1654 { return append(CreateConstIterator(first
), CreateConstIterator(last
)); }
1655 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1657 // same as `this_string = str'
1658 wxString
& assign(const wxString
& str
)
1659 { m_impl
= str
.m_impl
; return *this; }
1660 wxString
& assign(const wxString
& str
, size_t len
)
1662 m_impl
.assign(str
.m_impl
, 0, str
.LenToImpl(len
));
1665 // same as ` = str[pos..pos + n]
1666 wxString
& assign(const wxString
& str
, size_t pos
, size_t n
)
1669 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1670 m_impl
.assign(str
.m_impl
, from
, len
);
1673 // same as `= first n (or all if n == npos) characters of sz'
1674 wxString
& assign(const char *sz
)
1675 { m_impl
.assign(ImplStr(sz
)); return *this; }
1676 wxString
& assign(const wchar_t *sz
)
1677 { m_impl
.assign(ImplStr(sz
)); return *this; }
1678 wxString
& assign(const char *sz
, size_t n
)
1680 SubstrBufFromMB
str(ImplStr(sz
, n
));
1681 m_impl
.assign(str
.data
, str
.len
);
1684 wxString
& assign(const wchar_t *sz
, size_t n
)
1686 SubstrBufFromWC
str(ImplStr(sz
, n
));
1687 m_impl
.assign(str
.data
, str
.len
);
1690 // same as `= n copies of ch'
1691 wxString
& assign(size_t n
, wxUniChar ch
)
1693 #if wxUSE_UNICODE_UTF8
1694 if ( !ch
.IsAscii() )
1695 m_impl
.assign(wxStringOperations::EncodeNChars(n
, ch
));
1698 m_impl
.assign(n
, (wxStringCharType
)ch
);
1702 wxString
& assign(size_t n
, wxUniCharRef ch
)
1703 { return assign(n
, wxUniChar(ch
)); }
1704 wxString
& assign(size_t n
, char ch
)
1705 { return assign(n
, wxUniChar(ch
)); }
1706 wxString
& assign(size_t n
, unsigned char ch
)
1707 { return assign(n
, wxUniChar(ch
)); }
1708 wxString
& assign(size_t n
, wchar_t ch
)
1709 { return assign(n
, wxUniChar(ch
)); }
1711 // assign from first to last
1712 wxString
& assign(const_iterator first
, const_iterator last
)
1713 { m_impl
.assign(first
.impl(), last
.impl()); return *this; }
1714 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1715 wxString
& assign(const char *first
, const char *last
)
1716 { return assign(first
, last
- first
); }
1717 wxString
& assign(const wchar_t *first
, const wchar_t *last
)
1718 { return assign(first
, last
- first
); }
1719 wxString
& assign(const wxCStrData
& first
, const wxCStrData
& last
)
1720 { return assign(CreateConstIterator(first
), CreateConstIterator(last
)); }
1721 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1723 // string comparison
1724 int compare(const wxString
& str
) const;
1725 // comparison with a substring
1726 int compare(size_t nStart
, size_t nLen
, const wxString
& str
) const;
1727 // comparison of 2 substrings
1728 int compare(size_t nStart
, size_t nLen
,
1729 const wxString
& str
, size_t nStart2
, size_t nLen2
) const;
1730 // just like strcmp()
1731 int compare(const char* sz
) const;
1732 int compare(const wchar_t* sz
) const;
1733 // substring comparison with first nCount characters of sz
1734 int compare(size_t nStart
, size_t nLen
,
1735 const char* sz
, size_t nCount
= npos
) const;
1736 int compare(size_t nStart
, size_t nLen
,
1737 const wchar_t* sz
, size_t nCount
= npos
) const;
1739 // insert another string
1740 wxString
& insert(size_t nPos
, const wxString
& str
)
1741 { insert(begin() + nPos
, str
.begin(), str
.end()); return *this; }
1742 // insert n chars of str starting at nStart (in str)
1743 wxString
& insert(size_t nPos
, const wxString
& str
, size_t nStart
, size_t n
)
1746 str
.PosLenToImpl(nStart
, n
, &from
, &len
);
1747 m_impl
.insert(PosToImpl(nPos
), str
.m_impl
, from
, len
);
1750 // insert first n (or all if n == npos) characters of sz
1751 wxString
& insert(size_t nPos
, const char *sz
)
1752 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
1753 wxString
& insert(size_t nPos
, const wchar_t *sz
)
1754 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
1755 wxString
& insert(size_t nPos
, const char *sz
, size_t n
)
1757 SubstrBufFromMB
str(ImplStr(sz
, n
));
1758 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
1761 wxString
& insert(size_t nPos
, const wchar_t *sz
, size_t n
)
1763 SubstrBufFromWC
str(ImplStr(sz
, n
));
1764 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
1767 // insert n copies of ch
1768 wxString
& insert(size_t nPos
, size_t n
, wxUniChar ch
)
1770 #if wxUSE_UNICODE_UTF8
1771 if ( !ch
.IsAscii() )
1772 m_impl
.insert(PosToImpl(nPos
), wxStringOperations::EncodeNChars(n
, ch
));
1775 m_impl
.insert(PosToImpl(nPos
), n
, (wxStringCharType
)ch
);
1778 iterator
insert(iterator it
, wxUniChar ch
)
1780 #if wxUSE_UNICODE_UTF8
1781 if ( !ch
.IsAscii() )
1783 size_t pos
= IterToImplPos(it
);
1784 m_impl
.insert(pos
, wxStringOperations::EncodeChar(ch
));
1785 return iterator(this, m_impl
.begin() + pos
);
1789 return iterator(this, m_impl
.insert(it
.impl(), (wxStringCharType
)ch
));
1791 void insert(iterator it
, const_iterator first
, const_iterator last
)
1792 { m_impl
.insert(it
.impl(), first
.impl(), last
.impl()); }
1793 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1794 void insert(iterator it
, const char *first
, const char *last
)
1795 { insert(it
- begin(), first
, last
- first
); }
1796 void insert(iterator it
, const wchar_t *first
, const wchar_t *last
)
1797 { insert(it
- begin(), first
, last
- first
); }
1798 void insert(iterator it
, const wxCStrData
& first
, const wxCStrData
& last
)
1799 { insert(it
, CreateConstIterator(first
), CreateConstIterator(last
)); }
1800 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1802 void insert(iterator it
, size_type n
, wxUniChar ch
)
1804 #if wxUSE_UNICODE_UTF8
1805 if ( !ch
.IsAscii() )
1806 m_impl
.insert(IterToImplPos(it
), wxStringOperations::EncodeNChars(n
, ch
));
1809 m_impl
.insert(it
.impl(), n
, (wxStringCharType
)ch
);
1812 // delete characters from nStart to nStart + nLen
1813 wxString
& erase(size_type pos
= 0, size_type n
= npos
)
1816 PosLenToImpl(pos
, n
, &from
, &len
);
1817 m_impl
.erase(from
, len
);
1820 // delete characters from first up to last
1821 iterator
erase(iterator first
, iterator last
)
1822 { return iterator(this, m_impl
.erase(first
.impl(), last
.impl())); }
1823 iterator
erase(iterator first
)
1824 { return iterator(this, m_impl
.erase(first
.impl())); }
1826 #ifdef wxSTRING_BASE_HASNT_CLEAR
1827 void clear() { erase(); }
1829 void clear() { m_impl
.clear(); }
1832 // replaces the substring of length nLen starting at nStart
1833 wxString
& replace(size_t nStart
, size_t nLen
, const char* sz
)
1836 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1837 m_impl
.replace(from
, len
, ImplStr(sz
));
1840 wxString
& replace(size_t nStart
, size_t nLen
, const wchar_t* sz
)
1843 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1844 m_impl
.replace(from
, len
, ImplStr(sz
));
1847 // replaces the substring of length nLen starting at nStart
1848 wxString
& replace(size_t nStart
, size_t nLen
, const wxString
& str
)
1851 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1852 m_impl
.replace(from
, len
, str
.m_impl
);
1855 // replaces the substring with nCount copies of ch
1856 wxString
& replace(size_t nStart
, size_t nLen
, size_t nCount
, wxUniChar ch
)
1859 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1860 #if wxUSE_UNICODE_UTF8
1861 if ( !ch
.IsAscii() )
1862 m_impl
.replace(from
, len
, wxStringOperations::EncodeNChars(nCount
, ch
));
1865 m_impl
.replace(from
, len
, nCount
, (wxStringCharType
)ch
);
1868 // replaces a substring with another substring
1869 wxString
& replace(size_t nStart
, size_t nLen
,
1870 const wxString
& str
, size_t nStart2
, size_t nLen2
)
1873 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1876 str
.PosLenToImpl(nStart2
, nLen2
, &from2
, &len2
);
1878 m_impl
.replace(from
, len
, str
.m_impl
, from2
, len2
);
1881 // replaces the substring with first nCount chars of sz
1882 wxString
& replace(size_t nStart
, size_t nLen
,
1883 const char* sz
, size_t nCount
)
1886 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1888 SubstrBufFromMB
str(ImplStr(sz
, nCount
));
1890 m_impl
.replace(from
, len
, str
.data
, str
.len
);
1893 wxString
& replace(size_t nStart
, size_t nLen
,
1894 const wchar_t* sz
, size_t nCount
)
1897 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1899 SubstrBufFromWC
str(ImplStr(sz
, nCount
));
1901 m_impl
.replace(from
, len
, str
.data
, str
.len
);
1904 wxString
& replace(size_t nStart
, size_t nLen
,
1905 const wxString
& s
, size_t nCount
)
1908 PosLenToImpl(nStart
, nLen
, &from
, &len
);
1909 m_impl
.replace(from
, len
, s
.m_impl
.c_str(), s
.LenToImpl(nCount
));
1913 wxString
& replace(iterator first
, iterator last
, const char* s
)
1914 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
1915 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
)
1916 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
1917 wxString
& replace(iterator first
, iterator last
, const char* s
, size_type n
)
1919 SubstrBufFromMB
str(ImplStr(s
, n
));
1920 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
1923 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
, size_type n
)
1925 SubstrBufFromWC
str(ImplStr(s
, n
));
1926 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
1929 wxString
& replace(iterator first
, iterator last
, const wxString
& s
)
1930 { m_impl
.replace(first
.impl(), last
.impl(), s
.m_impl
); return *this; }
1931 wxString
& replace(iterator first
, iterator last
, size_type n
, wxUniChar ch
)
1933 #if wxUSE_UNICODE_UTF8
1934 if ( !ch
.IsAscii() )
1935 m_impl
.replace(first
.impl(), last
.impl(),
1936 wxStringOperations::EncodeNChars(n
, ch
));
1939 m_impl
.replace(first
.impl(), last
.impl(), n
, (wxStringCharType
)ch
);
1942 wxString
& replace(iterator first
, iterator last
,
1943 const_iterator first1
, const_iterator last1
)
1945 m_impl
.replace(first
.impl(), last
.impl(), first1
.impl(), last1
.impl());
1948 wxString
& replace(iterator first
, iterator last
,
1949 const char *first1
, const char *last1
)
1950 { replace(first
, last
, first1
, last1
- first1
); return *this; }
1951 wxString
& replace(iterator first
, iterator last
,
1952 const wchar_t *first1
, const wchar_t *last1
)
1953 { replace(first
, last
, first1
, last1
- first1
); return *this; }
1956 void swap(wxString
& str
)
1957 { m_impl
.swap(str
.m_impl
); }
1960 size_t find(const wxString
& str
, size_t nStart
= 0) const
1961 { return PosFromImpl(m_impl
.find(str
.m_impl
, PosToImpl(nStart
))); }
1963 // find first n characters of sz
1964 size_t find(const char* sz
, size_t nStart
= 0, size_t n
= npos
) const
1966 SubstrBufFromMB
str(ImplStr(sz
, n
));
1967 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
1969 size_t find(const wchar_t* sz
, size_t nStart
= 0, size_t n
= npos
) const
1971 SubstrBufFromWC
str(ImplStr(sz
, n
));
1972 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
1975 // find the first occurence of character ch after nStart
1976 size_t find(wxUniChar ch
, size_t nStart
= 0) const
1978 return PosFromImpl(m_impl
.find(wxStringOperations::EncodeChar(ch
),
1979 PosToImpl(nStart
)));
1981 size_t find(wxUniCharRef ch
, size_t nStart
= 0) const
1982 { return find(wxUniChar(ch
), nStart
); }
1983 size_t find(char ch
, size_t nStart
= 0) const
1984 { return find(wxUniChar(ch
), nStart
); }
1985 size_t find(unsigned char ch
, size_t nStart
= 0) const
1986 { return find(wxUniChar(ch
), nStart
); }
1987 size_t find(wchar_t ch
, size_t nStart
= 0) const
1988 { return find(wxUniChar(ch
), nStart
); }
1990 // rfind() family is exactly like find() but works right to left
1992 // as find, but from the end
1993 size_t rfind(const wxString
& str
, size_t nStart
= npos
) const
1994 { return PosFromImpl(m_impl
.rfind(str
.m_impl
, PosToImpl(nStart
))); }
1996 // as find, but from the end
1997 size_t rfind(const char* sz
, size_t nStart
= npos
, size_t n
= npos
) const
1999 SubstrBufFromMB
str(ImplStr(sz
, n
));
2000 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2002 size_t rfind(const wchar_t* sz
, size_t nStart
= npos
, size_t n
= npos
) const
2004 SubstrBufFromWC
str(ImplStr(sz
, n
));
2005 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2007 // as find, but from the end
2008 size_t rfind(wxUniChar ch
, size_t nStart
= npos
) const
2010 return PosFromImpl(m_impl
.rfind(wxStringOperations::EncodeChar(ch
),
2011 PosToImpl(nStart
)));
2013 size_t rfind(wxUniCharRef ch
, size_t nStart
= npos
) const
2014 { return rfind(wxUniChar(ch
), nStart
); }
2015 size_t rfind(char ch
, size_t nStart
= npos
) const
2016 { return rfind(wxUniChar(ch
), nStart
); }
2017 size_t rfind(unsigned char ch
, size_t nStart
= npos
) const
2018 { return rfind(wxUniChar(ch
), nStart
); }
2019 size_t rfind(wchar_t ch
, size_t nStart
= npos
) const
2020 { return rfind(wxUniChar(ch
), nStart
); }
2022 // find first/last occurence of any character (not) in the set:
2023 #if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2024 // FIXME-UTF8: this is not entirely correct, because it doesn't work if
2025 // sizeof(wchar_t)==2 and surrogates are present in the string;
2026 // should we care? Probably not.
2027 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2028 { return m_impl
.find_first_of(str
.m_impl
, nStart
); }
2029 size_t find_first_of(const char* sz
, size_t nStart
= 0) const
2030 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2031 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const
2032 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2033 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const
2034 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2035 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2036 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2037 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2038 { return m_impl
.find_first_of((wxChar
)c
, nStart
); }
2040 size_t find_last_of(const wxString
& str
, size_t nStart
= npos
) const
2041 { return m_impl
.find_last_of(str
.m_impl
, nStart
); }
2042 size_t find_last_of(const char* sz
, size_t nStart
= npos
) const
2043 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2044 size_t find_last_of(const wchar_t* sz
, size_t nStart
= npos
) const
2045 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2046 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const
2047 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2048 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2049 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2050 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2051 { return m_impl
.find_last_of((wxChar
)c
, nStart
); }
2053 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2054 { return m_impl
.find_first_not_of(str
.m_impl
, nStart
); }
2055 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const
2056 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2057 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const
2058 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2059 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const
2060 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2061 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2062 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2063 size_t find_first_not_of(wxUniChar c
, size_t nStart
= 0) const
2064 { return m_impl
.find_first_not_of((wxChar
)c
, nStart
); }
2066 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2067 { return m_impl
.find_last_not_of(str
.m_impl
, nStart
); }
2068 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const
2069 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2070 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const
2071 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2072 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const
2073 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2074 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2075 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2076 size_t find_last_not_of(wxUniChar c
, size_t nStart
= npos
) const
2077 { return m_impl
.find_last_not_of((wxChar
)c
, nStart
); }
2079 // we can't use std::string implementation in UTF-8 build, because the
2080 // character sets would be interpreted wrongly:
2082 // as strpbrk() but starts at nStart, returns npos if not found
2083 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2084 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2085 { return find_first_of(str
.mb_str().data(), nStart
); }
2087 { return find_first_of((const wxChar
*)str
.c_str(), nStart
); }
2090 size_t find_first_of(const char* sz
, size_t nStart
= 0) const;
2091 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const;
2092 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const;
2093 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2094 // same as find(char, size_t)
2095 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2096 { return find(c
, nStart
); }
2097 // find the last (starting from nStart) char from str in this string
2098 size_t find_last_of (const wxString
& str
, size_t nStart
= npos
) const
2099 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2100 { return find_last_of(str
.mb_str().data(), nStart
); }
2102 { return find_last_of((const wxChar
*)str
.c_str(), nStart
); }
2105 size_t find_last_of (const char* sz
, size_t nStart
= npos
) const;
2106 size_t find_last_of (const wchar_t* sz
, size_t nStart
= npos
) const;
2107 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const;
2108 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2110 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2111 { return rfind(c
, nStart
); }
2113 // find first/last occurence of any character not in the set
2115 // as strspn() (starting from nStart), returns npos on failure
2116 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2117 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2118 { return find_first_not_of(str
.mb_str().data(), nStart
); }
2120 { return find_first_not_of((const wxChar
*)str
.c_str(), nStart
); }
2123 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const;
2124 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const;
2125 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2126 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2128 size_t find_first_not_of(wxUniChar ch
, size_t nStart
= 0) const;
2130 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2131 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2132 { return find_last_not_of(str
.mb_str().data(), nStart
); }
2134 { return find_last_not_of((const wxChar
*)str
.c_str(), nStart
); }
2137 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const;
2138 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const;
2139 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2140 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2142 size_t find_last_not_of(wxUniChar ch
, size_t nStart
= npos
) const;
2143 #endif // wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 or not
2145 // provide char/wchar_t/wxUniCharRef overloads for char-finding functions
2146 // above to resolve ambiguities:
2147 size_t find_first_of(wxUniCharRef ch
, size_t nStart
= 0) const
2148 { return find_first_of(wxUniChar(ch
), nStart
); }
2149 size_t find_first_of(char ch
, size_t nStart
= 0) const
2150 { return find_first_of(wxUniChar(ch
), nStart
); }
2151 size_t find_first_of(unsigned char ch
, size_t nStart
= 0) const
2152 { return find_first_of(wxUniChar(ch
), nStart
); }
2153 size_t find_first_of(wchar_t ch
, size_t nStart
= 0) const
2154 { return find_first_of(wxUniChar(ch
), nStart
); }
2155 size_t find_last_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2156 { return find_last_of(wxUniChar(ch
), nStart
); }
2157 size_t find_last_of(char ch
, size_t nStart
= npos
) const
2158 { return find_last_of(wxUniChar(ch
), nStart
); }
2159 size_t find_last_of(unsigned char ch
, size_t nStart
= npos
) const
2160 { return find_last_of(wxUniChar(ch
), nStart
); }
2161 size_t find_last_of(wchar_t ch
, size_t nStart
= npos
) const
2162 { return find_last_of(wxUniChar(ch
), nStart
); }
2163 size_t find_first_not_of(wxUniCharRef ch
, size_t nStart
= 0) const
2164 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2165 size_t find_first_not_of(char ch
, size_t nStart
= 0) const
2166 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2167 size_t find_first_not_of(unsigned char ch
, size_t nStart
= 0) const
2168 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2169 size_t find_first_not_of(wchar_t ch
, size_t nStart
= 0) const
2170 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2171 size_t find_last_not_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2172 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2173 size_t find_last_not_of(char ch
, size_t nStart
= npos
) const
2174 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2175 size_t find_last_not_of(unsigned char ch
, size_t nStart
= npos
) const
2176 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2177 size_t find_last_not_of(wchar_t ch
, size_t nStart
= npos
) const
2178 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2181 wxString
& operator+=(const wxString
& s
)
2182 { m_impl
+= s
.m_impl
; return *this; }
2183 // string += C string
2184 wxString
& operator+=(const char *psz
)
2185 { m_impl
+= ImplStr(psz
); return *this; }
2186 wxString
& operator+=(const wchar_t *pwz
)
2187 { m_impl
+= ImplStr(pwz
); return *this; }
2188 wxString
& operator+=(const wxCStrData
& s
)
2189 { m_impl
+= s
.AsString().m_impl
; return *this; }
2191 wxString
& operator+=(wxUniChar ch
)
2192 { m_impl
+= wxStringOperations::EncodeChar(ch
); return *this; }
2193 wxString
& operator+=(wxUniCharRef ch
) { return *this += wxUniChar(ch
); }
2194 wxString
& operator+=(int ch
) { return *this += wxUniChar(ch
); }
2195 wxString
& operator+=(char ch
) { return *this += wxUniChar(ch
); }
2196 wxString
& operator+=(unsigned char ch
) { return *this += wxUniChar(ch
); }
2197 wxString
& operator+=(wchar_t ch
) { return *this += wxUniChar(ch
); }
2200 #if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2201 // helpers for wxStringBuffer and wxStringBufferLength
2202 wxStringCharType
*DoGetWriteBuf(size_t nLen
)
2203 { return m_impl
.DoGetWriteBuf(nLen
); }
2204 void DoUngetWriteBuf()
2205 { m_impl
.DoUngetWriteBuf(); }
2206 void DoUngetWriteBuf(size_t nLen
)
2207 { m_impl
.DoUngetWriteBuf(nLen
); }
2209 friend class WXDLLIMPEXP_BASE wxStringBuffer
;
2210 friend class WXDLLIMPEXP_BASE wxStringBufferLength
;
2211 #endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2213 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
2214 int DoPrintf(const wxChar
*format
, ...) ATTRIBUTE_PRINTF_2
;
2215 static wxString
DoFormat(const wxChar
*format
, ...) ATTRIBUTE_PRINTF_1
;
2218 #if !wxUSE_STL_BASED_WXSTRING
2219 // check string's data validity
2220 bool IsValid() const { return m_impl
.GetStringData()->IsValid(); }
2224 wxStringImpl m_impl
;
2226 // buffers for compatibility conversion from (char*)c_str() and
2227 // (wchar_t*)c_str():
2228 // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
2229 template<typename T
>
2230 struct ConvertedBuffer
2232 ConvertedBuffer() : m_buf(NULL
) {}
2236 operator T
*() const { return m_buf
; }
2238 ConvertedBuffer
& operator=(T
*str
)
2248 ConvertedBuffer
<char> m_convertedToChar
;
2250 #if !wxUSE_UNICODE_WCHAR
2251 ConvertedBuffer
<wchar_t> m_convertedToWChar
;
2253 friend class WXDLLIMPEXP_BASE wxCStrData
;
2256 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
2257 #pragma warning (default:4275)
2260 // string iterator operators that satisfy STL Random Access Iterator
2262 inline wxString::iterator
operator+(int n
, wxString::iterator i
)
2264 inline wxString::iterator
operator+(size_t n
, wxString::iterator i
)
2266 inline wxString::const_iterator
operator+(int n
, wxString::const_iterator i
)
2268 inline wxString::const_iterator
operator+(size_t n
, wxString::const_iterator i
)
2270 inline wxString::reverse_iterator
operator+(int n
, wxString::reverse_iterator i
)
2272 inline wxString::reverse_iterator
operator+(size_t n
, wxString::reverse_iterator i
)
2274 inline wxString::const_reverse_iterator
operator+(int n
, wxString::const_reverse_iterator i
)
2276 inline wxString::const_reverse_iterator
operator+(size_t n
, wxString::const_reverse_iterator i
)
2279 // notice that even though for many compilers the friend declarations above are
2280 // enough, from the point of view of C++ standard we must have the declarations
2281 // here as friend ones are not injected in the enclosing namespace and without
2282 // them the code fails to compile with conforming compilers such as xlC or g++4
2283 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
, const wxString
& string2
);
2284 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const char *psz
);
2285 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const wchar_t *pwz
);
2286 wxString WXDLLIMPEXP_BASE
operator+(const char *psz
, const wxString
& string
);
2287 wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
, const wxString
& string
);
2289 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
2290 wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
2292 inline wxString
operator+(const wxString
& string
, wxUniCharRef ch
)
2293 { return string
+ (wxUniChar
)ch
; }
2294 inline wxString
operator+(const wxString
& string
, char ch
)
2295 { return string
+ wxUniChar(ch
); }
2296 inline wxString
operator+(const wxString
& string
, wchar_t ch
)
2297 { return string
+ wxUniChar(ch
); }
2298 inline wxString
operator+(wxUniCharRef ch
, const wxString
& string
)
2299 { return (wxUniChar
)ch
+ string
; }
2300 inline wxString
operator+(char ch
, const wxString
& string
)
2301 { return wxUniChar(ch
) + string
; }
2302 inline wxString
operator+(wchar_t ch
, const wxString
& string
)
2303 { return wxUniChar(ch
) + string
; }
2306 #if wxUSE_STL_BASED_WXSTRING
2307 // return an empty wxString (not very useful with wxUSE_STL == 1)
2308 inline const wxString
wxGetEmptyString() { return wxString(); }
2309 #else // !wxUSE_STL_BASED_WXSTRING
2310 // return an empty wxString (more efficient than wxString() here)
2311 inline const wxString
& wxGetEmptyString()
2313 return *(wxString
*)&wxEmptyString
;
2315 #endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
2317 // ----------------------------------------------------------------------------
2318 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
2319 // ----------------------------------------------------------------------------
2321 #if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
2323 class WXDLLIMPEXP_BASE wxStringBuffer
2326 wxStringBuffer(wxString
& str
, size_t lenWanted
= 1024)
2327 : m_str(str
), m_buf(lenWanted
)
2330 ~wxStringBuffer() { m_str
.assign(m_buf
.data(), wxStrlen(m_buf
.data())); }
2332 operator wxChar
*() { return m_buf
.data(); }
2337 wxWCharBuffer m_buf
;
2342 DECLARE_NO_COPY_CLASS(wxStringBuffer
)
2345 class WXDLLIMPEXP_BASE wxStringBufferLength
2348 wxStringBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2349 : m_str(str
), m_buf(lenWanted
), m_len(0), m_lenSet(false)
2352 ~wxStringBufferLength()
2355 m_str
.assign(m_buf
.data(), m_len
);
2358 operator wxChar
*() { return m_buf
.data(); }
2359 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2364 wxWCharBuffer m_buf
;
2371 DECLARE_NO_COPY_CLASS(wxStringBufferLength
)
2374 #else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2376 class WXDLLIMPEXP_BASE wxStringBuffer
2379 wxStringBuffer(wxString
& str
, size_t lenWanted
= 1024)
2380 : m_str(str
), m_buf(NULL
)
2381 { m_buf
= m_str
.DoGetWriteBuf(lenWanted
); }
2383 ~wxStringBuffer() { m_str
.DoUngetWriteBuf(); }
2385 operator wxChar
*() const { return m_buf
; }
2391 DECLARE_NO_COPY_CLASS(wxStringBuffer
)
2394 class WXDLLIMPEXP_BASE wxStringBufferLength
2397 wxStringBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2398 : m_str(str
), m_buf(NULL
), m_len(0), m_lenSet(false)
2400 m_buf
= m_str
.DoGetWriteBuf(lenWanted
);
2401 wxASSERT(m_buf
!= NULL
);
2404 ~wxStringBufferLength()
2407 m_str
.DoUngetWriteBuf(m_len
);
2410 operator wxChar
*() const { return m_buf
; }
2411 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2419 DECLARE_NO_COPY_CLASS(wxStringBufferLength
)
2422 #endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2424 // ---------------------------------------------------------------------------
2425 // wxString comparison functions: operator versions are always case sensitive
2426 // ---------------------------------------------------------------------------
2428 #define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p)
2430 wxDEFINE_ALL_COMPARISONS(const wxChar
*, const wxString
&, wxCMP_WXCHAR_STRING
)
2432 #undef wxCMP_WXCHAR_STRING
2434 // note that there is an optimization in operator==() and !=(): we (quickly)
2435 // checks the strings length first, before comparing their data
2436 inline bool operator==(const wxString
& s1
, const wxString
& s2
)
2437 { return (s1
.Len() == s2
.Len()) && (s1
.Cmp(s2
) == 0); }
2438 inline bool operator!=(const wxString
& s1
, const wxString
& s2
)
2439 { return (s1
.Len() != s2
.Len()) || (s1
.Cmp(s2
) != 0); }
2440 inline bool operator< (const wxString
& s1
, const wxString
& s2
)
2441 { return s1
.Cmp(s2
) < 0; }
2442 inline bool operator> (const wxString
& s1
, const wxString
& s2
)
2443 { return s1
.Cmp(s2
) > 0; }
2444 inline bool operator<=(const wxString
& s1
, const wxString
& s2
)
2445 { return s1
.Cmp(s2
) <= 0; }
2446 inline bool operator>=(const wxString
& s1
, const wxString
& s2
)
2447 { return s1
.Cmp(s2
) >= 0; }
2450 inline bool operator==(const wxString
& s1
, const wxWCharBuffer
& s2
)
2451 { return (s1
.Cmp((const wchar_t *)s2
) == 0); }
2452 inline bool operator==(const wxWCharBuffer
& s1
, const wxString
& s2
)
2453 { return (s2
.Cmp((const wchar_t *)s1
) == 0); }
2454 inline bool operator!=(const wxString
& s1
, const wxWCharBuffer
& s2
)
2455 { return (s1
.Cmp((const wchar_t *)s2
) != 0); }
2456 inline bool operator!=(const wxWCharBuffer
& s1
, const wxString
& s2
)
2457 { return (s2
.Cmp((const wchar_t *)s1
) != 0); }
2458 #else // !wxUSE_UNICODE
2459 inline bool operator==(const wxString
& s1
, const wxCharBuffer
& s2
)
2460 { return (s1
.Cmp((const char *)s2
) == 0); }
2461 inline bool operator==(const wxCharBuffer
& s1
, const wxString
& s2
)
2462 { return (s2
.Cmp((const char *)s1
) == 0); }
2463 inline bool operator!=(const wxString
& s1
, const wxCharBuffer
& s2
)
2464 { return (s1
.Cmp((const char *)s2
) != 0); }
2465 inline bool operator!=(const wxCharBuffer
& s1
, const wxString
& s2
)
2466 { return (s2
.Cmp((const char *)s1
) != 0); }
2467 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2470 inline wxString
operator+(const wxString
& string
, const wxWCharBuffer
& buf
)
2471 { return string
+ (const wchar_t *)buf
; }
2472 inline wxString
operator+(const wxWCharBuffer
& buf
, const wxString
& string
)
2473 { return (const wchar_t *)buf
+ string
; }
2474 #else // !wxUSE_UNICODE
2475 inline wxString
operator+(const wxString
& string
, const wxCharBuffer
& buf
)
2476 { return string
+ (const char *)buf
; }
2477 inline wxString
operator+(const wxCharBuffer
& buf
, const wxString
& string
)
2478 { return (const char *)buf
+ string
; }
2479 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2481 // comparison with char
2482 inline bool operator==(const wxUniChar
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2483 inline bool operator==(const wxUniCharRef
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2484 inline bool operator==(char c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2485 inline bool operator==(wchar_t c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2486 inline bool operator==(int c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2487 inline bool operator==(const wxString
& s
, const wxUniChar
& c
) { return s
.IsSameAs(c
); }
2488 inline bool operator==(const wxString
& s
, const wxUniCharRef
& c
) { return s
.IsSameAs(c
); }
2489 inline bool operator==(const wxString
& s
, char c
) { return s
.IsSameAs(c
); }
2490 inline bool operator==(const wxString
& s
, wchar_t c
) { return s
.IsSameAs(c
); }
2491 inline bool operator!=(const wxUniChar
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2492 inline bool operator!=(const wxUniCharRef
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2493 inline bool operator!=(char c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2494 inline bool operator!=(wchar_t c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2495 inline bool operator!=(int c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2496 inline bool operator!=(const wxString
& s
, const wxUniChar
& c
) { return !s
.IsSameAs(c
); }
2497 inline bool operator!=(const wxString
& s
, const wxUniCharRef
& c
) { return !s
.IsSameAs(c
); }
2498 inline bool operator!=(const wxString
& s
, char c
) { return !s
.IsSameAs(c
); }
2499 inline bool operator!=(const wxString
& s
, wchar_t c
) { return !s
.IsSameAs(c
); }
2501 // comparison with C string in Unicode build
2504 #define wxCMP_CHAR_STRING(p, s, op) wxString(p) op s
2506 wxDEFINE_ALL_COMPARISONS(const char *, const wxString
&, wxCMP_CHAR_STRING
)
2508 #undef wxCMP_CHAR_STRING
2510 #endif // wxUSE_UNICODE
2512 // we also need to provide the operators for comparison with wxCStrData to
2513 // resolve ambiguity between operator(const wxChar *,const wxString &) and
2514 // operator(const wxChar *, const wxChar *) for "p == s.c_str()"
2516 // notice that these are (shallow) pointer comparisons, not (deep) string ones
2517 #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
2518 #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
2520 wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData
&, wxCMP_WCHAR_CSTRDATA
)
2521 wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData
&, wxCMP_CHAR_CSTRDATA
)
2523 #undef wxCMP_CHAR_CSTRDATA
2524 #undef wxCMP_WCHAR_CSTRDATA
2526 // ---------------------------------------------------------------------------
2527 // Implementation only from here until the end of file
2528 // ---------------------------------------------------------------------------
2530 #if wxUSE_STD_IOSTREAM
2532 #include "wx/iosfwrap.h"
2534 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxString
&);
2535 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCStrData
&);
2536 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCharBuffer
&);
2537 #ifndef __BORLANDC__
2538 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxWCharBuffer
&);
2541 #endif // wxSTD_STRING_COMPATIBILITY
2543 // ---------------------------------------------------------------------------
2544 // wxCStrData implementation
2545 // ---------------------------------------------------------------------------
2547 inline wxCStrData::wxCStrData(char *buf
)
2548 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
2549 inline wxCStrData::wxCStrData(wchar_t *buf
)
2550 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
2552 inline wxCStrData::~wxCStrData()
2558 inline wxCStrData::operator bool() const
2560 return !m_str
->empty();
2563 // simple cases for AsChar() and AsWChar(), the complicated ones are
2565 #if wxUSE_UNICODE_WCHAR
2566 inline const wchar_t* wxCStrData::AsWChar() const
2568 return m_str
->wx_str() + m_offset
;
2570 #endif // wxUSE_UNICODE_WCHAR
2573 inline const char* wxCStrData::AsChar() const
2575 return m_str
->wx_str() + m_offset
;
2577 #endif // !wxUSE_UNICODE
2579 inline const wxCharBuffer
wxCStrData::AsCharBuf() const
2582 return wxCharBuffer::CreateNonOwned(AsChar());
2584 return AsString().mb_str();
2588 inline const wxWCharBuffer
wxCStrData::AsWCharBuf() const
2590 #if wxUSE_UNICODE_WCHAR
2591 return wxWCharBuffer::CreateNonOwned(AsWChar());
2593 return AsString().wc_str();
2597 inline wxString
wxCStrData::AsString() const
2599 if ( m_offset
== 0 )
2602 return m_str
->Mid(m_offset
);
2605 inline wxUniChar
wxCStrData::operator*() const
2607 if ( m_str
->empty() )
2608 return wxUniChar(_T('\0'));
2610 return (*m_str
)[m_offset
];
2613 inline wxUniChar
wxCStrData::operator[](size_t n
) const
2615 return m_str
->at(m_offset
+ n
);
2618 // ----------------------------------------------------------------------------
2619 // more wxCStrData operators
2620 // ----------------------------------------------------------------------------
2622 // we need to define those to allow "size_t pos = p - s.c_str()" where p is
2623 // some pointer into the string
2624 inline size_t operator-(const char *p
, const wxCStrData
& cs
)
2626 return p
- cs
.AsChar();
2629 inline size_t operator-(const wchar_t *p
, const wxCStrData
& cs
)
2631 return p
- cs
.AsWChar();
2634 // ----------------------------------------------------------------------------
2635 // implementation of wx[W]CharBuffer inline methods using wxCStrData
2636 // ----------------------------------------------------------------------------
2638 // FIXME-UTF8: move this to buffer.h
2639 inline wxCharBuffer::wxCharBuffer(const wxCStrData
& cstr
)
2640 : wxCharTypeBufferBase(cstr
.AsCharBuf())
2644 inline wxWCharBuffer::wxWCharBuffer(const wxCStrData
& cstr
)
2645 : wxCharTypeBufferBase(cstr
.AsWCharBuf())
2649 #endif // _WX_WXSTRING_H_