1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/stringimpl.h
3 // Purpose: wxStringImpl class, implementation of wxString
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
13 This header implements std::string-like string class, wxStringImpl, that is
14 used by wxString to store the data. Alternatively, if wxUSE_STL=1,
15 wxStringImpl is just a typedef to std:: string class.
18 #ifndef _WX_WXSTRINGIMPL_H__
19 #define _WX_WXSTRINGIMPL_H__
21 // ----------------------------------------------------------------------------
23 // ----------------------------------------------------------------------------
25 #include "wx/defs.h" // everybody should include this
26 #include "wx/wxchar.h" // for wxChar, wxStrlen() etc.
30 // ---------------------------------------------------------------------------
32 // ---------------------------------------------------------------------------
34 // implementation only
35 #define wxASSERT_VALID_INDEX(i) \
36 wxASSERT_MSG( (size_t)(i) <= length(), _T("invalid index in wxString") )
39 // ----------------------------------------------------------------------------
41 // ----------------------------------------------------------------------------
43 // global pointer to empty string
44 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxEmptyString
;
47 // ----------------------------------------------------------------------------
48 // deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING
49 // ----------------------------------------------------------------------------
51 #define wxUSE_STL_BASED_WXSTRING wxUSE_STL
53 // in both cases we need to define wxStdString
54 #if wxUSE_STL_BASED_WXSTRING || wxUSE_STD_STRING
56 #include "wx/beforestd.h"
58 #include "wx/afterstd.h"
60 #if wxUSE_UNICODE_WCHAR
61 #ifdef HAVE_STD_WSTRING
62 typedef std::wstring wxStdString
;
64 typedef std::basic_string
<wxChar
> wxStdString
;
67 typedef std::string wxStdString
;
70 #endif // need <string>
72 #if wxUSE_STL_BASED_WXSTRING
74 // we always want ctor from std::string when using std::string internally
75 #undef wxUSE_STD_STRING
76 #define wxUSE_STD_STRING 1
78 #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
79 (defined(_MSC_VER) && (_MSC_VER <= 1200))
80 #define wxSTRING_BASE_HASNT_CLEAR
83 typedef wxStdString wxStringImpl
;
84 #else // if !wxUSE_STL_BASED_WXSTRING
86 // in non-STL mode, compare() is implemented in wxString and not wxStringImpl
87 #undef HAVE_STD_STRING_COMPARE
89 // ---------------------------------------------------------------------------
90 // string data prepended with some housekeeping info (used by wxString class),
91 // is never used directly (but had to be put here to allow inlining)
92 // ---------------------------------------------------------------------------
94 struct WXDLLIMPEXP_BASE wxStringData
96 int nRefs
; // reference count
97 size_t nDataLength
, // actual string length
98 nAllocLength
; // allocated memory size
100 // mimics declaration 'wxChar data[nAllocLength]'
101 wxChar
* data() const { return (wxChar
*)(this + 1); }
103 // empty string has a special ref count so it's never deleted
104 bool IsEmpty() const { return (nRefs
== -1); }
105 bool IsShared() const { return (nRefs
> 1); }
108 void Lock() { if ( !IsEmpty() ) nRefs
++; }
110 // VC++ will refuse to inline Unlock but profiling shows that it is wrong
111 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
114 // VC++ free must take place in same DLL as allocation when using non dll
115 // run-time library (e.g. Multithreaded instead of Multithreaded DLL)
116 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
117 void Unlock() { if ( !IsEmpty() && --nRefs
== 0) Free(); }
118 // we must not inline deallocation since allocation is not inlined
121 void Unlock() { if ( !IsEmpty() && --nRefs
== 0) free(this); }
124 // if we had taken control over string memory (GetWriteBuf), it's
125 // intentionally put in invalid state
126 void Validate(bool b
) { nRefs
= (b
? 1 : 0); }
127 bool IsValid() const { return (nRefs
!= 0); }
130 class WXDLLIMPEXP_BASE wxStringImpl
133 // an 'invalid' value for string index, moved to this place due to a CW bug
134 static const size_t npos
;
137 // points to data preceded by wxStringData structure with ref count info
138 wxStringCharType
*m_pchData
;
140 // accessor to string data
141 wxStringData
* GetStringData() const { return (wxStringData
*)m_pchData
- 1; }
143 // string (re)initialization functions
144 // initializes the string to the empty value (must be called only from
145 // ctors, use Reinit() otherwise)
146 void Init() { m_pchData
= (wxStringCharType
*)wxEmptyString
; }
147 // initializes the string with (a part of) C-string
148 void InitWith(const wxStringCharType
*psz
, size_t nPos
= 0, size_t nLen
= npos
);
149 // as Init, but also frees old data
150 void Reinit() { GetStringData()->Unlock(); Init(); }
153 // allocates memory for string of length nLen
154 bool AllocBuffer(size_t nLen
);
155 // effectively copies data to string
156 bool AssignCopy(size_t, const wxStringCharType
*);
158 // append a (sub)string
159 bool ConcatSelf(size_t nLen
, const wxStringCharType
*src
, size_t nMaxLen
);
160 bool ConcatSelf(size_t nLen
, const wxStringCharType
*src
)
161 { return ConcatSelf(nLen
, src
, nLen
); }
163 // functions called before writing to the string: they copy it if there
164 // are other references to our data (should be the only owner when writing)
165 bool CopyBeforeWrite();
166 bool AllocBeforeWrite(size_t);
168 // compatibility with wxString
169 bool Alloc(size_t nLen
);
173 typedef wxStringCharType value_type
;
174 typedef wxStringCharType char_type
;
175 typedef size_t size_type
;
176 typedef value_type
& reference
;
177 typedef const value_type
& const_reference
;
178 typedef value_type
* pointer
;
179 typedef const value_type
* const_pointer
;
181 // macro to define the bulk of iterator and const_iterator classes
182 #define WX_DEFINE_STRINGIMPL_ITERATOR(iterator_name, ref_type, ptr_type) \
184 typedef wxStringCharType value_type; \
185 typedef ref_type reference; \
186 typedef ptr_type pointer; \
188 iterator_name(pointer ptr) : m_ptr(ptr) { } \
190 reference operator*() const { return *m_ptr; } \
192 iterator_name& operator++() { m_ptr++; return *this; } \
193 iterator_name operator++(int) \
195 const iterator_name tmp(*this); \
200 iterator_name& operator--() { m_ptr--; return *this; } \
201 iterator_name operator--(int) \
203 const iterator_name tmp(*this); \
208 iterator_name operator+(int n) const \
209 { return iterator_name(m_ptr + n); } \
210 iterator_name operator-(int n) const \
211 { return iterator_name(m_ptr - n); } \
212 iterator_name& operator+=(int n) \
213 { m_ptr += n; return *this; } \
214 iterator_name& operator-=(int n) \
215 { m_ptr -= n; return *this; } \
217 size_t operator-(const iterator_name& i) const \
218 { return m_ptr - i.m_ptr; } \
220 bool operator==(const iterator_name& i) const \
221 { return m_ptr == i.m_ptr; } \
222 bool operator!=(const iterator_name& i) const \
223 { return m_ptr != i.m_ptr; } \
225 bool operator<(const iterator_name& i) const \
226 { return m_ptr < i.m_ptr; } \
227 bool operator>(const iterator_name& i) const \
228 { return m_ptr > i.m_ptr; } \
229 bool operator<=(const iterator_name& i) const \
230 { return m_ptr <= i.m_ptr; } \
231 bool operator>=(const iterator_name& i) const \
232 { return m_ptr >= i.m_ptr; } \
235 /* for wxStringImpl use only */ \
236 operator pointer() const { return m_ptr; } \
238 friend class WXDLLIMPEXP_BASE wxStringImpl; \
244 WX_DEFINE_STRINGIMPL_ITERATOR(iterator
,
248 friend class const_iterator
;
254 const_iterator(iterator i
) : m_ptr(i
.m_ptr
) { }
256 WX_DEFINE_STRINGIMPL_ITERATOR(const_iterator
,
257 const wxStringCharType
&,
258 const wxStringCharType
*);
262 // constructors and destructor
263 // ctor for an empty string
264 wxStringImpl() { Init(); }
266 wxStringImpl(const wxStringImpl
& stringSrc
)
268 wxASSERT_MSG( stringSrc
.GetStringData()->IsValid(),
269 _T("did you forget to call UngetWriteBuf()?") );
271 if ( stringSrc
.empty() ) {
272 // nothing to do for an empty string
276 m_pchData
= stringSrc
.m_pchData
; // share same data
277 GetStringData()->Lock(); // => one more copy
280 // string containing nRepeat copies of ch
281 wxStringImpl(size_type nRepeat
, wxStringCharType ch
);
282 // ctor takes first nLength characters from C string
283 // (default value of npos means take all the string)
284 wxStringImpl(const wxStringCharType
*psz
)
285 { InitWith(psz
, 0, npos
); }
286 wxStringImpl(const wxStringCharType
*psz
, size_t nLength
)
287 { InitWith(psz
, 0, nLength
); }
288 // take nLen chars starting at nPos
289 wxStringImpl(const wxStringImpl
& str
, size_t nPos
, size_t nLen
)
291 wxASSERT_MSG( str
.GetStringData()->IsValid(),
292 _T("did you forget to call UngetWriteBuf()?") );
294 size_t strLen
= str
.length() - nPos
; nLen
= strLen
< nLen
? strLen
: nLen
;
295 InitWith(str
.c_str(), nPos
, nLen
);
297 // take everything between start and end
298 wxStringImpl(const_iterator start
, const_iterator end
);
300 // dtor is not virtual, this class must not be inherited from!
303 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
304 //RN - according to the above VC++ does indeed inline this,
305 //even though it spits out two warnings
306 #pragma warning (disable:4714)
309 GetStringData()->Unlock();
312 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
313 //re-enable inlining warning
314 #pragma warning (default:4714)
316 // overloaded assignment
317 // from another wxString
318 wxStringImpl
& operator=(const wxStringImpl
& stringSrc
);
320 wxStringImpl
& operator=(wxStringCharType ch
);
322 wxStringImpl
& operator=(const wxStringCharType
*psz
);
324 // return the length of the string
325 size_type
length() const { return GetStringData()->nDataLength
; }
326 // return the length of the string
327 size_type
size() const { return length(); }
328 // return the maximum size of the string
329 size_type
max_size() const { return npos
; }
330 // resize the string, filling the space with c if c != 0
331 void resize(size_t nSize
, wxStringCharType ch
= '\0');
332 // delete the contents of the string
333 void clear() { erase(0, npos
); }
334 // returns true if the string is empty
335 bool empty() const { return length() == 0; }
336 // inform string about planned change in size
337 void reserve(size_t sz
) { Alloc(sz
); }
338 size_type
capacity() const { return GetStringData()->nAllocLength
; }
341 // return the character at position n
342 value_type
at(size_type n
) const
343 { wxASSERT_VALID_INDEX( n
); return m_pchData
[n
]; }
344 // returns the writable character at position n
345 reference
at(size_type n
)
347 wxASSERT_VALID_INDEX( n
);
350 } // FIXME-UTF8: not useful for us...?
352 // lib.string.modifiers
353 // append elements str[pos], ..., str[pos+n]
354 wxStringImpl
& append(const wxStringImpl
& str
, size_t pos
, size_t n
)
356 wxASSERT(pos
<= str
.length());
357 ConcatSelf(n
, str
.c_str() + pos
, str
.length() - pos
);
361 wxStringImpl
& append(const wxStringImpl
& str
)
362 { ConcatSelf(str
.length(), str
.c_str()); return *this; }
363 // append first n (or all if n == npos) characters of sz
364 wxStringImpl
& append(const wxStringCharType
*sz
)
365 { ConcatSelf(wxStrlen(sz
), sz
); return *this; }
366 wxStringImpl
& append(const wxStringCharType
*sz
, size_t n
)
367 { ConcatSelf(n
, sz
); return *this; }
368 // append n copies of ch
369 wxStringImpl
& append(size_t n
, wxStringCharType ch
);
370 // append from first to last
371 wxStringImpl
& append(const_iterator first
, const_iterator last
)
372 { ConcatSelf(last
- first
, first
); return *this; }
374 // same as `this_string = str'
375 wxStringImpl
& assign(const wxStringImpl
& str
)
376 { return *this = str
; }
377 // same as ` = str[pos..pos + n]
378 wxStringImpl
& assign(const wxStringImpl
& str
, size_t pos
, size_t n
)
379 { clear(); return append(str
, pos
, n
); }
380 // same as `= first n (or all if n == npos) characters of sz'
381 wxStringImpl
& assign(const wxStringCharType
*sz
)
382 { clear(); return append(sz
, wxStrlen(sz
)); }
383 wxStringImpl
& assign(const wxStringCharType
*sz
, size_t n
)
384 { clear(); return append(sz
, n
); }
385 // same as `= n copies of ch'
386 wxStringImpl
& assign(size_t n
, wxStringCharType ch
)
387 { clear(); return append(n
, ch
); }
388 // assign from first to last
389 wxStringImpl
& assign(const_iterator first
, const_iterator last
)
390 { clear(); return append(first
, last
); }
392 // first valid index position
393 const_iterator
begin() const { return m_pchData
; }
395 // position one after the last valid one
396 const_iterator
end() const { return m_pchData
+ length(); }
399 // insert another string
400 wxStringImpl
& insert(size_t nPos
, const wxStringImpl
& str
)
402 wxASSERT( str
.GetStringData()->IsValid() );
403 return insert(nPos
, str
.c_str(), str
.length());
405 // insert n chars of str starting at nStart (in str)
406 wxStringImpl
& insert(size_t nPos
, const wxStringImpl
& str
, size_t nStart
, size_t n
)
408 wxASSERT( str
.GetStringData()->IsValid() );
409 wxASSERT( nStart
< str
.length() );
410 size_t strLen
= str
.length() - nStart
;
411 n
= strLen
< n
? strLen
: n
;
412 return insert(nPos
, str
.c_str() + nStart
, n
);
414 // insert first n (or all if n == npos) characters of sz
415 wxStringImpl
& insert(size_t nPos
, const wxStringCharType
*sz
, size_t n
= npos
);
416 // insert n copies of ch
417 wxStringImpl
& insert(size_t nPos
, size_t n
, wxStringCharType ch
)// FIXME-UTF8: tricky
418 { return insert(nPos
, wxStringImpl(n
, ch
)); }
419 iterator
insert(iterator it
, wxStringCharType ch
) // FIXME-UTF8: tricky
420 { size_t idx
= it
- begin(); insert(idx
, 1, ch
); return begin() + idx
; }
421 void insert(iterator it
, const_iterator first
, const_iterator last
)
422 { insert(it
- begin(), first
, last
- first
); }
423 void insert(iterator it
, size_type n
, wxStringCharType ch
)
424 { insert(it
- begin(), n
, ch
); }
426 // delete characters from nStart to nStart + nLen
427 wxStringImpl
& erase(size_type pos
= 0, size_type n
= npos
);
428 iterator
erase(iterator first
, iterator last
)
430 size_t idx
= first
- begin();
431 erase(idx
, last
- first
);
432 return begin() + idx
;
434 iterator
erase(iterator first
);
436 // explicit conversion to C string (use this with printf()!)
437 const wxStringCharType
* c_str() const { return m_pchData
; }
438 const wxStringCharType
* data() const { return m_pchData
; }
440 // replaces the substring of length nLen starting at nStart
441 wxStringImpl
& replace(size_t nStart
, size_t nLen
, const wxStringCharType
* sz
);
442 // replaces the substring of length nLen starting at nStart
443 wxStringImpl
& replace(size_t nStart
, size_t nLen
, const wxStringImpl
& str
)
444 { return replace(nStart
, nLen
, str
.c_str()); }
445 // replaces the substring with nCount copies of ch
446 wxStringImpl
& replace(size_t nStart
, size_t nLen
, size_t nCount
, wxStringCharType ch
);
447 // replaces a substring with another substring
448 wxStringImpl
& replace(size_t nStart
, size_t nLen
,
449 const wxStringImpl
& str
, size_t nStart2
, size_t nLen2
);
450 // replaces the substring with first nCount chars of sz
451 wxStringImpl
& replace(size_t nStart
, size_t nLen
,
452 const wxStringCharType
* sz
, size_t nCount
);
453 wxStringImpl
& replace(iterator first
, iterator last
, const_pointer s
)
454 { return replace(first
- begin(), last
- first
, s
); }
455 wxStringImpl
& replace(iterator first
, iterator last
, const_pointer s
,
457 { return replace(first
- begin(), last
- first
, s
, n
); }
458 wxStringImpl
& replace(iterator first
, iterator last
, const wxStringImpl
& s
)
459 { return replace(first
- begin(), last
- first
, s
); }
460 wxStringImpl
& replace(iterator first
, iterator last
, size_type n
, wxStringCharType c
)
461 { return replace(first
- begin(), last
- first
, n
, c
); }
462 wxStringImpl
& replace(iterator first
, iterator last
,
463 const_iterator first1
, const_iterator last1
)
464 { return replace(first
- begin(), last
- first
, first1
, last1
- first1
); }
467 void swap(wxStringImpl
& str
);
469 // All find() functions take the nStart argument which specifies the
470 // position to start the search on, the default value is 0. All functions
471 // return npos if there were no match.
474 size_t find(const wxStringImpl
& str
, size_t nStart
= 0) const;
476 // find first n characters of sz
477 size_t find(const wxStringCharType
* sz
, size_t nStart
= 0, size_t n
= npos
) const;
479 // find the first occurrence of character ch after nStart
480 size_t find(wxStringCharType ch
, size_t nStart
= 0) const;
482 // rfind() family is exactly like find() but works right to left
484 // as find, but from the end
485 size_t rfind(const wxStringImpl
& str
, size_t nStart
= npos
) const;
487 // as find, but from the end
488 size_t rfind(const wxStringCharType
* sz
, size_t nStart
= npos
,
489 size_t n
= npos
) const;
490 // as find, but from the end
491 size_t rfind(wxStringCharType ch
, size_t nStart
= npos
) const;
493 size_type
copy(wxStringCharType
* s
, size_type n
, size_type pos
= 0);
495 // substring extraction
496 wxStringImpl
substr(size_t nStart
= 0, size_t nLen
= npos
) const;
499 wxStringImpl
& operator+=(const wxStringImpl
& s
) { return append(s
); }
500 // string += C string
501 wxStringImpl
& operator+=(const wxStringCharType
*psz
) { return append(psz
); }
503 wxStringImpl
& operator+=(wxStringCharType ch
) { return append(1, ch
); }
505 #if !wxUSE_UNICODE_UTF8
506 // helpers for wxStringBuffer and wxStringBufferLength
507 wxStringCharType
*DoGetWriteBuf(size_t nLen
);
508 void DoUngetWriteBuf();
509 void DoUngetWriteBuf(size_t nLen
);
512 friend class WXDLLIMPEXP_BASE wxString
;
515 #endif // !wxUSE_STL_BASED_WXSTRING
517 // don't pollute the library user's name space
518 #undef wxASSERT_VALID_INDEX
520 #endif // _WX_WXSTRINGIMPL_H__