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/wxcrtbase.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_FWD_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 // like _T(), but for literals in wxString's internal representation, i.e.
82 // char* in UTF-8 build and wxChar* otherwise:
83 #if wxUSE_UNICODE_UTF8
84 #define wxSTRING_TEXT(str) str
86 #define wxSTRING_TEXT(str) _T(str)
89 // ----------------------------------------------------------------------------
91 // ----------------------------------------------------------------------------
93 #if WXWIN_COMPATIBILITY_2_6
95 // deprecated in favour of wxString::npos, don't use in new code
97 // maximum possible length for a string means "take all string" everywhere
98 #define wxSTRING_MAXLEN wxString::npos
100 #endif // WXWIN_COMPATIBILITY_2_6
102 // ---------------------------------------------------------------------------
103 // global functions complementing standard C string library replacements for
104 // strlen() and portable strcasecmp()
105 //---------------------------------------------------------------------------
107 #if WXWIN_COMPATIBILITY_2_8
108 // Use wxXXX() functions from wxcrt.h instead! These functions are for
109 // backwards compatibility only.
111 // checks whether the passed in pointer is NULL and if the string is empty
112 wxDEPRECATED( inline bool IsEmpty(const char *p
) );
113 inline bool IsEmpty(const char *p
) { return (!p
|| !*p
); }
115 // safe version of strlen() (returns 0 if passed NULL pointer)
116 wxDEPRECATED( inline size_t Strlen(const char *psz
) );
117 inline size_t Strlen(const char *psz
)
118 { return psz
? strlen(psz
) : 0; }
120 // portable strcasecmp/_stricmp
121 wxDEPRECATED( inline int Stricmp(const char *psz1
, const char *psz2
) );
122 inline int Stricmp(const char *psz1
, const char *psz2
)
124 #if defined(__VISUALC__) && defined(__WXWINCE__)
125 register char c1
, c2
;
127 c1
= tolower(*psz1
++);
128 c2
= tolower(*psz2
++);
129 } while ( c1
&& (c1
== c2
) );
132 #elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
133 return _stricmp(psz1
, psz2
);
134 #elif defined(__SC__)
135 return _stricmp(psz1
, psz2
);
136 #elif defined(__SALFORDC__)
137 return stricmp(psz1
, psz2
);
138 #elif defined(__BORLANDC__)
139 return stricmp(psz1
, psz2
);
140 #elif defined(__WATCOMC__)
141 return stricmp(psz1
, psz2
);
142 #elif defined(__DJGPP__)
143 return stricmp(psz1
, psz2
);
144 #elif defined(__EMX__)
145 return stricmp(psz1
, psz2
);
146 #elif defined(__WXPM__)
147 return stricmp(psz1
, psz2
);
148 #elif defined(__WXPALMOS__) || \
149 defined(HAVE_STRCASECMP_IN_STRING_H) || \
150 defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
151 defined(__GNUWIN32__)
152 return strcasecmp(psz1
, psz2
);
153 #elif defined(__MWERKS__) && !defined(__INTEL__)
154 register char c1
, c2
;
156 c1
= tolower(*psz1
++);
157 c2
= tolower(*psz2
++);
158 } while ( c1
&& (c1
== c2
) );
162 // almost all compilers/libraries provide this function (unfortunately under
163 // different names), that's why we don't implement our own which will surely
164 // be more efficient than this code (uncomment to use):
166 register char c1, c2;
168 c1 = tolower(*psz1++);
169 c2 = tolower(*psz2++);
170 } while ( c1 && (c1 == c2) );
175 #error "Please define string case-insensitive compare for your OS/compiler"
176 #endif // OS/compiler
179 #endif // WXWIN_COMPATIBILITY_2_8
181 // ----------------------------------------------------------------------------
183 // ----------------------------------------------------------------------------
185 // Lightweight object returned by wxString::c_str() and implicitly convertible
186 // to either const char* or const wchar_t*.
187 class WXDLLIMPEXP_BASE wxCStrData
190 // Ctors; for internal use by wxString and wxCStrData only
191 wxCStrData(const wxString
*str
, size_t offset
= 0, bool owned
= false)
192 : m_str(str
), m_offset(offset
), m_owned(owned
) {}
195 // Ctor constructs the object from char literal; they are needed to make
196 // operator?: compile and they intentionally take char*, not const char*
197 inline wxCStrData(char *buf
);
198 inline wxCStrData(wchar_t *buf
);
199 inline wxCStrData(const wxCStrData
& data
);
201 inline ~wxCStrData();
203 // methods defined inline below must be declared inline or mingw32 3.4.5
204 // warns about "<symbol> defined locally after being referenced with
205 // dllimport linkage"
206 #if wxUSE_UNICODE_WCHAR
209 const wchar_t* AsWChar() const;
210 operator const wchar_t*() const { return AsWChar(); }
212 #if !wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY
215 const char* AsChar() const;
216 const unsigned char* AsUnsignedChar() const
217 { return (const unsigned char *) AsChar(); }
218 operator const char*() const { return AsChar(); }
219 operator const unsigned char*() const { return AsUnsignedChar(); }
221 operator const void*() const { return AsChar(); }
223 inline const wxCharBuffer
AsCharBuf() const;
224 inline const wxWCharBuffer
AsWCharBuf() const;
226 inline wxString
AsString() const;
228 // returns the value as C string in internal representation (equivalent
229 // to AsString().wx_str(), but more efficient)
230 const wxStringCharType
*AsInternal() const;
232 // allow expressions like "c_str()[0]":
233 inline wxUniChar
operator[](size_t n
) const;
234 wxUniChar
operator[](int n
) const { return operator[](size_t(n
)); }
235 wxUniChar
operator[](long n
) const { return operator[](size_t(n
)); }
236 #ifndef wxSIZE_T_IS_UINT
237 wxUniChar
operator[](unsigned int n
) const { return operator[](size_t(n
)); }
238 #endif // size_t != unsigned int
240 // these operators are needed to emulate the pointer semantics of c_str():
241 // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
242 // (we need both versions to resolve ambiguities):
243 wxCStrData
operator+(int n
) const
244 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
245 wxCStrData
operator+(long n
) const
246 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
247 wxCStrData
operator+(size_t n
) const
248 { return wxCStrData(m_str
, m_offset
+ n
, m_owned
); }
250 // and these for "str.c_str() + n - 2":
251 wxCStrData
operator-(int n
) const
253 wxASSERT_MSG( n
<= (int)m_offset
,
254 _T("attempt to construct address before the beginning of the string") );
255 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
257 wxCStrData
operator-(long n
) const
259 wxASSERT_MSG( n
<= (int)m_offset
,
260 _T("attempt to construct address before the beginning of the string") );
261 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
263 wxCStrData
operator-(size_t n
) const
265 wxASSERT_MSG( n
<= m_offset
,
266 _T("attempt to construct address before the beginning of the string") );
267 return wxCStrData(m_str
, m_offset
- n
, m_owned
);
270 // this operator is needed to make expressions like "*c_str()" or
271 // "*(c_str() + 2)" work
272 inline wxUniChar
operator*() const;
275 const wxString
*m_str
;
279 friend class WXDLLIMPEXP_FWD_BASE wxString
;
282 // ----------------------------------------------------------------------------
283 // wxStringPrintfMixin
284 // ---------------------------------------------------------------------------
286 // NB: VC6 has a bug that causes linker errors if you have template methods
287 // in a class using __declspec(dllimport). The solution is to split such
288 // class into two classes, one that contains the template methods and does
289 // *not* use WXDLLIMPEXP_BASE and another class that contains the rest
290 // (with DLL linkage).
292 // We only do this for VC6 here, because the code is less efficient
293 // (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler
294 // cannot compile this code.
296 #if defined(__VISUALC__) && __VISUALC__ < 1300
297 #define wxNEEDS_WXSTRING_PRINTF_MIXIN
300 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
301 // this class contains implementation of wxString's vararg methods, it's
302 // exported from wxBase DLL
303 class WXDLLIMPEXP_BASE wxStringPrintfMixinBase
306 wxStringPrintfMixinBase() {}
308 #if !wxUSE_UTF8_LOCALE_ONLY
309 int DoPrintfWchar(const wxChar
*format
, ...);
310 static wxString
DoFormatWchar(const wxChar
*format
, ...);
312 #if wxUSE_UNICODE_UTF8
313 int DoPrintfUtf8(const char *format
, ...);
314 static wxString
DoFormatUtf8(const char *format
, ...);
318 // this class contains template wrappers for wxString's vararg methods, it's
319 // intentionally *not* exported from the DLL in order to fix the VC6 bug
321 class wxStringPrintfMixin
: public wxStringPrintfMixinBase
324 // to further complicate things, we can't return wxString from
325 // wxStringPrintfMixin::Format() because wxString is not yet declared at
326 // this point; the solution is to use this fake type trait template - this
327 // way the compiler won't know the return type until Format() is used
328 // (this doesn't compile with Watcom, but VC6 compiles it just fine):
329 template<typename T
> struct StringReturnType
331 typedef wxString type
;
335 // these are duplicated wxString methods, they're also declared below
336 // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
338 // static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1;
339 WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType
<T1
>::type
,
340 Format
, 1, (const wxFormatString
&),
341 DoFormatWchar
, DoFormatUtf8
)
342 // We have to implement the version without template arguments manually
343 // because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC
344 // normally does it itself. It has to be a template so that we can use
345 // the hack, even though there's no real template parameter. We can't move
346 // it to wxStrig, because it would shadow these versions of Format() then.
348 inline static typename StringReturnType
<T
>::type
351 // NB: this doesn't compile if T is not (some form of) a string;
352 // this makes Format's prototype equivalent to
353 // Format(const wxFormatString& fmt)
354 return DoFormatWchar(wxFormatString(fmt
));
357 // int Printf(const wxString& format, ...);
358 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wxFormatString
&),
359 DoPrintfWchar
, DoPrintfUtf8
)
360 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
361 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wxFormatString
&),
362 DoPrintfWchar
, DoPrintfUtf8
)
365 wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
367 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
370 // ----------------------------------------------------------------------------
371 // wxString: string class trying to be compatible with std::string, MFC
372 // CString and wxWindows 1.x wxString all at once
373 // ---------------------------------------------------------------------------
375 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
376 // "non dll-interface class 'wxStringPrintfMixin' used as base interface
377 // for dll-interface class 'wxString'" -- this is OK in our case
378 #pragma warning (disable:4275)
381 #if wxUSE_UNICODE_UTF8
382 // see the comment near wxString::iterator for why we need this
383 struct WXDLLIMPEXP_BASE wxStringIteratorNode
385 wxStringIteratorNode()
386 : m_str(NULL
), m_citer(NULL
), m_iter(NULL
), m_prev(NULL
), m_next(NULL
) {}
387 wxStringIteratorNode(const wxString
*str
,
388 wxStringImpl::const_iterator
*citer
)
389 { DoSet(str
, citer
, NULL
); }
390 wxStringIteratorNode(const wxString
*str
, wxStringImpl::iterator
*iter
)
391 { DoSet(str
, NULL
, iter
); }
392 ~wxStringIteratorNode()
395 inline void set(const wxString
*str
, wxStringImpl::const_iterator
*citer
)
396 { clear(); DoSet(str
, citer
, NULL
); }
397 inline void set(const wxString
*str
, wxStringImpl::iterator
*iter
)
398 { clear(); DoSet(str
, NULL
, iter
); }
400 const wxString
*m_str
;
401 wxStringImpl::const_iterator
*m_citer
;
402 wxStringImpl::iterator
*m_iter
;
403 wxStringIteratorNode
*m_prev
, *m_next
;
407 inline void DoSet(const wxString
*str
,
408 wxStringImpl::const_iterator
*citer
,
409 wxStringImpl::iterator
*iter
);
411 // the node belongs to a particular iterator instance, it's not copied
412 // when a copy of the iterator is made
413 DECLARE_NO_COPY_CLASS(wxStringIteratorNode
)
415 #endif // wxUSE_UNICODE_UTF8
417 class WXDLLIMPEXP_BASE wxString
418 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
419 : public wxStringPrintfMixin
422 // NB: special care was taken in arranging the member functions in such order
423 // that all inline functions can be effectively inlined, verify that all
424 // performance critical functions are still inlined if you change order!
426 // an 'invalid' value for string index, moved to this place due to a CW bug
427 static const size_t npos
;
430 // if we hadn't made these operators private, it would be possible to
431 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
432 // converted to char in C and we do have operator=(char)
434 // NB: we don't need other versions (short/long and unsigned) as attempt
435 // to assign another numeric type to wxString will now result in
436 // ambiguity between operator=(char) and operator=(int)
437 wxString
& operator=(int);
439 // these methods are not implemented - there is _no_ conversion from int to
440 // string, you're doing something wrong if the compiler wants to call it!
442 // try `s << i' or `s.Printf("%d", i)' instead
446 // buffer for holding temporary substring when using any of the methods
447 // that take (char*,size_t) or (wchar_t*,size_t) arguments:
449 struct SubstrBufFromType
454 SubstrBufFromType(const T
& data_
, size_t len_
)
455 : data(data_
), len(len_
) {}
458 #if wxUSE_UNICODE_UTF8
459 // even char* -> char* needs conversion, from locale charset to UTF-8
460 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
461 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromMB
;
462 #elif wxUSE_UNICODE_WCHAR
463 typedef SubstrBufFromType
<const wchar_t*> SubstrBufFromWC
;
464 typedef SubstrBufFromType
<wxWCharBuffer
> SubstrBufFromMB
;
466 typedef SubstrBufFromType
<const char*> SubstrBufFromMB
;
467 typedef SubstrBufFromType
<wxCharBuffer
> SubstrBufFromWC
;
471 // Functions implementing primitive operations on string data; wxString
472 // methods and iterators are implemented in terms of it. The differences
473 // between UTF-8 and wchar_t* representations of the string are mostly
476 #if wxUSE_UNICODE_UTF8
477 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
478 const wxMBConv
& conv
);
479 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
480 const wxMBConv
& conv
);
481 #elif wxUSE_UNICODE_WCHAR
482 static SubstrBufFromMB
ConvertStr(const char *psz
, size_t nLength
,
483 const wxMBConv
& conv
);
485 static SubstrBufFromWC
ConvertStr(const wchar_t *pwz
, size_t nLength
,
486 const wxMBConv
& conv
);
489 #if !wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_WCHAR or !wxUSE_UNICODE
490 // returns C string encoded as the implementation expects:
492 static const wchar_t* ImplStr(const wchar_t* str
)
493 { return str
? str
: wxT(""); }
494 static const SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
495 { return SubstrBufFromWC(str
, (str
&& n
== npos
) ? wxWcslen(str
) : n
); }
496 static wxWCharBuffer
ImplStr(const char* str
,
497 const wxMBConv
& conv
= wxConvLibc
)
498 { return ConvertStr(str
, npos
, conv
).data
; }
499 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
500 const wxMBConv
& conv
= wxConvLibc
)
501 { return ConvertStr(str
, n
, conv
); }
503 static const char* ImplStr(const char* str
,
504 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
505 { return str
? str
: ""; }
506 static const SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
507 const wxMBConv
& WXUNUSED(conv
) = wxConvLibc
)
508 { return SubstrBufFromMB(str
, (str
&& n
== npos
) ? wxStrlen(str
) : n
); }
509 static wxCharBuffer
ImplStr(const wchar_t* str
)
510 { return ConvertStr(str
, npos
, wxConvLibc
).data
; }
511 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
512 { return ConvertStr(str
, n
, wxConvLibc
); }
515 // translates position index in wxString to/from index in underlying
517 static size_t PosToImpl(size_t pos
) { return pos
; }
518 static void PosLenToImpl(size_t pos
, size_t len
,
519 size_t *implPos
, size_t *implLen
)
520 { *implPos
= pos
; *implLen
= len
; }
521 static size_t LenToImpl(size_t len
) { return len
; }
522 static size_t PosFromImpl(size_t pos
) { return pos
; }
524 #else // wxUSE_UNICODE_UTF8
526 static wxCharBuffer
ImplStr(const char* str
,
527 const wxMBConv
& conv
= wxConvLibc
)
528 { return ConvertStr(str
, npos
, conv
).data
; }
529 static SubstrBufFromMB
ImplStr(const char* str
, size_t n
,
530 const wxMBConv
& conv
= wxConvLibc
)
531 { return ConvertStr(str
, n
, conv
); }
533 static wxCharBuffer
ImplStr(const wchar_t* str
)
534 { return ConvertStr(str
, npos
, wxMBConvUTF8()).data
; }
535 static SubstrBufFromWC
ImplStr(const wchar_t* str
, size_t n
)
536 { return ConvertStr(str
, n
, wxMBConvUTF8()); }
538 size_t PosToImpl(size_t pos
) const
540 if ( pos
== 0 || pos
== npos
)
543 return (begin() + pos
).impl() - m_impl
.begin();
546 void PosLenToImpl(size_t pos
, size_t len
, size_t *implPos
, size_t *implLen
) const;
548 size_t LenToImpl(size_t len
) const
551 PosLenToImpl(0, len
, &pos
, &len2
);
555 size_t PosFromImpl(size_t pos
) const
557 if ( pos
== 0 || pos
== npos
)
560 return const_iterator(this, m_impl
.begin() + pos
) - begin();
562 #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
566 typedef wxUniChar value_type
;
567 typedef wxUniChar char_type
;
568 typedef wxUniCharRef reference
;
569 typedef wxChar
* pointer
;
570 typedef const wxChar
* const_pointer
;
572 typedef size_t size_type
;
573 typedef wxUniChar const_reference
;
576 #if wxUSE_UNICODE_UTF8
577 // random access is not O(1), as required by Random Access Iterator
578 #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
580 #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
583 #define WX_STR_ITERATOR_TAG void /* dummy type */
586 #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
588 typedef wxStringImpl::iterator_name underlying_iterator; \
590 typedef WX_STR_ITERATOR_TAG iterator_category; \
591 typedef wxUniChar value_type; \
592 typedef int difference_type; \
593 typedef reference_type reference; \
594 typedef pointer_type pointer; \
596 reference operator[](size_t n) const { return *(*this + n); } \
598 iterator_name& operator++() \
599 { wxStringOperations::IncIter(m_cur); return *this; } \
600 iterator_name& operator--() \
601 { wxStringOperations::DecIter(m_cur); return *this; } \
602 iterator_name operator++(int) \
604 iterator_name tmp = *this; \
605 wxStringOperations::IncIter(m_cur); \
608 iterator_name operator--(int) \
610 iterator_name tmp = *this; \
611 wxStringOperations::DecIter(m_cur); \
615 iterator_name& operator+=(int n) \
617 m_cur = wxStringOperations::AddToIter(m_cur, n); \
620 iterator_name& operator+=(size_t n) \
622 m_cur = wxStringOperations::AddToIter(m_cur, (int)n); \
625 iterator_name& operator-=(int n) \
627 m_cur = wxStringOperations::AddToIter(m_cur, -n); \
630 iterator_name& operator-=(size_t n) \
632 m_cur = wxStringOperations::AddToIter(m_cur, -(int)n); \
636 difference_type operator-(const iterator_name& i) const \
637 { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \
639 bool operator==(const iterator_name& i) const \
640 { return m_cur == i.m_cur; } \
641 bool operator!=(const iterator_name& i) const \
642 { return m_cur != i.m_cur; } \
644 bool operator<(const iterator_name& i) const \
645 { return m_cur < i.m_cur; } \
646 bool operator>(const iterator_name& i) const \
647 { return m_cur > i.m_cur; } \
648 bool operator<=(const iterator_name& i) const \
649 { return m_cur <= i.m_cur; } \
650 bool operator>=(const iterator_name& i) const \
651 { return m_cur >= i.m_cur; } \
654 /* for internal wxString use only: */ \
655 underlying_iterator impl() const { return m_cur; } \
657 friend class wxString; \
658 friend class wxCStrData; \
661 underlying_iterator m_cur
663 class WXDLLIMPEXP_FWD_BASE const_iterator
;
665 #if wxUSE_UNICODE_UTF8
666 // NB: In UTF-8 build, (non-const) iterator needs to keep reference
667 // to the underlying wxStringImpl, because UTF-8 is variable-length
668 // encoding and changing the value pointer to by an iterator (using
669 // its operator*) requires calling wxStringImpl::replace() if the old
670 // and new values differ in their encoding's length.
672 // Furthermore, the replace() call may invalid all iterators for the
673 // string, so we have to keep track of outstanding iterators and update
674 // them if replace() happens.
676 // This is implemented by maintaining linked list of iterators for every
677 // string and traversing it in wxUniCharRef::operator=(). Head of the
678 // list is stored in wxString. (FIXME-UTF8)
680 class WXDLLIMPEXP_BASE iterator
682 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
);
686 iterator(const iterator
& i
)
687 : m_cur(i
.m_cur
), m_node(i
.str(), &m_cur
) {}
688 iterator
& operator=(const iterator
& i
)
689 { m_cur
= i
.m_cur
; m_node
.set(i
.str(), &m_cur
); return *this; }
691 reference
operator*()
692 { return wxUniCharRef::CreateForString(m_node
, m_cur
); }
694 iterator
operator+(int n
) const
695 { return iterator(str(), wxStringOperations::AddToIter(m_cur
, n
)); }
696 iterator
operator+(size_t n
) const
697 { return iterator(str(), wxStringOperations::AddToIter(m_cur
, (int)n
)); }
698 iterator
operator-(int n
) const
699 { return iterator(str(), wxStringOperations::AddToIter(m_cur
, -n
)); }
700 iterator
operator-(size_t n
) const
701 { return iterator(str(), wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
704 iterator(wxString
*str
, underlying_iterator ptr
)
705 : m_cur(ptr
), m_node(str
, &m_cur
) {}
707 wxString
* str() const { return wx_const_cast(wxString
*, m_node
.m_str
); }
709 wxStringIteratorNode m_node
;
711 friend class const_iterator
;
714 class WXDLLIMPEXP_BASE const_iterator
716 // NB: reference_type is intentionally value, not reference, the character
717 // may be encoded differently in wxString data:
718 WX_STR_ITERATOR_IMPL(const_iterator
, const wxChar
*, wxUniChar
);
722 const_iterator(const const_iterator
& i
)
723 : m_cur(i
.m_cur
), m_node(i
.str(), &m_cur
) {}
724 const_iterator(const iterator
& i
)
725 : m_cur(i
.m_cur
), m_node(i
.str(), &m_cur
) {}
727 const_iterator
& operator=(const const_iterator
& i
)
728 { m_cur
= i
.m_cur
; m_node
.set(i
.str(), &m_cur
); return *this; }
729 const_iterator
& operator=(const iterator
& i
)
730 { m_cur
= i
.m_cur
; m_node
.set(i
.str(), &m_cur
); return *this; }
732 reference
operator*() const
733 { return wxStringOperations::DecodeChar(m_cur
); }
735 const_iterator
operator+(int n
) const
736 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur
, n
)); }
737 const_iterator
operator+(size_t n
) const
738 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur
, (int)n
)); }
739 const_iterator
operator-(int n
) const
740 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur
, -n
)); }
741 const_iterator
operator-(size_t n
) const
742 { return const_iterator(str(), wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
745 // for internal wxString use only:
746 const_iterator(const wxString
*str
, underlying_iterator ptr
)
747 : m_cur(ptr
), m_node(str
, &m_cur
) {}
749 const wxString
* str() const { return m_node
.m_str
; }
751 wxStringIteratorNode m_node
;
754 size_t IterToImplPos(wxString::iterator i
) const
755 { return wxStringImpl::const_iterator(i
.impl()) - m_impl
.begin(); }
757 #else // !wxUSE_UNICODE_UTF8
759 class WXDLLIMPEXP_BASE iterator
761 WX_STR_ITERATOR_IMPL(iterator
, wxChar
*, wxUniCharRef
);
765 iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
767 reference
operator*()
768 { return wxUniCharRef::CreateForString(m_cur
); }
770 iterator
operator+(int n
) const
771 { return iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
772 iterator
operator+(size_t n
) const
773 { return iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
774 iterator
operator-(int n
) const
775 { return iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
776 iterator
operator-(size_t n
) const
777 { return iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
780 // for internal wxString use only:
781 iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
782 iterator(wxString
*WXUNUSED(str
), underlying_iterator ptr
) : m_cur(ptr
) {}
784 friend class const_iterator
;
787 class WXDLLIMPEXP_BASE const_iterator
789 // NB: reference_type is intentionally value, not reference, the character
790 // may be encoded differently in wxString data:
791 WX_STR_ITERATOR_IMPL(const_iterator
, const wxChar
*, wxUniChar
);
795 const_iterator(const const_iterator
& i
) : m_cur(i
.m_cur
) {}
796 const_iterator(const iterator
& i
) : m_cur(i
.m_cur
) {}
798 reference
operator*() const
799 { return wxStringOperations::DecodeChar(m_cur
); }
801 const_iterator
operator+(int n
) const
802 { return const_iterator(wxStringOperations::AddToIter(m_cur
, n
)); }
803 const_iterator
operator+(size_t n
) const
804 { return const_iterator(wxStringOperations::AddToIter(m_cur
, (int)n
)); }
805 const_iterator
operator-(int n
) const
806 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -n
)); }
807 const_iterator
operator-(size_t n
) const
808 { return const_iterator(wxStringOperations::AddToIter(m_cur
, -(int)n
)); }
811 // for internal wxString use only:
812 const_iterator(underlying_iterator ptr
) : m_cur(ptr
) {}
813 const_iterator(const wxString
*WXUNUSED(str
), underlying_iterator ptr
)
816 #endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
818 #undef WX_STR_ITERATOR_TAG
819 #undef WX_STR_ITERATOR_IMPL
821 friend class iterator
;
822 friend class const_iterator
;
824 template <typename T
>
825 class reverse_iterator_impl
828 typedef T iterator_type
;
830 typedef typename
T::iterator_category iterator_category
;
831 typedef typename
T::value_type value_type
;
832 typedef typename
T::difference_type difference_type
;
833 typedef typename
T::reference reference
;
834 typedef typename
T::pointer
*pointer
;
836 reverse_iterator_impl() {}
837 reverse_iterator_impl(iterator_type i
) : m_cur(i
) {}
838 reverse_iterator_impl(const reverse_iterator_impl
& ri
)
841 iterator_type
base() const { return m_cur
; }
843 reference
operator*() const { return *(m_cur
-1); }
844 reference
operator[](size_t n
) const { return *(*this + n
); }
846 reverse_iterator_impl
& operator++()
847 { --m_cur
; return *this; }
848 reverse_iterator_impl
operator++(int)
849 { reverse_iterator_impl tmp
= *this; --m_cur
; return tmp
; }
850 reverse_iterator_impl
& operator--()
851 { ++m_cur
; return *this; }
852 reverse_iterator_impl
operator--(int)
853 { reverse_iterator_impl tmp
= *this; ++m_cur
; return tmp
; }
855 // NB: explicit <T> in the functions below is to keep BCC 5.5 happy
856 reverse_iterator_impl
operator+(int n
) const
857 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
858 reverse_iterator_impl
operator+(size_t n
) const
859 { return reverse_iterator_impl
<T
>(m_cur
- n
); }
860 reverse_iterator_impl
operator-(int n
) const
861 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
862 reverse_iterator_impl
operator-(size_t n
) const
863 { return reverse_iterator_impl
<T
>(m_cur
+ n
); }
864 reverse_iterator_impl
operator+=(int n
)
865 { m_cur
-= n
; return *this; }
866 reverse_iterator_impl
operator+=(size_t n
)
867 { m_cur
-= n
; return *this; }
868 reverse_iterator_impl
operator-=(int n
)
869 { m_cur
+= n
; return *this; }
870 reverse_iterator_impl
operator-=(size_t n
)
871 { m_cur
+= n
; return *this; }
873 unsigned operator-(const reverse_iterator_impl
& i
) const
874 { return i
.m_cur
- m_cur
; }
876 bool operator==(const reverse_iterator_impl
& ri
) const
877 { return m_cur
== ri
.m_cur
; }
878 bool operator!=(const reverse_iterator_impl
& ri
) const
879 { return !(*this == ri
); }
881 bool operator<(const reverse_iterator_impl
& i
) const
882 { return m_cur
> i
.m_cur
; }
883 bool operator>(const reverse_iterator_impl
& i
) const
884 { return m_cur
< i
.m_cur
; }
885 bool operator<=(const reverse_iterator_impl
& i
) const
886 { return m_cur
>= i
.m_cur
; }
887 bool operator>=(const reverse_iterator_impl
& i
) const
888 { return m_cur
<= i
.m_cur
; }
894 typedef reverse_iterator_impl
<iterator
> reverse_iterator
;
895 typedef reverse_iterator_impl
<const_iterator
> const_reverse_iterator
;
898 // used to transform an expression built using c_str() (and hence of type
899 // wxCStrData) to an iterator into the string
900 static const_iterator
CreateConstIterator(const wxCStrData
& data
)
902 return const_iterator(data
.m_str
,
903 (data
.m_str
->begin() + data
.m_offset
).impl());
906 // in UTF-8 STL build, creation from std::string requires conversion under
907 // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor;
908 // instead we define dummy type that lets us have wxString ctor for creation
909 // from wxStringImpl that couldn't be used by user code (in all other builds,
910 // "standard" ctors can be used):
911 #if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING
912 struct CtorFromStringImplTag
{};
914 wxString(CtorFromStringImplTag
* WXUNUSED(dummy
), const wxStringImpl
& src
)
917 static wxString
FromImpl(const wxStringImpl
& src
)
918 { return wxString((CtorFromStringImplTag
*)NULL
, src
); }
920 #if !wxUSE_STL_BASED_WXSTRING
921 wxString(const wxStringImpl
& src
) : m_impl(src
) { }
922 // else: already defined as wxString(wxStdString) below
924 static wxString
FromImpl(const wxStringImpl
& src
) { return wxString(src
); }
928 // constructors and destructor
929 // ctor for an empty string
933 wxString(const wxString
& stringSrc
) : m_impl(stringSrc
.m_impl
) { }
935 // string containing nRepeat copies of ch
936 wxString(wxUniChar ch
, size_t nRepeat
= 1)
937 { assign(nRepeat
, ch
); }
938 wxString(size_t nRepeat
, wxUniChar ch
)
939 { assign(nRepeat
, ch
); }
940 wxString(wxUniCharRef ch
, size_t nRepeat
= 1)
941 { assign(nRepeat
, ch
); }
942 wxString(size_t nRepeat
, wxUniCharRef ch
)
943 { assign(nRepeat
, ch
); }
944 wxString(char ch
, size_t nRepeat
= 1)
945 { assign(nRepeat
, ch
); }
946 wxString(size_t nRepeat
, char ch
)
947 { assign(nRepeat
, ch
); }
948 wxString(wchar_t ch
, size_t nRepeat
= 1)
949 { assign(nRepeat
, ch
); }
950 wxString(size_t nRepeat
, wchar_t ch
)
951 { assign(nRepeat
, ch
); }
953 // ctors from char* strings:
954 wxString(const char *psz
)
955 : m_impl(ImplStr(psz
)) {}
956 wxString(const char *psz
, const wxMBConv
& conv
)
957 : m_impl(ImplStr(psz
, conv
)) {}
958 wxString(const char *psz
, size_t nLength
)
959 { assign(psz
, nLength
); }
960 wxString(const char *psz
, const wxMBConv
& conv
, size_t nLength
)
962 SubstrBufFromMB
str(ImplStr(psz
, nLength
, conv
));
963 m_impl
.assign(str
.data
, str
.len
);
966 // and unsigned char*:
967 wxString(const unsigned char *psz
)
968 : m_impl(ImplStr((const char*)psz
)) {}
969 wxString(const unsigned char *psz
, const wxMBConv
& conv
)
970 : m_impl(ImplStr((const char*)psz
, conv
)) {}
971 wxString(const unsigned char *psz
, size_t nLength
)
972 { assign((const char*)psz
, nLength
); }
973 wxString(const unsigned char *psz
, const wxMBConv
& conv
, size_t nLength
)
975 SubstrBufFromMB
str(ImplStr((const char*)psz
, nLength
, conv
));
976 m_impl
.assign(str
.data
, str
.len
);
979 // ctors from wchar_t* strings:
980 wxString(const wchar_t *pwz
)
981 : m_impl(ImplStr(pwz
)) {}
982 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
))
983 : m_impl(ImplStr(pwz
)) {}
984 wxString(const wchar_t *pwz
, size_t nLength
)
985 { assign(pwz
, nLength
); }
986 wxString(const wchar_t *pwz
, const wxMBConv
& WXUNUSED(conv
), size_t nLength
)
987 { assign(pwz
, nLength
); }
989 wxString(const wxCharBuffer
& buf
)
990 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
991 wxString(const wxWCharBuffer
& buf
)
992 { assign(buf
.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
994 wxString(const wxCStrData
& cstr
)
995 : m_impl(cstr
.AsString().m_impl
) { }
997 // as we provide both ctors with this signature for both char and unsigned
998 // char string, we need to provide one for wxCStrData to resolve ambiguity
999 wxString(const wxCStrData
& cstr
, size_t nLength
)
1000 : m_impl(cstr
.AsString().Mid(0, nLength
).m_impl
) {}
1002 // and because wxString is convertible to wxCStrData and const wxChar *
1003 // we also need to provide this one
1004 wxString(const wxString
& str
, size_t nLength
)
1005 { assign(str
, nLength
); }
1007 // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
1008 // implicit conversions from std::string to wxString and vice verse as this
1009 // allows to use the same strings in non-GUI and GUI code, however we don't
1010 // want to unconditionally add this ctor as it would make wx lib dependent on
1011 // libstdc++ on some Linux versions which is bad, so instead we ask the
1012 // client code to define this wxUSE_STD_STRING symbol if they need it
1013 #if wxUSE_STD_STRING
1014 #if wxUSE_UNICODE_WCHAR
1015 wxString(const wxStdWideString
& str
) : m_impl(str
) {}
1016 #else // UTF-8 or ANSI
1017 wxString(const wxStdWideString
& str
)
1018 { assign(str
.c_str(), str
.length()); }
1021 #if !wxUSE_UNICODE // ANSI build
1022 // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
1023 wxString(const std::string
& str
) : m_impl(str
) {}
1025 wxString(const std::string
& str
)
1026 { assign(str
.c_str(), str
.length()); }
1028 #endif // wxUSE_STD_STRING
1030 // Unlike ctor from std::string, we provide conversion to std::string only
1031 // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default),
1032 // because it conflicts with operator const char/wchar_t*:
1034 #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
1035 // wxStringImpl is std::string in the encoding we want
1036 operator const wxStdWideString
&() const { return m_impl
; }
1038 // wxStringImpl is either not std::string or needs conversion
1039 operator wxStdWideString() const
1040 // FIXME-UTF8: broken for embedded NULs
1041 { return wxStdWideString(wc_str()); }
1044 #if (!wxUSE_UNICODE || wxUSE_UTF8_LOCALE_ONLY) && wxUSE_STL_BASED_WXSTRING
1045 // wxStringImpl is std::string in the encoding we want
1046 operator const std::string
&() const { return m_impl
; }
1048 // wxStringImpl is either not std::string or needs conversion
1049 operator std::string() const
1050 // FIXME-UTF8: broken for embedded NULs
1051 { return std::string(mb_str()); }
1055 // first valid index position
1056 const_iterator
begin() const { return const_iterator(this, m_impl
.begin()); }
1057 iterator
begin() { return iterator(this, m_impl
.begin()); }
1058 // position one after the last valid one
1059 const_iterator
end() const { return const_iterator(this, m_impl
.end()); }
1060 iterator
end() { return iterator(this, m_impl
.end()); }
1062 // first element of the reversed string
1063 const_reverse_iterator
rbegin() const
1064 { return const_reverse_iterator(end()); }
1065 reverse_iterator
rbegin()
1066 { return reverse_iterator(end()); }
1067 // one beyond the end of the reversed string
1068 const_reverse_iterator
rend() const
1069 { return const_reverse_iterator(begin()); }
1070 reverse_iterator
rend()
1071 { return reverse_iterator(begin()); }
1073 // std::string methods:
1074 #if wxUSE_UNICODE_UTF8
1075 size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
1077 size_t length() const { return m_impl
.length(); }
1080 size_type
size() const { return length(); }
1081 size_type
max_size() const { return npos
; }
1083 bool empty() const { return m_impl
.empty(); }
1085 size_type
capacity() const { return m_impl
.capacity(); } // FIXME-UTF8
1086 void reserve(size_t sz
) { m_impl
.reserve(sz
); } // FIXME-UTF8
1088 void resize(size_t nSize
, wxUniChar ch
= wxT('\0'))
1090 const size_t len
= length();
1094 #if wxUSE_UNICODE_UTF8
1097 // we can't use wxStringImpl::resize() for truncating the string as it
1098 // counts in bytes, not characters
1103 // we also can't use (presumably more efficient) resize() if we have to
1104 // append characters taking more than one byte
1105 if ( !ch
.IsAscii() )
1106 append(nSize
- len
, ch
);
1108 #endif // wxUSE_UNICODE_UTF8
1109 m_impl
.resize(nSize
, (wxStringCharType
)ch
);
1112 wxString
substr(size_t nStart
= 0, size_t nLen
= npos
) const
1115 PosLenToImpl(nStart
, nLen
, &pos
, &len
);
1116 return FromImpl(m_impl
.substr(pos
, len
));
1119 // generic attributes & operations
1120 // as standard strlen()
1121 size_t Len() const { return length(); }
1122 // string contains any characters?
1123 bool IsEmpty() const { return empty(); }
1124 // empty string is "false", so !str will return true
1125 bool operator!() const { return empty(); }
1126 // truncate the string to given length
1127 wxString
& Truncate(size_t uiLen
);
1128 // empty string contents
1133 wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
1135 // empty the string and free memory
1138 wxString
tmp(wxEmptyString
);
1143 // Is an ascii value
1144 bool IsAscii() const;
1146 bool IsNumber() const;
1148 bool IsWord() const;
1150 // data access (all indexes are 0 based)
1152 wxUniChar
at(size_t n
) const
1153 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1154 wxUniChar
GetChar(size_t n
) const
1156 // read/write access
1157 wxUniCharRef
at(size_t n
)
1158 { return *(begin() + n
); } // FIXME-UTF8: optimize?
1159 wxUniCharRef
GetWritableChar(size_t n
)
1162 void SetChar(size_t n
, wxUniChar ch
)
1165 // get last character
1166 wxUniChar
Last() const
1168 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1172 // get writable last character
1175 wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1180 Note that we we must define all of the overloads below to avoid
1181 ambiguity when using str[0].
1183 wxUniChar
operator[](int n
) const
1185 wxUniChar
operator[](long n
) const
1187 wxUniChar
operator[](size_t n
) const
1189 #ifndef wxSIZE_T_IS_UINT
1190 wxUniChar
operator[](unsigned int n
) const
1192 #endif // size_t != unsigned int
1194 // operator versions of GetWriteableChar()
1195 wxUniCharRef
operator[](int n
)
1197 wxUniCharRef
operator[](long n
)
1199 wxUniCharRef
operator[](size_t n
)
1201 #ifndef wxSIZE_T_IS_UINT
1202 wxUniCharRef
operator[](unsigned int n
)
1204 #endif // size_t != unsigned int
1206 // explicit conversion to C string (use this with printf()!)
1207 wxCStrData
c_str() const { return wxCStrData(this); }
1208 wxCStrData
data() const { return c_str(); }
1210 // implicit conversion to C string
1211 operator wxCStrData() const { return c_str(); }
1213 // the first two operators conflict with operators for conversion to
1214 // std::string and they must be disabled in STL build; the next one only
1215 // makes sense if conversions to char* are also defined and not defining it
1216 // in STL build also helps us to get more clear error messages for the code
1217 // which relies on implicit conversion to char* in STL build
1219 operator const char*() const { return c_str(); }
1220 operator const wchar_t*() const { return c_str(); }
1222 // implicit conversion to untyped pointer for compatibility with previous
1223 // wxWidgets versions: this is the same as conversion to const char * so it
1225 operator const void*() const { return c_str(); }
1228 // identical to c_str(), for MFC compatibility
1229 const wxCStrData
GetData() const { return c_str(); }
1231 // explicit conversion to C string in internal representation (char*,
1232 // wchar_t*, UTF-8-encoded char*, depending on the build):
1233 const wxStringCharType
*wx_str() const { return m_impl
.c_str(); }
1235 // conversion to *non-const* multibyte or widestring buffer; modifying
1236 // returned buffer won't affect the string, these methods are only useful
1237 // for passing values to const-incorrect functions
1238 wxWritableCharBuffer
char_str(const wxMBConv
& conv
= wxConvLibc
) const
1239 { return mb_str(conv
); }
1240 wxWritableWCharBuffer
wchar_str() const { return wc_str(); }
1242 // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
1243 // converting numbers or strings which are certain not to contain special
1244 // chars (typically system functions, X atoms, environment variables etc.)
1246 // the behaviour of these functions with the strings containing anything
1247 // else than 7 bit ASCII characters is undefined, use at your own risk.
1249 static wxString
FromAscii(const char *ascii
, size_t len
);
1250 static wxString
FromAscii(const char *ascii
);
1251 static wxString
FromAscii(char ascii
);
1252 const wxCharBuffer
ToAscii() const;
1254 static wxString
FromAscii(const char *ascii
) { return wxString( ascii
); }
1255 static wxString
FromAscii(const char *ascii
, size_t len
)
1256 { return wxString( ascii
, len
); }
1257 static wxString
FromAscii(char ascii
) { return wxString( ascii
); }
1258 const char *ToAscii() const { return c_str(); }
1259 #endif // Unicode/!Unicode
1261 // also provide unsigned char overloads as signed/unsigned doesn't matter
1262 // for 7 bit ASCII characters
1263 static wxString
FromAscii(const unsigned char *ascii
)
1264 { return FromAscii((const char *)ascii
); }
1265 static wxString
FromAscii(const unsigned char *ascii
, size_t len
)
1266 { return FromAscii((const char *)ascii
, len
); }
1268 // conversion to/from UTF-8:
1269 #if wxUSE_UNICODE_UTF8
1270 static wxString
FromUTF8(const char *utf8
)
1273 return wxEmptyString
;
1275 wxASSERT( wxStringOperations::IsValidUtf8String(utf8
) );
1276 return FromImpl(wxStringImpl(utf8
));
1278 static wxString
FromUTF8(const char *utf8
, size_t len
)
1281 return wxEmptyString
;
1283 return FromUTF8(utf8
);
1285 wxASSERT( wxStringOperations::IsValidUtf8String(utf8
, len
) );
1286 return FromImpl(wxStringImpl(utf8
, len
));
1288 const char* utf8_str() const { return wx_str(); }
1289 const char* ToUTF8() const { return wx_str(); }
1290 #elif wxUSE_UNICODE_WCHAR
1291 static wxString
FromUTF8(const char *utf8
)
1292 { return wxString(utf8
, wxMBConvUTF8()); }
1293 static wxString
FromUTF8(const char *utf8
, size_t len
)
1294 { return wxString(utf8
, wxMBConvUTF8(), len
); }
1295 const wxCharBuffer
utf8_str() const { return mb_str(wxMBConvUTF8()); }
1296 const wxCharBuffer
ToUTF8() const { return utf8_str(); }
1298 static wxString
FromUTF8(const char *utf8
)
1299 { return wxString(wxMBConvUTF8().cMB2WC(utf8
)); }
1300 static wxString
FromUTF8(const char *utf8
, size_t len
)
1303 wxWCharBuffer
buf(wxMBConvUTF8().cMB2WC(utf8
, len
== npos
? wxNO_LEN
: len
, &wlen
));
1304 return wxString(buf
.data(), wlen
);
1306 const wxCharBuffer
utf8_str() const
1307 { return wxMBConvUTF8().cWC2MB(wc_str()); }
1308 const wxCharBuffer
ToUTF8() const { return utf8_str(); }
1311 // functions for storing binary data in wxString:
1313 static wxString
From8BitData(const char *data
, size_t len
)
1314 { return wxString(data
, wxConvISO8859_1
, len
); }
1315 // version for NUL-terminated data:
1316 static wxString
From8BitData(const char *data
)
1317 { return wxString(data
, wxConvISO8859_1
); }
1318 const wxCharBuffer
To8BitData() const { return mb_str(wxConvISO8859_1
); }
1320 static wxString
From8BitData(const char *data
, size_t len
)
1321 { return wxString(data
, len
); }
1322 // version for NUL-terminated data:
1323 static wxString
From8BitData(const char *data
)
1324 { return wxString(data
); }
1325 const char *To8BitData() const { return c_str(); }
1326 #endif // Unicode/ANSI
1328 // conversions with (possible) format conversions: have to return a
1329 // buffer with temporary data
1331 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
1332 // return an ANSI (multibyte) string, wc_str() to return a wide string and
1333 // fn_str() to return a string which should be used with the OS APIs
1334 // accepting the file names. The return value is always the same, but the
1335 // type differs because a function may either return pointer to the buffer
1336 // directly or have to use intermediate buffer for translation.
1339 #if wxUSE_UTF8_LOCALE_ONLY
1340 const char* mb_str() const { return wx_str(); }
1341 const wxCharBuffer
mb_str(const wxMBConv
& conv
) const;
1343 const wxCharBuffer
mb_str(const wxMBConv
& conv
= wxConvLibc
) const;
1346 const wxWX2MBbuf
mbc_str() const { return mb_str(*wxConvCurrent
); }
1348 #if wxUSE_UNICODE_WCHAR
1349 const wxChar
* wc_str() const { return wx_str(); }
1350 #elif wxUSE_UNICODE_UTF8
1351 const wxWCharBuffer
wc_str() const;
1353 // for compatibility with !wxUSE_UNICODE version
1354 const wxWX2WCbuf
wc_str(const wxMBConv
& WXUNUSED(conv
)) const
1355 { return wc_str(); }
1358 const wxCharBuffer
fn_str() const { return mb_str(wxConvFile
); }
1360 const wxWX2WCbuf
fn_str() const { return wc_str(); }
1361 #endif // wxMBFILES/!wxMBFILES
1364 const wxChar
* mb_str() const { return wx_str(); }
1366 // for compatibility with wxUSE_UNICODE version
1367 const wxChar
* mb_str(const wxMBConv
& WXUNUSED(conv
)) const { return wx_str(); }
1369 const wxWX2MBbuf
mbc_str() const { return mb_str(); }
1372 const wxWCharBuffer
wc_str(const wxMBConv
& conv
= wxConvLibc
) const;
1373 #endif // wxUSE_WCHAR_T
1375 const wxCharBuffer
fn_str() const { return wxConvFile
.cWC2WX( wc_str( wxConvLocal
) ); }
1377 const wxChar
* fn_str() const { return c_str(); }
1379 #endif // Unicode/ANSI
1381 // overloaded assignment
1382 // from another wxString
1383 wxString
& operator=(const wxString
& stringSrc
)
1384 { m_impl
= stringSrc
.m_impl
; return *this; }
1385 wxString
& operator=(const wxCStrData
& cstr
)
1386 { return *this = cstr
.AsString(); }
1388 wxString
& operator=(wxUniChar ch
)
1389 { m_impl
= wxStringOperations::EncodeChar(ch
); return *this; }
1390 wxString
& operator=(wxUniCharRef ch
)
1391 { return operator=((wxUniChar
)ch
); }
1392 wxString
& operator=(char ch
)
1393 { return operator=(wxUniChar(ch
)); }
1394 wxString
& operator=(unsigned char ch
)
1395 { return operator=(wxUniChar(ch
)); }
1396 wxString
& operator=(wchar_t ch
)
1397 { return operator=(wxUniChar(ch
)); }
1398 // from a C string - STL probably will crash on NULL,
1399 // so we need to compensate in that case
1400 #if wxUSE_STL_BASED_WXSTRING
1401 wxString
& operator=(const char *psz
)
1402 { if (psz
) m_impl
= ImplStr(psz
); else Clear(); return *this; }
1403 wxString
& operator=(const wchar_t *pwz
)
1404 { if (pwz
) m_impl
= ImplStr(pwz
); else Clear(); return *this; }
1406 wxString
& operator=(const char *psz
)
1407 { m_impl
= ImplStr(psz
); return *this; }
1408 wxString
& operator=(const wchar_t *pwz
)
1409 { m_impl
= ImplStr(pwz
); return *this; }
1411 wxString
& operator=(const unsigned char *psz
)
1412 { return operator=((const char*)psz
); }
1414 // from wxWCharBuffer
1415 wxString
& operator=(const wxWCharBuffer
& s
)
1416 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1417 // from wxCharBuffer
1418 wxString
& operator=(const wxCharBuffer
& s
)
1419 { return operator=(s
.data()); } // FIXME-UTF8: fix for embedded NULs
1421 // string concatenation
1422 // in place concatenation
1424 Concatenate and return the result. Note that the left to right
1425 associativity of << allows to write things like "str << str1 << str2
1426 << ..." (unlike with +=)
1429 wxString
& operator<<(const wxString
& s
)
1431 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1432 wxASSERT_MSG( s
.IsValid(),
1433 _T("did you forget to call UngetWriteBuf()?") );
1439 // string += C string
1440 wxString
& operator<<(const char *psz
)
1441 { append(psz
); return *this; }
1442 wxString
& operator<<(const wchar_t *pwz
)
1443 { append(pwz
); return *this; }
1444 wxString
& operator<<(const wxCStrData
& psz
)
1445 { append(psz
.AsString()); return *this; }
1447 wxString
& operator<<(wxUniChar ch
) { append(1, ch
); return *this; }
1448 wxString
& operator<<(wxUniCharRef ch
) { append(1, ch
); return *this; }
1449 wxString
& operator<<(char ch
) { append(1, ch
); return *this; }
1450 wxString
& operator<<(unsigned char ch
) { append(1, ch
); return *this; }
1451 wxString
& operator<<(wchar_t ch
) { append(1, ch
); return *this; }
1453 // string += buffer (i.e. from wxGetString)
1454 wxString
& operator<<(const wxWCharBuffer
& s
)
1455 { return operator<<((const wchar_t *)s
); }
1456 wxString
& operator<<(const wxCharBuffer
& s
)
1457 { return operator<<((const char *)s
); }
1459 // string += C string
1460 wxString
& Append(const wxString
& s
)
1462 // test for empty() to share the string if possible
1469 wxString
& Append(const char* psz
)
1470 { append(psz
); return *this; }
1471 wxString
& Append(const wchar_t* pwz
)
1472 { append(pwz
); return *this; }
1473 wxString
& Append(const wxCStrData
& psz
)
1474 { append(psz
); return *this; }
1475 wxString
& Append(const wxCharBuffer
& psz
)
1476 { append(psz
); return *this; }
1477 wxString
& Append(const wxWCharBuffer
& psz
)
1478 { append(psz
); return *this; }
1479 // append count copies of given character
1480 wxString
& Append(wxUniChar ch
, size_t count
= 1u)
1481 { append(count
, ch
); return *this; }
1482 wxString
& Append(wxUniCharRef ch
, size_t count
= 1u)
1483 { append(count
, ch
); return *this; }
1484 wxString
& Append(char ch
, size_t count
= 1u)
1485 { append(count
, ch
); return *this; }
1486 wxString
& Append(unsigned char ch
, size_t count
= 1u)
1487 { append(count
, ch
); return *this; }
1488 wxString
& Append(wchar_t ch
, size_t count
= 1u)
1489 { append(count
, ch
); return *this; }
1490 wxString
& Append(const char* psz
, size_t nLen
)
1491 { append(psz
, nLen
); return *this; }
1492 wxString
& Append(const wchar_t* pwz
, size_t nLen
)
1493 { append(pwz
, nLen
); return *this; }
1495 // prepend a string, return the string itself
1496 wxString
& Prepend(const wxString
& str
)
1497 { *this = str
+ *this; return *this; }
1499 // non-destructive concatenation
1501 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
,
1502 const wxString
& string2
);
1503 // string with a single char
1504 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
1505 // char with a string
1506 friend wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
1507 // string with C string
1508 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1510 friend wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
,
1511 const wchar_t *pwz
);
1512 // C string with string
1513 friend wxString WXDLLIMPEXP_BASE
operator+(const char *psz
,
1514 const wxString
& string
);
1515 friend wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
,
1516 const wxString
& string
);
1518 // stream-like functions
1519 // insert an int into string
1520 wxString
& operator<<(int i
)
1521 { return (*this) << Format(_T("%d"), i
); }
1522 // insert an unsigned int into string
1523 wxString
& operator<<(unsigned int ui
)
1524 { return (*this) << Format(_T("%u"), ui
); }
1525 // insert a long into string
1526 wxString
& operator<<(long l
)
1527 { return (*this) << Format(_T("%ld"), l
); }
1528 // insert an unsigned long into string
1529 wxString
& operator<<(unsigned long ul
)
1530 { return (*this) << Format(_T("%lu"), ul
); }
1531 #if defined wxLongLong_t && !defined wxLongLongIsLong
1532 // insert a long long if they exist and aren't longs
1533 wxString
& operator<<(wxLongLong_t ll
)
1535 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("d");
1536 return (*this) << Format(fmt
, ll
);
1538 // insert an unsigned long long
1539 wxString
& operator<<(wxULongLong_t ull
)
1541 const wxChar
*fmt
= _T("%") wxLongLongFmtSpec
_T("u");
1542 return (*this) << Format(fmt
, ull
);
1545 // insert a float into string
1546 wxString
& operator<<(float f
)
1547 { return (*this) << Format(_T("%f"), f
); }
1548 // insert a double into string
1549 wxString
& operator<<(double d
)
1550 { return (*this) << Format(_T("%g"), d
); }
1552 // string comparison
1553 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
1554 int Cmp(const char *psz
) const
1555 { return compare(psz
); }
1556 int Cmp(const wchar_t *pwz
) const
1557 { return compare(pwz
); }
1558 int Cmp(const wxString
& s
) const
1559 { return compare(s
); }
1560 int Cmp(const wxCStrData
& s
) const
1561 { return compare(s
); }
1562 int Cmp(const wxCharBuffer
& s
) const
1563 { return compare(s
); }
1564 int Cmp(const wxWCharBuffer
& s
) const
1565 { return compare(s
); }
1566 // same as Cmp() but not case-sensitive
1567 int CmpNoCase(const wxString
& s
) const;
1568 // test for the string equality, either considering case or not
1569 // (if compareWithCase then the case matters)
1570 bool IsSameAs(const wxString
& str
, bool compareWithCase
= true) const
1571 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1572 bool IsSameAs(const char *str
, bool compareWithCase
= true) const
1573 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1574 bool IsSameAs(const wchar_t *str
, bool compareWithCase
= true) const
1575 { return (compareWithCase
? Cmp(str
) : CmpNoCase(str
)) == 0; }
1576 bool IsSameAs(const wxCStrData
& str
, bool compareWithCase
= true) const
1577 { return IsSameAs(str
.AsString(), compareWithCase
); }
1578 bool IsSameAs(const wxCharBuffer
& str
, bool compareWithCase
= true) const
1579 { return IsSameAs(str
.data(), compareWithCase
); }
1580 bool IsSameAs(const wxWCharBuffer
& str
, bool compareWithCase
= true) const
1581 { return IsSameAs(str
.data(), compareWithCase
); }
1582 // comparison with a single character: returns true if equal
1583 bool IsSameAs(wxUniChar c
, bool compareWithCase
= true) const;
1584 // FIXME-UTF8: remove these overloads
1585 bool IsSameAs(wxUniCharRef c
, bool compareWithCase
= true) const
1586 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1587 bool IsSameAs(char c
, bool compareWithCase
= true) const
1588 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1589 bool IsSameAs(unsigned char c
, bool compareWithCase
= true) const
1590 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1591 bool IsSameAs(wchar_t c
, bool compareWithCase
= true) const
1592 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1593 bool IsSameAs(int c
, bool compareWithCase
= true) const
1594 { return IsSameAs(wxUniChar(c
), compareWithCase
); }
1596 // simple sub-string extraction
1597 // return substring starting at nFirst of length nCount (or till the end
1598 // if nCount = default value)
1599 wxString
Mid(size_t nFirst
, size_t nCount
= npos
) const;
1601 // operator version of Mid()
1602 wxString
operator()(size_t start
, size_t len
) const
1603 { return Mid(start
, len
); }
1605 // check if the string starts with the given prefix and return the rest
1606 // of the string in the provided pointer if it is not NULL; otherwise
1608 bool StartsWith(const wxString
& prefix
, wxString
*rest
= NULL
) const;
1609 // check if the string ends with the given suffix and return the
1610 // beginning of the string before the suffix in the provided pointer if
1611 // it is not NULL; otherwise return false
1612 bool EndsWith(const wxString
& suffix
, wxString
*rest
= NULL
) const;
1614 // get first nCount characters
1615 wxString
Left(size_t nCount
) const;
1616 // get last nCount characters
1617 wxString
Right(size_t nCount
) const;
1618 // get all characters before the first occurance of ch
1619 // (returns the whole string if ch not found)
1620 wxString
BeforeFirst(wxUniChar ch
) const;
1621 // get all characters before the last occurence of ch
1622 // (returns empty string if ch not found)
1623 wxString
BeforeLast(wxUniChar ch
) const;
1624 // get all characters after the first occurence of ch
1625 // (returns empty string if ch not found)
1626 wxString
AfterFirst(wxUniChar ch
) const;
1627 // get all characters after the last occurence of ch
1628 // (returns the whole string if ch not found)
1629 wxString
AfterLast(wxUniChar ch
) const;
1631 // for compatibility only, use more explicitly named functions above
1632 wxString
Before(wxUniChar ch
) const { return BeforeLast(ch
); }
1633 wxString
After(wxUniChar ch
) const { return AfterFirst(ch
); }
1636 // convert to upper case in place, return the string itself
1637 wxString
& MakeUpper();
1638 // convert to upper case, return the copy of the string
1639 // Here's something to remember: BC++ doesn't like returns in inlines.
1640 wxString
Upper() const ;
1641 // convert to lower case in place, return the string itself
1642 wxString
& MakeLower();
1643 // convert to lower case, return the copy of the string
1644 wxString
Lower() const ;
1646 // trimming/padding whitespace (either side) and truncating
1647 // remove spaces from left or from right (default) side
1648 wxString
& Trim(bool bFromRight
= true);
1649 // add nCount copies chPad in the beginning or at the end (default)
1650 wxString
& Pad(size_t nCount
, wxUniChar chPad
= wxT(' '), bool bFromRight
= true);
1652 // searching and replacing
1653 // searching (return starting index, or -1 if not found)
1654 int Find(wxUniChar ch
, bool bFromEnd
= false) const; // like strchr/strrchr
1655 int Find(wxUniCharRef ch
, bool bFromEnd
= false) const
1656 { return Find(wxUniChar(ch
), bFromEnd
); }
1657 int Find(char ch
, bool bFromEnd
= false) const
1658 { return Find(wxUniChar(ch
), bFromEnd
); }
1659 int Find(unsigned char ch
, bool bFromEnd
= false) const
1660 { return Find(wxUniChar(ch
), bFromEnd
); }
1661 int Find(wchar_t ch
, bool bFromEnd
= false) const
1662 { return Find(wxUniChar(ch
), bFromEnd
); }
1663 // searching (return starting index, or -1 if not found)
1664 int Find(const wxString
& sub
) const // like strstr
1666 size_type idx
= find(sub
);
1667 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1669 int Find(const char *sub
) const // like strstr
1671 size_type idx
= find(sub
);
1672 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1674 int Find(const wchar_t *sub
) const // like strstr
1676 size_type idx
= find(sub
);
1677 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1680 int Find(const wxCStrData
& sub
) const
1681 { return Find(sub
.AsString()); }
1682 int Find(const wxCharBuffer
& sub
) const
1683 { return Find(sub
.data()); }
1684 int Find(const wxWCharBuffer
& sub
) const
1685 { return Find(sub
.data()); }
1687 // replace first (or all of bReplaceAll) occurences of substring with
1688 // another string, returns the number of replacements made
1689 size_t Replace(const wxString
& strOld
,
1690 const wxString
& strNew
,
1691 bool bReplaceAll
= true);
1693 // check if the string contents matches a mask containing '*' and '?'
1694 bool Matches(const wxString
& mask
) const;
1696 // conversion to numbers: all functions return true only if the whole
1697 // string is a number and put the value of this number into the pointer
1698 // provided, the base is the numeric base in which the conversion should be
1699 // done and must be comprised between 2 and 36 or be 0 in which case the
1700 // standard C rules apply (leading '0' => octal, "0x" => hex)
1701 // convert to a signed integer
1702 bool ToLong(long *val
, int base
= 10) const;
1703 // convert to an unsigned integer
1704 bool ToULong(unsigned long *val
, int base
= 10) const;
1705 // convert to wxLongLong
1706 #if defined(wxLongLong_t)
1707 bool ToLongLong(wxLongLong_t
*val
, int base
= 10) const;
1708 // convert to wxULongLong
1709 bool ToULongLong(wxULongLong_t
*val
, int base
= 10) const;
1710 #endif // wxLongLong_t
1711 // convert to a double
1712 bool ToDouble(double *val
) const;
1715 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1716 // formatted input/output
1717 // as sprintf(), returns the number of characters written or < 0 on error
1718 // (take 'this' into account in attribute parameter count)
1719 // int Printf(const wxString& format, ...);
1720 WX_DEFINE_VARARG_FUNC(int, Printf
, 1, (const wxFormatString
&),
1721 DoPrintfWchar
, DoPrintfUtf8
)
1723 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1724 WX_VARARG_WATCOM_WORKAROUND(int, Printf
, 1, (const wxString
&),
1725 (wxFormatString(f1
)));
1726 WX_VARARG_WATCOM_WORKAROUND(int, Printf
, 1, (const wxCStrData
&),
1727 (wxFormatString(f1
)));
1728 WX_VARARG_WATCOM_WORKAROUND(int, Printf
, 1, (const char*),
1729 (wxFormatString(f1
)));
1730 WX_VARARG_WATCOM_WORKAROUND(int, Printf
, 1, (const wchar_t*),
1731 (wxFormatString(f1
)));
1733 #endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
1734 // as vprintf(), returns the number of characters written or < 0 on error
1735 int PrintfV(const wxString
& format
, va_list argptr
);
1737 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1738 // returns the string containing the result of Printf() to it
1739 // static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1;
1740 WX_DEFINE_VARARG_FUNC(static wxString
, Format
, 1, (const wxFormatString
&),
1741 DoFormatWchar
, DoFormatUtf8
)
1743 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1744 WX_VARARG_WATCOM_WORKAROUND(static wxString
, Format
, 1, (const wxString
&),
1745 (wxFormatString(f1
)));
1746 WX_VARARG_WATCOM_WORKAROUND(static wxString
, Format
, 1, (const wxCStrData
&),
1747 (wxFormatString(f1
)));
1748 WX_VARARG_WATCOM_WORKAROUND(static wxString
, Format
, 1, (const char*),
1749 (wxFormatString(f1
)));
1750 WX_VARARG_WATCOM_WORKAROUND(static wxString
, Format
, 1, (const wchar_t*),
1751 (wxFormatString(f1
)));
1754 // the same as above, but takes a va_list
1755 static wxString
FormatV(const wxString
& format
, va_list argptr
);
1757 // raw access to string memory
1758 // ensure that string has space for at least nLen characters
1759 // only works if the data of this string is not shared
1760 bool Alloc(size_t nLen
) { reserve(nLen
); /*return capacity() >= nLen;*/ return true; }
1761 // minimize the string's memory
1762 // only works if the data of this string is not shared
1764 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
1765 // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
1767 // get writable buffer of at least nLen bytes. Unget() *must* be called
1768 // a.s.a.p. to put string back in a reasonable state!
1769 wxDEPRECATED( wxStringCharType
*GetWriteBuf(size_t nLen
) );
1770 // call this immediately after GetWriteBuf() has been used
1771 wxDEPRECATED( void UngetWriteBuf() );
1772 wxDEPRECATED( void UngetWriteBuf(size_t nLen
) );
1773 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING && wxUSE_UNICODE_UTF8
1775 // wxWidgets version 1 compatibility functions
1778 wxString
SubString(size_t from
, size_t to
) const
1779 { return Mid(from
, (to
- from
+ 1)); }
1780 // values for second parameter of CompareTo function
1781 enum caseCompare
{exact
, ignoreCase
};
1782 // values for first parameter of Strip function
1783 enum stripType
{leading
= 0x1, trailing
= 0x2, both
= 0x3};
1785 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1787 // (take 'this' into account in attribute parameter count)
1788 // int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
1789 WX_DEFINE_VARARG_FUNC(int, sprintf
, 1, (const wxFormatString
&),
1790 DoPrintfWchar
, DoPrintfUtf8
)
1792 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1793 WX_VARARG_WATCOM_WORKAROUND(int, sprintf
, 1, (const wxString
&),
1794 (wxFormatString(f1
)));
1795 WX_VARARG_WATCOM_WORKAROUND(int, sprintf
, 1, (const wxCStrData
&),
1796 (wxFormatString(f1
)));
1797 WX_VARARG_WATCOM_WORKAROUND(int, sprintf
, 1, (const char*),
1798 (wxFormatString(f1
)));
1799 WX_VARARG_WATCOM_WORKAROUND(int, sprintf
, 1, (const wchar_t*),
1800 (wxFormatString(f1
)));
1802 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
1805 inline int CompareTo(const wxChar
* psz
, caseCompare cmp
= exact
) const
1806 { return cmp
== exact
? Cmp(psz
) : CmpNoCase(psz
); }
1809 size_t Length() const { return length(); }
1810 // Count the number of characters
1811 int Freq(wxUniChar ch
) const;
1813 void LowerCase() { MakeLower(); }
1815 void UpperCase() { MakeUpper(); }
1816 // use Trim except that it doesn't change this string
1817 wxString
Strip(stripType w
= trailing
) const;
1819 // use Find (more general variants not yet supported)
1820 size_t Index(const wxChar
* psz
) const { return Find(psz
); }
1821 size_t Index(wxUniChar ch
) const { return Find(ch
); }
1823 wxString
& Remove(size_t pos
) { return Truncate(pos
); }
1824 wxString
& RemoveLast(size_t n
= 1) { return Truncate(length() - n
); }
1826 wxString
& Remove(size_t nStart
, size_t nLen
)
1827 { return (wxString
&)erase( nStart
, nLen
); }
1830 int First( wxUniChar ch
) const { return Find(ch
); }
1831 int First( wxUniCharRef ch
) const { return Find(ch
); }
1832 int First( char ch
) const { return Find(ch
); }
1833 int First( unsigned char ch
) const { return Find(ch
); }
1834 int First( wchar_t ch
) const { return Find(ch
); }
1835 int First( const wxString
& str
) const { return Find(str
); }
1836 int Last( wxUniChar ch
) const { return Find(ch
, true); }
1837 bool Contains(const wxString
& str
) const { return Find(str
) != wxNOT_FOUND
; }
1840 bool IsNull() const { return empty(); }
1842 // std::string compatibility functions
1844 // take nLen chars starting at nPos
1845 wxString(const wxString
& str
, size_t nPos
, size_t nLen
)
1846 { assign(str
, nPos
, nLen
); }
1847 // take all characters from first to last
1848 wxString(const_iterator first
, const_iterator last
)
1849 : m_impl(first
.impl(), last
.impl()) { }
1850 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1851 // the 2 overloads below are for compatibility with the existing code using
1852 // pointers instead of iterators
1853 wxString(const char *first
, const char *last
)
1855 SubstrBufFromMB
str(ImplStr(first
, last
- first
));
1856 m_impl
.assign(str
.data
, str
.len
);
1858 wxString(const wchar_t *first
, const wchar_t *last
)
1860 SubstrBufFromWC
str(ImplStr(first
, last
- first
));
1861 m_impl
.assign(str
.data
, str
.len
);
1863 // and this one is needed to compile code adding offsets to c_str() result
1864 wxString(const wxCStrData
& first
, const wxCStrData
& last
)
1865 : m_impl(CreateConstIterator(first
).impl(),
1866 CreateConstIterator(last
).impl())
1868 wxASSERT_MSG( first
.m_str
== last
.m_str
,
1869 _T("pointers must be into the same string") );
1871 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1873 // lib.string.modifiers
1874 // append elements str[pos], ..., str[pos+n]
1875 wxString
& append(const wxString
& str
, size_t pos
, size_t n
)
1878 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1879 m_impl
.append(str
.m_impl
, from
, len
);
1883 wxString
& append(const wxString
& str
)
1884 { m_impl
.append(str
.m_impl
); return *this; }
1885 // append first n (or all if n == npos) characters of sz
1886 wxString
& append(const char *sz
)
1887 { m_impl
.append(ImplStr(sz
)); return *this; }
1888 wxString
& append(const wchar_t *sz
)
1889 { m_impl
.append(ImplStr(sz
)); return *this; }
1890 wxString
& append(const char *sz
, size_t n
)
1892 SubstrBufFromMB
str(ImplStr(sz
, n
));
1893 m_impl
.append(str
.data
, str
.len
);
1896 wxString
& append(const wchar_t *sz
, size_t n
)
1898 SubstrBufFromWC
str(ImplStr(sz
, n
));
1899 m_impl
.append(str
.data
, str
.len
);
1903 wxString
& append(const wxCStrData
& str
)
1904 { return append(str
.AsString()); }
1905 wxString
& append(const wxCharBuffer
& str
)
1906 { return append(str
.data()); }
1907 wxString
& append(const wxWCharBuffer
& str
)
1908 { return append(str
.data()); }
1910 // append n copies of ch
1911 wxString
& append(size_t n
, wxUniChar ch
)
1913 #if wxUSE_UNICODE_UTF8
1914 if ( !ch
.IsAscii() )
1915 m_impl
.append(wxStringOperations::EncodeNChars(n
, ch
));
1918 m_impl
.append(n
, (wxStringCharType
)ch
);
1921 // append from first to last
1922 wxString
& append(const_iterator first
, const_iterator last
)
1923 { m_impl
.append(first
.impl(), last
.impl()); return *this; }
1924 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1925 wxString
& append(const char *first
, const char *last
)
1926 { return append(first
, last
- first
); }
1927 wxString
& append(const wchar_t *first
, const wchar_t *last
)
1928 { return append(first
, last
- first
); }
1929 wxString
& append(const wxCStrData
& first
, const wxCStrData
& last
)
1930 { return append(CreateConstIterator(first
), CreateConstIterator(last
)); }
1931 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
1933 // same as `this_string = str'
1934 wxString
& assign(const wxString
& str
)
1935 { m_impl
= str
.m_impl
; return *this; }
1936 wxString
& assign(const wxString
& str
, size_t len
)
1938 m_impl
.assign(str
.m_impl
, 0, str
.LenToImpl(len
));
1941 // same as ` = str[pos..pos + n]
1942 wxString
& assign(const wxString
& str
, size_t pos
, size_t n
)
1945 str
.PosLenToImpl(pos
, n
, &from
, &len
);
1946 m_impl
.assign(str
.m_impl
, from
, len
);
1949 // same as `= first n (or all if n == npos) characters of sz'
1950 wxString
& assign(const char *sz
)
1951 { m_impl
.assign(ImplStr(sz
)); return *this; }
1952 wxString
& assign(const wchar_t *sz
)
1953 { m_impl
.assign(ImplStr(sz
)); return *this; }
1954 wxString
& assign(const char *sz
, size_t n
)
1956 SubstrBufFromMB
str(ImplStr(sz
, n
));
1957 m_impl
.assign(str
.data
, str
.len
);
1960 wxString
& assign(const wchar_t *sz
, size_t n
)
1962 SubstrBufFromWC
str(ImplStr(sz
, n
));
1963 m_impl
.assign(str
.data
, str
.len
);
1967 wxString
& assign(const wxCStrData
& str
)
1968 { return assign(str
.AsString()); }
1969 wxString
& assign(const wxCharBuffer
& str
)
1970 { return assign(str
.data()); }
1971 wxString
& assign(const wxWCharBuffer
& str
)
1972 { return assign(str
.data()); }
1973 wxString
& assign(const wxCStrData
& str
, size_t len
)
1974 { return assign(str
.AsString(), len
); }
1975 wxString
& assign(const wxCharBuffer
& str
, size_t len
)
1976 { return assign(str
.data(), len
); }
1977 wxString
& assign(const wxWCharBuffer
& str
, size_t len
)
1978 { return assign(str
.data(), len
); }
1980 // same as `= n copies of ch'
1981 wxString
& assign(size_t n
, wxUniChar ch
)
1983 #if wxUSE_UNICODE_UTF8
1984 if ( !ch
.IsAscii() )
1985 m_impl
.assign(wxStringOperations::EncodeNChars(n
, ch
));
1988 m_impl
.assign(n
, (wxStringCharType
)ch
);
1992 wxString
& assign(size_t n
, wxUniCharRef ch
)
1993 { return assign(n
, wxUniChar(ch
)); }
1994 wxString
& assign(size_t n
, char ch
)
1995 { return assign(n
, wxUniChar(ch
)); }
1996 wxString
& assign(size_t n
, unsigned char ch
)
1997 { return assign(n
, wxUniChar(ch
)); }
1998 wxString
& assign(size_t n
, wchar_t ch
)
1999 { return assign(n
, wxUniChar(ch
)); }
2001 // assign from first to last
2002 wxString
& assign(const_iterator first
, const_iterator last
)
2003 { m_impl
.assign(first
.impl(), last
.impl()); return *this; }
2004 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
2005 wxString
& assign(const char *first
, const char *last
)
2006 { return assign(first
, last
- first
); }
2007 wxString
& assign(const wchar_t *first
, const wchar_t *last
)
2008 { return assign(first
, last
- first
); }
2009 wxString
& assign(const wxCStrData
& first
, const wxCStrData
& last
)
2010 { return assign(CreateConstIterator(first
), CreateConstIterator(last
)); }
2011 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
2013 // string comparison
2014 int compare(const wxString
& str
) const;
2015 int compare(const char* sz
) const;
2016 int compare(const wchar_t* sz
) const;
2017 int compare(const wxCStrData
& str
) const
2018 { return compare(str
.AsString()); }
2019 int compare(const wxCharBuffer
& str
) const
2020 { return compare(str
.data()); }
2021 int compare(const wxWCharBuffer
& str
) const
2022 { return compare(str
.data()); }
2023 // comparison with a substring
2024 int compare(size_t nStart
, size_t nLen
, const wxString
& str
) const;
2025 // comparison of 2 substrings
2026 int compare(size_t nStart
, size_t nLen
,
2027 const wxString
& str
, size_t nStart2
, size_t nLen2
) const;
2028 // substring comparison with first nCount characters of sz
2029 int compare(size_t nStart
, size_t nLen
,
2030 const char* sz
, size_t nCount
= npos
) const;
2031 int compare(size_t nStart
, size_t nLen
,
2032 const wchar_t* sz
, size_t nCount
= npos
) const;
2034 // insert another string
2035 wxString
& insert(size_t nPos
, const wxString
& str
)
2036 { insert(begin() + nPos
, str
.begin(), str
.end()); return *this; }
2037 // insert n chars of str starting at nStart (in str)
2038 wxString
& insert(size_t nPos
, const wxString
& str
, size_t nStart
, size_t n
)
2041 str
.PosLenToImpl(nStart
, n
, &from
, &len
);
2042 m_impl
.insert(PosToImpl(nPos
), str
.m_impl
, from
, len
);
2045 // insert first n (or all if n == npos) characters of sz
2046 wxString
& insert(size_t nPos
, const char *sz
)
2047 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
2048 wxString
& insert(size_t nPos
, const wchar_t *sz
)
2049 { m_impl
.insert(PosToImpl(nPos
), ImplStr(sz
)); return *this; }
2050 wxString
& insert(size_t nPos
, const char *sz
, size_t n
)
2052 SubstrBufFromMB
str(ImplStr(sz
, n
));
2053 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
2056 wxString
& insert(size_t nPos
, const wchar_t *sz
, size_t n
)
2058 SubstrBufFromWC
str(ImplStr(sz
, n
));
2059 m_impl
.insert(PosToImpl(nPos
), str
.data
, str
.len
);
2062 // insert n copies of ch
2063 wxString
& insert(size_t nPos
, size_t n
, wxUniChar ch
)
2065 #if wxUSE_UNICODE_UTF8
2066 if ( !ch
.IsAscii() )
2067 m_impl
.insert(PosToImpl(nPos
), wxStringOperations::EncodeNChars(n
, ch
));
2070 m_impl
.insert(PosToImpl(nPos
), n
, (wxStringCharType
)ch
);
2073 iterator
insert(iterator it
, wxUniChar ch
)
2075 #if wxUSE_UNICODE_UTF8
2076 if ( !ch
.IsAscii() )
2078 size_t pos
= IterToImplPos(it
);
2079 m_impl
.insert(pos
, wxStringOperations::EncodeChar(ch
));
2080 return iterator(this, m_impl
.begin() + pos
);
2084 return iterator(this, m_impl
.insert(it
.impl(), (wxStringCharType
)ch
));
2086 void insert(iterator it
, const_iterator first
, const_iterator last
)
2087 { m_impl
.insert(it
.impl(), first
.impl(), last
.impl()); }
2088 #if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
2089 void insert(iterator it
, const char *first
, const char *last
)
2090 { insert(it
- begin(), first
, last
- first
); }
2091 void insert(iterator it
, const wchar_t *first
, const wchar_t *last
)
2092 { insert(it
- begin(), first
, last
- first
); }
2093 void insert(iterator it
, const wxCStrData
& first
, const wxCStrData
& last
)
2094 { insert(it
, CreateConstIterator(first
), CreateConstIterator(last
)); }
2095 #endif // WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
2097 void insert(iterator it
, size_type n
, wxUniChar ch
)
2099 #if wxUSE_UNICODE_UTF8
2100 if ( !ch
.IsAscii() )
2101 m_impl
.insert(IterToImplPos(it
), wxStringOperations::EncodeNChars(n
, ch
));
2104 m_impl
.insert(it
.impl(), n
, (wxStringCharType
)ch
);
2107 // delete characters from nStart to nStart + nLen
2108 wxString
& erase(size_type pos
= 0, size_type n
= npos
)
2111 PosLenToImpl(pos
, n
, &from
, &len
);
2112 m_impl
.erase(from
, len
);
2115 // delete characters from first up to last
2116 iterator
erase(iterator first
, iterator last
)
2117 { return iterator(this, m_impl
.erase(first
.impl(), last
.impl())); }
2118 iterator
erase(iterator first
)
2119 { return iterator(this, m_impl
.erase(first
.impl())); }
2121 #ifdef wxSTRING_BASE_HASNT_CLEAR
2122 void clear() { erase(); }
2124 void clear() { m_impl
.clear(); }
2127 // replaces the substring of length nLen starting at nStart
2128 wxString
& replace(size_t nStart
, size_t nLen
, const char* sz
)
2131 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2132 m_impl
.replace(from
, len
, ImplStr(sz
));
2135 wxString
& replace(size_t nStart
, size_t nLen
, const wchar_t* sz
)
2138 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2139 m_impl
.replace(from
, len
, ImplStr(sz
));
2142 // replaces the substring of length nLen starting at nStart
2143 wxString
& replace(size_t nStart
, size_t nLen
, const wxString
& str
)
2146 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2147 m_impl
.replace(from
, len
, str
.m_impl
);
2150 // replaces the substring with nCount copies of ch
2151 wxString
& replace(size_t nStart
, size_t nLen
, size_t nCount
, wxUniChar ch
)
2154 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2155 #if wxUSE_UNICODE_UTF8
2156 if ( !ch
.IsAscii() )
2157 m_impl
.replace(from
, len
, wxStringOperations::EncodeNChars(nCount
, ch
));
2160 m_impl
.replace(from
, len
, nCount
, (wxStringCharType
)ch
);
2163 // replaces a substring with another substring
2164 wxString
& replace(size_t nStart
, size_t nLen
,
2165 const wxString
& str
, size_t nStart2
, size_t nLen2
)
2168 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2171 str
.PosLenToImpl(nStart2
, nLen2
, &from2
, &len2
);
2173 m_impl
.replace(from
, len
, str
.m_impl
, from2
, len2
);
2176 // replaces the substring with first nCount chars of sz
2177 wxString
& replace(size_t nStart
, size_t nLen
,
2178 const char* sz
, size_t nCount
)
2181 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2183 SubstrBufFromMB
str(ImplStr(sz
, nCount
));
2185 m_impl
.replace(from
, len
, str
.data
, str
.len
);
2188 wxString
& replace(size_t nStart
, size_t nLen
,
2189 const wchar_t* sz
, size_t nCount
)
2192 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2194 SubstrBufFromWC
str(ImplStr(sz
, nCount
));
2196 m_impl
.replace(from
, len
, str
.data
, str
.len
);
2199 wxString
& replace(size_t nStart
, size_t nLen
,
2200 const wxString
& s
, size_t nCount
)
2203 PosLenToImpl(nStart
, nLen
, &from
, &len
);
2204 m_impl
.replace(from
, len
, s
.m_impl
.c_str(), s
.LenToImpl(nCount
));
2208 wxString
& replace(iterator first
, iterator last
, const char* s
)
2209 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
2210 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
)
2211 { m_impl
.replace(first
.impl(), last
.impl(), ImplStr(s
)); return *this; }
2212 wxString
& replace(iterator first
, iterator last
, const char* s
, size_type n
)
2214 SubstrBufFromMB
str(ImplStr(s
, n
));
2215 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
2218 wxString
& replace(iterator first
, iterator last
, const wchar_t* s
, size_type n
)
2220 SubstrBufFromWC
str(ImplStr(s
, n
));
2221 m_impl
.replace(first
.impl(), last
.impl(), str
.data
, str
.len
);
2224 wxString
& replace(iterator first
, iterator last
, const wxString
& s
)
2225 { m_impl
.replace(first
.impl(), last
.impl(), s
.m_impl
); return *this; }
2226 wxString
& replace(iterator first
, iterator last
, size_type n
, wxUniChar ch
)
2228 #if wxUSE_UNICODE_UTF8
2229 if ( !ch
.IsAscii() )
2230 m_impl
.replace(first
.impl(), last
.impl(),
2231 wxStringOperations::EncodeNChars(n
, ch
));
2234 m_impl
.replace(first
.impl(), last
.impl(), n
, (wxStringCharType
)ch
);
2237 wxString
& replace(iterator first
, iterator last
,
2238 const_iterator first1
, const_iterator last1
)
2240 m_impl
.replace(first
.impl(), last
.impl(), first1
.impl(), last1
.impl());
2243 wxString
& replace(iterator first
, iterator last
,
2244 const char *first1
, const char *last1
)
2245 { replace(first
, last
, first1
, last1
- first1
); return *this; }
2246 wxString
& replace(iterator first
, iterator last
,
2247 const wchar_t *first1
, const wchar_t *last1
)
2248 { replace(first
, last
, first1
, last1
- first1
); return *this; }
2251 void swap(wxString
& str
)
2252 { m_impl
.swap(str
.m_impl
); }
2255 size_t find(const wxString
& str
, size_t nStart
= 0) const
2256 { return PosFromImpl(m_impl
.find(str
.m_impl
, PosToImpl(nStart
))); }
2258 // find first n characters of sz
2259 size_t find(const char* sz
, size_t nStart
= 0, size_t n
= npos
) const
2261 SubstrBufFromMB
str(ImplStr(sz
, n
));
2262 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
2264 size_t find(const wchar_t* sz
, size_t nStart
= 0, size_t n
= npos
) const
2266 SubstrBufFromWC
str(ImplStr(sz
, n
));
2267 return PosFromImpl(m_impl
.find(str
.data
, PosToImpl(nStart
), str
.len
));
2269 size_t find(const wxCharBuffer
& s
, size_t nStart
= 0, size_t n
= npos
) const
2270 { return find(s
.data(), nStart
, n
); }
2271 size_t find(const wxWCharBuffer
& s
, size_t nStart
= 0, size_t n
= npos
) const
2272 { return find(s
.data(), nStart
, n
); }
2273 size_t find(const wxCStrData
& s
, size_t nStart
= 0, size_t n
= npos
) const
2274 { return find(s
.AsWChar(), nStart
, n
); }
2276 // find the first occurence of character ch after nStart
2277 size_t find(wxUniChar ch
, size_t nStart
= 0) const
2279 return PosFromImpl(m_impl
.find(wxStringOperations::EncodeChar(ch
),
2280 PosToImpl(nStart
)));
2282 size_t find(wxUniCharRef ch
, size_t nStart
= 0) const
2283 { return find(wxUniChar(ch
), nStart
); }
2284 size_t find(char ch
, size_t nStart
= 0) const
2285 { return find(wxUniChar(ch
), nStart
); }
2286 size_t find(unsigned char ch
, size_t nStart
= 0) const
2287 { return find(wxUniChar(ch
), nStart
); }
2288 size_t find(wchar_t ch
, size_t nStart
= 0) const
2289 { return find(wxUniChar(ch
), nStart
); }
2291 // rfind() family is exactly like find() but works right to left
2293 // as find, but from the end
2294 size_t rfind(const wxString
& str
, size_t nStart
= npos
) const
2295 { return PosFromImpl(m_impl
.rfind(str
.m_impl
, PosToImpl(nStart
))); }
2297 // as find, but from the end
2298 size_t rfind(const char* sz
, size_t nStart
= npos
, size_t n
= npos
) const
2300 SubstrBufFromMB
str(ImplStr(sz
, n
));
2301 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2303 size_t rfind(const wchar_t* sz
, size_t nStart
= npos
, size_t n
= npos
) const
2305 SubstrBufFromWC
str(ImplStr(sz
, n
));
2306 return PosFromImpl(m_impl
.rfind(str
.data
, PosToImpl(nStart
), str
.len
));
2308 size_t rfind(const wxCharBuffer
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2309 { return rfind(s
.data(), nStart
, n
); }
2310 size_t rfind(const wxWCharBuffer
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2311 { return rfind(s
.data(), nStart
, n
); }
2312 size_t rfind(const wxCStrData
& s
, size_t nStart
= npos
, size_t n
= npos
) const
2313 { return rfind(s
.AsWChar(), nStart
, n
); }
2314 // as find, but from the end
2315 size_t rfind(wxUniChar ch
, size_t nStart
= npos
) const
2317 return PosFromImpl(m_impl
.rfind(wxStringOperations::EncodeChar(ch
),
2318 PosToImpl(nStart
)));
2320 size_t rfind(wxUniCharRef ch
, size_t nStart
= npos
) const
2321 { return rfind(wxUniChar(ch
), nStart
); }
2322 size_t rfind(char ch
, size_t nStart
= npos
) const
2323 { return rfind(wxUniChar(ch
), nStart
); }
2324 size_t rfind(unsigned char ch
, size_t nStart
= npos
) const
2325 { return rfind(wxUniChar(ch
), nStart
); }
2326 size_t rfind(wchar_t ch
, size_t nStart
= npos
) const
2327 { return rfind(wxUniChar(ch
), nStart
); }
2329 // find first/last occurence of any character (not) in the set:
2330 #if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2331 // FIXME-UTF8: this is not entirely correct, because it doesn't work if
2332 // sizeof(wchar_t)==2 and surrogates are present in the string;
2333 // should we care? Probably not.
2334 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2335 { return m_impl
.find_first_of(str
.m_impl
, nStart
); }
2336 size_t find_first_of(const char* sz
, size_t nStart
= 0) const
2337 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2338 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const
2339 { return m_impl
.find_first_of(ImplStr(sz
), nStart
); }
2340 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const
2341 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2342 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2343 { return m_impl
.find_first_of(ImplStr(sz
), nStart
, n
); }
2344 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2345 { return m_impl
.find_first_of((wxChar
)c
, nStart
); }
2347 size_t find_last_of(const wxString
& str
, size_t nStart
= npos
) const
2348 { return m_impl
.find_last_of(str
.m_impl
, nStart
); }
2349 size_t find_last_of(const char* sz
, size_t nStart
= npos
) const
2350 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2351 size_t find_last_of(const wchar_t* sz
, size_t nStart
= npos
) const
2352 { return m_impl
.find_last_of(ImplStr(sz
), nStart
); }
2353 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const
2354 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2355 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2356 { return m_impl
.find_last_of(ImplStr(sz
), nStart
, n
); }
2357 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2358 { return m_impl
.find_last_of((wxChar
)c
, nStart
); }
2360 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2361 { return m_impl
.find_first_not_of(str
.m_impl
, nStart
); }
2362 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const
2363 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2364 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const
2365 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
); }
2366 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const
2367 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2368 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2369 { return m_impl
.find_first_not_of(ImplStr(sz
), nStart
, n
); }
2370 size_t find_first_not_of(wxUniChar c
, size_t nStart
= 0) const
2371 { return m_impl
.find_first_not_of((wxChar
)c
, nStart
); }
2373 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2374 { return m_impl
.find_last_not_of(str
.m_impl
, nStart
); }
2375 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const
2376 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2377 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const
2378 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
); }
2379 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const
2380 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2381 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const
2382 { return m_impl
.find_last_not_of(ImplStr(sz
), nStart
, n
); }
2383 size_t find_last_not_of(wxUniChar c
, size_t nStart
= npos
) const
2384 { return m_impl
.find_last_not_of((wxChar
)c
, nStart
); }
2386 // we can't use std::string implementation in UTF-8 build, because the
2387 // character sets would be interpreted wrongly:
2389 // as strpbrk() but starts at nStart, returns npos if not found
2390 size_t find_first_of(const wxString
& str
, size_t nStart
= 0) const
2391 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2392 { return find_first_of(str
.wc_str(), nStart
); }
2394 { return find_first_of(str
.mb_str(), nStart
); }
2397 size_t find_first_of(const char* sz
, size_t nStart
= 0) const;
2398 size_t find_first_of(const wchar_t* sz
, size_t nStart
= 0) const;
2399 size_t find_first_of(const char* sz
, size_t nStart
, size_t n
) const;
2400 size_t find_first_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2401 // same as find(char, size_t)
2402 size_t find_first_of(wxUniChar c
, size_t nStart
= 0) const
2403 { return find(c
, nStart
); }
2404 // find the last (starting from nStart) char from str in this string
2405 size_t find_last_of (const wxString
& str
, size_t nStart
= npos
) const
2406 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2407 { return find_last_of(str
.wc_str(), nStart
); }
2409 { return find_last_of(str
.mb_str(), nStart
); }
2412 size_t find_last_of (const char* sz
, size_t nStart
= npos
) const;
2413 size_t find_last_of (const wchar_t* sz
, size_t nStart
= npos
) const;
2414 size_t find_last_of(const char* sz
, size_t nStart
, size_t n
) const;
2415 size_t find_last_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2417 size_t find_last_of(wxUniChar c
, size_t nStart
= npos
) const
2418 { return rfind(c
, nStart
); }
2420 // find first/last occurence of any character not in the set
2422 // as strspn() (starting from nStart), returns npos on failure
2423 size_t find_first_not_of(const wxString
& str
, size_t nStart
= 0) const
2424 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2425 { return find_first_not_of(str
.wc_str(), nStart
); }
2427 { return find_first_not_of(str
.mb_str(), nStart
); }
2430 size_t find_first_not_of(const char* sz
, size_t nStart
= 0) const;
2431 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
= 0) const;
2432 size_t find_first_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2433 size_t find_first_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2435 size_t find_first_not_of(wxUniChar ch
, size_t nStart
= 0) const;
2437 size_t find_last_not_of(const wxString
& str
, size_t nStart
= npos
) const
2438 #if wxUSE_UNICODE // FIXME-UTF8: temporary
2439 { return find_last_not_of(str
.wc_str(), nStart
); }
2441 { return find_last_not_of(str
.mb_str(), nStart
); }
2444 size_t find_last_not_of(const char* sz
, size_t nStart
= npos
) const;
2445 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
= npos
) const;
2446 size_t find_last_not_of(const char* sz
, size_t nStart
, size_t n
) const;
2447 size_t find_last_not_of(const wchar_t* sz
, size_t nStart
, size_t n
) const;
2449 size_t find_last_not_of(wxUniChar ch
, size_t nStart
= npos
) const;
2450 #endif // wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8 or not
2452 // provide char/wchar_t/wxUniCharRef overloads for char-finding functions
2453 // above to resolve ambiguities:
2454 size_t find_first_of(wxUniCharRef ch
, size_t nStart
= 0) const
2455 { return find_first_of(wxUniChar(ch
), nStart
); }
2456 size_t find_first_of(char ch
, size_t nStart
= 0) const
2457 { return find_first_of(wxUniChar(ch
), nStart
); }
2458 size_t find_first_of(unsigned char ch
, size_t nStart
= 0) const
2459 { return find_first_of(wxUniChar(ch
), nStart
); }
2460 size_t find_first_of(wchar_t ch
, size_t nStart
= 0) const
2461 { return find_first_of(wxUniChar(ch
), nStart
); }
2462 size_t find_last_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2463 { return find_last_of(wxUniChar(ch
), nStart
); }
2464 size_t find_last_of(char ch
, size_t nStart
= npos
) const
2465 { return find_last_of(wxUniChar(ch
), nStart
); }
2466 size_t find_last_of(unsigned char ch
, size_t nStart
= npos
) const
2467 { return find_last_of(wxUniChar(ch
), nStart
); }
2468 size_t find_last_of(wchar_t ch
, size_t nStart
= npos
) const
2469 { return find_last_of(wxUniChar(ch
), nStart
); }
2470 size_t find_first_not_of(wxUniCharRef ch
, size_t nStart
= 0) const
2471 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2472 size_t find_first_not_of(char ch
, size_t nStart
= 0) const
2473 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2474 size_t find_first_not_of(unsigned char ch
, size_t nStart
= 0) const
2475 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2476 size_t find_first_not_of(wchar_t ch
, size_t nStart
= 0) const
2477 { return find_first_not_of(wxUniChar(ch
), nStart
); }
2478 size_t find_last_not_of(wxUniCharRef ch
, size_t nStart
= npos
) const
2479 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2480 size_t find_last_not_of(char ch
, size_t nStart
= npos
) const
2481 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2482 size_t find_last_not_of(unsigned char ch
, size_t nStart
= npos
) const
2483 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2484 size_t find_last_not_of(wchar_t ch
, size_t nStart
= npos
) const
2485 { return find_last_not_of(wxUniChar(ch
), nStart
); }
2487 // and additional overloads for the versions taking strings:
2488 size_t find_first_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2489 { return find_first_of(sz
.AsString(), nStart
); }
2490 size_t find_first_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2491 { return find_first_of(sz
.data(), nStart
); }
2492 size_t find_first_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2493 { return find_first_of(sz
.data(), nStart
); }
2494 size_t find_first_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2495 { return find_first_of(sz
.AsWChar(), nStart
, n
); }
2496 size_t find_first_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2497 { return find_first_of(sz
.data(), nStart
, n
); }
2498 size_t find_first_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2499 { return find_first_of(sz
.data(), nStart
, n
); }
2501 size_t find_last_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2502 { return find_last_of(sz
.AsString(), nStart
); }
2503 size_t find_last_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2504 { return find_last_of(sz
.data(), nStart
); }
2505 size_t find_last_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2506 { return find_last_of(sz
.data(), nStart
); }
2507 size_t find_last_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2508 { return find_last_of(sz
.AsWChar(), nStart
, n
); }
2509 size_t find_last_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2510 { return find_last_of(sz
.data(), nStart
, n
); }
2511 size_t find_last_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2512 { return find_last_of(sz
.data(), nStart
, n
); }
2514 size_t find_first_not_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2515 { return find_first_not_of(sz
.AsString(), nStart
); }
2516 size_t find_first_not_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2517 { return find_first_not_of(sz
.data(), nStart
); }
2518 size_t find_first_not_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2519 { return find_first_not_of(sz
.data(), nStart
); }
2520 size_t find_first_not_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2521 { return find_first_not_of(sz
.AsWChar(), nStart
, n
); }
2522 size_t find_first_not_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2523 { return find_first_not_of(sz
.data(), nStart
, n
); }
2524 size_t find_first_not_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2525 { return find_first_not_of(sz
.data(), nStart
, n
); }
2527 size_t find_last_not_of(const wxCStrData
& sz
, size_t nStart
= 0) const
2528 { return find_last_not_of(sz
.AsString(), nStart
); }
2529 size_t find_last_not_of(const wxCharBuffer
& sz
, size_t nStart
= 0) const
2530 { return find_last_not_of(sz
.data(), nStart
); }
2531 size_t find_last_not_of(const wxWCharBuffer
& sz
, size_t nStart
= 0) const
2532 { return find_last_not_of(sz
.data(), nStart
); }
2533 size_t find_last_not_of(const wxCStrData
& sz
, size_t nStart
, size_t n
) const
2534 { return find_last_not_of(sz
.AsWChar(), nStart
, n
); }
2535 size_t find_last_not_of(const wxCharBuffer
& sz
, size_t nStart
, size_t n
) const
2536 { return find_last_not_of(sz
.data(), nStart
, n
); }
2537 size_t find_last_not_of(const wxWCharBuffer
& sz
, size_t nStart
, size_t n
) const
2538 { return find_last_not_of(sz
.data(), nStart
, n
); }
2541 wxString
& operator+=(const wxString
& s
)
2542 { m_impl
+= s
.m_impl
; return *this; }
2543 // string += C string
2544 wxString
& operator+=(const char *psz
)
2545 { m_impl
+= ImplStr(psz
); return *this; }
2546 wxString
& operator+=(const wchar_t *pwz
)
2547 { m_impl
+= ImplStr(pwz
); return *this; }
2548 wxString
& operator+=(const wxCStrData
& s
)
2549 { m_impl
+= s
.AsString().m_impl
; return *this; }
2550 wxString
& operator+=(const wxCharBuffer
& s
)
2551 { return operator+=(s
.data()); }
2552 wxString
& operator+=(const wxWCharBuffer
& s
)
2553 { return operator+=(s
.data()); }
2555 wxString
& operator+=(wxUniChar ch
)
2556 { m_impl
+= wxStringOperations::EncodeChar(ch
); return *this; }
2557 wxString
& operator+=(wxUniCharRef ch
) { return *this += wxUniChar(ch
); }
2558 wxString
& operator+=(int ch
) { return *this += wxUniChar(ch
); }
2559 wxString
& operator+=(char ch
) { return *this += wxUniChar(ch
); }
2560 wxString
& operator+=(unsigned char ch
) { return *this += wxUniChar(ch
); }
2561 wxString
& operator+=(wchar_t ch
) { return *this += wxUniChar(ch
); }
2564 #if !wxUSE_STL_BASED_WXSTRING
2565 // helpers for wxStringBuffer and wxStringBufferLength
2566 wxStringCharType
*DoGetWriteBuf(size_t nLen
)
2567 { return m_impl
.DoGetWriteBuf(nLen
); }
2568 void DoUngetWriteBuf()
2569 { m_impl
.DoUngetWriteBuf(); }
2570 void DoUngetWriteBuf(size_t nLen
)
2571 { m_impl
.DoUngetWriteBuf(nLen
); }
2572 #endif // !wxUSE_STL_BASED_WXSTRING
2574 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
2575 #if !wxUSE_UTF8_LOCALE_ONLY
2576 int DoPrintfWchar(const wxChar
*format
, ...);
2577 static wxString
DoFormatWchar(const wxChar
*format
, ...);
2579 #if wxUSE_UNICODE_UTF8
2580 int DoPrintfUtf8(const char *format
, ...);
2581 static wxString
DoFormatUtf8(const char *format
, ...);
2585 #if !wxUSE_STL_BASED_WXSTRING
2586 // check string's data validity
2587 bool IsValid() const { return m_impl
.GetStringData()->IsValid(); }
2591 wxStringImpl m_impl
;
2594 // "struct 'ConvertedBuffer<T>' needs to have dll-interface to be used by
2595 // clients of class 'wxString'" - this is private, we don't care
2596 #pragma warning (disable:4251)
2599 // buffers for compatibility conversion from (char*)c_str() and
2600 // (wchar_t*)c_str():
2601 // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
2602 template<typename T
>
2603 struct ConvertedBuffer
2605 ConvertedBuffer() : m_buf(NULL
) {}
2609 operator T
*() const { return m_buf
; }
2611 ConvertedBuffer
& operator=(T
*str
)
2620 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
2621 ConvertedBuffer
<char> m_convertedToChar
;
2623 #if !wxUSE_UNICODE_WCHAR
2624 ConvertedBuffer
<wchar_t> m_convertedToWChar
;
2628 #pragma warning (default:4251)
2631 #if wxUSE_UNICODE_UTF8
2632 // FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently
2633 // assigning to character pointer to by wxString::interator may
2634 // change the underlying wxStringImpl iterator, so we have to
2635 // keep track of all iterators and update them as necessary:
2636 struct wxStringIteratorNodeHead
2638 wxStringIteratorNodeHead() : ptr(NULL
) {}
2639 wxStringIteratorNode
*ptr
;
2641 // copying is disallowed as it would result in more than one pointer into
2642 // the same linked list
2643 DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead
)
2646 wxStringIteratorNodeHead m_iterators
;
2648 friend class WXDLLIMPEXP_FWD_BASE wxStringIteratorNode
;
2649 friend class WXDLLIMPEXP_FWD_BASE wxUniCharRef
;
2650 #endif // wxUSE_UNICODE_UTF8
2652 friend class WXDLLIMPEXP_FWD_BASE wxCStrData
;
2653 friend class wxStringInternalBuffer
;
2654 friend class wxStringInternalBufferLength
;
2657 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
2658 #pragma warning (default:4275)
2661 // string iterator operators that satisfy STL Random Access Iterator
2663 inline wxString::iterator
operator+(int n
, wxString::iterator i
)
2665 inline wxString::iterator
operator+(size_t n
, wxString::iterator i
)
2667 inline wxString::const_iterator
operator+(int n
, wxString::const_iterator i
)
2669 inline wxString::const_iterator
operator+(size_t n
, wxString::const_iterator i
)
2671 inline wxString::reverse_iterator
operator+(int n
, wxString::reverse_iterator i
)
2673 inline wxString::reverse_iterator
operator+(size_t n
, wxString::reverse_iterator i
)
2675 inline wxString::const_reverse_iterator
operator+(int n
, wxString::const_reverse_iterator i
)
2677 inline wxString::const_reverse_iterator
operator+(size_t n
, wxString::const_reverse_iterator i
)
2680 // notice that even though for many compilers the friend declarations above are
2681 // enough, from the point of view of C++ standard we must have the declarations
2682 // here as friend ones are not injected in the enclosing namespace and without
2683 // them the code fails to compile with conforming compilers such as xlC or g++4
2684 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string1
, const wxString
& string2
);
2685 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const char *psz
);
2686 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, const wchar_t *pwz
);
2687 wxString WXDLLIMPEXP_BASE
operator+(const char *psz
, const wxString
& string
);
2688 wxString WXDLLIMPEXP_BASE
operator+(const wchar_t *pwz
, const wxString
& string
);
2690 wxString WXDLLIMPEXP_BASE
operator+(const wxString
& string
, wxUniChar ch
);
2691 wxString WXDLLIMPEXP_BASE
operator+(wxUniChar ch
, const wxString
& string
);
2693 inline wxString
operator+(const wxString
& string
, wxUniCharRef ch
)
2694 { return string
+ (wxUniChar
)ch
; }
2695 inline wxString
operator+(const wxString
& string
, char ch
)
2696 { return string
+ wxUniChar(ch
); }
2697 inline wxString
operator+(const wxString
& string
, wchar_t ch
)
2698 { return string
+ wxUniChar(ch
); }
2699 inline wxString
operator+(wxUniCharRef ch
, const wxString
& string
)
2700 { return (wxUniChar
)ch
+ string
; }
2701 inline wxString
operator+(char ch
, const wxString
& string
)
2702 { return wxUniChar(ch
) + string
; }
2703 inline wxString
operator+(wchar_t ch
, const wxString
& string
)
2704 { return wxUniChar(ch
) + string
; }
2707 #define wxGetEmptyString() wxString()
2709 // ----------------------------------------------------------------------------
2710 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
2711 // ----------------------------------------------------------------------------
2713 #if !wxUSE_STL_BASED_WXSTRING
2714 // string buffer for direct access to string data in their native
2716 class wxStringInternalBuffer
2719 typedef wxStringCharType CharType
;
2721 wxStringInternalBuffer(wxString
& str
, size_t lenWanted
= 1024)
2722 : m_str(str
), m_buf(NULL
)
2723 { m_buf
= m_str
.DoGetWriteBuf(lenWanted
); }
2725 ~wxStringInternalBuffer() { m_str
.DoUngetWriteBuf(); }
2727 operator wxStringCharType
*() const { return m_buf
; }
2731 wxStringCharType
*m_buf
;
2733 DECLARE_NO_COPY_CLASS(wxStringInternalBuffer
)
2736 class wxStringInternalBufferLength
2739 typedef wxStringCharType CharType
;
2741 wxStringInternalBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2742 : m_str(str
), m_buf(NULL
), m_len(0), m_lenSet(false)
2744 m_buf
= m_str
.DoGetWriteBuf(lenWanted
);
2745 wxASSERT(m_buf
!= NULL
);
2748 ~wxStringInternalBufferLength()
2751 m_str
.DoUngetWriteBuf(m_len
);
2754 operator wxStringCharType
*() const { return m_buf
; }
2755 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2759 wxStringCharType
*m_buf
;
2763 DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength
)
2766 #endif // !wxUSE_STL_BASED_WXSTRING
2768 template<typename T
>
2769 class WXDLLIMPEXP_BASE wxStringTypeBufferBase
2774 wxStringTypeBufferBase(wxString
& str
, size_t lenWanted
= 1024)
2775 : m_str(str
), m_buf(lenWanted
)
2779 operator CharType
*() { return m_buf
.data(); }
2783 wxCharTypeBuffer
<CharType
> m_buf
;
2786 template<typename T
>
2787 class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
2792 wxStringTypeBufferLengthBase(wxString
& str
, size_t lenWanted
= 1024)
2793 : m_str(str
), m_buf(lenWanted
), m_len(0), m_lenSet(false)
2796 operator CharType
*() { return m_buf
.data(); }
2797 void SetLength(size_t length
) { m_len
= length
; m_lenSet
= true; }
2801 wxCharTypeBuffer
<CharType
> m_buf
;
2806 template<typename T
>
2807 class wxStringTypeBuffer
: public wxStringTypeBufferBase
<T
>
2810 wxStringTypeBuffer(wxString
& str
, size_t lenWanted
= 1024)
2811 : wxStringTypeBufferBase
<T
>(str
, lenWanted
) {}
2812 ~wxStringTypeBuffer()
2814 this->m_str
.assign(this->m_buf
.data());
2817 DECLARE_NO_COPY_CLASS(wxStringTypeBuffer
)
2820 template<typename T
>
2821 class wxStringTypeBufferLength
: public wxStringTypeBufferLengthBase
<T
>
2824 wxStringTypeBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2825 : wxStringTypeBufferLengthBase
<T
>(str
, lenWanted
) {}
2827 ~wxStringTypeBufferLength()
2829 wxASSERT(this->m_lenSet
);
2830 this->m_str
.assign(this->m_buf
.data(), this->m_len
);
2833 DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength
)
2836 #if wxUSE_STL_BASED_WXSTRING
2838 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase
<wxStringCharType
> )
2840 class wxStringInternalBuffer
: public wxStringTypeBufferBase
<wxStringCharType
>
2843 wxStringInternalBuffer(wxString
& str
, size_t lenWanted
= 1024)
2844 : wxStringTypeBufferBase
<wxStringCharType
>(str
, lenWanted
) {}
2845 ~wxStringInternalBuffer()
2846 { m_str
.m_impl
.assign(m_buf
.data()); }
2848 DECLARE_NO_COPY_CLASS(wxStringInternalBuffer
)
2851 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
2852 wxStringTypeBufferLengthBase
<wxStringCharType
> )
2854 class wxStringInternalBufferLength
2855 : public wxStringTypeBufferLengthBase
<wxStringCharType
>
2858 wxStringInternalBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2859 : wxStringTypeBufferLengthBase
<wxStringCharType
>(str
, lenWanted
) {}
2861 ~wxStringInternalBufferLength()
2864 m_str
.m_impl
.assign(m_buf
.data(), m_len
);
2867 DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength
)
2869 #endif // wxUSE_STL_BASED_WXSTRING
2872 #if wxUSE_STL_BASED_WXSTRING || wxUSE_UNICODE_UTF8
2873 typedef wxStringTypeBuffer
<wxChar
> wxStringBuffer
;
2874 typedef wxStringTypeBufferLength
<wxChar
> wxStringBufferLength
;
2875 #else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2876 typedef wxStringInternalBuffer wxStringBuffer
;
2877 typedef wxStringInternalBufferLength wxStringBufferLength
;
2878 #endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
2880 #if wxUSE_UNICODE_UTF8
2881 typedef wxStringInternalBuffer wxUTF8StringBuffer
;
2882 typedef wxStringInternalBufferLength wxUTF8StringBufferLength
;
2883 #elif wxUSE_UNICODE_WCHAR
2885 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase
<char> )
2887 class WXDLLIMPEXP_BASE wxUTF8StringBuffer
: public wxStringTypeBufferBase
<char>
2890 wxUTF8StringBuffer(wxString
& str
, size_t lenWanted
= 1024)
2891 : wxStringTypeBufferBase
<char>(str
, lenWanted
) {}
2892 ~wxUTF8StringBuffer();
2894 DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer
)
2897 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase
<char> )
2899 class WXDLLIMPEXP_BASE wxUTF8StringBufferLength
2900 : public wxStringTypeBufferLengthBase
<char>
2903 wxUTF8StringBufferLength(wxString
& str
, size_t lenWanted
= 1024)
2904 : wxStringTypeBufferLengthBase
<char>(str
, lenWanted
) {}
2905 ~wxUTF8StringBufferLength();
2907 DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength
)
2909 #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
2912 // ---------------------------------------------------------------------------
2913 // wxString comparison functions: operator versions are always case sensitive
2914 // ---------------------------------------------------------------------------
2916 #define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p)
2918 wxDEFINE_ALL_COMPARISONS(const wxChar
*, const wxString
&, wxCMP_WXCHAR_STRING
)
2920 #undef wxCMP_WXCHAR_STRING
2922 // note that there is an optimization in operator==() and !=(): we (quickly)
2923 // checks the strings length first, before comparing their data
2924 inline bool operator==(const wxString
& s1
, const wxString
& s2
)
2925 { return (s1
.Len() == s2
.Len()) && (s1
.Cmp(s2
) == 0); }
2926 inline bool operator!=(const wxString
& s1
, const wxString
& s2
)
2927 { return (s1
.Len() != s2
.Len()) || (s1
.Cmp(s2
) != 0); }
2928 inline bool operator< (const wxString
& s1
, const wxString
& s2
)
2929 { return s1
.Cmp(s2
) < 0; }
2930 inline bool operator> (const wxString
& s1
, const wxString
& s2
)
2931 { return s1
.Cmp(s2
) > 0; }
2932 inline bool operator<=(const wxString
& s1
, const wxString
& s2
)
2933 { return s1
.Cmp(s2
) <= 0; }
2934 inline bool operator>=(const wxString
& s1
, const wxString
& s2
)
2935 { return s1
.Cmp(s2
) >= 0; }
2937 inline bool operator==(const wxString
& s1
, const wxCStrData
& s2
)
2938 { return s1
== s2
.AsString(); }
2939 inline bool operator==(const wxCStrData
& s1
, const wxString
& s2
)
2940 { return s1
.AsString() == s2
; }
2941 inline bool operator!=(const wxString
& s1
, const wxCStrData
& s2
)
2942 { return s1
!= s2
.AsString(); }
2943 inline bool operator!=(const wxCStrData
& s1
, const wxString
& s2
)
2944 { return s1
.AsString() != s2
; }
2946 inline bool operator==(const wxString
& s1
, const wxWCharBuffer
& s2
)
2947 { return (s1
.Cmp((const wchar_t *)s2
) == 0); }
2948 inline bool operator==(const wxWCharBuffer
& s1
, const wxString
& s2
)
2949 { return (s2
.Cmp((const wchar_t *)s1
) == 0); }
2950 inline bool operator!=(const wxString
& s1
, const wxWCharBuffer
& s2
)
2951 { return (s1
.Cmp((const wchar_t *)s2
) != 0); }
2952 inline bool operator!=(const wxWCharBuffer
& s1
, const wxString
& s2
)
2953 { return (s2
.Cmp((const wchar_t *)s1
) != 0); }
2955 inline bool operator==(const wxString
& s1
, const wxCharBuffer
& s2
)
2956 { return (s1
.Cmp((const char *)s2
) == 0); }
2957 inline bool operator==(const wxCharBuffer
& s1
, const wxString
& s2
)
2958 { return (s2
.Cmp((const char *)s1
) == 0); }
2959 inline bool operator!=(const wxString
& s1
, const wxCharBuffer
& s2
)
2960 { return (s1
.Cmp((const char *)s2
) != 0); }
2961 inline bool operator!=(const wxCharBuffer
& s1
, const wxString
& s2
)
2962 { return (s2
.Cmp((const char *)s1
) != 0); }
2964 inline wxString
operator+(const wxString
& string
, const wxWCharBuffer
& buf
)
2965 { return string
+ (const wchar_t *)buf
; }
2966 inline wxString
operator+(const wxWCharBuffer
& buf
, const wxString
& string
)
2967 { return (const wchar_t *)buf
+ string
; }
2969 inline wxString
operator+(const wxString
& string
, const wxCharBuffer
& buf
)
2970 { return string
+ (const char *)buf
; }
2971 inline wxString
operator+(const wxCharBuffer
& buf
, const wxString
& string
)
2972 { return (const char *)buf
+ string
; }
2974 // comparison with char
2975 inline bool operator==(const wxUniChar
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2976 inline bool operator==(const wxUniCharRef
& c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2977 inline bool operator==(char c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2978 inline bool operator==(wchar_t c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2979 inline bool operator==(int c
, const wxString
& s
) { return s
.IsSameAs(c
); }
2980 inline bool operator==(const wxString
& s
, const wxUniChar
& c
) { return s
.IsSameAs(c
); }
2981 inline bool operator==(const wxString
& s
, const wxUniCharRef
& c
) { return s
.IsSameAs(c
); }
2982 inline bool operator==(const wxString
& s
, char c
) { return s
.IsSameAs(c
); }
2983 inline bool operator==(const wxString
& s
, wchar_t c
) { return s
.IsSameAs(c
); }
2984 inline bool operator!=(const wxUniChar
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2985 inline bool operator!=(const wxUniCharRef
& c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2986 inline bool operator!=(char c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2987 inline bool operator!=(wchar_t c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2988 inline bool operator!=(int c
, const wxString
& s
) { return !s
.IsSameAs(c
); }
2989 inline bool operator!=(const wxString
& s
, const wxUniChar
& c
) { return !s
.IsSameAs(c
); }
2990 inline bool operator!=(const wxString
& s
, const wxUniCharRef
& c
) { return !s
.IsSameAs(c
); }
2991 inline bool operator!=(const wxString
& s
, char c
) { return !s
.IsSameAs(c
); }
2992 inline bool operator!=(const wxString
& s
, wchar_t c
) { return !s
.IsSameAs(c
); }
2994 // comparison with C string in Unicode build
2997 #define wxCMP_CHAR_STRING(p, s, op) wxString(p) op s
2999 wxDEFINE_ALL_COMPARISONS(const char *, const wxString
&, wxCMP_CHAR_STRING
)
3001 #undef wxCMP_CHAR_STRING
3003 #endif // wxUSE_UNICODE
3005 // we also need to provide the operators for comparison with wxCStrData to
3006 // resolve ambiguity between operator(const wxChar *,const wxString &) and
3007 // operator(const wxChar *, const wxChar *) for "p == s.c_str()"
3009 // notice that these are (shallow) pointer comparisons, not (deep) string ones
3010 #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
3011 #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
3013 wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData
&, wxCMP_WCHAR_CSTRDATA
)
3014 wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData
&, wxCMP_CHAR_CSTRDATA
)
3016 #undef wxCMP_CHAR_CSTRDATA
3017 #undef wxCMP_WCHAR_CSTRDATA
3019 // ---------------------------------------------------------------------------
3020 // Implementation only from here until the end of file
3021 // ---------------------------------------------------------------------------
3023 #if wxUSE_STD_IOSTREAM
3025 #include "wx/iosfwrap.h"
3027 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxString
&);
3028 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCStrData
&);
3029 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxCharBuffer
&);
3030 #ifndef __BORLANDC__
3031 WXDLLIMPEXP_BASE wxSTD ostream
& operator<<(wxSTD ostream
&, const wxWCharBuffer
&);
3036 WXDLLIMPEXP_BASE wxSTD wostream
& operator<<(wxSTD wostream
&, const wxString
&);
3037 WXDLLIMPEXP_BASE wxSTD wostream
& operator<<(wxSTD wostream
&, const wxCStrData
&);
3038 WXDLLIMPEXP_BASE wxSTD wostream
& operator<<(wxSTD wostream
&, const wxWCharBuffer
&);
3040 #endif // wxUSE_UNICODE
3042 #endif // wxUSE_STD_IOSTREAM
3044 // ---------------------------------------------------------------------------
3045 // wxCStrData implementation
3046 // ---------------------------------------------------------------------------
3048 inline wxCStrData::wxCStrData(char *buf
)
3049 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
3050 inline wxCStrData::wxCStrData(wchar_t *buf
)
3051 : m_str(new wxString(buf
)), m_offset(0), m_owned(true) {}
3053 inline wxCStrData::wxCStrData(const wxCStrData
& data
)
3054 : m_str(data
.m_owned
? new wxString(*data
.m_str
) : data
.m_str
),
3055 m_offset(data
.m_offset
),
3056 m_owned(data
.m_owned
)
3060 inline wxCStrData::~wxCStrData()
3063 delete wx_const_cast(wxString
*, m_str
); // cast to silence warnings
3066 // simple cases for AsChar() and AsWChar(), the complicated ones are
3068 #if wxUSE_UNICODE_WCHAR
3069 inline const wchar_t* wxCStrData::AsWChar() const
3071 return m_str
->wx_str() + m_offset
;
3073 #endif // wxUSE_UNICODE_WCHAR
3076 inline const char* wxCStrData::AsChar() const
3078 return m_str
->wx_str() + m_offset
;
3080 #endif // !wxUSE_UNICODE
3082 #if wxUSE_UTF8_LOCALE_ONLY
3083 inline const char* wxCStrData::AsChar() const
3085 return wxStringOperations::AddToIter(m_str
->wx_str(), m_offset
);
3087 #endif // wxUSE_UTF8_LOCALE_ONLY
3089 inline const wxCharBuffer
wxCStrData::AsCharBuf() const
3092 return wxCharBuffer::CreateNonOwned(AsChar());
3094 return AsString().mb_str();
3098 inline const wxWCharBuffer
wxCStrData::AsWCharBuf() const
3100 #if wxUSE_UNICODE_WCHAR
3101 return wxWCharBuffer::CreateNonOwned(AsWChar());
3103 return AsString().wc_str();
3107 inline wxString
wxCStrData::AsString() const
3109 if ( m_offset
== 0 )
3112 return m_str
->Mid(m_offset
);
3115 inline const wxStringCharType
*wxCStrData::AsInternal() const
3117 #if wxUSE_UNICODE_UTF8
3118 return wxStringOperations::AddToIter(m_str
->wx_str(), m_offset
);
3120 return m_str
->wx_str() + m_offset
;
3124 inline wxUniChar
wxCStrData::operator*() const
3126 if ( m_str
->empty() )
3127 return wxUniChar(_T('\0'));
3129 return (*m_str
)[m_offset
];
3132 inline wxUniChar
wxCStrData::operator[](size_t n
) const
3134 // NB: we intentionally use operator[] and not at() here because the former
3135 // works for the terminating NUL while the latter does not
3136 return (*m_str
)[m_offset
+ n
];
3139 // ----------------------------------------------------------------------------
3140 // more wxCStrData operators
3141 // ----------------------------------------------------------------------------
3143 // we need to define those to allow "size_t pos = p - s.c_str()" where p is
3144 // some pointer into the string
3145 inline size_t operator-(const char *p
, const wxCStrData
& cs
)
3147 return p
- cs
.AsChar();
3150 inline size_t operator-(const wchar_t *p
, const wxCStrData
& cs
)
3152 return p
- cs
.AsWChar();
3155 // ----------------------------------------------------------------------------
3156 // implementation of wx[W]CharBuffer inline methods using wxCStrData
3157 // ----------------------------------------------------------------------------
3159 // FIXME-UTF8: move this to buffer.h
3160 inline wxCharBuffer::wxCharBuffer(const wxCStrData
& cstr
)
3161 : wxCharTypeBufferBase(cstr
.AsCharBuf())
3165 inline wxWCharBuffer::wxWCharBuffer(const wxCStrData
& cstr
)
3166 : wxCharTypeBufferBase(cstr
.AsWCharBuf())
3170 #if wxUSE_UNICODE_UTF8
3171 // ----------------------------------------------------------------------------
3172 // implementation of wxStringIteratorNode inline methods
3173 // ----------------------------------------------------------------------------
3175 void wxStringIteratorNode::DoSet(const wxString
*str
,
3176 wxStringImpl::const_iterator
*citer
,
3177 wxStringImpl::iterator
*iter
)
3185 m_next
= str
->m_iterators
.ptr
;
3186 wx_const_cast(wxString
*, m_str
)->m_iterators
.ptr
= this;
3188 m_next
->m_prev
= this;
3196 void wxStringIteratorNode::clear()
3199 m_next
->m_prev
= m_prev
;
3201 m_prev
->m_next
= m_next
;
3202 else if ( m_str
) // first in the list
3203 wx_const_cast(wxString
*, m_str
)->m_iterators
.ptr
= m_next
;
3205 m_next
= m_prev
= NULL
;
3210 #endif // wxUSE_UNICODE_UTF8
3212 #if WXWIN_COMPATIBILITY_2_8
3213 // lot of code out there doesn't explicitly include wx/crt.h, but uses
3214 // CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h,
3215 // so let's include this header now that wxString is defined and it's safe
3220 #endif // _WX_WXSTRING_H_