1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxString class
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "string.h"
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
23 // ===========================================================================
24 // headers, declarations, constants
25 // ===========================================================================
27 // For compilers that support precompilation, includes "wx.h".
28 #include "wx/wxprec.h"
36 #include "wx/string.h"
44 #ifdef WXSTRING_IS_WXOBJECT
45 IMPLEMENT_DYNAMIC_CLASS(wxString
, wxObject
)
46 #endif //WXSTRING_IS_WXOBJECT
48 // allocating extra space for each string consumes more memory but speeds up
49 // the concatenation operations (nLen is the current string's length)
50 // NB: EXTRA_ALLOC must be >= 0!
51 #define EXTRA_ALLOC (19 - nLen % 16)
53 // ---------------------------------------------------------------------------
54 // static class variables definition
55 // ---------------------------------------------------------------------------
57 #ifdef STD_STRING_COMPATIBILITY
58 const size_t wxString::npos
= STRING_MAXLEN
;
61 // ----------------------------------------------------------------------------
63 // ----------------------------------------------------------------------------
65 // for an empty string, GetStringData() will return this address: this
66 // structure has the same layout as wxStringData and it's data() method will
67 // return the empty string (dummy pointer)
72 } g_strEmpty
= { {-1, 0, 0}, '\0' };
74 // empty C style string: points to 'string data' byte of g_strEmpty
75 extern const char *g_szNul
= &g_strEmpty
.dummy
;
77 // ----------------------------------------------------------------------------
79 // ----------------------------------------------------------------------------
81 #ifdef STD_STRING_COMPATIBILITY
83 // MS Visual C++ version 5.0 provides the new STL headers as well as the old
86 // ATTN: you can _not_ use both of these in the same program!
89 #define NAMESPACE std::
95 NAMESPACE istream
& operator>>(NAMESPACE istream
& is
, wxString
& WXUNUSED(str
))
100 NAMESPACE streambuf
*sb
= is
.rdbuf();
103 int ch
= sb
->sbumpc ();
105 is
.setstate(NAMESPACE
ios::eofbit
);
108 else if ( isspace(ch
) ) {
120 if ( str
.length() == 0 )
121 is
.setstate(NAMESPACE
ios::failbit
);
126 #endif //std::string compatibility
128 // ----------------------------------------------------------------------------
130 // ----------------------------------------------------------------------------
132 // this small class is used to gather statistics for performance tuning
133 //#define WXSTRING_STATISTICS
134 #ifdef WXSTRING_STATISTICS
138 Averager(const char *sz
) { m_sz
= sz
; m_nTotal
= m_nCount
= 0; }
140 { printf("wxString: average %s = %f\n", m_sz
, ((float)m_nTotal
)/m_nCount
); }
142 void Add(size_t n
) { m_nTotal
+= n
; m_nCount
++; }
145 size_t m_nCount
, m_nTotal
;
147 } g_averageLength("allocation size"),
148 g_averageSummandLength("summand length"),
149 g_averageConcatHit("hit probability in concat"),
150 g_averageInitialLength("initial string length");
152 #define STATISTICS_ADD(av, val) g_average##av.Add(val)
154 #define STATISTICS_ADD(av, val)
155 #endif // WXSTRING_STATISTICS
157 // ===========================================================================
158 // wxString class core
159 // ===========================================================================
161 // ---------------------------------------------------------------------------
163 // ---------------------------------------------------------------------------
165 // constructs string of <nLength> copies of character <ch>
166 wxString::wxString(char ch
, size_t nLength
)
171 AllocBuffer(nLength
);
173 wxASSERT( sizeof(char) == 1 ); // can't use memset if not
175 memset(m_pchData
, ch
, nLength
);
179 // takes nLength elements of psz starting at nPos
180 void wxString::InitWith(const char *psz
, size_t nPos
, size_t nLength
)
184 wxASSERT( nPos
<= Strlen(psz
) );
186 if ( nLength
== STRING_MAXLEN
)
187 nLength
= Strlen(psz
+ nPos
);
189 STATISTICS_ADD(InitialLength
, nLength
);
192 // trailing '\0' is written in AllocBuffer()
193 AllocBuffer(nLength
);
194 memcpy(m_pchData
, psz
+ nPos
, nLength
*sizeof(char));
198 // the same as previous constructor, but for compilers using unsigned char
199 wxString::wxString(const unsigned char* psz
, size_t nLength
)
201 InitWith((const char *)psz
, 0, nLength
);
204 #ifdef STD_STRING_COMPATIBILITY
206 // poor man's iterators are "void *" pointers
207 wxString::wxString(const void *pStart
, const void *pEnd
)
209 InitWith((const char *)pStart
, 0,
210 (const char *)pEnd
- (const char *)pStart
);
213 #endif //std::string compatibility
216 wxString::wxString(const wchar_t *pwz
)
218 // first get necessary size
219 size_t nLen
= wcstombs((char *) NULL
, pwz
, 0);
224 wcstombs(m_pchData
, pwz
, nLen
);
231 // ---------------------------------------------------------------------------
233 // ---------------------------------------------------------------------------
235 // allocates memory needed to store a C string of length nLen
236 void wxString::AllocBuffer(size_t nLen
)
238 wxASSERT( nLen
> 0 ); //
239 wxASSERT( nLen
<= INT_MAX
-1 ); // max size (enough room for 1 extra)
241 STATISTICS_ADD(Length
, nLen
);
244 // 1) one extra character for '\0' termination
245 // 2) sizeof(wxStringData) for housekeeping info
246 wxStringData
* pData
= (wxStringData
*)
247 malloc(sizeof(wxStringData
) + (nLen
+ EXTRA_ALLOC
+ 1)*sizeof(char));
249 pData
->nDataLength
= nLen
;
250 pData
->nAllocLength
= nLen
+ EXTRA_ALLOC
;
251 m_pchData
= pData
->data(); // data starts after wxStringData
252 m_pchData
[nLen
] = '\0';
255 // must be called before changing this string
256 void wxString::CopyBeforeWrite()
258 wxStringData
* pData
= GetStringData();
260 if ( pData
->IsShared() ) {
261 pData
->Unlock(); // memory not freed because shared
262 size_t nLen
= pData
->nDataLength
;
264 memcpy(m_pchData
, pData
->data(), nLen
*sizeof(char));
267 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
270 // must be called before replacing contents of this string
271 void wxString::AllocBeforeWrite(size_t nLen
)
273 wxASSERT( nLen
!= 0 ); // doesn't make any sense
275 // must not share string and must have enough space
276 wxStringData
* pData
= GetStringData();
277 if ( pData
->IsShared() || (nLen
> pData
->nAllocLength
) ) {
278 // can't work with old buffer, get new one
283 wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
286 // allocate enough memory for nLen characters
287 void wxString::Alloc(size_t nLen
)
289 wxStringData
*pData
= GetStringData();
290 if ( pData
->nAllocLength
<= nLen
) {
291 if ( pData
->IsEmpty() ) {
294 wxStringData
* pData
= (wxStringData
*)
295 malloc(sizeof(wxStringData
) + (nLen
+ 1)*sizeof(char));
297 pData
->nDataLength
= 0;
298 pData
->nAllocLength
= nLen
;
299 m_pchData
= pData
->data(); // data starts after wxStringData
300 m_pchData
[0u] = '\0';
302 else if ( pData
->IsShared() ) {
303 pData
->Unlock(); // memory not freed because shared
304 size_t nOldLen
= pData
->nDataLength
;
306 memcpy(m_pchData
, pData
->data(), nOldLen
*sizeof(char));
311 wxStringData
*p
= (wxStringData
*)
312 realloc(pData
, sizeof(wxStringData
) + (nLen
+ 1)*sizeof(char));
315 // @@@ what to do on memory error?
319 // it's not important if the pointer changed or not (the check for this
320 // is not faster than assigning to m_pchData in all cases)
321 p
->nAllocLength
= nLen
;
322 m_pchData
= p
->data();
325 //else: we've already got enough
328 // shrink to minimal size (releasing extra memory)
329 void wxString::Shrink()
331 wxStringData
*pData
= GetStringData();
333 // this variable is unused in release build, so avoid the compiler warning by
334 // just not declaring it
338 realloc(pData
, sizeof(wxStringData
) + (pData
->nDataLength
+ 1)*sizeof(char));
340 wxASSERT( p
!= NULL
); // can't free memory?
341 wxASSERT( p
== pData
); // we're decrementing the size - block shouldn't move!
344 // get the pointer to writable buffer of (at least) nLen bytes
345 char *wxString::GetWriteBuf(size_t nLen
)
347 AllocBeforeWrite(nLen
);
349 wxASSERT( GetStringData()->nRefs
== 1 );
350 GetStringData()->Validate(FALSE
);
355 // put string back in a reasonable state after GetWriteBuf
356 void wxString::UngetWriteBuf()
358 GetStringData()->nDataLength
= strlen(m_pchData
);
359 GetStringData()->Validate(TRUE
);
362 // ---------------------------------------------------------------------------
364 // ---------------------------------------------------------------------------
366 // all functions are inline in string.h
368 // ---------------------------------------------------------------------------
369 // assignment operators
370 // ---------------------------------------------------------------------------
372 // helper function: does real copy
373 void wxString::AssignCopy(size_t nSrcLen
, const char *pszSrcData
)
375 if ( nSrcLen
== 0 ) {
379 AllocBeforeWrite(nSrcLen
);
380 memcpy(m_pchData
, pszSrcData
, nSrcLen
*sizeof(char));
381 GetStringData()->nDataLength
= nSrcLen
;
382 m_pchData
[nSrcLen
] = '\0';
386 // assigns one string to another
387 wxString
& wxString::operator=(const wxString
& stringSrc
)
389 wxASSERT( stringSrc
.GetStringData()->IsValid() );
391 // don't copy string over itself
392 if ( m_pchData
!= stringSrc
.m_pchData
) {
393 if ( stringSrc
.GetStringData()->IsEmpty() ) {
398 GetStringData()->Unlock();
399 m_pchData
= stringSrc
.m_pchData
;
400 GetStringData()->Lock();
407 // assigns a single character
408 wxString
& wxString::operator=(char ch
)
415 wxString
& wxString::operator=(const char *psz
)
417 AssignCopy(Strlen(psz
), psz
);
421 // same as 'signed char' variant
422 wxString
& wxString::operator=(const unsigned char* psz
)
424 *this = (const char *)psz
;
428 wxString
& wxString::operator=(const wchar_t *pwz
)
435 // ---------------------------------------------------------------------------
436 // string concatenation
437 // ---------------------------------------------------------------------------
439 // add something to this string
440 void wxString::ConcatSelf(int nSrcLen
, const char *pszSrcData
)
442 STATISTICS_ADD(SummandLength
, nSrcLen
);
444 // concatenating an empty string is a NOP, but it happens quite rarely,
445 // so we don't waste our time checking for it
446 // if ( nSrcLen > 0 )
447 wxStringData
*pData
= GetStringData();
448 size_t nLen
= pData
->nDataLength
;
449 size_t nNewLen
= nLen
+ nSrcLen
;
451 // alloc new buffer if current is too small
452 if ( pData
->IsShared() ) {
453 STATISTICS_ADD(ConcatHit
, 0);
455 // we have to allocate another buffer
456 wxStringData
* pOldData
= GetStringData();
457 AllocBuffer(nNewLen
);
458 memcpy(m_pchData
, pOldData
->data(), nLen
*sizeof(char));
461 else if ( nNewLen
> pData
->nAllocLength
) {
462 STATISTICS_ADD(ConcatHit
, 0);
464 // we have to grow the buffer
468 STATISTICS_ADD(ConcatHit
, 1);
470 // the buffer is already big enough
473 // should be enough space
474 wxASSERT( nNewLen
<= GetStringData()->nAllocLength
);
476 // fast concatenation - all is done in our buffer
477 memcpy(m_pchData
+ nLen
, pszSrcData
, nSrcLen
*sizeof(char));
479 m_pchData
[nNewLen
] = '\0'; // put terminating '\0'
480 GetStringData()->nDataLength
= nNewLen
; // and fix the length
484 * concatenation functions come in 5 flavours:
486 * char + string and string + char
487 * C str + string and string + C str
490 wxString
operator+(const wxString
& string1
, const wxString
& string2
)
492 wxASSERT( string1
.GetStringData()->IsValid() );
493 wxASSERT( string2
.GetStringData()->IsValid() );
495 wxString s
= string1
;
501 wxString
operator+(const wxString
& string
, char ch
)
503 wxASSERT( string
.GetStringData()->IsValid() );
511 wxString
operator+(char ch
, const wxString
& string
)
513 wxASSERT( string
.GetStringData()->IsValid() );
521 wxString
operator+(const wxString
& string
, const char *psz
)
523 wxASSERT( string
.GetStringData()->IsValid() );
526 s
.Alloc(Strlen(psz
) + string
.Len());
533 wxString
operator+(const char *psz
, const wxString
& string
)
535 wxASSERT( string
.GetStringData()->IsValid() );
538 s
.Alloc(Strlen(psz
) + string
.Len());
545 // ===========================================================================
546 // other common string functions
547 // ===========================================================================
549 // ---------------------------------------------------------------------------
550 // simple sub-string extraction
551 // ---------------------------------------------------------------------------
553 // helper function: clone the data attached to this string
554 void wxString::AllocCopy(wxString
& dest
, int nCopyLen
, int nCopyIndex
) const
556 if ( nCopyLen
== 0 ) {
560 dest
.AllocBuffer(nCopyLen
);
561 memcpy(dest
.m_pchData
, m_pchData
+ nCopyIndex
, nCopyLen
*sizeof(char));
565 // extract string of length nCount starting at nFirst
566 // default value of nCount is 0 and means "till the end"
567 wxString
wxString::Mid(size_t nFirst
, size_t nCount
) const
569 // out-of-bounds requests return sensible things
571 nCount
= GetStringData()->nDataLength
- nFirst
;
573 if ( nFirst
+ nCount
> (size_t)GetStringData()->nDataLength
)
574 nCount
= GetStringData()->nDataLength
- nFirst
;
575 if ( nFirst
> (size_t)GetStringData()->nDataLength
)
579 AllocCopy(dest
, nCount
, nFirst
);
583 // extract nCount last (rightmost) characters
584 wxString
wxString::Right(size_t nCount
) const
586 if ( nCount
> (size_t)GetStringData()->nDataLength
)
587 nCount
= GetStringData()->nDataLength
;
590 AllocCopy(dest
, nCount
, GetStringData()->nDataLength
- nCount
);
594 // get all characters after the last occurence of ch
595 // (returns the whole string if ch not found)
596 wxString
wxString::Right(char ch
) const
599 int iPos
= Find(ch
, TRUE
);
600 if ( iPos
== NOT_FOUND
)
603 str
= c_str() + iPos
+ 1;
608 // extract nCount first (leftmost) characters
609 wxString
wxString::Left(size_t nCount
) const
611 if ( nCount
> (size_t)GetStringData()->nDataLength
)
612 nCount
= GetStringData()->nDataLength
;
615 AllocCopy(dest
, nCount
, 0);
619 // get all characters before the first occurence of ch
620 // (returns the whole string if ch not found)
621 wxString
wxString::Left(char ch
) const
624 for ( const char *pc
= m_pchData
; *pc
!= '\0' && *pc
!= ch
; pc
++ )
630 /// get all characters before the last occurence of ch
631 /// (returns empty string if ch not found)
632 wxString
wxString::Before(char ch
) const
635 int iPos
= Find(ch
, TRUE
);
636 if ( iPos
!= NOT_FOUND
&& iPos
!= 0 )
637 str
= wxString(c_str(), iPos
);
642 /// get all characters after the first occurence of ch
643 /// (returns empty string if ch not found)
644 wxString
wxString::After(char ch
) const
648 if ( iPos
!= NOT_FOUND
)
649 str
= c_str() + iPos
+ 1;
654 // replace first (or all) occurences of some substring with another one
655 size_t wxString::Replace(const char *szOld
, const char *szNew
, bool bReplaceAll
)
657 size_t uiCount
= 0; // count of replacements made
659 size_t uiOldLen
= Strlen(szOld
);
662 const char *pCurrent
= m_pchData
;
664 while ( *pCurrent
!= '\0' ) {
665 pSubstr
= strstr(pCurrent
, szOld
);
666 if ( pSubstr
== NULL
) {
667 // strTemp is unused if no replacements were made, so avoid the copy
671 strTemp
+= pCurrent
; // copy the rest
672 break; // exit the loop
675 // take chars before match
676 strTemp
.ConcatSelf(pSubstr
- pCurrent
, pCurrent
);
678 pCurrent
= pSubstr
+ uiOldLen
; // restart after match
683 if ( !bReplaceAll
) {
684 strTemp
+= pCurrent
; // copy the rest
685 break; // exit the loop
690 // only done if there were replacements, otherwise would have returned above
696 bool wxString::IsAscii() const
698 const char *s
= (const char*) *this;
700 if(!isascii(*s
)) return(FALSE
);
706 bool wxString::IsWord() const
708 const char *s
= (const char*) *this;
710 if(!isalpha(*s
)) return(FALSE
);
716 bool wxString::IsNumber() const
718 const char *s
= (const char*) *this;
720 if(!isdigit(*s
)) return(FALSE
);
726 wxString
wxString::Strip(stripType w
) const
729 if ( w
& leading
) s
.Trim(FALSE
);
730 if ( w
& trailing
) s
.Trim(TRUE
);
734 // ---------------------------------------------------------------------------
736 // ---------------------------------------------------------------------------
738 wxString
& wxString::MakeUpper()
742 for ( char *p
= m_pchData
; *p
; p
++ )
743 *p
= (char)toupper(*p
);
748 wxString
& wxString::MakeLower()
752 for ( char *p
= m_pchData
; *p
; p
++ )
753 *p
= (char)tolower(*p
);
758 // ---------------------------------------------------------------------------
759 // trimming and padding
760 // ---------------------------------------------------------------------------
762 // trims spaces (in the sense of isspace) from left or right side
763 wxString
& wxString::Trim(bool bFromRight
)
769 // find last non-space character
770 char *psz
= m_pchData
+ GetStringData()->nDataLength
- 1;
771 while ( isspace(*psz
) && (psz
>= m_pchData
) )
774 // truncate at trailing space start
776 GetStringData()->nDataLength
= psz
- m_pchData
;
780 // find first non-space character
781 const char *psz
= m_pchData
;
782 while ( isspace(*psz
) )
785 // fix up data and length
786 int nDataLength
= GetStringData()->nDataLength
- (psz
- m_pchData
);
787 memmove(m_pchData
, psz
, (nDataLength
+ 1)*sizeof(char));
788 GetStringData()->nDataLength
= nDataLength
;
794 // adds nCount characters chPad to the string from either side
795 wxString
& wxString::Pad(size_t nCount
, char chPad
, bool bFromRight
)
797 wxString
s(chPad
, nCount
);
810 // truncate the string
811 wxString
& wxString::Truncate(size_t uiLen
)
813 *(m_pchData
+ uiLen
) = '\0';
814 GetStringData()->nDataLength
= uiLen
;
819 // ---------------------------------------------------------------------------
820 // finding (return NOT_FOUND if not found and index otherwise)
821 // ---------------------------------------------------------------------------
824 int wxString::Find(char ch
, bool bFromEnd
) const
826 const char *psz
= bFromEnd
? strrchr(m_pchData
, ch
) : strchr(m_pchData
, ch
);
828 return (psz
== NULL
) ? NOT_FOUND
: psz
- m_pchData
;
831 // find a sub-string (like strstr)
832 int wxString::Find(const char *pszSub
) const
834 const char *psz
= strstr(m_pchData
, pszSub
);
836 return (psz
== NULL
) ? NOT_FOUND
: psz
- m_pchData
;
839 // ---------------------------------------------------------------------------
841 // ---------------------------------------------------------------------------
842 int wxString::Printf(const char *pszFormat
, ...)
845 va_start(argptr
, pszFormat
);
847 int iLen
= PrintfV(pszFormat
, argptr
);
854 int wxString::PrintfV(const char* pszFormat
, va_list argptr
)
856 static char s_szScratch
[1024];
858 int iLen
= vsprintf(s_szScratch
, pszFormat
, argptr
);
859 AllocBeforeWrite(iLen
);
860 strcpy(m_pchData
, s_szScratch
);
865 // ----------------------------------------------------------------------------
866 // misc other operations
867 // ----------------------------------------------------------------------------
868 bool wxString::Matches(const char *pszMask
) const
870 // check char by char
872 for ( pszTxt
= c_str(); *pszMask
!= '\0'; pszMask
++, pszTxt
++ ) {
873 switch ( *pszMask
) {
875 if ( *pszTxt
== '\0' )
884 // ignore special chars immediately following this one
885 while ( *pszMask
== '*' || *pszMask
== '?' )
888 // if there is nothing more, match
889 if ( *pszMask
== '\0' )
892 // are there any other metacharacters in the mask?
894 const char *pEndMask
= strpbrk(pszMask
, "*?");
896 if ( pEndMask
!= NULL
) {
897 // we have to match the string between two metachars
898 uiLenMask
= pEndMask
- pszMask
;
901 // we have to match the remainder of the string
902 uiLenMask
= strlen(pszMask
);
905 wxString
strToMatch(pszMask
, uiLenMask
);
906 const char* pMatch
= strstr(pszTxt
, strToMatch
);
907 if ( pMatch
== NULL
)
910 // -1 to compensate "++" in the loop
911 pszTxt
= pMatch
+ uiLenMask
- 1;
912 pszMask
+= uiLenMask
- 1;
917 if ( *pszMask
!= *pszTxt
)
923 // match only if nothing left
924 return *pszTxt
== '\0';
927 // ---------------------------------------------------------------------------
928 // standard C++ library string functions
929 // ---------------------------------------------------------------------------
930 #ifdef STD_STRING_COMPATIBILITY
932 wxString
& wxString::insert(size_t nPos
, const wxString
& str
)
934 wxASSERT( str
.GetStringData()->IsValid() );
935 wxASSERT( nPos
<= Len() );
937 if ( !str
.IsEmpty() ) {
939 char *pc
= strTmp
.GetWriteBuf(Len() + str
.Len());
940 strncpy(pc
, c_str(), nPos
);
941 strcpy(pc
+ nPos
, str
);
942 strcpy(pc
+ nPos
+ str
.Len(), c_str() + nPos
);
943 strTmp
.UngetWriteBuf();
950 size_t wxString::find(const wxString
& str
, size_t nStart
) const
952 wxASSERT( str
.GetStringData()->IsValid() );
953 wxASSERT( nStart
<= Len() );
955 const char *p
= strstr(c_str() + nStart
, str
);
957 return p
== NULL
? npos
: p
- c_str();
960 // VC++ 1.5 can't cope with the default argument in the header.
961 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
962 size_t wxString::find(const char* sz
, size_t nStart
, size_t n
) const
964 return find(wxString(sz
, n
== npos
? 0 : n
), nStart
);
968 size_t wxString::find(char ch
, size_t nStart
) const
970 wxASSERT( nStart
<= Len() );
972 const char *p
= strchr(c_str() + nStart
, ch
);
974 return p
== NULL
? npos
: p
- c_str();
977 size_t wxString::rfind(const wxString
& str
, size_t nStart
) const
979 wxASSERT( str
.GetStringData()->IsValid() );
980 wxASSERT( nStart
<= Len() );
982 // # could be quicker than that
983 const char *p
= c_str() + (nStart
== npos
? Len() : nStart
);
984 while ( p
>= c_str() + str
.Len() ) {
985 if ( strncmp(p
- str
.Len(), str
, str
.Len()) == 0 )
986 return p
- str
.Len() - c_str();
993 // VC++ 1.5 can't cope with the default argument in the header.
994 #if ! (defined(_MSC_VER) && !defined(__WIN32__))
995 size_t wxString::rfind(const char* sz
, size_t nStart
, size_t n
) const
997 return rfind(wxString(sz
, n
== npos
? 0 : n
), nStart
);
1000 size_t wxString::rfind(char ch
, size_t nStart
) const
1002 wxASSERT( nStart
<= Len() );
1004 const char *p
= strrchr(c_str() + nStart
, ch
);
1006 return p
== NULL
? npos
: p
- c_str();
1010 wxString
wxString::substr(size_t nStart
, size_t nLen
) const
1012 // npos means 'take all'
1016 wxASSERT( nStart
+ nLen
<= Len() );
1018 return wxString(c_str() + nStart
, nLen
== npos
? 0 : nLen
);
1021 wxString
& wxString::erase(size_t nStart
, size_t nLen
)
1023 wxString
strTmp(c_str(), nStart
);
1024 if ( nLen
!= npos
) {
1025 wxASSERT( nStart
+ nLen
<= Len() );
1027 strTmp
.append(c_str() + nStart
+ nLen
);
1034 wxString
& wxString::replace(size_t nStart
, size_t nLen
, const char *sz
)
1036 wxASSERT( nStart
+ nLen
<= Strlen(sz
) );
1040 strTmp
.append(c_str(), nStart
);
1042 strTmp
.append(c_str() + nStart
+ nLen
);
1048 wxString
& wxString::replace(size_t nStart
, size_t nLen
, size_t nCount
, char ch
)
1050 return replace(nStart
, nLen
, wxString(ch
, nCount
));
1053 wxString
& wxString::replace(size_t nStart
, size_t nLen
,
1054 const wxString
& str
, size_t nStart2
, size_t nLen2
)
1056 return replace(nStart
, nLen
, str
.substr(nStart2
, nLen2
));
1059 wxString
& wxString::replace(size_t nStart
, size_t nLen
,
1060 const char* sz
, size_t nCount
)
1062 return replace(nStart
, nLen
, wxString(sz
, nCount
));
1065 #endif //std::string compatibility
1067 // ============================================================================
1069 // ============================================================================
1071 // size increment = max(50% of current size, ARRAY_MAXSIZE_INCREMENT)
1072 #define ARRAY_MAXSIZE_INCREMENT 4096
1073 #ifndef ARRAY_DEFAULT_INITIAL_SIZE // also defined in dynarray.h
1074 #define ARRAY_DEFAULT_INITIAL_SIZE (16)
1077 #define STRING(p) ((wxString *)(&(p)))
1080 wxArrayString::wxArrayString()
1084 m_pItems
= (char **) NULL
;
1088 wxArrayString::wxArrayString(const wxArrayString
& src
)
1092 m_pItems
= (char **) NULL
;
1097 // assignment operator
1098 wxArrayString
& wxArrayString::operator=(const wxArrayString
& src
)
1103 if ( src
.m_nCount
> ARRAY_DEFAULT_INITIAL_SIZE
)
1104 Alloc(src
.m_nCount
);
1106 // we can't just copy the pointers here because otherwise we would share
1107 // the strings with another array
1108 for ( size_t n
= 0; n
< src
.m_nCount
; n
++ )
1111 if ( m_nCount
!= 0 )
1112 memcpy(m_pItems
, src
.m_pItems
, m_nCount
*sizeof(char *));
1118 void wxArrayString::Grow()
1120 // only do it if no more place
1121 if( m_nCount
== m_nSize
) {
1122 if( m_nSize
== 0 ) {
1123 // was empty, alloc some memory
1124 m_nSize
= ARRAY_DEFAULT_INITIAL_SIZE
;
1125 m_pItems
= new char *[m_nSize
];
1128 // otherwise when it's called for the first time, nIncrement would be 0
1129 // and the array would never be expanded
1130 wxASSERT( ARRAY_DEFAULT_INITIAL_SIZE
!= 0 );
1132 // add 50% but not too much
1133 size_t nIncrement
= m_nSize
< ARRAY_DEFAULT_INITIAL_SIZE
1134 ? ARRAY_DEFAULT_INITIAL_SIZE
: m_nSize
>> 1;
1135 if ( nIncrement
> ARRAY_MAXSIZE_INCREMENT
)
1136 nIncrement
= ARRAY_MAXSIZE_INCREMENT
;
1137 m_nSize
+= nIncrement
;
1138 char **pNew
= new char *[m_nSize
];
1140 // copy data to new location
1141 memcpy(pNew
, m_pItems
, m_nCount
*sizeof(char *));
1143 // delete old memory (but do not release the strings!)
1144 wxDELETEA(m_pItems
);
1151 void wxArrayString::Free()
1153 for ( size_t n
= 0; n
< m_nCount
; n
++ ) {
1154 STRING(m_pItems
[n
])->GetStringData()->Unlock();
1158 // deletes all the strings from the list
1159 void wxArrayString::Empty()
1166 // as Empty, but also frees memory
1167 void wxArrayString::Clear()
1174 wxDELETEA(m_pItems
);
1178 wxArrayString::~wxArrayString()
1182 wxDELETEA(m_pItems
);
1185 // pre-allocates memory (frees the previous data!)
1186 void wxArrayString::Alloc(size_t nSize
)
1188 wxASSERT( nSize
> 0 );
1190 // only if old buffer was not big enough
1191 if ( nSize
> m_nSize
) {
1193 wxDELETEA(m_pItems
);
1194 m_pItems
= new char *[nSize
];
1201 // searches the array for an item (forward or backwards)
1202 int wxArrayString::Index(const char *sz
, bool bCase
, bool bFromEnd
) const
1205 if ( m_nCount
> 0 ) {
1206 size_t ui
= m_nCount
;
1208 if ( STRING(m_pItems
[--ui
])->IsSameAs(sz
, bCase
) )
1215 for( size_t ui
= 0; ui
< m_nCount
; ui
++ ) {
1216 if( STRING(m_pItems
[ui
])->IsSameAs(sz
, bCase
) )
1224 // add item at the end
1225 void wxArrayString::Add(const wxString
& str
)
1227 wxASSERT( str
.GetStringData()->IsValid() );
1231 // the string data must not be deleted!
1232 str
.GetStringData()->Lock();
1233 m_pItems
[m_nCount
++] = (char *)str
.c_str();
1236 // add item at the given position
1237 void wxArrayString::Insert(const wxString
& str
, size_t nIndex
)
1239 wxASSERT( str
.GetStringData()->IsValid() );
1241 wxCHECK_RET( nIndex
<= m_nCount
, ("bad index in wxArrayString::Insert") );
1245 memmove(&m_pItems
[nIndex
+ 1], &m_pItems
[nIndex
],
1246 (m_nCount
- nIndex
)*sizeof(char *));
1248 str
.GetStringData()->Lock();
1249 m_pItems
[nIndex
] = (char *)str
.c_str();
1254 // removes item from array (by index)
1255 void wxArrayString::Remove(size_t nIndex
)
1257 wxCHECK_RET( nIndex
<= m_nCount
, _("bad index in wxArrayString::Remove") );
1260 Item(nIndex
).GetStringData()->Unlock();
1262 memmove(&m_pItems
[nIndex
], &m_pItems
[nIndex
+ 1],
1263 (m_nCount
- nIndex
- 1)*sizeof(char *));
1267 // removes item from array (by value)
1268 void wxArrayString::Remove(const char *sz
)
1270 int iIndex
= Index(sz
);
1272 wxCHECK_RET( iIndex
!= NOT_FOUND
,
1273 _("removing inexistent element in wxArrayString::Remove") );
1278 // sort array elements using passed comparaison function
1280 void wxArrayString::Sort(bool WXUNUSED(bCase
), bool WXUNUSED(bReverse
) )
1283 //qsort(m_pItems, m_nCount, sizeof(char *), fCmp);