1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/string.cpp
3 // Purpose: wxString class
4 // Author: Vadim Zeitlin, Ryan Norton
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // (c) 2004 Ryan Norton <wxprojects@comcast.net>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
15 * 1) all empty strings use g_strEmpty, nRefs = -1 (set in Init())
16 * 2) AllocBuffer() sets nRefs to 1, Lock() increments it by one
17 * 3) Unlock() decrements nRefs and frees memory if it goes to 0
20 // ===========================================================================
21 // headers, declarations, constants
22 // ===========================================================================
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/string.h"
34 #include "wx/thread.h"
50 // allocating extra space for each string consumes more memory but speeds up
51 // the concatenation operations (nLen is the current string's length)
52 // NB: EXTRA_ALLOC must be >= 0!
53 #define EXTRA_ALLOC (19 - nLen % 16)
55 // ---------------------------------------------------------------------------
56 // static class variables definition
57 // ---------------------------------------------------------------------------
60 //According to STL _must_ be a -1 size_t
61 const size_t wxStringBase::npos
= (size_t) -1;
64 // ----------------------------------------------------------------------------
66 // ----------------------------------------------------------------------------
70 extern const wxChar WXDLLIMPEXP_BASE
*wxEmptyString
= _T("");
74 // for an empty string, GetStringData() will return this address: this
75 // structure has the same layout as wxStringData and it's data() method will
76 // return the empty string (dummy pointer)
81 } g_strEmpty
= { {-1, 0, 0}, wxT('\0') };
83 // empty C style string: points to 'string data' byte of g_strEmpty
84 extern const wxChar WXDLLIMPEXP_BASE
*wxEmptyString
= &g_strEmpty
.dummy
;
88 // ----------------------------------------------------------------------------
90 // ----------------------------------------------------------------------------
92 #if wxUSE_STD_IOSTREAM
96 wxSTD ostream
& operator<<(wxSTD ostream
& os
, const wxString
& str
)
106 #endif // wxUSE_STD_IOSTREAM
108 // ----------------------------------------------------------------------------
110 // ----------------------------------------------------------------------------
112 // this small class is used to gather statistics for performance tuning
113 //#define WXSTRING_STATISTICS
114 #ifdef WXSTRING_STATISTICS
118 Averager(const wxChar
*sz
) { m_sz
= sz
; m_nTotal
= m_nCount
= 0; }
120 { wxPrintf("wxString: average %s = %f\n", m_sz
, ((float)m_nTotal
)/m_nCount
); }
122 void Add(size_t n
) { m_nTotal
+= n
; m_nCount
++; }
125 size_t m_nCount
, m_nTotal
;
127 } g_averageLength("allocation size"),
128 g_averageSummandLength("summand length"),
129 g_averageConcatHit("hit probability in concat"),
130 g_averageInitialLength("initial string length");
132 #define STATISTICS_ADD(av, val) g_average##av.Add(val)
134 #define STATISTICS_ADD(av, val)
135 #endif // WXSTRING_STATISTICS
139 // ===========================================================================
140 // wxStringData class deallocation
141 // ===========================================================================
143 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
144 # pragma message (__FILE__ ": building with Multithreaded non DLL runtime has a performance impact on wxString!")
145 void wxStringData::Free()
151 // ===========================================================================
153 // ===========================================================================
155 // takes nLength elements of psz starting at nPos
156 void wxStringBase::InitWith(const wxChar
*psz
, size_t nPos
, size_t nLength
)
160 // if the length is not given, assume the string to be NUL terminated
161 if ( nLength
== npos
) {
162 wxASSERT_MSG( nPos
<= wxStrlen(psz
), _T("index out of bounds") );
164 nLength
= wxStrlen(psz
+ nPos
);
167 STATISTICS_ADD(InitialLength
, nLength
);
170 // trailing '\0' is written in AllocBuffer()
171 if ( !AllocBuffer(nLength
) ) {
172 wxFAIL_MSG( _T("out of memory in wxStringBase::InitWith") );
175 wxTmemcpy(m_pchData
, psz
+ nPos
, nLength
);
179 // poor man's iterators are "void *" pointers
180 wxStringBase::wxStringBase(const void *pStart
, const void *pEnd
)
182 if ( pEnd
>= pStart
)
184 InitWith((const wxChar
*)pStart
, 0,
185 (const wxChar
*)pEnd
- (const wxChar
*)pStart
);
189 wxFAIL_MSG( _T("pStart is not before pEnd") );
194 wxStringBase::wxStringBase(size_type n
, wxChar ch
)
200 // ---------------------------------------------------------------------------
202 // ---------------------------------------------------------------------------
204 // allocates memory needed to store a C string of length nLen
205 bool wxStringBase::AllocBuffer(size_t nLen
)
207 // allocating 0 sized buffer doesn't make sense, all empty strings should
209 wxASSERT( nLen
> 0 );
211 // make sure that we don't overflow
212 wxASSERT( nLen
< (INT_MAX
/ sizeof(wxChar
)) -
213 (sizeof(wxStringData
) + EXTRA_ALLOC
+ 1) );
215 STATISTICS_ADD(Length
, nLen
);
218 // 1) one extra character for '\0' termination
219 // 2) sizeof(wxStringData) for housekeeping info
220 wxStringData
* pData
= (wxStringData
*)
221 malloc(sizeof(wxStringData
) + (nLen
+ EXTRA_ALLOC
+ 1)*sizeof(wxChar
));
223 if ( pData
== NULL
) {
224 // allocation failures are handled by the caller
229 pData
->nDataLength
= nLen
;
230 pData
->nAllocLength
= nLen
+ EXTRA_ALLOC
;
231 m_pchData
= pData
->data(); // data starts after wxStringData
232 m_pchData
[nLen
] = wxT('\0');
236 // must be called before changing this string
237 bool wxStringBase::CopyBeforeWrite()
239 wxStringData
* pData
= GetStringData();
241 if ( pData
->IsShared() ) {
242 pData
->Unlock(); // memory not freed because shared
243 size_t nLen
= pData
->nDataLength
;
244 if ( !AllocBuffer(nLen
) ) {
245 // allocation failures are handled by the caller
248 wxTmemcpy(m_pchData
, pData
->data(), nLen
);
251 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
256 // must be called before replacing contents of this string
257 bool wxStringBase::AllocBeforeWrite(size_t nLen
)
259 wxASSERT( nLen
!= 0 ); // doesn't make any sense
261 // must not share string and must have enough space
262 wxStringData
* pData
= GetStringData();
263 if ( pData
->IsShared() || pData
->IsEmpty() ) {
264 // can't work with old buffer, get new one
266 if ( !AllocBuffer(nLen
) ) {
267 // allocation failures are handled by the caller
272 if ( nLen
> pData
->nAllocLength
) {
273 // realloc the buffer instead of calling malloc() again, this is more
275 STATISTICS_ADD(Length
, nLen
);
279 pData
= (wxStringData
*)
280 realloc(pData
, sizeof(wxStringData
) + (nLen
+ 1)*sizeof(wxChar
));
282 if ( pData
== NULL
) {
283 // allocation failures are handled by the caller
284 // keep previous data since reallocation failed
288 pData
->nAllocLength
= nLen
;
289 m_pchData
= pData
->data();
293 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
295 // it doesn't really matter what the string length is as it's going to be
296 // overwritten later but, for extra safety, set it to 0 for now as we may
297 // have some junk in m_pchData
298 GetStringData()->nDataLength
= 0;
303 wxStringBase
& wxStringBase::append(size_t n
, wxChar ch
)
305 size_type len
= length();
307 if ( !Alloc(len
+ n
) || !CopyBeforeWrite() ) {
308 wxFAIL_MSG( _T("out of memory in wxStringBase::append") );
310 GetStringData()->nDataLength
= len
+ n
;
311 m_pchData
[len
+ n
] = '\0';
312 for ( size_t i
= 0; i
< n
; ++i
)
313 m_pchData
[len
+ i
] = ch
;
317 void wxStringBase::resize(size_t nSize
, wxChar ch
)
319 size_t len
= length();
323 erase(begin() + nSize
, end());
325 else if ( nSize
> len
)
327 append(nSize
- len
, ch
);
329 //else: we have exactly the specified length, nothing to do
332 // allocate enough memory for nLen characters
333 bool wxStringBase::Alloc(size_t nLen
)
335 wxStringData
*pData
= GetStringData();
336 if ( pData
->nAllocLength
<= nLen
) {
337 if ( pData
->IsEmpty() ) {
340 pData
= (wxStringData
*)
341 malloc(sizeof(wxStringData
) + (nLen
+ 1)*sizeof(wxChar
));
343 if ( pData
== NULL
) {
344 // allocation failure handled by caller
349 pData
->nDataLength
= 0;
350 pData
->nAllocLength
= nLen
;
351 m_pchData
= pData
->data(); // data starts after wxStringData
352 m_pchData
[0u] = wxT('\0');
354 else if ( pData
->IsShared() ) {
355 pData
->Unlock(); // memory not freed because shared
356 size_t nOldLen
= pData
->nDataLength
;
357 if ( !AllocBuffer(nLen
) ) {
358 // allocation failure handled by caller
361 // +1 to copy the terminator, too
362 memcpy(m_pchData
, pData
->data(), (nOldLen
+1)*sizeof(wxChar
));
363 GetStringData()->nDataLength
= nOldLen
;
368 pData
= (wxStringData
*)
369 realloc(pData
, sizeof(wxStringData
) + (nLen
+ 1)*sizeof(wxChar
));
371 if ( pData
== NULL
) {
372 // allocation failure handled by caller
373 // keep previous data since reallocation failed
377 // it's not important if the pointer changed or not (the check for this
378 // is not faster than assigning to m_pchData in all cases)
379 pData
->nAllocLength
= nLen
;
380 m_pchData
= pData
->data();
383 //else: we've already got enough
387 wxStringBase::iterator
wxStringBase::begin()
394 wxStringBase::iterator
wxStringBase::end()
398 return m_pchData
+ length();
401 wxStringBase::iterator
wxStringBase::erase(iterator it
)
403 size_type idx
= it
- begin();
405 return begin() + idx
;
408 wxStringBase
& wxStringBase::erase(size_t nStart
, size_t nLen
)
410 wxASSERT(nStart
<= length());
411 size_t strLen
= length() - nStart
;
412 // delete nLen or up to the end of the string characters
413 nLen
= strLen
< nLen
? strLen
: nLen
;
414 wxString
strTmp(c_str(), nStart
);
415 strTmp
.append(c_str() + nStart
+ nLen
, length() - nStart
- nLen
);
421 wxStringBase
& wxStringBase::insert(size_t nPos
, const wxChar
*sz
, size_t n
)
423 wxASSERT( nPos
<= length() );
425 if ( n
== npos
) n
= wxStrlen(sz
);
426 if ( n
== 0 ) return *this;
428 if ( !Alloc(length() + n
) || !CopyBeforeWrite() ) {
429 wxFAIL_MSG( _T("out of memory in wxStringBase::insert") );
432 memmove(m_pchData
+ nPos
+ n
, m_pchData
+ nPos
,
433 (length() - nPos
) * sizeof(wxChar
));
434 memcpy(m_pchData
+ nPos
, sz
, n
* sizeof(wxChar
));
435 GetStringData()->nDataLength
= length() + n
;
436 m_pchData
[length()] = '\0';
441 void wxStringBase::swap(wxStringBase
& str
)
443 wxChar
* tmp
= str
.m_pchData
;
444 str
.m_pchData
= m_pchData
;
448 size_t wxStringBase::find(const wxStringBase
& str
, size_t nStart
) const
450 // deal with the special case of empty string first
451 const size_t nLen
= length();
452 const size_t nLenOther
= str
.length();
456 // empty string is a substring of anything
462 // the other string is non empty so can't be our substring
466 wxASSERT( str
.GetStringData()->IsValid() );
467 wxASSERT( nStart
<= nLen
);
469 const wxChar
* const other
= str
.c_str();
472 const wxChar
* p
= (const wxChar
*)wxTmemchr(c_str() + nStart
,
479 while ( p
- c_str() + nLenOther
<= nLen
&& wxTmemcmp(p
, other
, nLenOther
) )
484 p
= (const wxChar
*)wxTmemchr(p
, *other
, nLen
- (p
- c_str()));
490 return p
- c_str() + nLenOther
<= nLen
? p
- c_str() : npos
;
493 size_t wxStringBase::find(const wxChar
* sz
, size_t nStart
, size_t n
) const
495 return find(wxStringBase(sz
, n
), nStart
);
498 size_t wxStringBase::find(wxChar ch
, size_t nStart
) const
500 wxASSERT( nStart
<= length() );
502 const wxChar
*p
= (const wxChar
*)wxTmemchr(c_str() + nStart
, ch
, length() - nStart
);
504 return p
== NULL
? npos
: p
- c_str();
507 size_t wxStringBase::rfind(const wxStringBase
& str
, size_t nStart
) const
509 wxASSERT( str
.GetStringData()->IsValid() );
510 wxASSERT( nStart
== npos
|| nStart
<= length() );
512 if ( length() >= str
.length() )
514 // avoids a corner case later
515 if ( length() == 0 && str
.length() == 0 )
518 // "top" is the point where search starts from
519 size_t top
= length() - str
.length();
521 if ( nStart
== npos
)
522 nStart
= length() - 1;
526 const wxChar
*cursor
= c_str() + top
;
529 if ( wxTmemcmp(cursor
, str
.c_str(),
532 return cursor
- c_str();
534 } while ( cursor
-- > c_str() );
540 size_t wxStringBase::rfind(const wxChar
* sz
, size_t nStart
, size_t n
) const
542 return rfind(wxStringBase(sz
, n
), nStart
);
545 size_t wxStringBase::rfind(wxChar ch
, size_t nStart
) const
547 if ( nStart
== npos
)
553 wxASSERT( nStart
<= length() );
556 const wxChar
*actual
;
557 for ( actual
= c_str() + ( nStart
== npos
? length() : nStart
+ 1 );
558 actual
> c_str(); --actual
)
560 if ( *(actual
- 1) == ch
)
561 return (actual
- 1) - c_str();
567 size_t wxStringBase::find_first_of(const wxChar
* sz
, size_t nStart
) const
569 wxASSERT(nStart
<= length());
571 size_t len
= wxStrlen(sz
);
574 for(i
= nStart
; i
< this->length(); ++i
)
576 if (wxTmemchr(sz
, *(c_str() + i
), len
))
580 if(i
== this->length())
586 size_t wxStringBase::find_first_of(const wxChar
* sz
, size_t nStart
,
589 return find_first_of(wxStringBase(sz
, n
), nStart
);
592 size_t wxStringBase::find_last_of(const wxChar
* sz
, size_t nStart
) const
594 if ( nStart
== npos
)
596 nStart
= length() - 1;
600 wxASSERT_MSG( nStart
<= length(),
601 _T("invalid index in find_last_of()") );
604 size_t len
= wxStrlen(sz
);
606 for ( const wxChar
*p
= c_str() + nStart
; p
>= c_str(); --p
)
608 if ( wxTmemchr(sz
, *p
, len
) )
615 size_t wxStringBase::find_last_of(const wxChar
* sz
, size_t nStart
,
618 return find_last_of(wxStringBase(sz
, n
), nStart
);
621 size_t wxStringBase::find_first_not_of(const wxChar
* sz
, size_t nStart
) const
623 if ( nStart
== npos
)
629 wxASSERT( nStart
<= length() );
632 size_t len
= wxStrlen(sz
);
635 for(i
= nStart
; i
< this->length(); ++i
)
637 if (!wxTmemchr(sz
, *(c_str() + i
), len
))
641 if(i
== this->length())
647 size_t wxStringBase::find_first_not_of(const wxChar
* sz
, size_t nStart
,
650 return find_first_not_of(wxStringBase(sz
, n
), nStart
);
653 size_t wxStringBase::find_first_not_of(wxChar ch
, size_t nStart
) const
655 wxASSERT( nStart
<= length() );
657 for ( const wxChar
*p
= c_str() + nStart
; *p
; p
++ )
666 size_t wxStringBase::find_last_not_of(const wxChar
* sz
, size_t nStart
) const
668 if ( nStart
== npos
)
670 nStart
= length() - 1;
674 wxASSERT( nStart
<= length() );
677 size_t len
= wxStrlen(sz
);
679 for ( const wxChar
*p
= c_str() + nStart
; p
>= c_str(); --p
)
681 if ( !wxTmemchr(sz
, *p
,len
) )
688 size_t wxStringBase::find_last_not_of(const wxChar
* sz
, size_t nStart
,
691 return find_last_not_of(wxStringBase(sz
, n
), nStart
);
694 size_t wxStringBase::find_last_not_of(wxChar ch
, size_t nStart
) const
696 if ( nStart
== npos
)
698 nStart
= length() - 1;
702 wxASSERT( nStart
<= length() );
705 for ( const wxChar
*p
= c_str() + nStart
; p
>= c_str(); --p
)
714 wxStringBase
& wxStringBase::replace(size_t nStart
, size_t nLen
,
717 wxASSERT_MSG( nStart
<= length(),
718 _T("index out of bounds in wxStringBase::replace") );
719 size_t strLen
= length() - nStart
;
720 nLen
= strLen
< nLen
? strLen
: nLen
;
723 strTmp
.reserve(length()); // micro optimisation to avoid multiple mem allocs
725 //This is kind of inefficient, but its pretty good considering...
726 //we don't want to use character access operators here because on STL
727 //it will freeze the reference count of strTmp, which means a deep copy
728 //at the end when swap is called
730 //Also, we can't use append with the full character pointer and must
731 //do it manually because this string can contain null characters
732 for(size_t i1
= 0; i1
< nStart
; ++i1
)
733 strTmp
.append(1, this->c_str()[i1
]);
735 //its safe to do the full version here because
736 //sz must be a normal c string
739 for(size_t i2
= nStart
+ nLen
; i2
< length(); ++i2
)
740 strTmp
.append(1, this->c_str()[i2
]);
746 wxStringBase
& wxStringBase::replace(size_t nStart
, size_t nLen
,
747 size_t nCount
, wxChar ch
)
749 return replace(nStart
, nLen
, wxStringBase(nCount
, ch
).c_str());
752 wxStringBase
& wxStringBase::replace(size_t nStart
, size_t nLen
,
753 const wxStringBase
& str
,
754 size_t nStart2
, size_t nLen2
)
756 return replace(nStart
, nLen
, str
.substr(nStart2
, nLen2
));
759 wxStringBase
& wxStringBase::replace(size_t nStart
, size_t nLen
,
760 const wxChar
* sz
, size_t nCount
)
762 return replace(nStart
, nLen
, wxStringBase(sz
, nCount
).c_str());
765 wxStringBase
wxStringBase::substr(size_t nStart
, size_t nLen
) const
768 nLen
= length() - nStart
;
769 return wxStringBase(*this, nStart
, nLen
);
772 // assigns one string to another
773 wxStringBase
& wxStringBase::operator=(const wxStringBase
& stringSrc
)
775 wxASSERT( stringSrc
.GetStringData()->IsValid() );
777 // don't copy string over itself
778 if ( m_pchData
!= stringSrc
.m_pchData
) {
779 if ( stringSrc
.GetStringData()->IsEmpty() ) {
784 GetStringData()->Unlock();
785 m_pchData
= stringSrc
.m_pchData
;
786 GetStringData()->Lock();
793 // assigns a single character
794 wxStringBase
& wxStringBase::operator=(wxChar ch
)
796 if ( !AssignCopy(1, &ch
) ) {
797 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(wxChar)") );
803 wxStringBase
& wxStringBase::operator=(const wxChar
*psz
)
805 if ( !AssignCopy(wxStrlen(psz
), psz
) ) {
806 wxFAIL_MSG( _T("out of memory in wxStringBase::operator=(const wxChar *)") );
811 // helper function: does real copy
812 bool wxStringBase::AssignCopy(size_t nSrcLen
, const wxChar
*pszSrcData
)
814 if ( nSrcLen
== 0 ) {
818 if ( !AllocBeforeWrite(nSrcLen
) ) {
819 // allocation failure handled by caller
822 memcpy(m_pchData
, pszSrcData
, nSrcLen
*sizeof(wxChar
));
823 GetStringData()->nDataLength
= nSrcLen
;
824 m_pchData
[nSrcLen
] = wxT('\0');
829 // ---------------------------------------------------------------------------
830 // string concatenation
831 // ---------------------------------------------------------------------------
833 // add something to this string
834 bool wxStringBase::ConcatSelf(size_t nSrcLen
, const wxChar
*pszSrcData
,
837 STATISTICS_ADD(SummandLength
, nSrcLen
);
839 nSrcLen
= nSrcLen
< nMaxLen
? nSrcLen
: nMaxLen
;
841 // concatenating an empty string is a NOP
843 wxStringData
*pData
= GetStringData();
844 size_t nLen
= pData
->nDataLength
;
845 size_t nNewLen
= nLen
+ nSrcLen
;
847 // alloc new buffer if current is too small
848 if ( pData
->IsShared() ) {
849 STATISTICS_ADD(ConcatHit
, 0);
851 // we have to allocate another buffer
852 wxStringData
* pOldData
= GetStringData();
853 if ( !AllocBuffer(nNewLen
) ) {
854 // allocation failure handled by caller
857 memcpy(m_pchData
, pOldData
->data(), nLen
*sizeof(wxChar
));
860 else if ( nNewLen
> pData
->nAllocLength
) {
861 STATISTICS_ADD(ConcatHit
, 0);
864 // we have to grow the buffer
865 if ( capacity() < nNewLen
) {
866 // allocation failure handled by caller
871 STATISTICS_ADD(ConcatHit
, 1);
873 // the buffer is already big enough
876 // should be enough space
877 wxASSERT( nNewLen
<= GetStringData()->nAllocLength
);
879 // fast concatenation - all is done in our buffer
880 memcpy(m_pchData
+ nLen
, pszSrcData
, nSrcLen
*sizeof(wxChar
));
882 m_pchData
[nNewLen
] = wxT('\0'); // put terminating '\0'
883 GetStringData()->nDataLength
= nNewLen
; // and fix the length
885 //else: the string to append was empty
889 // ---------------------------------------------------------------------------
890 // simple sub-string extraction
891 // ---------------------------------------------------------------------------
893 // helper function: clone the data attached to this string
894 bool wxStringBase::AllocCopy(wxString
& dest
, int nCopyLen
, int nCopyIndex
) const
896 if ( nCopyLen
== 0 ) {
900 if ( !dest
.AllocBuffer(nCopyLen
) ) {
901 // allocation failure handled by caller
904 memcpy(dest
.m_pchData
, m_pchData
+ nCopyIndex
, nCopyLen
*sizeof(wxChar
));
911 #if !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
914 #define STRINGCLASS wxStringBase
916 #define STRINGCLASS wxString
919 static inline int wxDoCmp(const wxChar
* s1
, size_t l1
,
920 const wxChar
* s2
, size_t l2
)
923 return wxTmemcmp(s1
, s2
, l1
);
926 int ret
= wxTmemcmp(s1
, s2
, l1
);
927 return ret
== 0 ? -1 : ret
;
931 int ret
= wxTmemcmp(s1
, s2
, l2
);
932 return ret
== 0 ? +1 : ret
;
936 int STRINGCLASS::compare(const wxStringBase
& str
) const
938 return ::wxDoCmp(data(), length(), str
.data(), str
.length());
941 int STRINGCLASS::compare(size_t nStart
, size_t nLen
,
942 const wxStringBase
& str
) const
944 wxASSERT(nStart
<= length());
945 size_type strLen
= length() - nStart
;
946 nLen
= strLen
< nLen
? strLen
: nLen
;
947 return ::wxDoCmp(data() + nStart
, nLen
, str
.data(), str
.length());
950 int STRINGCLASS::compare(size_t nStart
, size_t nLen
,
951 const wxStringBase
& str
,
952 size_t nStart2
, size_t nLen2
) const
954 wxASSERT(nStart
<= length());
955 wxASSERT(nStart2
<= str
.length());
956 size_type strLen
= length() - nStart
,
957 strLen2
= str
.length() - nStart2
;
958 nLen
= strLen
< nLen
? strLen
: nLen
;
959 nLen2
= strLen2
< nLen2
? strLen2
: nLen2
;
960 return ::wxDoCmp(data() + nStart
, nLen
, str
.data() + nStart2
, nLen2
);
963 int STRINGCLASS::compare(const wxChar
* sz
) const
965 size_t nLen
= wxStrlen(sz
);
966 return ::wxDoCmp(data(), length(), sz
, nLen
);
969 int STRINGCLASS::compare(size_t nStart
, size_t nLen
,
970 const wxChar
* sz
, size_t nCount
) const
972 wxASSERT(nStart
<= length());
973 size_type strLen
= length() - nStart
;
974 nLen
= strLen
< nLen
? strLen
: nLen
;
976 nCount
= wxStrlen(sz
);
978 return ::wxDoCmp(data() + nStart
, nLen
, sz
, nCount
);
983 #endif // !wxUSE_STL || !defined(HAVE_STD_STRING_COMPARE)
985 // ===========================================================================
986 // wxString class core
987 // ===========================================================================
989 // ---------------------------------------------------------------------------
990 // construction and conversion
991 // ---------------------------------------------------------------------------
995 // from multibyte string
996 wxString::wxString(const char *psz
, const wxMBConv
& conv
, size_t nLength
)
999 if ( psz
&& nLength
!= 0 )
1001 if ( nLength
== npos
)
1007 wxWCharBuffer wbuf
= conv
.cMB2WC(psz
, nLength
, &nLenWide
);
1010 assign(wbuf
, nLenWide
);
1014 //Convert wxString in Unicode mode to a multi-byte string
1015 const wxCharBuffer
wxString::mb_str(const wxMBConv
& conv
) const
1017 return conv
.cWC2MB(c_str(), length() + 1 /* size, not length */, NULL
);
1025 wxString::wxString(const wchar_t *pwz
, const wxMBConv
& conv
, size_t nLength
)
1028 if ( pwz
&& nLength
!= 0 )
1030 if ( nLength
== npos
)
1036 wxCharBuffer buf
= conv
.cWC2MB(pwz
, nLength
, &nLenMB
);
1039 assign(buf
, nLenMB
);
1043 //Converts this string to a wide character string if unicode
1044 //mode is not enabled and wxUSE_WCHAR_T is enabled
1045 const wxWCharBuffer
wxString::wc_str(const wxMBConv
& conv
) const
1047 return conv
.cMB2WC(c_str(), length() + 1 /* size, not length */, NULL
);
1050 #endif // wxUSE_WCHAR_T
1052 #endif // Unicode/ANSI
1054 // shrink to minimal size (releasing extra memory)
1055 bool wxString::Shrink()
1057 wxString
tmp(begin(), end());
1059 return tmp
.length() == length();
1063 // get the pointer to writable buffer of (at least) nLen bytes
1064 wxChar
*wxString::GetWriteBuf(size_t nLen
)
1066 if ( !AllocBeforeWrite(nLen
) ) {
1067 // allocation failure handled by caller
1071 wxASSERT( GetStringData()->nRefs
== 1 );
1072 GetStringData()->Validate(false);
1077 // put string back in a reasonable state after GetWriteBuf
1078 void wxString::UngetWriteBuf()
1080 GetStringData()->nDataLength
= wxStrlen(m_pchData
);
1081 GetStringData()->Validate(true);
1084 void wxString::UngetWriteBuf(size_t nLen
)
1086 GetStringData()->nDataLength
= nLen
;
1087 GetStringData()->Validate(true);
1091 // ---------------------------------------------------------------------------
1093 // ---------------------------------------------------------------------------
1095 // all functions are inline in string.h
1097 // ---------------------------------------------------------------------------
1098 // assignment operators
1099 // ---------------------------------------------------------------------------
1103 // same as 'signed char' variant
1104 wxString
& wxString::operator=(const unsigned char* psz
)
1106 *this = (const char *)psz
;
1111 wxString
& wxString::operator=(const wchar_t *pwz
)
1122 * concatenation functions come in 5 flavours:
1124 * char + string and string + char
1125 * C str + string and string + C str
1128 wxString
operator+(const wxString
& str1
, const wxString
& str2
)
1131 wxASSERT( str1
.GetStringData()->IsValid() );
1132 wxASSERT( str2
.GetStringData()->IsValid() );
1141 wxString
operator+(const wxString
& str
, wxChar ch
)
1144 wxASSERT( str
.GetStringData()->IsValid() );
1153 wxString
operator+(wxChar ch
, const wxString
& str
)
1156 wxASSERT( str
.GetStringData()->IsValid() );
1165 wxString
operator+(const wxString
& str
, const wxChar
*psz
)
1168 wxASSERT( str
.GetStringData()->IsValid() );
1172 if ( !s
.Alloc(wxStrlen(psz
) + str
.length()) ) {
1173 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1181 wxString
operator+(const wxChar
*psz
, const wxString
& str
)
1184 wxASSERT( str
.GetStringData()->IsValid() );
1188 if ( !s
.Alloc(wxStrlen(psz
) + str
.length()) ) {
1189 wxFAIL_MSG( _T("out of memory in wxString::operator+") );
1197 // ===========================================================================
1198 // other common string functions
1199 // ===========================================================================
1201 int wxString::Cmp(const wxString
& s
) const
1206 int wxString::Cmp(const wxChar
* psz
) const
1208 return compare(psz
);
1211 static inline int wxDoCmpNoCase(const wxChar
* s1
, size_t l1
,
1212 const wxChar
* s2
, size_t l2
)
1218 for(i
= 0; i
< l1
; ++i
)
1220 if(wxTolower(s1
[i
]) != wxTolower(s2
[i
]))
1223 return i
== l1
? 0 : wxTolower(s1
[i
]) < wxTolower(s2
[i
]) ? -1 : 1;
1227 for(i
= 0; i
< l1
; ++i
)
1229 if(wxTolower(s1
[i
]) != wxTolower(s2
[i
]))
1232 return i
== l1
? -1 : wxTolower(s1
[i
]) < wxTolower(s2
[i
]) ? -1 : 1;
1236 for(i
= 0; i
< l2
; ++i
)
1238 if(wxTolower(s1
[i
]) != wxTolower(s2
[i
]))
1241 return i
== l2
? 1 : wxTolower(s1
[i
]) < wxTolower(s2
[i
]) ? -1 : 1;
1245 int wxString::CmpNoCase(const wxString
& s
) const
1247 return wxDoCmpNoCase(data(), length(), s
.data(), s
.length());
1250 int wxString::CmpNoCase(const wxChar
* psz
) const
1252 int nLen
= wxStrlen(psz
);
1254 return wxDoCmpNoCase(data(), length(), psz
, nLen
);
1261 #ifndef __SCHAR_MAX__
1262 #define __SCHAR_MAX__ 127
1266 wxString
wxString::FromAscii(const char *ascii
)
1269 return wxEmptyString
;
1271 size_t len
= strlen( ascii
);
1276 wxStringBuffer
buf(res
, len
);
1278 wchar_t *dest
= buf
;
1282 if ( (*dest
++ = (wchar_t)(unsigned char)*ascii
++) == L
'\0' )
1290 wxString
wxString::FromAscii(const char ascii
)
1292 // What do we do with '\0' ?
1295 res
+= (wchar_t)(unsigned char) ascii
;
1300 const wxCharBuffer
wxString::ToAscii() const
1302 // this will allocate enough space for the terminating NUL too
1303 wxCharBuffer
buffer(length());
1306 char *dest
= buffer
.data();
1308 const wchar_t *pwc
= c_str();
1311 *dest
++ = (char)(*pwc
> SCHAR_MAX
? wxT('_') : *pwc
);
1313 // the output string can't have embedded NULs anyhow, so we can safely
1314 // stop at first of them even if we do have any
1324 // extract string of length nCount starting at nFirst
1325 wxString
wxString::Mid(size_t nFirst
, size_t nCount
) const
1327 size_t nLen
= length();
1329 // default value of nCount is npos and means "till the end"
1330 if ( nCount
== npos
)
1332 nCount
= nLen
- nFirst
;
1335 // out-of-bounds requests return sensible things
1336 if ( nFirst
+ nCount
> nLen
)
1338 nCount
= nLen
- nFirst
;
1341 if ( nFirst
> nLen
)
1343 // AllocCopy() will return empty string
1344 return wxEmptyString
;
1347 wxString
dest(*this, nFirst
, nCount
);
1348 if ( dest
.length() != nCount
)
1350 wxFAIL_MSG( _T("out of memory in wxString::Mid") );
1356 // check that the string starts with prefix and return the rest of the string
1357 // in the provided pointer if it is not NULL, otherwise return false
1358 bool wxString::StartsWith(const wxChar
*prefix
, wxString
*rest
) const
1360 wxASSERT_MSG( prefix
, _T("invalid parameter in wxString::StartsWith") );
1362 // first check if the beginning of the string matches the prefix: note
1363 // that we don't have to check that we don't run out of this string as
1364 // when we reach the terminating NUL, either prefix string ends too (and
1365 // then it's ok) or we break out of the loop because there is no match
1366 const wxChar
*p
= c_str();
1369 if ( *prefix
++ != *p
++ )
1378 // put the rest of the string into provided pointer
1386 // check that the string ends with suffix and return the rest of it in the
1387 // provided pointer if it is not NULL, otherwise return false
1388 bool wxString::EndsWith(const wxChar
*suffix
, wxString
*rest
) const
1390 wxASSERT_MSG( suffix
, _T("invalid parameter in wxString::EndssWith") );
1392 int start
= length() - wxStrlen(suffix
);
1393 if ( start
< 0 || wxStrcmp(c_str() + start
, suffix
) != 0 )
1398 // put the rest of the string into provided pointer
1399 rest
->assign(*this, 0, start
);
1406 // extract nCount last (rightmost) characters
1407 wxString
wxString::Right(size_t nCount
) const
1409 if ( nCount
> length() )
1412 wxString
dest(*this, length() - nCount
, nCount
);
1413 if ( dest
.length() != nCount
) {
1414 wxFAIL_MSG( _T("out of memory in wxString::Right") );
1419 // get all characters after the last occurence of ch
1420 // (returns the whole string if ch not found)
1421 wxString
wxString::AfterLast(wxChar ch
) const
1424 int iPos
= Find(ch
, true);
1425 if ( iPos
== wxNOT_FOUND
)
1428 str
= c_str() + iPos
+ 1;
1433 // extract nCount first (leftmost) characters
1434 wxString
wxString::Left(size_t nCount
) const
1436 if ( nCount
> length() )
1439 wxString
dest(*this, 0, nCount
);
1440 if ( dest
.length() != nCount
) {
1441 wxFAIL_MSG( _T("out of memory in wxString::Left") );
1446 // get all characters before the first occurence of ch
1447 // (returns the whole string if ch not found)
1448 wxString
wxString::BeforeFirst(wxChar ch
) const
1450 int iPos
= Find(ch
);
1451 if ( iPos
== wxNOT_FOUND
) iPos
= length();
1452 return wxString(*this, 0, iPos
);
1455 /// get all characters before the last occurence of ch
1456 /// (returns empty string if ch not found)
1457 wxString
wxString::BeforeLast(wxChar ch
) const
1460 int iPos
= Find(ch
, true);
1461 if ( iPos
!= wxNOT_FOUND
&& iPos
!= 0 )
1462 str
= wxString(c_str(), iPos
);
1467 /// get all characters after the first occurence of ch
1468 /// (returns empty string if ch not found)
1469 wxString
wxString::AfterFirst(wxChar ch
) const
1472 int iPos
= Find(ch
);
1473 if ( iPos
!= wxNOT_FOUND
)
1474 str
= c_str() + iPos
+ 1;
1479 // replace first (or all) occurences of some substring with another one
1480 size_t wxString::Replace(const wxChar
*szOld
,
1481 const wxChar
*szNew
, bool bReplaceAll
)
1483 // if we tried to replace an empty string we'd enter an infinite loop below
1484 wxCHECK_MSG( szOld
&& *szOld
&& szNew
, 0,
1485 _T("wxString::Replace(): invalid parameter") );
1487 size_t uiCount
= 0; // count of replacements made
1489 size_t uiOldLen
= wxStrlen(szOld
);
1490 size_t uiNewLen
= wxStrlen(szNew
);
1494 while ( this->c_str()[dwPos
] != wxT('\0') )
1496 //DO NOT USE STRSTR HERE
1497 //this string can contain embedded null characters,
1498 //so strstr will function incorrectly
1499 dwPos
= find(szOld
, dwPos
);
1500 if ( dwPos
== npos
)
1501 break; // exit the loop
1504 //replace this occurance of the old string with the new one
1505 replace(dwPos
, uiOldLen
, szNew
, uiNewLen
);
1507 //move up pos past the string that was replaced
1510 //increase replace count
1515 break; // exit the loop
1522 bool wxString::IsAscii() const
1524 const wxChar
*s
= (const wxChar
*) *this;
1526 if(!isascii(*s
)) return(false);
1532 bool wxString::IsWord() const
1534 const wxChar
*s
= (const wxChar
*) *this;
1536 if(!wxIsalpha(*s
)) return(false);
1542 bool wxString::IsNumber() const
1544 const wxChar
*s
= (const wxChar
*) *this;
1546 if ((s
[0] == wxT('-')) || (s
[0] == wxT('+'))) s
++;
1548 if(!wxIsdigit(*s
)) return(false);
1554 wxString
wxString::Strip(stripType w
) const
1557 if ( w
& leading
) s
.Trim(false);
1558 if ( w
& trailing
) s
.Trim(true);
1562 // ---------------------------------------------------------------------------
1564 // ---------------------------------------------------------------------------
1566 wxString
& wxString::MakeUpper()
1568 for ( iterator it
= begin(), en
= end(); it
!= en
; ++it
)
1569 *it
= (wxChar
)wxToupper(*it
);
1574 wxString
& wxString::MakeLower()
1576 for ( iterator it
= begin(), en
= end(); it
!= en
; ++it
)
1577 *it
= (wxChar
)wxTolower(*it
);
1582 // ---------------------------------------------------------------------------
1583 // trimming and padding
1584 // ---------------------------------------------------------------------------
1586 // some compilers (VC++ 6.0 not to name them) return true for a call to
1587 // isspace('ê') in the C locale which seems to be broken to me, but we have to
1588 // live with this by checking that the character is a 7 bit one - even if this
1589 // may fail to detect some spaces (I don't know if Unicode doesn't have
1590 // space-like symbols somewhere except in the first 128 chars), it is arguably
1591 // still better than trimming away accented letters
1592 inline int wxSafeIsspace(wxChar ch
) { return (ch
< 127) && wxIsspace(ch
); }
1594 // trims spaces (in the sense of isspace) from left or right side
1595 wxString
& wxString::Trim(bool bFromRight
)
1597 // first check if we're going to modify the string at all
1600 (bFromRight
&& wxSafeIsspace(GetChar(length() - 1))) ||
1601 (!bFromRight
&& wxSafeIsspace(GetChar(0u)))
1607 // find last non-space character
1608 reverse_iterator psz
= rbegin();
1609 while ( (psz
!= rend()) && wxSafeIsspace(*psz
) )
1612 // truncate at trailing space start
1613 erase(psz
.base(), end());
1617 // find first non-space character
1618 iterator psz
= begin();
1619 while ( (psz
!= end()) && wxSafeIsspace(*psz
) )
1622 // fix up data and length
1623 erase(begin(), psz
);
1630 // adds nCount characters chPad to the string from either side
1631 wxString
& wxString::Pad(size_t nCount
, wxChar chPad
, bool bFromRight
)
1633 wxString
s(chPad
, nCount
);
1646 // truncate the string
1647 wxString
& wxString::Truncate(size_t uiLen
)
1649 if ( uiLen
< length() )
1651 erase(begin() + uiLen
, end());
1653 //else: nothing to do, string is already short enough
1658 // ---------------------------------------------------------------------------
1659 // finding (return wxNOT_FOUND if not found and index otherwise)
1660 // ---------------------------------------------------------------------------
1663 int wxString::Find(wxChar ch
, bool bFromEnd
) const
1665 size_type idx
= bFromEnd
? find_last_of(ch
) : find_first_of(ch
);
1667 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1670 // find a sub-string (like strstr)
1671 int wxString::Find(const wxChar
*pszSub
) const
1673 size_type idx
= find(pszSub
);
1675 return (idx
== npos
) ? wxNOT_FOUND
: (int)idx
;
1678 // ----------------------------------------------------------------------------
1679 // conversion to numbers
1680 // ----------------------------------------------------------------------------
1682 // the implementation of all the functions below is exactly the same so factor
1685 template <typename T
, typename F
>
1686 bool wxStringToIntType(const wxChar
*start
,
1691 wxCHECK_MSG( val
, false, _T("NULL output pointer") );
1692 wxASSERT_MSG( !base
|| (base
> 1 && base
<= 36), _T("invalid base") );
1699 *val
= (*func
)(start
, &end
, base
);
1701 // return true only if scan was stopped by the terminating NUL and if the
1702 // string was not empty to start with and no under/overflow occurred
1703 return !*end
&& (end
!= start
)
1705 && (errno
!= ERANGE
)
1710 bool wxString::ToLong(long *val
, int base
) const
1712 return wxStringToIntType(c_str(), val
, base
, wxStrtol
);
1715 bool wxString::ToULong(unsigned long *val
, int base
) const
1717 return wxStringToIntType(c_str(), val
, base
, wxStrtoul
);
1720 bool wxString::ToLongLong(wxLongLong_t
*val
, int base
) const
1722 #ifdef wxHAS_STRTOLL
1723 return wxStringToIntType(c_str(), val
, base
, wxStrtoll
);
1725 // TODO: implement this ourselves
1729 #endif // wxHAS_STRTOLL
1732 bool wxString::ToULongLong(wxULongLong_t
*val
, int base
) const
1734 #ifdef wxHAS_STRTOLL
1735 return wxStringToIntType(c_str(), val
, base
, wxStrtoull
);
1737 // TODO: implement this ourselves
1744 bool wxString::ToDouble(double *val
) const
1746 wxCHECK_MSG( val
, false, _T("NULL pointer in wxString::ToDouble") );
1752 const wxChar
*start
= c_str();
1754 *val
= wxStrtod(start
, &end
);
1756 // return true only if scan was stopped by the terminating NUL and if the
1757 // string was not empty to start with and no under/overflow occurred
1758 return !*end
&& (end
!= start
)
1760 && (errno
!= ERANGE
)
1765 // ---------------------------------------------------------------------------
1767 // ---------------------------------------------------------------------------
1770 wxString
wxString::Format(const wxChar
*pszFormat
, ...)
1773 va_start(argptr
, pszFormat
);
1776 s
.PrintfV(pszFormat
, argptr
);
1784 wxString
wxString::FormatV(const wxChar
*pszFormat
, va_list argptr
)
1787 s
.PrintfV(pszFormat
, argptr
);
1791 int wxString::Printf(const wxChar
*pszFormat
, ...)
1794 va_start(argptr
, pszFormat
);
1796 int iLen
= PrintfV(pszFormat
, argptr
);
1803 int wxString::PrintfV(const wxChar
* pszFormat
, va_list argptr
)
1809 wxStringBuffer
tmp(*this, size
+ 1);
1818 // wxVsnprintf() may modify the original arg pointer, so pass it
1821 wxVaCopy(argptrcopy
, argptr
);
1822 int len
= wxVsnprintf(buf
, size
, pszFormat
, argptrcopy
);
1825 // some implementations of vsnprintf() don't NUL terminate
1826 // the string if there is not enough space for it so
1827 // always do it manually
1828 buf
[size
] = _T('\0');
1830 // vsnprintf() may return either -1 (traditional Unix behaviour) or the
1831 // total number of characters which would have been written if the
1832 // buffer were large enough (newer standards such as Unix98)
1835 // still not enough, as we don't know how much we need, double the
1836 // current size of the buffer
1839 else if ( len
>= size
)
1841 // some vsnprintf() implementations NUL-terminate the buffer and
1842 // some don't in len == size case, to be safe always add 1
1845 else // ok, there was enough space
1851 // we could have overshot
1857 // ----------------------------------------------------------------------------
1858 // misc other operations
1859 // ----------------------------------------------------------------------------
1861 // returns true if the string matches the pattern which may contain '*' and
1862 // '?' metacharacters (as usual, '?' matches any character and '*' any number
1864 bool wxString::Matches(const wxChar
*pszMask
) const
1866 // I disable this code as it doesn't seem to be faster (in fact, it seems
1867 // to be much slower) than the old, hand-written code below and using it
1868 // here requires always linking with libregex even if the user code doesn't
1870 #if 0 // wxUSE_REGEX
1871 // first translate the shell-like mask into a regex
1873 pattern
.reserve(wxStrlen(pszMask
));
1885 pattern
+= _T(".*");
1896 // these characters are special in a RE, quote them
1897 // (however note that we don't quote '[' and ']' to allow
1898 // using them for Unix shell like matching)
1899 pattern
+= _T('\\');
1903 pattern
+= *pszMask
;
1911 return wxRegEx(pattern
, wxRE_NOSUB
| wxRE_EXTENDED
).Matches(c_str());
1912 #else // !wxUSE_REGEX
1913 // TODO: this is, of course, awfully inefficient...
1915 // the char currently being checked
1916 const wxChar
*pszTxt
= c_str();
1918 // the last location where '*' matched
1919 const wxChar
*pszLastStarInText
= NULL
;
1920 const wxChar
*pszLastStarInMask
= NULL
;
1923 for ( ; *pszMask
!= wxT('\0'); pszMask
++, pszTxt
++ ) {
1924 switch ( *pszMask
) {
1926 if ( *pszTxt
== wxT('\0') )
1929 // pszTxt and pszMask will be incremented in the loop statement
1935 // remember where we started to be able to backtrack later
1936 pszLastStarInText
= pszTxt
;
1937 pszLastStarInMask
= pszMask
;
1939 // ignore special chars immediately following this one
1940 // (should this be an error?)
1941 while ( *pszMask
== wxT('*') || *pszMask
== wxT('?') )
1944 // if there is nothing more, match
1945 if ( *pszMask
== wxT('\0') )
1948 // are there any other metacharacters in the mask?
1950 const wxChar
*pEndMask
= wxStrpbrk(pszMask
, wxT("*?"));
1952 if ( pEndMask
!= NULL
) {
1953 // we have to match the string between two metachars
1954 uiLenMask
= pEndMask
- pszMask
;
1957 // we have to match the remainder of the string
1958 uiLenMask
= wxStrlen(pszMask
);
1961 wxString
strToMatch(pszMask
, uiLenMask
);
1962 const wxChar
* pMatch
= wxStrstr(pszTxt
, strToMatch
);
1963 if ( pMatch
== NULL
)
1966 // -1 to compensate "++" in the loop
1967 pszTxt
= pMatch
+ uiLenMask
- 1;
1968 pszMask
+= uiLenMask
- 1;
1973 if ( *pszMask
!= *pszTxt
)
1979 // match only if nothing left
1980 if ( *pszTxt
== wxT('\0') )
1983 // if we failed to match, backtrack if we can
1984 if ( pszLastStarInText
) {
1985 pszTxt
= pszLastStarInText
+ 1;
1986 pszMask
= pszLastStarInMask
;
1988 pszLastStarInText
= NULL
;
1990 // don't bother resetting pszLastStarInMask, it's unnecessary
1996 #endif // wxUSE_REGEX/!wxUSE_REGEX
1999 // Count the number of chars
2000 int wxString::Freq(wxChar ch
) const
2004 for (int i
= 0; i
< len
; i
++)
2006 if (GetChar(i
) == ch
)
2012 // convert to upper case, return the copy of the string
2013 wxString
wxString::Upper() const
2014 { wxString
s(*this); return s
.MakeUpper(); }
2016 // convert to lower case, return the copy of the string
2017 wxString
wxString::Lower() const { wxString
s(*this); return s
.MakeLower(); }
2019 int wxString::sprintf(const wxChar
*pszFormat
, ...)
2022 va_start(argptr
, pszFormat
);
2023 int iLen
= PrintfV(pszFormat
, argptr
);
2028 // ============================================================================
2030 // ============================================================================
2032 #include "wx/arrstr.h"
2034 wxArrayString::wxArrayString(size_t sz
, const wxChar
** a
)
2039 for (size_t i
=0; i
< sz
; i
++)
2043 wxArrayString::wxArrayString(size_t sz
, const wxString
* a
)
2048 for (size_t i
=0; i
< sz
; i
++)
2054 // size increment = min(50% of current size, ARRAY_MAXSIZE_INCREMENT)
2055 #define ARRAY_MAXSIZE_INCREMENT 4096
2057 #ifndef ARRAY_DEFAULT_INITIAL_SIZE // also defined in dynarray.h
2058 #define ARRAY_DEFAULT_INITIAL_SIZE (16)
2061 #define STRING(p) ((wxString *)(&(p)))
2064 void wxArrayString::Init(bool autoSort
)
2068 m_pItems
= (wxChar
**) NULL
;
2069 m_autoSort
= autoSort
;
2073 wxArrayString::wxArrayString(const wxArrayString
& src
)
2075 Init(src
.m_autoSort
);
2080 // assignment operator
2081 wxArrayString
& wxArrayString::operator=(const wxArrayString
& src
)
2088 m_autoSort
= src
.m_autoSort
;
2093 void wxArrayString::Copy(const wxArrayString
& src
)
2095 if ( src
.m_nCount
> ARRAY_DEFAULT_INITIAL_SIZE
)
2096 Alloc(src
.m_nCount
);
2098 for ( size_t n
= 0; n
< src
.m_nCount
; n
++ )
2103 void wxArrayString::Grow(size_t nIncrement
)
2105 // only do it if no more place
2106 if ( (m_nSize
- m_nCount
) < nIncrement
) {
2107 // if ARRAY_DEFAULT_INITIAL_SIZE were set to 0, the initially empty would
2108 // be never resized!
2109 #if ARRAY_DEFAULT_INITIAL_SIZE == 0
2110 #error "ARRAY_DEFAULT_INITIAL_SIZE must be > 0!"
2113 if ( m_nSize
== 0 ) {
2114 // was empty, alloc some memory
2115 m_nSize
= ARRAY_DEFAULT_INITIAL_SIZE
;
2116 if (m_nSize
< nIncrement
)
2117 m_nSize
= nIncrement
;
2118 m_pItems
= new wxChar
*[m_nSize
];
2121 // otherwise when it's called for the first time, nIncrement would be 0
2122 // and the array would never be expanded
2123 // add 50% but not too much
2124 size_t ndefIncrement
= m_nSize
< ARRAY_DEFAULT_INITIAL_SIZE
2125 ? ARRAY_DEFAULT_INITIAL_SIZE
: m_nSize
>> 1;
2126 if ( ndefIncrement
> ARRAY_MAXSIZE_INCREMENT
)
2127 ndefIncrement
= ARRAY_MAXSIZE_INCREMENT
;
2128 if ( nIncrement
< ndefIncrement
)
2129 nIncrement
= ndefIncrement
;
2130 m_nSize
+= nIncrement
;
2131 wxChar
**pNew
= new wxChar
*[m_nSize
];
2133 // copy data to new location
2134 memcpy(pNew
, m_pItems
, m_nCount
*sizeof(wxChar
*));
2136 // delete old memory (but do not release the strings!)
2137 wxDELETEA(m_pItems
);
2144 void wxArrayString::Free()
2146 for ( size_t n
= 0; n
< m_nCount
; n
++ ) {
2147 STRING(m_pItems
[n
])->GetStringData()->Unlock();
2151 // deletes all the strings from the list
2152 void wxArrayString::Empty()
2159 // as Empty, but also frees memory
2160 void wxArrayString::Clear()
2167 wxDELETEA(m_pItems
);
2171 wxArrayString::~wxArrayString()
2175 wxDELETEA(m_pItems
);
2178 void wxArrayString::reserve(size_t nSize
)
2183 // pre-allocates memory (frees the previous data!)
2184 void wxArrayString::Alloc(size_t nSize
)
2186 // only if old buffer was not big enough
2187 if ( nSize
> m_nSize
) {
2188 wxChar
**pNew
= new wxChar
*[nSize
];
2192 memcpy(pNew
, m_pItems
, m_nCount
*sizeof(wxChar
*));
2200 // minimizes the memory usage by freeing unused memory
2201 void wxArrayString::Shrink()
2203 // only do it if we have some memory to free
2204 if( m_nCount
< m_nSize
) {
2205 // allocates exactly as much memory as we need
2206 wxChar
**pNew
= new wxChar
*[m_nCount
];
2208 // copy data to new location
2209 memcpy(pNew
, m_pItems
, m_nCount
*sizeof(wxChar
*));
2215 #if WXWIN_COMPATIBILITY_2_4
2217 // return a wxString[] as required for some control ctors.
2218 wxString
* wxArrayString::GetStringArray() const
2220 wxString
*array
= 0;
2224 array
= new wxString
[m_nCount
];
2225 for( size_t i
= 0; i
< m_nCount
; i
++ )
2226 array
[i
] = m_pItems
[i
];
2232 void wxArrayString::Remove(size_t nIndex
, size_t nRemove
)
2234 RemoveAt(nIndex
, nRemove
);
2237 #endif // WXWIN_COMPATIBILITY_2_4
2239 // searches the array for an item (forward or backwards)
2240 int wxArrayString::Index(const wxChar
*sz
, bool bCase
, bool bFromEnd
) const
2243 // use binary search in the sorted array
2244 wxASSERT_MSG( bCase
&& !bFromEnd
,
2245 wxT("search parameters ignored for auto sorted array") );
2254 res
= wxStrcmp(sz
, m_pItems
[i
]);
2266 // use linear search in unsorted array
2268 if ( m_nCount
> 0 ) {
2269 size_t ui
= m_nCount
;
2271 if ( STRING(m_pItems
[--ui
])->IsSameAs(sz
, bCase
) )
2278 for( size_t ui
= 0; ui
< m_nCount
; ui
++ ) {
2279 if( STRING(m_pItems
[ui
])->IsSameAs(sz
, bCase
) )
2288 // add item at the end
2289 size_t wxArrayString::Add(const wxString
& str
, size_t nInsert
)
2292 // insert the string at the correct position to keep the array sorted
2300 res
= str
.Cmp(m_pItems
[i
]);
2311 wxASSERT_MSG( lo
== hi
, wxT("binary search broken") );
2313 Insert(str
, lo
, nInsert
);
2318 wxASSERT( str
.GetStringData()->IsValid() );
2322 for (size_t i
= 0; i
< nInsert
; i
++)
2324 // the string data must not be deleted!
2325 str
.GetStringData()->Lock();
2328 m_pItems
[m_nCount
+ i
] = (wxChar
*)str
.c_str(); // const_cast
2330 size_t ret
= m_nCount
;
2331 m_nCount
+= nInsert
;
2336 // add item at the given position
2337 void wxArrayString::Insert(const wxString
& str
, size_t nIndex
, size_t nInsert
)
2339 wxASSERT( str
.GetStringData()->IsValid() );
2341 wxCHECK_RET( nIndex
<= m_nCount
, wxT("bad index in wxArrayString::Insert") );
2342 wxCHECK_RET( m_nCount
<= m_nCount
+ nInsert
,
2343 wxT("array size overflow in wxArrayString::Insert") );
2347 memmove(&m_pItems
[nIndex
+ nInsert
], &m_pItems
[nIndex
],
2348 (m_nCount
- nIndex
)*sizeof(wxChar
*));
2350 for (size_t i
= 0; i
< nInsert
; i
++)
2352 str
.GetStringData()->Lock();
2353 m_pItems
[nIndex
+ i
] = (wxChar
*)str
.c_str();
2355 m_nCount
+= nInsert
;
2358 // range insert (STL 23.2.4.3)
2360 wxArrayString::insert(iterator it
, const_iterator first
, const_iterator last
)
2362 const int idx
= it
- begin();
2367 // reset "it" since it can change inside Grow()
2370 while ( first
!= last
)
2372 it
= insert(it
, *first
);
2374 // insert returns an iterator to the last element inserted but we need
2375 // insert the next after this one, that is before the next one
2383 void wxArrayString::SetCount(size_t count
)
2388 while ( m_nCount
< count
)
2389 m_pItems
[m_nCount
++] = (wxChar
*)s
.c_str();
2392 // removes item from array (by index)
2393 void wxArrayString::RemoveAt(size_t nIndex
, size_t nRemove
)
2395 wxCHECK_RET( nIndex
< m_nCount
, wxT("bad index in wxArrayString::Remove") );
2396 wxCHECK_RET( nIndex
+ nRemove
<= m_nCount
,
2397 wxT("removing too many elements in wxArrayString::Remove") );
2400 for (size_t i
= 0; i
< nRemove
; i
++)
2401 Item(nIndex
+ i
).GetStringData()->Unlock();
2403 memmove(&m_pItems
[nIndex
], &m_pItems
[nIndex
+ nRemove
],
2404 (m_nCount
- nIndex
- nRemove
)*sizeof(wxChar
*));
2405 m_nCount
-= nRemove
;
2408 // removes item from array (by value)
2409 void wxArrayString::Remove(const wxChar
*sz
)
2411 int iIndex
= Index(sz
);
2413 wxCHECK_RET( iIndex
!= wxNOT_FOUND
,
2414 wxT("removing inexistent element in wxArrayString::Remove") );
2419 void wxArrayString::assign(const_iterator first
, const_iterator last
)
2421 reserve(last
- first
);
2422 for(; first
!= last
; ++first
)
2426 // ----------------------------------------------------------------------------
2428 // ----------------------------------------------------------------------------
2430 // we can only sort one array at a time with the quick-sort based
2433 // need a critical section to protect access to gs_compareFunction and
2434 // gs_sortAscending variables
2435 static wxCriticalSection gs_critsectStringSort
;
2436 #endif // wxUSE_THREADS
2438 // function to use for string comparaison
2439 static wxArrayString::CompareFunction gs_compareFunction
= NULL
;
2441 // if we don't use the compare function, this flag tells us if we sort the
2442 // array in ascending or descending order
2443 static bool gs_sortAscending
= true;
2445 // function which is called by quick sort
2446 extern "C" int wxC_CALLING_CONV
// LINKAGEMODE
2447 wxStringCompareFunction(const void *first
, const void *second
)
2449 wxString
*strFirst
= (wxString
*)first
;
2450 wxString
*strSecond
= (wxString
*)second
;
2452 if ( gs_compareFunction
) {
2453 return gs_compareFunction(*strFirst
, *strSecond
);
2456 // maybe we should use wxStrcoll
2457 int result
= strFirst
->Cmp(*strSecond
);
2459 return gs_sortAscending
? result
: -result
;
2463 // sort array elements using passed comparaison function
2464 void wxArrayString::Sort(CompareFunction compareFunction
)
2466 wxCRIT_SECT_LOCKER(lockCmpFunc
, gs_critsectStringSort
);
2468 wxASSERT( !gs_compareFunction
); // must have been reset to NULL
2469 gs_compareFunction
= compareFunction
;
2473 // reset it to NULL so that Sort(bool) will work the next time
2474 gs_compareFunction
= NULL
;
2479 typedef int (wxC_CALLING_CONV
* wxStringCompareFn
)(const void *first
,
2480 const void *second
);
2483 void wxArrayString::Sort(CompareFunction2 compareFunction
)
2485 qsort(m_pItems
, m_nCount
, sizeof(wxChar
*), (wxStringCompareFn
)compareFunction
);
2488 void wxArrayString::Sort(bool reverseOrder
)
2490 Sort(reverseOrder
? wxStringSortDescending
: wxStringSortAscending
);
2493 void wxArrayString::DoSort()
2495 wxCHECK_RET( !m_autoSort
, wxT("can't use this method with sorted arrays") );
2497 // just sort the pointers using qsort() - of course it only works because
2498 // wxString() *is* a pointer to its data
2499 qsort(m_pItems
, m_nCount
, sizeof(wxChar
*), wxStringCompareFunction
);
2502 bool wxArrayString::operator==(const wxArrayString
& a
) const
2504 if ( m_nCount
!= a
.m_nCount
)
2507 for ( size_t n
= 0; n
< m_nCount
; n
++ )
2509 if ( Item(n
) != a
[n
] )
2516 #endif // !wxUSE_STL
2518 int wxCMPFUNC_CONV
wxStringSortAscending(wxString
* s1
, wxString
* s2
)
2520 return s1
->Cmp(*s2
);
2523 int wxCMPFUNC_CONV
wxStringSortDescending(wxString
* s1
, wxString
* s2
)
2525 return -s1
->Cmp(*s2
);