]>
Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: string.cpp | |
3 | // Purpose: wxString class | |
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> | |
dd1eaa89 | 9 | // Licence: wxWindows license |
c801d85f KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | #ifdef __GNUG__ | |
13 | #pragma implementation "string.h" | |
14 | #endif | |
15 | ||
16 | /* | |
17 | * About ref counting: | |
18 | * 1) all empty strings use g_strEmpty, nRefs = -1 (set in Init()) | |
19 | * 2) AllocBuffer() sets nRefs to 1, Lock() increments it by one | |
20 | * 3) Unlock() decrements nRefs and frees memory if it goes to 0 | |
21 | */ | |
22 | ||
23 | // =========================================================================== | |
24 | // headers, declarations, constants | |
25 | // =========================================================================== | |
26 | ||
27 | // For compilers that support precompilation, includes "wx.h". | |
28 | #include "wx/wxprec.h" | |
29 | ||
30 | #ifdef __BORLANDC__ | |
31 | #pragma hdrstop | |
32 | #endif | |
33 | ||
34 | #ifndef WX_PRECOMP | |
3c024cc2 VZ |
35 | #include "wx/defs.h" |
36 | #include "wx/string.h" | |
37 | #include "wx/intl.h" | |
c801d85f KB |
38 | #endif |
39 | ||
40 | #include <ctype.h> | |
41 | #include <string.h> | |
42 | #include <stdlib.h> | |
43 | ||
4fabb575 JS |
44 | // This probably isn't right, what should it be Vadim? |
45 | // Otherwise we end up with no wxVsprintf defined. | |
46 | #ifdef __WXMOTIF__ | |
47 | #define HAVE_VPRINTF | |
48 | #endif | |
49 | ||
fb4e5803 VZ |
50 | #ifdef wxUSE_WCSRTOMBS |
51 | #include <wchar.h> // for wcsrtombs(), see comments where it's used | |
52 | #endif // GNU | |
53 | ||
c801d85f KB |
54 | #ifdef WXSTRING_IS_WXOBJECT |
55 | IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject) | |
56 | #endif //WXSTRING_IS_WXOBJECT | |
57 | ||
3168a13f VZ |
58 | // allocating extra space for each string consumes more memory but speeds up |
59 | // the concatenation operations (nLen is the current string's length) | |
77ca46e7 VZ |
60 | // NB: EXTRA_ALLOC must be >= 0! |
61 | #define EXTRA_ALLOC (19 - nLen % 16) | |
3168a13f | 62 | |
c801d85f KB |
63 | // --------------------------------------------------------------------------- |
64 | // static class variables definition | |
65 | // --------------------------------------------------------------------------- | |
66 | ||
67 | #ifdef STD_STRING_COMPATIBILITY | |
68 | const size_t wxString::npos = STRING_MAXLEN; | |
69 | #endif | |
70 | ||
3168a13f VZ |
71 | // ---------------------------------------------------------------------------- |
72 | // static data | |
73 | // ---------------------------------------------------------------------------- | |
c801d85f | 74 | |
3c024cc2 VZ |
75 | // for an empty string, GetStringData() will return this address: this |
76 | // structure has the same layout as wxStringData and it's data() method will | |
77 | // return the empty string (dummy pointer) | |
78 | static const struct | |
79 | { | |
80 | wxStringData data; | |
81 | char dummy; | |
82 | } g_strEmpty = { {-1, 0, 0}, '\0' }; | |
83 | ||
c801d85f | 84 | // empty C style string: points to 'string data' byte of g_strEmpty |
3c024cc2 | 85 | extern const char *g_szNul = &g_strEmpty.dummy; |
c801d85f | 86 | |
89b892a2 VZ |
87 | // ---------------------------------------------------------------------------- |
88 | // conditional compilation | |
89 | // ---------------------------------------------------------------------------- | |
90 | ||
91 | // we want to find out if the current platform supports vsnprintf()-like | |
92 | // function: for Unix this is done with configure, for Windows we test the | |
93 | // compiler explicitly. | |
94 | #ifdef __WXMSW__ | |
95 | #ifdef _MSC_VER | |
96 | #define wxVsprintf _vsnprintf | |
97 | #endif | |
98 | #else // !Windows | |
99 | #ifdef HAVE_VSNPRINTF | |
100 | #define wxVsprintf vsnprintf | |
101 | #endif | |
102 | #endif // Windows/!Windows | |
103 | ||
104 | #ifndef wxVsprintf | |
105 | // in this case we'll use vsprintf() (which is ANSI and thus should be | |
106 | // always available), but it's unsafe because it doesn't check for buffer | |
107 | // size - so give a warning | |
108 | #define wxVsprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr) | |
109 | #pragma message("Using sprintf() because no snprintf()-like function defined") | |
110 | #endif | |
111 | ||
3168a13f | 112 | // ---------------------------------------------------------------------------- |
c801d85f | 113 | // global functions |
3168a13f | 114 | // ---------------------------------------------------------------------------- |
c801d85f KB |
115 | |
116 | #ifdef STD_STRING_COMPATIBILITY | |
117 | ||
118 | // MS Visual C++ version 5.0 provides the new STL headers as well as the old | |
119 | // iostream ones. | |
120 | // | |
121 | // ATTN: you can _not_ use both of these in the same program! | |
fbc535ff JS |
122 | #if wxUSE_IOSTREAMH |
123 | #include <iostream.h> | |
124 | #define NAMESPACE | |
125 | #else | |
126 | #include <iostream> | |
127 | # ifdef _MSC_VER | |
128 | using namespace std; | |
129 | # endif | |
5f31d862 UU |
130 | // for msvc (bcc50+ also) you don't need these NAMESPACE defines, |
131 | // using namespace std; takes care of that. | |
fbc535ff JS |
132 | #define NAMESPACE std:: |
133 | #endif | |
134 | ||
a38b83c3 | 135 | #ifdef __WXMSW__ |
7aa88ac4 VZ |
136 | #ifdef _MSC_VER |
137 | #define wxVsprintf _vsnprintf | |
138 | #endif | |
a38b83c3 | 139 | #else |
7aa88ac4 VZ |
140 | #if defined ( HAVE_VSNPRINTF ) |
141 | #define wxVsprintf vsnprintf | |
142 | #endif | |
a38b83c3 KB |
143 | #endif |
144 | ||
145 | #ifndef wxVsprintf | |
7aa88ac4 | 146 | // vsprintf() is ANSI so we can always use it, but it's unsafe! |
a38b83c3 KB |
147 | #define wxVsprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr) |
148 | #pragma message("Using sprintf() because no snprintf()-like function defined") | |
a38b83c3 | 149 | #endif |
fbc535ff | 150 | |
c801d85f KB |
151 | NAMESPACE istream& operator>>(NAMESPACE istream& is, wxString& WXUNUSED(str)) |
152 | { | |
153 | #if 0 | |
154 | int w = is.width(0); | |
155 | if ( is.ipfx(0) ) { | |
156 | NAMESPACE streambuf *sb = is.rdbuf(); | |
157 | str.erase(); | |
158 | while ( true ) { | |
159 | int ch = sb->sbumpc (); | |
160 | if ( ch == EOF ) { | |
161 | is.setstate(NAMESPACE ios::eofbit); | |
162 | break; | |
163 | } | |
164 | else if ( isspace(ch) ) { | |
165 | sb->sungetc(); | |
166 | break; | |
167 | } | |
dd1eaa89 | 168 | |
c801d85f KB |
169 | str += ch; |
170 | if ( --w == 1 ) | |
171 | break; | |
172 | } | |
173 | } | |
174 | ||
175 | is.isfx(); | |
176 | if ( str.length() == 0 ) | |
177 | is.setstate(NAMESPACE ios::failbit); | |
178 | #endif | |
179 | return is; | |
180 | } | |
181 | ||
182 | #endif //std::string compatibility | |
183 | ||
3168a13f VZ |
184 | // ---------------------------------------------------------------------------- |
185 | // private classes | |
186 | // ---------------------------------------------------------------------------- | |
187 | ||
188 | // this small class is used to gather statistics for performance tuning | |
189 | //#define WXSTRING_STATISTICS | |
190 | #ifdef WXSTRING_STATISTICS | |
191 | class Averager | |
192 | { | |
193 | public: | |
194 | Averager(const char *sz) { m_sz = sz; m_nTotal = m_nCount = 0; } | |
2c3b684c | 195 | ~Averager() |
3168a13f VZ |
196 | { printf("wxString: average %s = %f\n", m_sz, ((float)m_nTotal)/m_nCount); } |
197 | ||
c86f1403 | 198 | void Add(size_t n) { m_nTotal += n; m_nCount++; } |
3168a13f VZ |
199 | |
200 | private: | |
c86f1403 | 201 | size_t m_nCount, m_nTotal; |
3168a13f VZ |
202 | const char *m_sz; |
203 | } g_averageLength("allocation size"), | |
204 | g_averageSummandLength("summand length"), | |
205 | g_averageConcatHit("hit probability in concat"), | |
206 | g_averageInitialLength("initial string length"); | |
207 | ||
208 | #define STATISTICS_ADD(av, val) g_average##av.Add(val) | |
209 | #else | |
210 | #define STATISTICS_ADD(av, val) | |
211 | #endif // WXSTRING_STATISTICS | |
212 | ||
c801d85f KB |
213 | // =========================================================================== |
214 | // wxString class core | |
215 | // =========================================================================== | |
216 | ||
217 | // --------------------------------------------------------------------------- | |
218 | // construction | |
219 | // --------------------------------------------------------------------------- | |
220 | ||
c801d85f KB |
221 | // constructs string of <nLength> copies of character <ch> |
222 | wxString::wxString(char ch, size_t nLength) | |
223 | { | |
224 | Init(); | |
225 | ||
226 | if ( nLength > 0 ) { | |
227 | AllocBuffer(nLength); | |
f1da2f03 | 228 | |
c801d85f KB |
229 | wxASSERT( sizeof(char) == 1 ); // can't use memset if not |
230 | ||
231 | memset(m_pchData, ch, nLength); | |
232 | } | |
233 | } | |
234 | ||
235 | // takes nLength elements of psz starting at nPos | |
236 | void wxString::InitWith(const char *psz, size_t nPos, size_t nLength) | |
237 | { | |
238 | Init(); | |
239 | ||
240 | wxASSERT( nPos <= Strlen(psz) ); | |
241 | ||
242 | if ( nLength == STRING_MAXLEN ) | |
243 | nLength = Strlen(psz + nPos); | |
244 | ||
3168a13f VZ |
245 | STATISTICS_ADD(InitialLength, nLength); |
246 | ||
c801d85f KB |
247 | if ( nLength > 0 ) { |
248 | // trailing '\0' is written in AllocBuffer() | |
249 | AllocBuffer(nLength); | |
250 | memcpy(m_pchData, psz + nPos, nLength*sizeof(char)); | |
251 | } | |
252 | } | |
dd1eaa89 | 253 | |
c801d85f KB |
254 | // the same as previous constructor, but for compilers using unsigned char |
255 | wxString::wxString(const unsigned char* psz, size_t nLength) | |
256 | { | |
257 | InitWith((const char *)psz, 0, nLength); | |
dd1eaa89 VZ |
258 | } |
259 | ||
c801d85f KB |
260 | #ifdef STD_STRING_COMPATIBILITY |
261 | ||
c801d85f KB |
262 | // poor man's iterators are "void *" pointers |
263 | wxString::wxString(const void *pStart, const void *pEnd) | |
264 | { | |
dd1eaa89 | 265 | InitWith((const char *)pStart, 0, |
c801d85f KB |
266 | (const char *)pEnd - (const char *)pStart); |
267 | } | |
268 | ||
269 | #endif //std::string compatibility | |
270 | ||
271 | // from wide string | |
272 | wxString::wxString(const wchar_t *pwz) | |
273 | { | |
274 | // first get necessary size | |
fb4e5803 VZ |
275 | |
276 | // NB: GNU libc5 wcstombs() is completely broken, don't use it (it doesn't | |
277 | // honor the 3rd parameter, thus it will happily crash here). | |
278 | #ifdef wxUSE_WCSRTOMBS | |
279 | // don't know if it's really needed (or if we can pass NULL), but better safe | |
280 | // than quick | |
281 | mbstate_t mbstate; | |
282 | size_t nLen = wcsrtombs((char *) NULL, &pwz, 0, &mbstate); | |
283 | #else // !GNU libc | |
c67daf87 | 284 | size_t nLen = wcstombs((char *) NULL, pwz, 0); |
fb4e5803 | 285 | #endif // GNU |
c801d85f KB |
286 | |
287 | // empty? | |
288 | if ( nLen != 0 ) { | |
289 | AllocBuffer(nLen); | |
290 | wcstombs(m_pchData, pwz, nLen); | |
291 | } | |
292 | else { | |
293 | Init(); | |
294 | } | |
295 | } | |
296 | ||
297 | // --------------------------------------------------------------------------- | |
298 | // memory allocation | |
299 | // --------------------------------------------------------------------------- | |
300 | ||
301 | // allocates memory needed to store a C string of length nLen | |
302 | void wxString::AllocBuffer(size_t nLen) | |
303 | { | |
304 | wxASSERT( nLen > 0 ); // | |
305 | wxASSERT( nLen <= INT_MAX-1 ); // max size (enough room for 1 extra) | |
306 | ||
3168a13f VZ |
307 | STATISTICS_ADD(Length, nLen); |
308 | ||
c801d85f KB |
309 | // allocate memory: |
310 | // 1) one extra character for '\0' termination | |
311 | // 2) sizeof(wxStringData) for housekeeping info | |
3168a13f VZ |
312 | wxStringData* pData = (wxStringData*) |
313 | malloc(sizeof(wxStringData) + (nLen + EXTRA_ALLOC + 1)*sizeof(char)); | |
c801d85f | 314 | pData->nRefs = 1; |
c801d85f | 315 | pData->nDataLength = nLen; |
3168a13f | 316 | pData->nAllocLength = nLen + EXTRA_ALLOC; |
c801d85f | 317 | m_pchData = pData->data(); // data starts after wxStringData |
3168a13f | 318 | m_pchData[nLen] = '\0'; |
c801d85f KB |
319 | } |
320 | ||
c801d85f KB |
321 | // must be called before changing this string |
322 | void wxString::CopyBeforeWrite() | |
323 | { | |
324 | wxStringData* pData = GetStringData(); | |
325 | ||
326 | if ( pData->IsShared() ) { | |
327 | pData->Unlock(); // memory not freed because shared | |
c86f1403 | 328 | size_t nLen = pData->nDataLength; |
3168a13f VZ |
329 | AllocBuffer(nLen); |
330 | memcpy(m_pchData, pData->data(), nLen*sizeof(char)); | |
c801d85f KB |
331 | } |
332 | ||
3bbb630a | 333 | wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner |
c801d85f KB |
334 | } |
335 | ||
336 | // must be called before replacing contents of this string | |
337 | void wxString::AllocBeforeWrite(size_t nLen) | |
338 | { | |
339 | wxASSERT( nLen != 0 ); // doesn't make any sense | |
340 | ||
341 | // must not share string and must have enough space | |
3168a13f | 342 | wxStringData* pData = GetStringData(); |
c801d85f KB |
343 | if ( pData->IsShared() || (nLen > pData->nAllocLength) ) { |
344 | // can't work with old buffer, get new one | |
345 | pData->Unlock(); | |
346 | AllocBuffer(nLen); | |
347 | } | |
348 | ||
f1da2f03 | 349 | wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner |
c801d85f KB |
350 | } |
351 | ||
dd1eaa89 | 352 | // allocate enough memory for nLen characters |
c86f1403 | 353 | void wxString::Alloc(size_t nLen) |
dd1eaa89 VZ |
354 | { |
355 | wxStringData *pData = GetStringData(); | |
356 | if ( pData->nAllocLength <= nLen ) { | |
9fbd8b8d VZ |
357 | if ( pData->IsEmpty() ) { |
358 | nLen += EXTRA_ALLOC; | |
359 | ||
360 | wxStringData* pData = (wxStringData*) | |
361 | malloc(sizeof(wxStringData) + (nLen + 1)*sizeof(char)); | |
362 | pData->nRefs = 1; | |
363 | pData->nDataLength = 0; | |
364 | pData->nAllocLength = nLen; | |
365 | m_pchData = pData->data(); // data starts after wxStringData | |
366 | m_pchData[0u] = '\0'; | |
367 | } | |
3168a13f VZ |
368 | else if ( pData->IsShared() ) { |
369 | pData->Unlock(); // memory not freed because shared | |
c86f1403 | 370 | size_t nOldLen = pData->nDataLength; |
3168a13f | 371 | AllocBuffer(nLen); |
9fbd8b8d | 372 | memcpy(m_pchData, pData->data(), nOldLen*sizeof(char)); |
3168a13f | 373 | } |
dd1eaa89 | 374 | else { |
3168a13f VZ |
375 | nLen += EXTRA_ALLOC; |
376 | ||
dd1eaa89 VZ |
377 | wxStringData *p = (wxStringData *) |
378 | realloc(pData, sizeof(wxStringData) + (nLen + 1)*sizeof(char)); | |
3168a13f VZ |
379 | |
380 | if ( p == NULL ) { | |
381 | // @@@ what to do on memory error? | |
382 | return; | |
dd1eaa89 | 383 | } |
3168a13f VZ |
384 | |
385 | // it's not important if the pointer changed or not (the check for this | |
386 | // is not faster than assigning to m_pchData in all cases) | |
387 | p->nAllocLength = nLen; | |
388 | m_pchData = p->data(); | |
dd1eaa89 VZ |
389 | } |
390 | } | |
391 | //else: we've already got enough | |
392 | } | |
393 | ||
394 | // shrink to minimal size (releasing extra memory) | |
395 | void wxString::Shrink() | |
396 | { | |
397 | wxStringData *pData = GetStringData(); | |
3bbb630a VZ |
398 | |
399 | // this variable is unused in release build, so avoid the compiler warning by | |
400 | // just not declaring it | |
401 | #ifdef __WXDEBUG__ | |
402 | void *p = | |
403 | #endif | |
404 | realloc(pData, sizeof(wxStringData) + (pData->nDataLength + 1)*sizeof(char)); | |
405 | ||
3168a13f | 406 | wxASSERT( p != NULL ); // can't free memory? |
dd1eaa89 VZ |
407 | wxASSERT( p == pData ); // we're decrementing the size - block shouldn't move! |
408 | } | |
409 | ||
c801d85f | 410 | // get the pointer to writable buffer of (at least) nLen bytes |
c86f1403 | 411 | char *wxString::GetWriteBuf(size_t nLen) |
c801d85f KB |
412 | { |
413 | AllocBeforeWrite(nLen); | |
097c080b VZ |
414 | |
415 | wxASSERT( GetStringData()->nRefs == 1 ); | |
416 | GetStringData()->Validate(FALSE); | |
417 | ||
c801d85f KB |
418 | return m_pchData; |
419 | } | |
420 | ||
097c080b VZ |
421 | // put string back in a reasonable state after GetWriteBuf |
422 | void wxString::UngetWriteBuf() | |
423 | { | |
424 | GetStringData()->nDataLength = strlen(m_pchData); | |
425 | GetStringData()->Validate(TRUE); | |
426 | } | |
427 | ||
c801d85f KB |
428 | // --------------------------------------------------------------------------- |
429 | // data access | |
430 | // --------------------------------------------------------------------------- | |
431 | ||
432 | // all functions are inline in string.h | |
433 | ||
434 | // --------------------------------------------------------------------------- | |
435 | // assignment operators | |
436 | // --------------------------------------------------------------------------- | |
437 | ||
dd1eaa89 | 438 | // helper function: does real copy |
c801d85f KB |
439 | void wxString::AssignCopy(size_t nSrcLen, const char *pszSrcData) |
440 | { | |
441 | if ( nSrcLen == 0 ) { | |
442 | Reinit(); | |
443 | } | |
444 | else { | |
445 | AllocBeforeWrite(nSrcLen); | |
446 | memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(char)); | |
447 | GetStringData()->nDataLength = nSrcLen; | |
448 | m_pchData[nSrcLen] = '\0'; | |
449 | } | |
450 | } | |
451 | ||
452 | // assigns one string to another | |
453 | wxString& wxString::operator=(const wxString& stringSrc) | |
454 | { | |
097c080b VZ |
455 | wxASSERT( stringSrc.GetStringData()->IsValid() ); |
456 | ||
c801d85f KB |
457 | // don't copy string over itself |
458 | if ( m_pchData != stringSrc.m_pchData ) { | |
459 | if ( stringSrc.GetStringData()->IsEmpty() ) { | |
460 | Reinit(); | |
461 | } | |
462 | else { | |
463 | // adjust references | |
464 | GetStringData()->Unlock(); | |
465 | m_pchData = stringSrc.m_pchData; | |
466 | GetStringData()->Lock(); | |
467 | } | |
468 | } | |
469 | ||
470 | return *this; | |
471 | } | |
472 | ||
473 | // assigns a single character | |
474 | wxString& wxString::operator=(char ch) | |
475 | { | |
476 | AssignCopy(1, &ch); | |
477 | return *this; | |
478 | } | |
479 | ||
480 | // assigns C string | |
481 | wxString& wxString::operator=(const char *psz) | |
482 | { | |
483 | AssignCopy(Strlen(psz), psz); | |
484 | return *this; | |
485 | } | |
486 | ||
487 | // same as 'signed char' variant | |
488 | wxString& wxString::operator=(const unsigned char* psz) | |
489 | { | |
490 | *this = (const char *)psz; | |
491 | return *this; | |
492 | } | |
493 | ||
494 | wxString& wxString::operator=(const wchar_t *pwz) | |
495 | { | |
496 | wxString str(pwz); | |
497 | *this = str; | |
498 | return *this; | |
499 | } | |
500 | ||
501 | // --------------------------------------------------------------------------- | |
502 | // string concatenation | |
503 | // --------------------------------------------------------------------------- | |
504 | ||
c801d85f KB |
505 | // add something to this string |
506 | void wxString::ConcatSelf(int nSrcLen, const char *pszSrcData) | |
507 | { | |
3168a13f | 508 | STATISTICS_ADD(SummandLength, nSrcLen); |
c801d85f | 509 | |
05488905 VZ |
510 | // concatenating an empty string is a NOP |
511 | if ( nSrcLen > 0 ) { | |
512 | wxStringData *pData = GetStringData(); | |
513 | size_t nLen = pData->nDataLength; | |
514 | size_t nNewLen = nLen + nSrcLen; | |
c801d85f | 515 | |
05488905 VZ |
516 | // alloc new buffer if current is too small |
517 | if ( pData->IsShared() ) { | |
518 | STATISTICS_ADD(ConcatHit, 0); | |
3168a13f | 519 | |
05488905 VZ |
520 | // we have to allocate another buffer |
521 | wxStringData* pOldData = GetStringData(); | |
522 | AllocBuffer(nNewLen); | |
523 | memcpy(m_pchData, pOldData->data(), nLen*sizeof(char)); | |
524 | pOldData->Unlock(); | |
525 | } | |
526 | else if ( nNewLen > pData->nAllocLength ) { | |
527 | STATISTICS_ADD(ConcatHit, 0); | |
3168a13f | 528 | |
05488905 VZ |
529 | // we have to grow the buffer |
530 | Alloc(nNewLen); | |
531 | } | |
532 | else { | |
533 | STATISTICS_ADD(ConcatHit, 1); | |
3168a13f | 534 | |
05488905 VZ |
535 | // the buffer is already big enough |
536 | } | |
3168a13f | 537 | |
05488905 VZ |
538 | // should be enough space |
539 | wxASSERT( nNewLen <= GetStringData()->nAllocLength ); | |
3168a13f | 540 | |
05488905 VZ |
541 | // fast concatenation - all is done in our buffer |
542 | memcpy(m_pchData + nLen, pszSrcData, nSrcLen*sizeof(char)); | |
3168a13f | 543 | |
05488905 VZ |
544 | m_pchData[nNewLen] = '\0'; // put terminating '\0' |
545 | GetStringData()->nDataLength = nNewLen; // and fix the length | |
546 | } | |
547 | //else: the string to append was empty | |
c801d85f KB |
548 | } |
549 | ||
550 | /* | |
c801d85f KB |
551 | * concatenation functions come in 5 flavours: |
552 | * string + string | |
553 | * char + string and string + char | |
554 | * C str + string and string + C str | |
555 | */ | |
556 | ||
557 | wxString operator+(const wxString& string1, const wxString& string2) | |
558 | { | |
097c080b VZ |
559 | wxASSERT( string1.GetStringData()->IsValid() ); |
560 | wxASSERT( string2.GetStringData()->IsValid() ); | |
561 | ||
3168a13f VZ |
562 | wxString s = string1; |
563 | s += string2; | |
564 | ||
c801d85f KB |
565 | return s; |
566 | } | |
567 | ||
3168a13f | 568 | wxString operator+(const wxString& string, char ch) |
c801d85f | 569 | { |
3168a13f VZ |
570 | wxASSERT( string.GetStringData()->IsValid() ); |
571 | ||
572 | wxString s = string; | |
573 | s += ch; | |
097c080b | 574 | |
c801d85f KB |
575 | return s; |
576 | } | |
577 | ||
578 | wxString operator+(char ch, const wxString& string) | |
579 | { | |
097c080b VZ |
580 | wxASSERT( string.GetStringData()->IsValid() ); |
581 | ||
3168a13f VZ |
582 | wxString s = ch; |
583 | s += string; | |
584 | ||
c801d85f KB |
585 | return s; |
586 | } | |
587 | ||
588 | wxString operator+(const wxString& string, const char *psz) | |
589 | { | |
097c080b VZ |
590 | wxASSERT( string.GetStringData()->IsValid() ); |
591 | ||
c801d85f | 592 | wxString s; |
3168a13f VZ |
593 | s.Alloc(Strlen(psz) + string.Len()); |
594 | s = string; | |
595 | s += psz; | |
596 | ||
c801d85f KB |
597 | return s; |
598 | } | |
599 | ||
600 | wxString operator+(const char *psz, const wxString& string) | |
601 | { | |
097c080b VZ |
602 | wxASSERT( string.GetStringData()->IsValid() ); |
603 | ||
c801d85f | 604 | wxString s; |
3168a13f VZ |
605 | s.Alloc(Strlen(psz) + string.Len()); |
606 | s = psz; | |
607 | s += string; | |
608 | ||
c801d85f KB |
609 | return s; |
610 | } | |
611 | ||
612 | // =========================================================================== | |
613 | // other common string functions | |
614 | // =========================================================================== | |
615 | ||
616 | // --------------------------------------------------------------------------- | |
617 | // simple sub-string extraction | |
618 | // --------------------------------------------------------------------------- | |
619 | ||
620 | // helper function: clone the data attached to this string | |
621 | void wxString::AllocCopy(wxString& dest, int nCopyLen, int nCopyIndex) const | |
622 | { | |
3168a13f | 623 | if ( nCopyLen == 0 ) { |
c801d85f KB |
624 | dest.Init(); |
625 | } | |
3168a13f | 626 | else { |
c801d85f KB |
627 | dest.AllocBuffer(nCopyLen); |
628 | memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(char)); | |
629 | } | |
630 | } | |
631 | ||
632 | // extract string of length nCount starting at nFirst | |
c801d85f KB |
633 | wxString wxString::Mid(size_t nFirst, size_t nCount) const |
634 | { | |
30d9011f VZ |
635 | wxStringData *pData = GetStringData(); |
636 | size_t nLen = pData->nDataLength; | |
637 | ||
638 | // default value of nCount is STRING_MAXLEN and means "till the end" | |
639 | if ( nCount == STRING_MAXLEN ) | |
640 | { | |
641 | nCount = nLen - nFirst; | |
642 | } | |
643 | ||
c801d85f | 644 | // out-of-bounds requests return sensible things |
30d9011f VZ |
645 | if ( nFirst + nCount > nLen ) |
646 | { | |
647 | nCount = nLen - nFirst; | |
648 | } | |
c801d85f | 649 | |
30d9011f VZ |
650 | if ( nFirst > nLen ) |
651 | { | |
652 | // AllocCopy() will return empty string | |
c801d85f | 653 | nCount = 0; |
30d9011f | 654 | } |
c801d85f KB |
655 | |
656 | wxString dest; | |
657 | AllocCopy(dest, nCount, nFirst); | |
30d9011f | 658 | |
c801d85f KB |
659 | return dest; |
660 | } | |
661 | ||
662 | // extract nCount last (rightmost) characters | |
663 | wxString wxString::Right(size_t nCount) const | |
664 | { | |
665 | if ( nCount > (size_t)GetStringData()->nDataLength ) | |
666 | nCount = GetStringData()->nDataLength; | |
667 | ||
668 | wxString dest; | |
669 | AllocCopy(dest, nCount, GetStringData()->nDataLength - nCount); | |
670 | return dest; | |
671 | } | |
672 | ||
673 | // get all characters after the last occurence of ch | |
674 | // (returns the whole string if ch not found) | |
675 | wxString wxString::Right(char ch) const | |
676 | { | |
677 | wxString str; | |
678 | int iPos = Find(ch, TRUE); | |
679 | if ( iPos == NOT_FOUND ) | |
680 | str = *this; | |
681 | else | |
c8cfb486 | 682 | str = c_str() + iPos + 1; |
c801d85f KB |
683 | |
684 | return str; | |
685 | } | |
686 | ||
687 | // extract nCount first (leftmost) characters | |
688 | wxString wxString::Left(size_t nCount) const | |
689 | { | |
690 | if ( nCount > (size_t)GetStringData()->nDataLength ) | |
691 | nCount = GetStringData()->nDataLength; | |
692 | ||
693 | wxString dest; | |
694 | AllocCopy(dest, nCount, 0); | |
695 | return dest; | |
696 | } | |
697 | ||
698 | // get all characters before the first occurence of ch | |
699 | // (returns the whole string if ch not found) | |
700 | wxString wxString::Left(char ch) const | |
701 | { | |
702 | wxString str; | |
703 | for ( const char *pc = m_pchData; *pc != '\0' && *pc != ch; pc++ ) | |
704 | str += *pc; | |
705 | ||
706 | return str; | |
707 | } | |
708 | ||
709 | /// get all characters before the last occurence of ch | |
710 | /// (returns empty string if ch not found) | |
711 | wxString wxString::Before(char ch) const | |
712 | { | |
713 | wxString str; | |
714 | int iPos = Find(ch, TRUE); | |
715 | if ( iPos != NOT_FOUND && iPos != 0 ) | |
d1c9bbf6 | 716 | str = wxString(c_str(), iPos); |
c801d85f KB |
717 | |
718 | return str; | |
719 | } | |
720 | ||
721 | /// get all characters after the first occurence of ch | |
722 | /// (returns empty string if ch not found) | |
723 | wxString wxString::After(char ch) const | |
724 | { | |
725 | wxString str; | |
726 | int iPos = Find(ch); | |
727 | if ( iPos != NOT_FOUND ) | |
728 | str = c_str() + iPos + 1; | |
729 | ||
730 | return str; | |
731 | } | |
732 | ||
733 | // replace first (or all) occurences of some substring with another one | |
c86f1403 | 734 | size_t wxString::Replace(const char *szOld, const char *szNew, bool bReplaceAll) |
c801d85f | 735 | { |
c86f1403 | 736 | size_t uiCount = 0; // count of replacements made |
c801d85f | 737 | |
c86f1403 | 738 | size_t uiOldLen = Strlen(szOld); |
c801d85f KB |
739 | |
740 | wxString strTemp; | |
741 | const char *pCurrent = m_pchData; | |
dd1eaa89 | 742 | const char *pSubstr; |
c801d85f KB |
743 | while ( *pCurrent != '\0' ) { |
744 | pSubstr = strstr(pCurrent, szOld); | |
745 | if ( pSubstr == NULL ) { | |
746 | // strTemp is unused if no replacements were made, so avoid the copy | |
747 | if ( uiCount == 0 ) | |
748 | return 0; | |
749 | ||
750 | strTemp += pCurrent; // copy the rest | |
751 | break; // exit the loop | |
752 | } | |
753 | else { | |
754 | // take chars before match | |
755 | strTemp.ConcatSelf(pSubstr - pCurrent, pCurrent); | |
756 | strTemp += szNew; | |
757 | pCurrent = pSubstr + uiOldLen; // restart after match | |
758 | ||
759 | uiCount++; | |
760 | ||
761 | // stop now? | |
762 | if ( !bReplaceAll ) { | |
763 | strTemp += pCurrent; // copy the rest | |
764 | break; // exit the loop | |
765 | } | |
766 | } | |
767 | } | |
768 | ||
769 | // only done if there were replacements, otherwise would have returned above | |
770 | *this = strTemp; | |
771 | ||
772 | return uiCount; | |
773 | } | |
774 | ||
775 | bool wxString::IsAscii() const | |
776 | { | |
777 | const char *s = (const char*) *this; | |
778 | while(*s){ | |
779 | if(!isascii(*s)) return(FALSE); | |
780 | s++; | |
781 | } | |
782 | return(TRUE); | |
783 | } | |
dd1eaa89 | 784 | |
c801d85f KB |
785 | bool wxString::IsWord() const |
786 | { | |
787 | const char *s = (const char*) *this; | |
788 | while(*s){ | |
789 | if(!isalpha(*s)) return(FALSE); | |
790 | s++; | |
791 | } | |
792 | return(TRUE); | |
793 | } | |
dd1eaa89 | 794 | |
c801d85f KB |
795 | bool wxString::IsNumber() const |
796 | { | |
797 | const char *s = (const char*) *this; | |
798 | while(*s){ | |
799 | if(!isdigit(*s)) return(FALSE); | |
800 | s++; | |
801 | } | |
802 | return(TRUE); | |
803 | } | |
804 | ||
c801d85f KB |
805 | wxString wxString::Strip(stripType w) const |
806 | { | |
807 | wxString s = *this; | |
808 | if ( w & leading ) s.Trim(FALSE); | |
809 | if ( w & trailing ) s.Trim(TRUE); | |
810 | return s; | |
811 | } | |
812 | ||
c801d85f KB |
813 | // --------------------------------------------------------------------------- |
814 | // case conversion | |
815 | // --------------------------------------------------------------------------- | |
816 | ||
817 | wxString& wxString::MakeUpper() | |
818 | { | |
819 | CopyBeforeWrite(); | |
820 | ||
821 | for ( char *p = m_pchData; *p; p++ ) | |
822 | *p = (char)toupper(*p); | |
823 | ||
824 | return *this; | |
825 | } | |
826 | ||
827 | wxString& wxString::MakeLower() | |
828 | { | |
829 | CopyBeforeWrite(); | |
dd1eaa89 | 830 | |
c801d85f KB |
831 | for ( char *p = m_pchData; *p; p++ ) |
832 | *p = (char)tolower(*p); | |
833 | ||
834 | return *this; | |
835 | } | |
836 | ||
837 | // --------------------------------------------------------------------------- | |
838 | // trimming and padding | |
839 | // --------------------------------------------------------------------------- | |
840 | ||
841 | // trims spaces (in the sense of isspace) from left or right side | |
842 | wxString& wxString::Trim(bool bFromRight) | |
843 | { | |
2c3b684c VZ |
844 | // first check if we're going to modify the string at all |
845 | if ( !IsEmpty() && | |
846 | ( | |
847 | (bFromRight && isspace(GetChar(Len() - 1))) || | |
848 | (!bFromRight && isspace(GetChar(0u))) | |
849 | ) | |
850 | ) | |
c801d85f | 851 | { |
2c3b684c VZ |
852 | // ok, there is at least one space to trim |
853 | CopyBeforeWrite(); | |
854 | ||
855 | if ( bFromRight ) | |
856 | { | |
857 | // find last non-space character | |
858 | char *psz = m_pchData + GetStringData()->nDataLength - 1; | |
859 | while ( isspace(*psz) && (psz >= m_pchData) ) | |
860 | psz--; | |
861 | ||
862 | // truncate at trailing space start | |
863 | *++psz = '\0'; | |
864 | GetStringData()->nDataLength = psz - m_pchData; | |
865 | } | |
866 | else | |
867 | { | |
868 | // find first non-space character | |
869 | const char *psz = m_pchData; | |
870 | while ( isspace(*psz) ) | |
871 | psz++; | |
872 | ||
873 | // fix up data and length | |
874 | int nDataLength = GetStringData()->nDataLength - (psz - m_pchData); | |
875 | memmove(m_pchData, psz, (nDataLength + 1)*sizeof(char)); | |
876 | GetStringData()->nDataLength = nDataLength; | |
877 | } | |
c801d85f KB |
878 | } |
879 | ||
880 | return *this; | |
881 | } | |
882 | ||
883 | // adds nCount characters chPad to the string from either side | |
884 | wxString& wxString::Pad(size_t nCount, char chPad, bool bFromRight) | |
885 | { | |
886 | wxString s(chPad, nCount); | |
887 | ||
888 | if ( bFromRight ) | |
889 | *this += s; | |
890 | else | |
891 | { | |
892 | s += *this; | |
893 | *this = s; | |
894 | } | |
895 | ||
896 | return *this; | |
897 | } | |
898 | ||
899 | // truncate the string | |
900 | wxString& wxString::Truncate(size_t uiLen) | |
901 | { | |
902 | *(m_pchData + uiLen) = '\0'; | |
903 | GetStringData()->nDataLength = uiLen; | |
904 | ||
905 | return *this; | |
906 | } | |
907 | ||
908 | // --------------------------------------------------------------------------- | |
909 | // finding (return NOT_FOUND if not found and index otherwise) | |
910 | // --------------------------------------------------------------------------- | |
911 | ||
912 | // find a character | |
913 | int wxString::Find(char ch, bool bFromEnd) const | |
914 | { | |
915 | const char *psz = bFromEnd ? strrchr(m_pchData, ch) : strchr(m_pchData, ch); | |
916 | ||
917 | return (psz == NULL) ? NOT_FOUND : psz - m_pchData; | |
918 | } | |
919 | ||
920 | // find a sub-string (like strstr) | |
921 | int wxString::Find(const char *pszSub) const | |
922 | { | |
923 | const char *psz = strstr(m_pchData, pszSub); | |
924 | ||
925 | return (psz == NULL) ? NOT_FOUND : psz - m_pchData; | |
926 | } | |
927 | ||
7be07660 VZ |
928 | // --------------------------------------------------------------------------- |
929 | // stream-like operators | |
930 | // --------------------------------------------------------------------------- | |
931 | wxString& wxString::operator<<(int i) | |
932 | { | |
933 | wxString res; | |
934 | res.Printf("%d", i); | |
935 | ||
936 | return (*this) << res; | |
937 | } | |
938 | ||
939 | wxString& wxString::operator<<(float f) | |
940 | { | |
941 | wxString res; | |
942 | res.Printf("%f", f); | |
943 | ||
944 | return (*this) << res; | |
945 | } | |
946 | ||
947 | wxString& wxString::operator<<(double d) | |
948 | { | |
949 | wxString res; | |
950 | res.Printf("%g", d); | |
951 | ||
952 | return (*this) << res; | |
953 | } | |
954 | ||
c801d85f | 955 | // --------------------------------------------------------------------------- |
9efd3367 | 956 | // formatted output |
c801d85f KB |
957 | // --------------------------------------------------------------------------- |
958 | int wxString::Printf(const char *pszFormat, ...) | |
959 | { | |
960 | va_list argptr; | |
961 | va_start(argptr, pszFormat); | |
962 | ||
963 | int iLen = PrintfV(pszFormat, argptr); | |
964 | ||
965 | va_end(argptr); | |
966 | ||
967 | return iLen; | |
968 | } | |
969 | ||
970 | int wxString::PrintfV(const char* pszFormat, va_list argptr) | |
971 | { | |
7be07660 | 972 | // static buffer to avoid dynamic memory allocation each time |
9efd3367 | 973 | static char s_szScratch[1024]; |
c801d85f | 974 | |
89b892a2 VZ |
975 | // NB: wxVsprintf() may return either less than the buffer size or -1 if there |
976 | // is not enough place depending on implementation | |
7be07660 VZ |
977 | int iLen = wxVsprintf(s_szScratch, WXSIZEOF(s_szScratch), pszFormat, argptr); |
978 | char *buffer; | |
89b892a2 | 979 | if ( iLen < (int)WXSIZEOF(s_szScratch) ) { |
7be07660 VZ |
980 | buffer = s_szScratch; |
981 | } | |
982 | else { | |
983 | int size = WXSIZEOF(s_szScratch) * 2; | |
984 | buffer = (char *)malloc(size); | |
985 | while ( buffer != NULL ) { | |
986 | iLen = wxVsprintf(buffer, WXSIZEOF(s_szScratch), pszFormat, argptr); | |
987 | if ( iLen < size ) { | |
988 | // ok, there was enough space | |
989 | break; | |
990 | } | |
991 | ||
992 | // still not enough, double it again | |
993 | buffer = (char *)realloc(buffer, size *= 2); | |
994 | } | |
995 | ||
996 | if ( !buffer ) { | |
997 | // out of memory | |
998 | return -1; | |
999 | } | |
1000 | } | |
1001 | ||
c801d85f | 1002 | AllocBeforeWrite(iLen); |
7be07660 VZ |
1003 | strcpy(m_pchData, buffer); |
1004 | ||
1005 | if ( buffer != s_szScratch ) | |
1006 | free(buffer); | |
c801d85f KB |
1007 | |
1008 | return iLen; | |
1009 | } | |
1010 | ||
097c080b VZ |
1011 | // ---------------------------------------------------------------------------- |
1012 | // misc other operations | |
1013 | // ---------------------------------------------------------------------------- | |
1014 | bool wxString::Matches(const char *pszMask) const | |
1015 | { | |
1016 | // check char by char | |
1017 | const char *pszTxt; | |
1018 | for ( pszTxt = c_str(); *pszMask != '\0'; pszMask++, pszTxt++ ) { | |
1019 | switch ( *pszMask ) { | |
1020 | case '?': | |
1021 | if ( *pszTxt == '\0' ) | |
1022 | return FALSE; | |
1023 | ||
1024 | pszTxt++; | |
1025 | pszMask++; | |
1026 | break; | |
1027 | ||
1028 | case '*': | |
1029 | { | |
1030 | // ignore special chars immediately following this one | |
1031 | while ( *pszMask == '*' || *pszMask == '?' ) | |
1032 | pszMask++; | |
1033 | ||
1034 | // if there is nothing more, match | |
1035 | if ( *pszMask == '\0' ) | |
1036 | return TRUE; | |
1037 | ||
1038 | // are there any other metacharacters in the mask? | |
c86f1403 | 1039 | size_t uiLenMask; |
097c080b VZ |
1040 | const char *pEndMask = strpbrk(pszMask, "*?"); |
1041 | ||
1042 | if ( pEndMask != NULL ) { | |
1043 | // we have to match the string between two metachars | |
1044 | uiLenMask = pEndMask - pszMask; | |
1045 | } | |
1046 | else { | |
1047 | // we have to match the remainder of the string | |
1048 | uiLenMask = strlen(pszMask); | |
1049 | } | |
1050 | ||
1051 | wxString strToMatch(pszMask, uiLenMask); | |
1052 | const char* pMatch = strstr(pszTxt, strToMatch); | |
1053 | if ( pMatch == NULL ) | |
1054 | return FALSE; | |
1055 | ||
1056 | // -1 to compensate "++" in the loop | |
1057 | pszTxt = pMatch + uiLenMask - 1; | |
1058 | pszMask += uiLenMask - 1; | |
1059 | } | |
1060 | break; | |
1061 | ||
1062 | default: | |
1063 | if ( *pszMask != *pszTxt ) | |
1064 | return FALSE; | |
1065 | break; | |
1066 | } | |
1067 | } | |
1068 | ||
1069 | // match only if nothing left | |
1070 | return *pszTxt == '\0'; | |
1071 | } | |
1072 | ||
c801d85f KB |
1073 | // --------------------------------------------------------------------------- |
1074 | // standard C++ library string functions | |
1075 | // --------------------------------------------------------------------------- | |
1076 | #ifdef STD_STRING_COMPATIBILITY | |
1077 | ||
1078 | wxString& wxString::insert(size_t nPos, const wxString& str) | |
1079 | { | |
097c080b | 1080 | wxASSERT( str.GetStringData()->IsValid() ); |
c801d85f KB |
1081 | wxASSERT( nPos <= Len() ); |
1082 | ||
cb6780ff VZ |
1083 | if ( !str.IsEmpty() ) { |
1084 | wxString strTmp; | |
1085 | char *pc = strTmp.GetWriteBuf(Len() + str.Len()); | |
1086 | strncpy(pc, c_str(), nPos); | |
1087 | strcpy(pc + nPos, str); | |
1088 | strcpy(pc + nPos + str.Len(), c_str() + nPos); | |
1089 | strTmp.UngetWriteBuf(); | |
1090 | *this = strTmp; | |
1091 | } | |
dd1eaa89 VZ |
1092 | |
1093 | return *this; | |
c801d85f KB |
1094 | } |
1095 | ||
1096 | size_t wxString::find(const wxString& str, size_t nStart) const | |
1097 | { | |
097c080b | 1098 | wxASSERT( str.GetStringData()->IsValid() ); |
c801d85f KB |
1099 | wxASSERT( nStart <= Len() ); |
1100 | ||
1101 | const char *p = strstr(c_str() + nStart, str); | |
dd1eaa89 | 1102 | |
c801d85f KB |
1103 | return p == NULL ? npos : p - c_str(); |
1104 | } | |
1105 | ||
f0b3249b JS |
1106 | // VC++ 1.5 can't cope with the default argument in the header. |
1107 | #if ! (defined(_MSC_VER) && !defined(__WIN32__)) | |
c801d85f KB |
1108 | size_t wxString::find(const char* sz, size_t nStart, size_t n) const |
1109 | { | |
1110 | return find(wxString(sz, n == npos ? 0 : n), nStart); | |
1111 | } | |
f0b3249b | 1112 | #endif |
dd1eaa89 | 1113 | |
c801d85f KB |
1114 | size_t wxString::find(char ch, size_t nStart) const |
1115 | { | |
1116 | wxASSERT( nStart <= Len() ); | |
1117 | ||
1118 | const char *p = strchr(c_str() + nStart, ch); | |
dd1eaa89 | 1119 | |
c801d85f KB |
1120 | return p == NULL ? npos : p - c_str(); |
1121 | } | |
1122 | ||
1123 | size_t wxString::rfind(const wxString& str, size_t nStart) const | |
1124 | { | |
097c080b | 1125 | wxASSERT( str.GetStringData()->IsValid() ); |
c801d85f KB |
1126 | wxASSERT( nStart <= Len() ); |
1127 | ||
1128 | // # could be quicker than that | |
1129 | const char *p = c_str() + (nStart == npos ? Len() : nStart); | |
1130 | while ( p >= c_str() + str.Len() ) { | |
1131 | if ( strncmp(p - str.Len(), str, str.Len()) == 0 ) | |
1132 | return p - str.Len() - c_str(); | |
1133 | p--; | |
1134 | } | |
dd1eaa89 | 1135 | |
c801d85f KB |
1136 | return npos; |
1137 | } | |
dd1eaa89 | 1138 | |
f0b3249b JS |
1139 | // VC++ 1.5 can't cope with the default argument in the header. |
1140 | #if ! (defined(_MSC_VER) && !defined(__WIN32__)) | |
c801d85f KB |
1141 | size_t wxString::rfind(const char* sz, size_t nStart, size_t n) const |
1142 | { | |
1143 | return rfind(wxString(sz, n == npos ? 0 : n), nStart); | |
1144 | } | |
1145 | ||
1146 | size_t wxString::rfind(char ch, size_t nStart) const | |
1147 | { | |
1148 | wxASSERT( nStart <= Len() ); | |
1149 | ||
1150 | const char *p = strrchr(c_str() + nStart, ch); | |
dd1eaa89 | 1151 | |
c801d85f KB |
1152 | return p == NULL ? npos : p - c_str(); |
1153 | } | |
f0b3249b | 1154 | #endif |
c801d85f KB |
1155 | |
1156 | wxString wxString::substr(size_t nStart, size_t nLen) const | |
1157 | { | |
1158 | // npos means 'take all' | |
1159 | if ( nLen == npos ) | |
1160 | nLen = 0; | |
1161 | ||
1162 | wxASSERT( nStart + nLen <= Len() ); | |
1163 | ||
1164 | return wxString(c_str() + nStart, nLen == npos ? 0 : nLen); | |
1165 | } | |
1166 | ||
1167 | wxString& wxString::erase(size_t nStart, size_t nLen) | |
1168 | { | |
1169 | wxString strTmp(c_str(), nStart); | |
1170 | if ( nLen != npos ) { | |
1171 | wxASSERT( nStart + nLen <= Len() ); | |
1172 | ||
1173 | strTmp.append(c_str() + nStart + nLen); | |
1174 | } | |
1175 | ||
1176 | *this = strTmp; | |
1177 | return *this; | |
1178 | } | |
1179 | ||
1180 | wxString& wxString::replace(size_t nStart, size_t nLen, const char *sz) | |
1181 | { | |
1182 | wxASSERT( nStart + nLen <= Strlen(sz) ); | |
1183 | ||
1184 | wxString strTmp; | |
1185 | if ( nStart != 0 ) | |
1186 | strTmp.append(c_str(), nStart); | |
1187 | strTmp += sz; | |
1188 | strTmp.append(c_str() + nStart + nLen); | |
dd1eaa89 | 1189 | |
c801d85f KB |
1190 | *this = strTmp; |
1191 | return *this; | |
1192 | } | |
1193 | ||
1194 | wxString& wxString::replace(size_t nStart, size_t nLen, size_t nCount, char ch) | |
1195 | { | |
1196 | return replace(nStart, nLen, wxString(ch, nCount)); | |
1197 | } | |
1198 | ||
dd1eaa89 | 1199 | wxString& wxString::replace(size_t nStart, size_t nLen, |
097c080b | 1200 | const wxString& str, size_t nStart2, size_t nLen2) |
c801d85f KB |
1201 | { |
1202 | return replace(nStart, nLen, str.substr(nStart2, nLen2)); | |
1203 | } | |
1204 | ||
dd1eaa89 | 1205 | wxString& wxString::replace(size_t nStart, size_t nLen, |
c801d85f KB |
1206 | const char* sz, size_t nCount) |
1207 | { | |
1208 | return replace(nStart, nLen, wxString(sz, nCount)); | |
1209 | } | |
1210 | ||
1211 | #endif //std::string compatibility | |
1212 | ||
1213 | // ============================================================================ | |
1214 | // ArrayString | |
1215 | // ============================================================================ | |
1216 | ||
1217 | // size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT) | |
1218 | #define ARRAY_MAXSIZE_INCREMENT 4096 | |
1219 | #ifndef ARRAY_DEFAULT_INITIAL_SIZE // also defined in dynarray.h | |
1220 | #define ARRAY_DEFAULT_INITIAL_SIZE (16) | |
1221 | #endif | |
1222 | ||
1223 | #define STRING(p) ((wxString *)(&(p))) | |
1224 | ||
1225 | // ctor | |
1226 | wxArrayString::wxArrayString() | |
1227 | { | |
1228 | m_nSize = | |
1229 | m_nCount = 0; | |
c67daf87 | 1230 | m_pItems = (char **) NULL; |
c801d85f KB |
1231 | } |
1232 | ||
1233 | // copy ctor | |
1234 | wxArrayString::wxArrayString(const wxArrayString& src) | |
1235 | { | |
3bbb630a VZ |
1236 | m_nSize = |
1237 | m_nCount = 0; | |
c67daf87 | 1238 | m_pItems = (char **) NULL; |
c801d85f | 1239 | |
4d14b524 | 1240 | *this = src; |
c801d85f KB |
1241 | } |
1242 | ||
4d14b524 | 1243 | // assignment operator |
c801d85f KB |
1244 | wxArrayString& wxArrayString::operator=(const wxArrayString& src) |
1245 | { | |
d93f63db VZ |
1246 | if ( m_nSize > 0 ) |
1247 | Clear(); | |
c801d85f | 1248 | |
4d14b524 VZ |
1249 | if ( src.m_nCount > ARRAY_DEFAULT_INITIAL_SIZE ) |
1250 | Alloc(src.m_nCount); | |
c801d85f | 1251 | |
4d14b524 VZ |
1252 | // we can't just copy the pointers here because otherwise we would share |
1253 | // the strings with another array | |
c86f1403 | 1254 | for ( size_t n = 0; n < src.m_nCount; n++ ) |
4d14b524 | 1255 | Add(src[n]); |
c801d85f | 1256 | |
3bbb630a VZ |
1257 | if ( m_nCount != 0 ) |
1258 | memcpy(m_pItems, src.m_pItems, m_nCount*sizeof(char *)); | |
1259 | ||
c801d85f KB |
1260 | return *this; |
1261 | } | |
1262 | ||
1263 | // grow the array | |
1264 | void wxArrayString::Grow() | |
1265 | { | |
1266 | // only do it if no more place | |
1267 | if( m_nCount == m_nSize ) { | |
1268 | if( m_nSize == 0 ) { | |
1269 | // was empty, alloc some memory | |
1270 | m_nSize = ARRAY_DEFAULT_INITIAL_SIZE; | |
1271 | m_pItems = new char *[m_nSize]; | |
1272 | } | |
1273 | else { | |
3bbb630a VZ |
1274 | // otherwise when it's called for the first time, nIncrement would be 0 |
1275 | // and the array would never be expanded | |
1276 | wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE != 0 ); | |
1277 | ||
c801d85f | 1278 | // add 50% but not too much |
3bbb630a | 1279 | size_t nIncrement = m_nSize < ARRAY_DEFAULT_INITIAL_SIZE |
4d14b524 | 1280 | ? ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1; |
c801d85f KB |
1281 | if ( nIncrement > ARRAY_MAXSIZE_INCREMENT ) |
1282 | nIncrement = ARRAY_MAXSIZE_INCREMENT; | |
1283 | m_nSize += nIncrement; | |
1284 | char **pNew = new char *[m_nSize]; | |
1285 | ||
1286 | // copy data to new location | |
1287 | memcpy(pNew, m_pItems, m_nCount*sizeof(char *)); | |
1288 | ||
1289 | // delete old memory (but do not release the strings!) | |
a3622daa | 1290 | wxDELETEA(m_pItems); |
c801d85f KB |
1291 | |
1292 | m_pItems = pNew; | |
1293 | } | |
1294 | } | |
1295 | } | |
1296 | ||
1297 | void wxArrayString::Free() | |
1298 | { | |
1299 | for ( size_t n = 0; n < m_nCount; n++ ) { | |
1300 | STRING(m_pItems[n])->GetStringData()->Unlock(); | |
1301 | } | |
1302 | } | |
1303 | ||
1304 | // deletes all the strings from the list | |
1305 | void wxArrayString::Empty() | |
1306 | { | |
1307 | Free(); | |
1308 | ||
1309 | m_nCount = 0; | |
1310 | } | |
1311 | ||
1312 | // as Empty, but also frees memory | |
1313 | void wxArrayString::Clear() | |
1314 | { | |
1315 | Free(); | |
1316 | ||
dd1eaa89 | 1317 | m_nSize = |
c801d85f KB |
1318 | m_nCount = 0; |
1319 | ||
a3622daa | 1320 | wxDELETEA(m_pItems); |
c801d85f KB |
1321 | } |
1322 | ||
1323 | // dtor | |
1324 | wxArrayString::~wxArrayString() | |
1325 | { | |
1326 | Free(); | |
1327 | ||
a3622daa | 1328 | wxDELETEA(m_pItems); |
c801d85f KB |
1329 | } |
1330 | ||
1331 | // pre-allocates memory (frees the previous data!) | |
1332 | void wxArrayString::Alloc(size_t nSize) | |
1333 | { | |
1334 | wxASSERT( nSize > 0 ); | |
1335 | ||
1336 | // only if old buffer was not big enough | |
1337 | if ( nSize > m_nSize ) { | |
1338 | Free(); | |
a3622daa | 1339 | wxDELETEA(m_pItems); |
c801d85f KB |
1340 | m_pItems = new char *[nSize]; |
1341 | m_nSize = nSize; | |
1342 | } | |
1343 | ||
1344 | m_nCount = 0; | |
1345 | } | |
1346 | ||
1347 | // searches the array for an item (forward or backwards) | |
c801d85f KB |
1348 | int wxArrayString::Index(const char *sz, bool bCase, bool bFromEnd) const |
1349 | { | |
1350 | if ( bFromEnd ) { | |
1351 | if ( m_nCount > 0 ) { | |
c86f1403 | 1352 | size_t ui = m_nCount; |
c801d85f KB |
1353 | do { |
1354 | if ( STRING(m_pItems[--ui])->IsSameAs(sz, bCase) ) | |
1355 | return ui; | |
1356 | } | |
1357 | while ( ui != 0 ); | |
1358 | } | |
1359 | } | |
1360 | else { | |
c86f1403 | 1361 | for( size_t ui = 0; ui < m_nCount; ui++ ) { |
c801d85f KB |
1362 | if( STRING(m_pItems[ui])->IsSameAs(sz, bCase) ) |
1363 | return ui; | |
1364 | } | |
1365 | } | |
1366 | ||
1367 | return NOT_FOUND; | |
1368 | } | |
1369 | ||
1370 | // add item at the end | |
097c080b | 1371 | void wxArrayString::Add(const wxString& str) |
c801d85f | 1372 | { |
097c080b VZ |
1373 | wxASSERT( str.GetStringData()->IsValid() ); |
1374 | ||
c801d85f KB |
1375 | Grow(); |
1376 | ||
1377 | // the string data must not be deleted! | |
097c080b VZ |
1378 | str.GetStringData()->Lock(); |
1379 | m_pItems[m_nCount++] = (char *)str.c_str(); | |
c801d85f KB |
1380 | } |
1381 | ||
1382 | // add item at the given position | |
097c080b | 1383 | void wxArrayString::Insert(const wxString& str, size_t nIndex) |
c801d85f | 1384 | { |
097c080b VZ |
1385 | wxASSERT( str.GetStringData()->IsValid() ); |
1386 | ||
1a5a8367 | 1387 | wxCHECK_RET( nIndex <= m_nCount, ("bad index in wxArrayString::Insert") ); |
c801d85f KB |
1388 | |
1389 | Grow(); | |
1390 | ||
dd1eaa89 | 1391 | memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex], |
c801d85f KB |
1392 | (m_nCount - nIndex)*sizeof(char *)); |
1393 | ||
097c080b VZ |
1394 | str.GetStringData()->Lock(); |
1395 | m_pItems[nIndex] = (char *)str.c_str(); | |
c801d85f KB |
1396 | |
1397 | m_nCount++; | |
1398 | } | |
1399 | ||
1400 | // removes item from array (by index) | |
1401 | void wxArrayString::Remove(size_t nIndex) | |
1402 | { | |
1a5a8367 | 1403 | wxCHECK_RET( nIndex <= m_nCount, _("bad index in wxArrayString::Remove") ); |
c801d85f KB |
1404 | |
1405 | // release our lock | |
1406 | Item(nIndex).GetStringData()->Unlock(); | |
1407 | ||
dd1eaa89 | 1408 | memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1], |
c801d85f KB |
1409 | (m_nCount - nIndex - 1)*sizeof(char *)); |
1410 | m_nCount--; | |
1411 | } | |
1412 | ||
1413 | // removes item from array (by value) | |
1414 | void wxArrayString::Remove(const char *sz) | |
1415 | { | |
1416 | int iIndex = Index(sz); | |
1417 | ||
9efd3367 | 1418 | wxCHECK_RET( iIndex != NOT_FOUND, |
1a5a8367 | 1419 | _("removing inexistent element in wxArrayString::Remove") ); |
c801d85f | 1420 | |
c86f1403 | 1421 | Remove(iIndex); |
c801d85f KB |
1422 | } |
1423 | ||
1424 | // sort array elements using passed comparaison function | |
1425 | ||
d355d3fe | 1426 | void wxArrayString::Sort(bool WXUNUSED(bCase), bool WXUNUSED(bReverse) ) |
c801d85f KB |
1427 | { |
1428 | //@@@@ TO DO | |
1429 | //qsort(m_pItems, m_nCount, sizeof(char *), fCmp); | |
1430 | } |