]> git.saurik.com Git - wxWidgets.git/blob - include/wx/string.h
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxX11:
[wxWidgets.git] / include / wx / string.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: string.h
3 // Purpose: wxString and wxArrayString classes
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 /*
13 Efficient string class [more or less] compatible with MFC CString,
14 wxWindows version 1 wxString and std::string and some handy functions
15 missing from string.h.
16 */
17
18 #ifndef _WX_WXSTRINGH__
19 #define _WX_WXSTRINGH__
20
21 #ifdef __GNUG__
22 #pragma interface "string.h"
23 #endif
24
25 // ----------------------------------------------------------------------------
26 // conditinal compilation
27 // ----------------------------------------------------------------------------
28
29 // compile the std::string compatibility functions if defined
30 #define wxSTD_STRING_COMPATIBILITY
31
32 // ----------------------------------------------------------------------------
33 // headers
34 // ----------------------------------------------------------------------------
35
36 #include "wx/defs.h" // everybody should include this
37
38 #if defined(__WXMAC__) || defined(__VISAGECPP__)
39 #include <ctype.h>
40 #endif
41
42 #ifdef __EMX__
43 #include <std.h>
44 #endif
45
46 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
47 // problem in VACPP V4 with including stdlib.h multiple times
48 // strconv includes it anyway
49 # include <stdio.h>
50 # include <string.h>
51 # include <stdarg.h>
52 # include <limits.h>
53 #else
54 # include <string.h>
55 # include <stdio.h>
56 # include <stdarg.h>
57 # include <limits.h>
58 # include <stdlib.h>
59 #endif
60
61 #ifdef HAVE_STRINGS_H
62 #include <strings.h> // for strcasecmp()
63 #endif // HAVE_STRINGS_H
64
65 #include "wx/wxchar.h" // for wxChar
66 #include "wx/buffer.h" // for wxCharBuffer
67 #include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
68
69 // ---------------------------------------------------------------------------
70 // macros
71 // ---------------------------------------------------------------------------
72
73 // casts [unfortunately!] needed to call some broken functions which require
74 // "char *" instead of "const char *"
75 #define WXSTRINGCAST (wxChar *)(const wxChar *)
76 #define wxCSTRINGCAST (wxChar *)(const wxChar *)
77 #define wxMBSTRINGCAST (char *)(const char *)
78 #define wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
79
80 // implementation only
81 #define wxASSERT_VALID_INDEX(i) \
82 wxASSERT_MSG( (size_t)(i) <= Len(), _T("invaid index in wxString") )
83
84 // ----------------------------------------------------------------------------
85 // constants
86 // ----------------------------------------------------------------------------
87
88 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
89 // must define this static for VA or else you get multiply defined symbols everywhere
90 extern const unsigned int wxSTRING_MAXLEN;
91
92 #else
93 // maximum possible length for a string means "take all string" everywhere
94 // (as sizeof(StringData) is unknown here, we substract 100)
95 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
96
97 #endif
98
99 // ----------------------------------------------------------------------------
100 // global data
101 // ----------------------------------------------------------------------------
102
103 // global pointer to empty string
104 WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
105
106 // ---------------------------------------------------------------------------
107 // global functions complementing standard C string library replacements for
108 // strlen() and portable strcasecmp()
109 //---------------------------------------------------------------------------
110
111 // Use wxXXX() functions from wxchar.h instead! These functions are for
112 // backwards compatibility only.
113
114 // checks whether the passed in pointer is NULL and if the string is empty
115 inline bool IsEmpty(const char *p) { return (!p || !*p); }
116
117 // safe version of strlen() (returns 0 if passed NULL pointer)
118 inline size_t Strlen(const char *psz)
119 { return psz ? strlen(psz) : 0; }
120
121 // portable strcasecmp/_stricmp
122 inline int Stricmp(const char *psz1, const char *psz2)
123 {
124 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
125 return _stricmp(psz1, psz2);
126 #elif defined(__SC__)
127 return _stricmp(psz1, psz2);
128 #elif defined(__SALFORDC__)
129 return stricmp(psz1, psz2);
130 #elif defined(__BORLANDC__)
131 return stricmp(psz1, psz2);
132 #elif defined(__WATCOMC__)
133 return stricmp(psz1, psz2);
134 #elif defined(__DJGPP__)
135 return stricmp(psz1, psz2);
136 #elif defined(__EMX__)
137 return stricmp(psz1, psz2);
138 #elif defined(__WXPM__)
139 return stricmp(psz1, psz2);
140 #elif defined(__UNIX__) || defined(__GNUWIN32__)
141 return strcasecmp(psz1, psz2);
142 #elif defined(__MWERKS__) && !defined(__INTEL__)
143 register char c1, c2;
144 do {
145 c1 = tolower(*psz1++);
146 c2 = tolower(*psz2++);
147 } while ( c1 && (c1 == c2) );
148
149 return c1 - c2;
150 #else
151 // almost all compilers/libraries provide this function (unfortunately under
152 // different names), that's why we don't implement our own which will surely
153 // be more efficient than this code (uncomment to use):
154 /*
155 register char c1, c2;
156 do {
157 c1 = tolower(*psz1++);
158 c2 = tolower(*psz2++);
159 } while ( c1 && (c1 == c2) );
160
161 return c1 - c2;
162 */
163
164 #error "Please define string case-insensitive compare for your OS/compiler"
165 #endif // OS/compiler
166 }
167
168 // wxSnprintf() is like snprintf() if it's available and sprintf() (always
169 // available, but dangerous!) if not
170 extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
171 const wxChar *format, ...);
172
173 // and wxVsnprintf() is like vsnprintf() or vsprintf()
174 extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
175 const wxChar *format, va_list argptr);
176
177 // return an empty wxString
178 class WXDLLEXPORT wxString; // not yet defined
179 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
180
181 // ---------------------------------------------------------------------------
182 // string data prepended with some housekeeping info (used by wxString class),
183 // is never used directly (but had to be put here to allow inlining)
184 // ---------------------------------------------------------------------------
185
186 struct WXDLLEXPORT wxStringData
187 {
188 int nRefs; // reference count
189 size_t nDataLength, // actual string length
190 nAllocLength; // allocated memory size
191
192 // mimics declaration 'wxChar data[nAllocLength]'
193 wxChar* data() const { return (wxChar*)(this + 1); }
194
195 // empty string has a special ref count so it's never deleted
196 bool IsEmpty() const { return (nRefs == -1); }
197 bool IsShared() const { return (nRefs > 1); }
198
199 // lock/unlock
200 void Lock() { if ( !IsEmpty() ) nRefs++; }
201
202 // VC++ will refuse to inline this function but profiling shows that it
203 // is wrong
204 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
205 __forceinline
206 #endif
207 void Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this); }
208
209 // if we had taken control over string memory (GetWriteBuf), it's
210 // intentionally put in invalid state
211 void Validate(bool b) { nRefs = (b ? 1 : 0); }
212 bool IsValid() const { return (nRefs != 0); }
213 };
214
215 // ---------------------------------------------------------------------------
216 // This is (yet another one) String class for C++ programmers. It doesn't use
217 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
218 // thus you should be able to compile it with practicaly any C++ compiler.
219 // This class uses copy-on-write technique, i.e. identical strings share the
220 // same memory as long as neither of them is changed.
221 //
222 // This class aims to be as compatible as possible with the new standard
223 // std::string class, but adds some additional functions and should be at
224 // least as efficient than the standard implementation.
225 //
226 // Performance note: it's more efficient to write functions which take "const
227 // String&" arguments than "const char *" if you assign the argument to
228 // another string.
229 //
230 // It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
231 //
232 // To do:
233 // - ressource support (string tables in ressources)
234 // - more wide character (UNICODE) support
235 // - regular expressions support
236 // ---------------------------------------------------------------------------
237
238 class WXDLLEXPORT wxString
239 {
240 friend class WXDLLEXPORT wxArrayString;
241
242 // NB: special care was taken in arranging the member functions in such order
243 // that all inline functions can be effectively inlined, verify that all
244 // performace critical functions are still inlined if you change order!
245 private:
246 // points to data preceded by wxStringData structure with ref count info
247 wxChar *m_pchData;
248
249 // accessor to string data
250 wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
251
252 // string (re)initialization functions
253 // initializes the string to the empty value (must be called only from
254 // ctors, use Reinit() otherwise)
255 void Init() { m_pchData = (wxChar *)wxEmptyString; }
256 // initializaes the string with (a part of) C-string
257 void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = wxSTRING_MAXLEN);
258 // as Init, but also frees old data
259 void Reinit() { GetStringData()->Unlock(); Init(); }
260
261 // memory allocation
262 // allocates memory for string of lenght nLen
263 void AllocBuffer(size_t nLen);
264 // copies data to another string
265 void AllocCopy(wxString&, int, int) const;
266 // effectively copies data to string
267 void AssignCopy(size_t, const wxChar *);
268
269 // append a (sub)string
270 void ConcatSelf(int nLen, const wxChar *src);
271
272 // functions called before writing to the string: they copy it if there
273 // are other references to our data (should be the only owner when writing)
274 void CopyBeforeWrite();
275 void AllocBeforeWrite(size_t);
276
277 // if we hadn't made these operators private, it would be possible to
278 // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
279 // converted to char in C and we do have operator=(char)
280 //
281 // NB: we don't need other versions (short/long and unsigned) as attempt
282 // to assign another numeric type to wxString will now result in
283 // ambiguity between operator=(char) and operator=(int)
284 wxString& operator=(int);
285
286 // these methods are not implemented - there is _no_ conversion from int to
287 // string, you're doing something wrong if the compiler wants to call it!
288 //
289 // try `s << i' or `s.Printf("%d", i)' instead
290 wxString(int);
291
292 public:
293 // constructors and destructor
294 // ctor for an empty string
295 wxString() { Init(); }
296 // copy ctor
297 wxString(const wxString& stringSrc)
298 {
299 wxASSERT( stringSrc.GetStringData()->IsValid() );
300
301 if ( stringSrc.IsEmpty() ) {
302 // nothing to do for an empty string
303 Init();
304 }
305 else {
306 m_pchData = stringSrc.m_pchData; // share same data
307 GetStringData()->Lock(); // => one more copy
308 }
309 }
310 // string containing nRepeat copies of ch
311 wxString(wxChar ch, size_t nRepeat = 1);
312 // ctor takes first nLength characters from C string
313 // (default value of wxSTRING_MAXLEN means take all the string)
314 wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
315 { InitWith(psz, 0, nLength); }
316 wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
317 { InitWith(psz, 0, nLength); }
318
319 #if wxUSE_UNICODE
320 // from multibyte string
321 // (NB: nLength is right now number of Unicode characters, not
322 // characters in psz! So try not to use it yet!)
323 wxString(const char *psz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);
324 // from wxWCharBuffer (i.e. return from wxGetString)
325 wxString(const wxWCharBuffer& psz)
326 { InitWith(psz, 0, wxSTRING_MAXLEN); }
327 #else // ANSI
328 // from C string (for compilers using unsigned char)
329 wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
330 { InitWith((const char*)psz, 0, nLength); }
331
332 #if wxUSE_WCHAR_T
333 // from wide (Unicode) string
334 wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);
335 #endif // !wxUSE_WCHAR_T
336
337 // from wxCharBuffer
338 wxString(const wxCharBuffer& psz)
339 { InitWith(psz, 0, wxSTRING_MAXLEN); }
340 #endif // Unicode/ANSI
341
342 // dtor is not virtual, this class must not be inherited from!
343 ~wxString() { GetStringData()->Unlock(); }
344
345 // generic attributes & operations
346 // as standard strlen()
347 size_t Len() const { return GetStringData()->nDataLength; }
348 // string contains any characters?
349 bool IsEmpty() const { return Len() == 0; }
350 // empty string is "FALSE", so !str will return TRUE
351 bool operator!() const { return IsEmpty(); }
352 // truncate the string to given length
353 wxString& Truncate(size_t uiLen);
354 // empty string contents
355 void Empty()
356 {
357 Truncate(0);
358
359 wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );
360 }
361 // empty the string and free memory
362 void Clear()
363 {
364 if ( !GetStringData()->IsEmpty() )
365 Reinit();
366
367 wxASSERT( GetStringData()->nDataLength == 0 ); // should be empty
368 wxASSERT( GetStringData()->nAllocLength == 0 ); // and not own any memory
369 }
370
371 // contents test
372 // Is an ascii value
373 bool IsAscii() const;
374 // Is a number
375 bool IsNumber() const;
376 // Is a word
377 bool IsWord() const;
378
379 // data access (all indexes are 0 based)
380 // read access
381 wxChar GetChar(size_t n) const
382 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
383 // read/write access
384 wxChar& GetWritableChar(size_t n)
385 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
386 // write access
387 void SetChar(size_t n, wxChar ch)
388 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }
389
390 // get last character
391 wxChar Last() const
392 { wxASSERT( !IsEmpty() ); return m_pchData[Len() - 1]; }
393 // get writable last character
394 wxChar& Last()
395 { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
396
397 /*
398 So why do we have all these overloaded operator[]s? A bit of history:
399 initially there was only one of them, taking size_t. Then people
400 started complaining because they wanted to use ints as indices (I
401 wonder why) and compilers were giving warnings about it, so we had to
402 add the operator[](int). Then it became apparent that you couldn't
403 write str[0] any longer because there was ambiguity between two
404 overloads and so you now had to write str[0u] (or, of course, use the
405 explicit casts to either int or size_t but nobody did this).
406
407 Finally, someone decided to compile wxWin on an Alpha machine and got
408 a surprize: str[0u] didn't compile there because it is of type
409 unsigned int and size_t is unsigned _long_ on Alpha and so there was
410 ambiguity between converting uint to int or ulong. To fix this one we
411 now add operator[](uint) for the machines where size_t is not already
412 the same as unsigned int - hopefully this fixes the problem (for some
413 time)
414
415 The only real fix is, of course, to remove all versions but the one
416 taking size_t...
417 */
418
419 // operator version of GetChar
420 wxChar operator[](size_t n) const
421 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
422
423 // operator version of GetChar
424 wxChar operator[](int n) const
425 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
426
427 // operator version of GetWriteableChar
428 wxChar& operator[](size_t n)
429 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
430
431 #ifndef wxSIZE_T_IS_UINT
432 // operator version of GetChar
433 wxChar operator[](unsigned int n) const
434 { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
435
436 // operator version of GetWriteableChar
437 wxChar& operator[](unsigned int n)
438 { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
439 #endif // size_t != unsigned int
440
441 // implicit conversion to C string
442 operator const wxChar*() const { return m_pchData; }
443 // explicit conversion to C string (use this with printf()!)
444 const wxChar* c_str() const { return m_pchData; }
445 // identical to c_str()
446 const wxChar* wx_str() const { return m_pchData; }
447 // identical to c_str()
448 const wxChar* GetData() const { return m_pchData; }
449
450 // conversions with (possible) format convertions: have to return a
451 // buffer with temporary data
452 //
453 // the functions defined (in either Unicode or ANSI) mode are mb_str() to
454 // return an ANSI (multibyte) string, wc_str() to return a wide string and
455 // fn_str() to return a string which should be used with the OS APIs
456 // accepting the file names. The return value is always the same, but the
457 // type differs because a function may either return pointer to the buffer
458 // directly or have to use intermediate buffer for translation.
459 #if wxUSE_UNICODE
460 const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
461 { return conv.cWC2MB(m_pchData); }
462
463 const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
464
465 const wxChar* wc_str() const { return m_pchData; }
466
467 // for compatibility with !wxUSE_UNICODE version
468 const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
469
470 #if wxMBFILES
471 const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
472 #else // !wxMBFILES
473 const wxChar* fn_str() const { return m_pchData; }
474 #endif // wxMBFILES/!wxMBFILES
475 #else // ANSI
476 const wxChar* mb_str() const { return m_pchData; }
477
478 // for compatibility with wxUSE_UNICODE version
479 const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
480
481 const wxWX2MBbuf mbc_str() const { return mb_str(); }
482
483 #if wxUSE_WCHAR_T
484 const wxWCharBuffer wc_str(wxMBConv& conv) const
485 { return conv.cMB2WC(m_pchData); }
486 #endif // wxUSE_WCHAR_T
487
488 const wxChar* fn_str() const { return m_pchData; }
489 #endif // Unicode/ANSI
490
491 // overloaded assignment
492 // from another wxString
493 wxString& operator=(const wxString& stringSrc);
494 // from a character
495 wxString& operator=(wxChar ch);
496 // from a C string
497 wxString& operator=(const wxChar *psz);
498 #if wxUSE_UNICODE
499 // from wxWCharBuffer
500 wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); }
501 #else // ANSI
502 // from another kind of C string
503 wxString& operator=(const unsigned char* psz);
504 #if wxUSE_WCHAR_T
505 // from a wide string
506 wxString& operator=(const wchar_t *pwz);
507 #endif
508 // from wxCharBuffer
509 wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); }
510 #endif // Unicode/ANSI
511
512 // string concatenation
513 // in place concatenation
514 /*
515 Concatenate and return the result. Note that the left to right
516 associativity of << allows to write things like "str << str1 << str2
517 << ..." (unlike with +=)
518 */
519 // string += string
520 wxString& operator<<(const wxString& s)
521 {
522 wxASSERT( s.GetStringData()->IsValid() );
523
524 ConcatSelf(s.Len(), s);
525 return *this;
526 }
527 // string += C string
528 wxString& operator<<(const wxChar *psz)
529 { ConcatSelf(wxStrlen(psz), psz); return *this; }
530 // string += char
531 wxString& operator<<(wxChar ch) { ConcatSelf(1, &ch); return *this; }
532
533 // string += string
534 void operator+=(const wxString& s) { (void)operator<<(s); }
535 // string += C string
536 void operator+=(const wxChar *psz) { (void)operator<<(psz); }
537 // string += char
538 void operator+=(wxChar ch) { (void)operator<<(ch); }
539
540 // string += buffer (i.e. from wxGetString)
541 #if wxUSE_UNICODE
542 wxString& operator<<(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); return *this; }
543 void operator+=(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); }
544 #else
545 wxString& operator<<(const wxCharBuffer& s) { (void)operator<<((const char *)s); return *this; }
546 void operator+=(const wxCharBuffer& s) { (void)operator<<((const char *)s); }
547 #endif
548
549 // string += C string
550 wxString& Append(const wxChar* psz)
551 { ConcatSelf(wxStrlen(psz), psz); return *this; }
552 // append count copies of given character
553 wxString& Append(wxChar ch, size_t count = 1u)
554 { wxString str(ch, count); return *this << str; }
555 wxString& Append(const wxChar* psz, size_t nLen)
556 { ConcatSelf(nLen, psz); return *this; }
557
558 // prepend a string, return the string itself
559 wxString& Prepend(const wxString& str)
560 { *this = str + *this; return *this; }
561
562 // non-destructive concatenation
563 //
564 friend wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2);
565 //
566 friend wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
567 //
568 friend wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
569 //
570 friend wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
571 //
572 friend wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
573
574 // stream-like functions
575 // insert an int into string
576 wxString& operator<<(int i)
577 { return (*this) << Format(_T("%d"), i); }
578 // insert an unsigned int into string
579 wxString& operator<<(unsigned int ui)
580 { return (*this) << Format(_T("%u"), ui); }
581 // insert a long into string
582 wxString& operator<<(long l)
583 { return (*this) << Format(_T("%ld"), l); }
584 // insert an unsigned long into string
585 wxString& operator<<(unsigned long ul)
586 { return (*this) << Format(_T("%lu"), ul); }
587 // insert a float into string
588 wxString& operator<<(float f)
589 { return (*this) << Format(_T("%f"), f); }
590 // insert a double into string
591 wxString& operator<<(double d)
592 { return (*this) << Format(_T("%g"), d); }
593
594 // string comparison
595 // case-sensitive comparison (returns a value < 0, = 0 or > 0)
596 int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
597 // same as Cmp() but not case-sensitive
598 int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
599 // test for the string equality, either considering case or not
600 // (if compareWithCase then the case matters)
601 bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
602 { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
603 // comparison with a signle character: returns TRUE if equal
604 bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
605 {
606 return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
607 : wxToupper(GetChar(0u)) == wxToupper(c));
608 }
609
610 // simple sub-string extraction
611 // return substring starting at nFirst of length nCount (or till the end
612 // if nCount = default value)
613 wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
614
615 // operator version of Mid()
616 wxString operator()(size_t start, size_t len) const
617 { return Mid(start, len); }
618
619 // check that the string starts with prefix and return the rest of the
620 // string in the provided pointer if it is not NULL, otherwise return
621 // FALSE
622 bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
623
624 // get first nCount characters
625 wxString Left(size_t nCount) const;
626 // get last nCount characters
627 wxString Right(size_t nCount) const;
628 // get all characters before the first occurance of ch
629 // (returns the whole string if ch not found)
630 wxString BeforeFirst(wxChar ch) const;
631 // get all characters before the last occurence of ch
632 // (returns empty string if ch not found)
633 wxString BeforeLast(wxChar ch) const;
634 // get all characters after the first occurence of ch
635 // (returns empty string if ch not found)
636 wxString AfterFirst(wxChar ch) const;
637 // get all characters after the last occurence of ch
638 // (returns the whole string if ch not found)
639 wxString AfterLast(wxChar ch) const;
640
641 // for compatibility only, use more explicitly named functions above
642 wxString Before(wxChar ch) const { return BeforeLast(ch); }
643 wxString After(wxChar ch) const { return AfterFirst(ch); }
644
645 // case conversion
646 // convert to upper case in place, return the string itself
647 wxString& MakeUpper();
648 // convert to upper case, return the copy of the string
649 // Here's something to remember: BC++ doesn't like returns in inlines.
650 wxString Upper() const ;
651 // convert to lower case in place, return the string itself
652 wxString& MakeLower();
653 // convert to lower case, return the copy of the string
654 wxString Lower() const ;
655
656 // trimming/padding whitespace (either side) and truncating
657 // remove spaces from left or from right (default) side
658 wxString& Trim(bool bFromRight = TRUE);
659 // add nCount copies chPad in the beginning or at the end (default)
660 wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
661
662 // searching and replacing
663 // searching (return starting index, or -1 if not found)
664 int Find(wxChar ch, bool bFromEnd = FALSE) const; // like strchr/strrchr
665 // searching (return starting index, or -1 if not found)
666 int Find(const wxChar *pszSub) const; // like strstr
667 // replace first (or all of bReplaceAll) occurences of substring with
668 // another string, returns the number of replacements made
669 size_t Replace(const wxChar *szOld,
670 const wxChar *szNew,
671 bool bReplaceAll = TRUE);
672
673 // check if the string contents matches a mask containing '*' and '?'
674 bool Matches(const wxChar *szMask) const;
675
676 // conversion to numbers: all functions return TRUE only if the whole string
677 // is a number and put the value of this number into the pointer provided
678 // convert to a signed integer
679 bool ToLong(long *val, int base = 0) const;
680 // convert to an unsigned integer
681 bool ToULong(unsigned long *val, int base = 0) const;
682 // convert to a double
683 bool ToDouble(double *val) const;
684
685 // formated input/output
686 // as sprintf(), returns the number of characters written or < 0 on error
687 int Printf(const wxChar *pszFormat, ...);
688 // as vprintf(), returns the number of characters written or < 0 on error
689 int PrintfV(const wxChar* pszFormat, va_list argptr);
690
691 // returns the string containing the result of Printf() to it
692 static wxString Format(const wxChar *pszFormat, ...);
693 // the same as above, but takes a va_list
694 static wxString FormatV(const wxChar *pszFormat, va_list argptr);
695
696 // raw access to string memory
697 // ensure that string has space for at least nLen characters
698 // only works if the data of this string is not shared
699 void Alloc(size_t nLen);
700 // minimize the string's memory
701 // only works if the data of this string is not shared
702 void Shrink();
703 // get writable buffer of at least nLen bytes. Unget() *must* be called
704 // a.s.a.p. to put string back in a reasonable state!
705 wxChar *GetWriteBuf(size_t nLen);
706 // call this immediately after GetWriteBuf() has been used
707 void UngetWriteBuf();
708 void UngetWriteBuf(size_t nLen);
709
710 // wxWindows version 1 compatibility functions
711
712 // use Mid()
713 wxString SubString(size_t from, size_t to) const
714 { return Mid(from, (to - from + 1)); }
715 // values for second parameter of CompareTo function
716 enum caseCompare {exact, ignoreCase};
717 // values for first parameter of Strip function
718 enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
719
720 // use Printf()
721 int sprintf(const wxChar *pszFormat, ...);
722
723 // use Cmp()
724 inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
725 { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
726
727 // use Len
728 size_t Length() const { return Len(); }
729 // Count the number of characters
730 int Freq(wxChar ch) const;
731 // use MakeLower
732 void LowerCase() { MakeLower(); }
733 // use MakeUpper
734 void UpperCase() { MakeUpper(); }
735 // use Trim except that it doesn't change this string
736 wxString Strip(stripType w = trailing) const;
737
738 // use Find (more general variants not yet supported)
739 size_t Index(const wxChar* psz) const { return Find(psz); }
740 size_t Index(wxChar ch) const { return Find(ch); }
741 // use Truncate
742 wxString& Remove(size_t pos) { return Truncate(pos); }
743 wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }
744
745 wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
746
747 // use Find()
748 int First( const wxChar ch ) const { return Find(ch); }
749 int First( const wxChar* psz ) const { return Find(psz); }
750 int First( const wxString &str ) const { return Find(str); }
751 int Last( const wxChar ch ) const { return Find(ch, TRUE); }
752 bool Contains(const wxString& str) const { return Find(str) != -1; }
753
754 // use IsEmpty()
755 bool IsNull() const { return IsEmpty(); }
756
757 #ifdef wxSTD_STRING_COMPATIBILITY
758 // std::string compatibility functions
759
760 // standard types
761 typedef wxChar value_type;
762 typedef const value_type *const_iterator;
763
764 // an 'invalid' value for string index
765 static const size_t npos;
766
767 // constructors
768 // take nLen chars starting at nPos
769 wxString(const wxString& str, size_t nPos, size_t nLen)
770 {
771 wxASSERT( str.GetStringData()->IsValid() );
772 InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
773 }
774 // take all characters from pStart to pEnd
775 wxString(const void *pStart, const void *pEnd);
776
777 // lib.string.capacity
778 // return the length of the string
779 size_t size() const { return Len(); }
780 // return the length of the string
781 size_t length() const { return Len(); }
782 // return the maximum size of the string
783 size_t max_size() const { return wxSTRING_MAXLEN; }
784 // resize the string, filling the space with c if c != 0
785 void resize(size_t nSize, wxChar ch = wxT('\0'));
786 // delete the contents of the string
787 void clear() { Empty(); }
788 // returns true if the string is empty
789 bool empty() const { return IsEmpty(); }
790 // inform string about planned change in size
791 void reserve(size_t size) { Alloc(size); }
792
793 // lib.string.access
794 // return the character at position n
795 wxChar at(size_t n) const { return GetChar(n); }
796 // returns the writable character at position n
797 wxChar& at(size_t n) { return GetWritableChar(n); }
798
799 // first valid index position
800 const_iterator begin() const { return wx_str(); }
801 // position one after the last valid one
802 const_iterator end() const { return wx_str() + length(); }
803
804 // lib.string.modifiers
805 // append a string
806 wxString& append(const wxString& str)
807 { *this += str; return *this; }
808 // append elements str[pos], ..., str[pos+n]
809 wxString& append(const wxString& str, size_t pos, size_t n)
810 { ConcatSelf(n, str.c_str() + pos); return *this; }
811 // append first n (or all if n == npos) characters of sz
812 wxString& append(const wxChar *sz, size_t n = npos)
813 { ConcatSelf(n == npos ? wxStrlen(sz) : n, sz); return *this; }
814
815 // append n copies of ch
816 wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
817
818 // same as `this_string = str'
819 wxString& assign(const wxString& str)
820 { return *this = str; }
821 // same as ` = str[pos..pos + n]
822 wxString& assign(const wxString& str, size_t pos, size_t n)
823 { Empty(); return Append(str.c_str() + pos, n); }
824 // same as `= first n (or all if n == npos) characters of sz'
825 wxString& assign(const wxChar *sz, size_t n = npos)
826 { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }
827 // same as `= n copies of ch'
828 wxString& assign(size_t n, wxChar ch)
829 { Empty(); return Append(ch, n); }
830
831 // insert another string
832 wxString& insert(size_t nPos, const wxString& str);
833 // insert n chars of str starting at nStart (in str)
834 wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
835 { return insert(nPos, wxString((const wxChar *)str + nStart, n)); }
836
837 // insert first n (or all if n == npos) characters of sz
838 wxString& insert(size_t nPos, const wxChar *sz, size_t n = npos)
839 { return insert(nPos, wxString(sz, n)); }
840 // insert n copies of ch
841 wxString& insert(size_t nPos, size_t n, wxChar ch)
842 { return insert(nPos, wxString(ch, n)); }
843
844 // delete characters from nStart to nStart + nLen
845 wxString& erase(size_t nStart = 0, size_t nLen = npos);
846
847 // replaces the substring of length nLen starting at nStart
848 wxString& replace(size_t nStart, size_t nLen, const wxChar* sz);
849 // replaces the substring with nCount copies of ch
850 wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);
851 // replaces a substring with another substring
852 wxString& replace(size_t nStart, size_t nLen,
853 const wxString& str, size_t nStart2, size_t nLen2);
854 // replaces the substring with first nCount chars of sz
855 wxString& replace(size_t nStart, size_t nLen,
856 const wxChar* sz, size_t nCount);
857
858 // swap two strings
859 void swap(wxString& str);
860
861 // All find() functions take the nStart argument which specifies the
862 // position to start the search on, the default value is 0. All functions
863 // return npos if there were no match.
864
865 // find a substring
866 size_t find(const wxString& str, size_t nStart = 0) const;
867
868 // VC++ 1.5 can't cope with this syntax.
869 #if !defined(__VISUALC__) || defined(__WIN32__)
870 // find first n characters of sz
871 size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
872 #endif // VC++ 1.5
873
874 // Gives a duplicate symbol (presumably a case-insensitivity problem)
875 #if !defined(__BORLANDC__)
876 // find the first occurence of character ch after nStart
877 size_t find(wxChar ch, size_t nStart = 0) const;
878 #endif
879 // rfind() family is exactly like find() but works right to left
880
881 // as find, but from the end
882 size_t rfind(const wxString& str, size_t nStart = npos) const;
883
884 // VC++ 1.5 can't cope with this syntax.
885 #if !defined(__VISUALC__) || defined(__WIN32__)
886 // as find, but from the end
887 size_t rfind(const wxChar* sz, size_t nStart = npos,
888 size_t n = npos) const;
889 // as find, but from the end
890 size_t rfind(wxChar ch, size_t nStart = npos) const;
891 #endif // VC++ 1.5
892
893 // find first/last occurence of any character in the set
894
895 // as strpbrk() but starts at nStart, returns npos if not found
896 size_t find_first_of(const wxString& str, size_t nStart = 0) const
897 { return find_first_of(str.c_str(), nStart); }
898 // same as above
899 size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
900 // same as find(char, size_t)
901 size_t find_first_of(wxChar c, size_t nStart = 0) const
902 { return find(c, nStart); }
903 // find the last (starting from nStart) char from str in this string
904 size_t find_last_of (const wxString& str, size_t nStart = npos) const
905 { return find_last_of(str.c_str(), nStart); }
906 // same as above
907 size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
908 // same as above
909 size_t find_last_of(wxChar c, size_t nStart = npos) const
910 { return rfind(c, nStart); }
911
912 // find first/last occurence of any character not in the set
913
914 // as strspn() (starting from nStart), returns npos on failure
915 size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
916 { return find_first_not_of(str.c_str(), nStart); }
917 // same as above
918 size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
919 // same as above
920 size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
921 // as strcspn()
922 size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
923 { return find_first_not_of(str.c_str(), nStart); }
924 // same as above
925 size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
926 // same as above
927 size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
928
929 // All compare functions return -1, 0 or 1 if the [sub]string is less,
930 // equal or greater than the compare() argument.
931
932 // just like strcmp()
933 int compare(const wxString& str) const { return Cmp(str); }
934 // comparison with a substring
935 int compare(size_t nStart, size_t nLen, const wxString& str) const
936 { return Mid(nStart, nLen).Cmp(str); }
937 // comparison of 2 substrings
938 int compare(size_t nStart, size_t nLen,
939 const wxString& str, size_t nStart2, size_t nLen2) const
940 { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }
941 // just like strcmp()
942 int compare(const wxChar* sz) const { return Cmp(sz); }
943 // substring comparison with first nCount characters of sz
944 int compare(size_t nStart, size_t nLen,
945 const wxChar* sz, size_t nCount = npos) const
946 { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }
947
948 // substring extraction
949 wxString substr(size_t nStart = 0, size_t nLen = npos) const
950 { return Mid(nStart, nLen); }
951 #endif // wxSTD_STRING_COMPATIBILITY
952 };
953
954 // ----------------------------------------------------------------------------
955 // The string array uses it's knowledge of internal structure of the wxString
956 // class to optimize string storage. Normally, we would store pointers to
957 // string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is
958 // sizeof(char *)) we store these pointers instead. The cast to "wxString *" is
959 // really all we need to turn such pointer into a string!
960 //
961 // Of course, it can be called a dirty hack, but we use twice less memory and
962 // this approach is also more speed efficient, so it's probably worth it.
963 //
964 // Usage notes: when a string is added/inserted, a new copy of it is created,
965 // so the original string may be safely deleted. When a string is retrieved
966 // from the array (operator[] or Item() method), a reference is returned.
967 // ----------------------------------------------------------------------------
968
969 class WXDLLEXPORT wxArrayString
970 {
971 public:
972 // type of function used by wxArrayString::Sort()
973 typedef int (*CompareFunction)(const wxString& first,
974 const wxString& second);
975
976 // constructors and destructor
977 // default ctor
978 wxArrayString() { Init(FALSE); }
979 // if autoSort is TRUE, the array is always sorted (in alphabetical order)
980 //
981 // NB: the reason for using int and not bool is that like this we can avoid
982 // using this ctor for implicit conversions from "const char *" (which
983 // we'd like to be implicitly converted to wxString instead!)
984 //
985 // of course, using explicit would be even better - if all compilers
986 // supported it...
987 wxArrayString(int autoSort) { Init(autoSort != 0); }
988 // copy ctor
989 wxArrayString(const wxArrayString& array);
990 // assignment operator
991 wxArrayString& operator=(const wxArrayString& src);
992 // not virtual, this class should not be derived from
993 ~wxArrayString();
994
995 // memory management
996 // empties the list, but doesn't release memory
997 void Empty();
998 // empties the list and releases memory
999 void Clear();
1000 // preallocates memory for given number of items
1001 void Alloc(size_t nCount);
1002 // minimzes the memory usage (by freeing all extra memory)
1003 void Shrink();
1004
1005 // simple accessors
1006 // number of elements in the array
1007 size_t GetCount() const { return m_nCount; }
1008 // is it empty?
1009 bool IsEmpty() const { return m_nCount == 0; }
1010 // number of elements in the array (GetCount is preferred API)
1011 size_t Count() const { return m_nCount; }
1012
1013 // items access (range checking is done in debug version)
1014 // get item at position uiIndex
1015 wxString& Item(size_t nIndex) const
1016 { wxASSERT( nIndex < m_nCount ); return *(wxString *)&(m_pItems[nIndex]); }
1017 // same as Item()
1018 wxString& operator[](size_t nIndex) const { return Item(nIndex); }
1019 // get last item
1020 wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
1021
1022 // return a wxString[], useful for the controls which
1023 // take one in their ctor. You must delete[] it yourself
1024 // once you are done with it. Will return NULL if the
1025 // ArrayString was empty.
1026 wxString* GetStringArray() const;
1027
1028 // item management
1029 // Search the element in the array, starting from the beginning if
1030 // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
1031 // sensitive (default). Returns index of the first item matched or
1032 // wxNOT_FOUND
1033 int Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
1034 // add new element at the end (if the array is not sorted), return its
1035 // index
1036 size_t Add(const wxString& str);
1037 // add new element at given position
1038 void Insert(const wxString& str, size_t uiIndex);
1039 // expand the array to have count elements
1040 void SetCount(size_t count);
1041 // remove first item matching this value
1042 void Remove(const wxChar *sz);
1043 // remove item by index
1044 void Remove(size_t nIndex);
1045 void RemoveAt(size_t nIndex) { Remove(nIndex); }
1046
1047 // sorting
1048 // sort array elements in alphabetical order (or reversed alphabetical
1049 // order if reverseOrder parameter is TRUE)
1050 void Sort(bool reverseOrder = FALSE);
1051 // sort array elements using specified comparaison function
1052 void Sort(CompareFunction compareFunction);
1053
1054 // comparison
1055 // compare two arrays case sensitively
1056 bool operator==(const wxArrayString& a) const;
1057 // compare two arrays case sensitively
1058 bool operator!=(const wxArrayString& a) const { return !(*this == a); }
1059
1060 protected:
1061 void Init(bool autoSort); // common part of all ctors
1062 void Copy(const wxArrayString& src); // copies the contents of another array
1063
1064 private:
1065 void Grow(); // makes array bigger if needed
1066 void Free(); // free all the strings stored
1067
1068 void DoSort(); // common part of all Sort() variants
1069
1070 size_t m_nSize, // current size of the array
1071 m_nCount; // current number of elements
1072
1073 wxChar **m_pItems; // pointer to data
1074
1075 bool m_autoSort; // if TRUE, keep the array always sorted
1076 };
1077
1078 class WXDLLEXPORT wxSortedArrayString : public wxArrayString
1079 {
1080 public:
1081 wxSortedArrayString() : wxArrayString(TRUE)
1082 { }
1083 wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE)
1084 { Copy(array); }
1085 };
1086
1087 // ----------------------------------------------------------------------------
1088 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
1089 // ----------------------------------------------------------------------------
1090
1091 class WXDLLEXPORT wxStringBuffer
1092 {
1093 public:
1094 wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1095 : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); }
1096
1097 ~wxStringBuffer() { m_str.UngetWriteBuf(); }
1098
1099 operator wxChar*() const { return m_buf; }
1100
1101 private:
1102 wxString& m_str;
1103 wxChar *m_buf;
1104 };
1105
1106 // ---------------------------------------------------------------------------
1107 // wxString comparison functions: operator versions are always case sensitive
1108 // ---------------------------------------------------------------------------
1109
1110 inline bool operator==(const wxString& s1, const wxString& s2)
1111 { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
1112 inline bool operator==(const wxString& s1, const wxChar * s2)
1113 { return s1.Cmp(s2) == 0; }
1114 inline bool operator==(const wxChar * s1, const wxString& s2)
1115 { return s2.Cmp(s1) == 0; }
1116 inline bool operator!=(const wxString& s1, const wxString& s2)
1117 { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
1118 inline bool operator!=(const wxString& s1, const wxChar * s2)
1119 { return s1.Cmp(s2) != 0; }
1120 inline bool operator!=(const wxChar * s1, const wxString& s2)
1121 { return s2.Cmp(s1) != 0; }
1122 inline bool operator< (const wxString& s1, const wxString& s2)
1123 { return s1.Cmp(s2) < 0; }
1124 inline bool operator< (const wxString& s1, const wxChar * s2)
1125 { return s1.Cmp(s2) < 0; }
1126 inline bool operator< (const wxChar * s1, const wxString& s2)
1127 { return s2.Cmp(s1) > 0; }
1128 inline bool operator> (const wxString& s1, const wxString& s2)
1129 { return s1.Cmp(s2) > 0; }
1130 inline bool operator> (const wxString& s1, const wxChar * s2)
1131 { return s1.Cmp(s2) > 0; }
1132 inline bool operator> (const wxChar * s1, const wxString& s2)
1133 { return s2.Cmp(s1) < 0; }
1134 inline bool operator<=(const wxString& s1, const wxString& s2)
1135 { return s1.Cmp(s2) <= 0; }
1136 inline bool operator<=(const wxString& s1, const wxChar * s2)
1137 { return s1.Cmp(s2) <= 0; }
1138 inline bool operator<=(const wxChar * s1, const wxString& s2)
1139 { return s2.Cmp(s1) >= 0; }
1140 inline bool operator>=(const wxString& s1, const wxString& s2)
1141 { return s1.Cmp(s2) >= 0; }
1142 inline bool operator>=(const wxString& s1, const wxChar * s2)
1143 { return s1.Cmp(s2) >= 0; }
1144 inline bool operator>=(const wxChar * s1, const wxString& s2)
1145 { return s2.Cmp(s1) <= 0; }
1146
1147 // comparison with char
1148 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
1149 inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
1150 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
1151 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
1152
1153 #if wxUSE_UNICODE
1154 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
1155 { return (s1.Cmp((const wchar_t *)s2) == 0); }
1156 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
1157 { return (s2.Cmp((const wchar_t *)s1) == 0); }
1158 inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
1159 { return (s1.Cmp((const wchar_t *)s2) != 0); }
1160 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
1161 { return (s2.Cmp((const wchar_t *)s1) != 0); }
1162 #else // !wxUSE_UNICODE
1163 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
1164 { return (s1.Cmp((const char *)s2) == 0); }
1165 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
1166 { return (s2.Cmp((const char *)s1) == 0); }
1167 inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
1168 { return (s1.Cmp((const char *)s2) != 0); }
1169 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
1170 { return (s2.Cmp((const char *)s1) != 0); }
1171 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1172
1173 wxString WXDLLEXPORT operator+(const wxString& string1, const wxString& string2);
1174 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
1175 wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
1176 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
1177 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
1178 #if wxUSE_UNICODE
1179 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
1180 { return string + (const wchar_t *)buf; }
1181 inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
1182 { return (const wchar_t *)buf + string; }
1183 #else // !wxUSE_UNICODE
1184 inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
1185 { return string + (const char *)buf; }
1186 inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
1187 { return (const char *)buf + string; }
1188 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1189
1190 // ---------------------------------------------------------------------------
1191 // Implementation only from here until the end of file
1192 // ---------------------------------------------------------------------------
1193
1194 // don't pollute the library user's name space
1195 #undef wxASSERT_VALID_INDEX
1196
1197 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
1198
1199 #include "wx/ioswrap.h"
1200
1201 WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
1202 WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
1203
1204 #endif // wxSTD_STRING_COMPATIBILITY
1205
1206 #endif // _WX_WXSTRINGH__
wxWidgets (Impactor)