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; \
242 // we need to declare const_iterator in wxStringImpl scope, the friend
243 // declaration inside iterator class itself is not enough, or at least not
244 // for g++ 3.4 (g++ 4 is ok)
245 class const_iterator
;
249 WX_DEFINE_STRINGIMPL_ITERATOR(iterator
,
253 friend class const_iterator
;
259 const_iterator(iterator i
) : m_ptr(i
.m_ptr
) { }
261 WX_DEFINE_STRINGIMPL_ITERATOR(const_iterator
,
262 const wxStringCharType
&,
263 const wxStringCharType
*);
267 // constructors and destructor
268 // ctor for an empty string
269 wxStringImpl() { Init(); }
271 wxStringImpl(const wxStringImpl
& stringSrc
)
273 wxASSERT_MSG( stringSrc
.GetStringData()->IsValid(),
274 _T("did you forget to call UngetWriteBuf()?") );
276 if ( stringSrc
.empty() ) {
277 // nothing to do for an empty string
281 m_pchData
= stringSrc
.m_pchData
; // share same data
282 GetStringData()->Lock(); // => one more copy
285 // string containing nRepeat copies of ch
286 wxStringImpl(size_type nRepeat
, wxStringCharType ch
);
287 // ctor takes first nLength characters from C string
288 // (default value of npos means take all the string)
289 wxStringImpl(const wxStringCharType
*psz
)
290 { InitWith(psz
, 0, npos
); }
291 wxStringImpl(const wxStringCharType
*psz
, size_t nLength
)
292 { InitWith(psz
, 0, nLength
); }
293 // take nLen chars starting at nPos
294 wxStringImpl(const wxStringImpl
& str
, size_t nPos
, size_t nLen
)
296 wxASSERT_MSG( str
.GetStringData()->IsValid(),
297 _T("did you forget to call UngetWriteBuf()?") );
299 size_t strLen
= str
.length() - nPos
; nLen
= strLen
< nLen
? strLen
: nLen
;
300 InitWith(str
.c_str(), nPos
, nLen
);
302 // take everything between start and end
303 wxStringImpl(const_iterator start
, const_iterator end
);
305 // dtor is not virtual, this class must not be inherited from!
308 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
309 //RN - according to the above VC++ does indeed inline this,
310 //even though it spits out two warnings
311 #pragma warning (disable:4714)
314 GetStringData()->Unlock();
317 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
318 //re-enable inlining warning
319 #pragma warning (default:4714)
321 // overloaded assignment
322 // from another wxString
323 wxStringImpl
& operator=(const wxStringImpl
& stringSrc
);
325 wxStringImpl
& operator=(wxStringCharType ch
);
327 wxStringImpl
& operator=(const wxStringCharType
*psz
);
329 // return the length of the string
330 size_type
length() const { return GetStringData()->nDataLength
; }
331 // return the length of the string
332 size_type
size() const { return length(); }
333 // return the maximum size of the string
334 size_type
max_size() const { return npos
; }
335 // resize the string, filling the space with c if c != 0
336 void resize(size_t nSize
, wxStringCharType ch
= '\0');
337 // delete the contents of the string
338 void clear() { erase(0, npos
); }
339 // returns true if the string is empty
340 bool empty() const { return length() == 0; }
341 // inform string about planned change in size
342 void reserve(size_t sz
) { Alloc(sz
); }
343 size_type
capacity() const { return GetStringData()->nAllocLength
; }
346 // return the character at position n
347 value_type
at(size_type n
) const
348 { wxASSERT_VALID_INDEX( n
); return m_pchData
[n
]; }
349 // returns the writable character at position n
350 reference
at(size_type n
)
352 wxASSERT_VALID_INDEX( n
);
355 } // FIXME-UTF8: not useful for us...?
357 // lib.string.modifiers
358 // append elements str[pos], ..., str[pos+n]
359 wxStringImpl
& append(const wxStringImpl
& str
, size_t pos
, size_t n
)
361 wxASSERT(pos
<= str
.length());
362 ConcatSelf(n
, str
.c_str() + pos
, str
.length() - pos
);
366 wxStringImpl
& append(const wxStringImpl
& str
)
367 { ConcatSelf(str
.length(), str
.c_str()); return *this; }
368 // append first n (or all if n == npos) characters of sz
369 wxStringImpl
& append(const wxStringCharType
*sz
)
370 { ConcatSelf(wxStrlen(sz
), sz
); return *this; }
371 wxStringImpl
& append(const wxStringCharType
*sz
, size_t n
)
372 { ConcatSelf(n
, sz
); return *this; }
373 // append n copies of ch
374 wxStringImpl
& append(size_t n
, wxStringCharType ch
);
375 // append from first to last
376 wxStringImpl
& append(const_iterator first
, const_iterator last
)
377 { ConcatSelf(last
- first
, first
); return *this; }
379 // same as `this_string = str'
380 wxStringImpl
& assign(const wxStringImpl
& str
)
381 { return *this = str
; }
382 // same as ` = str[pos..pos + n]
383 wxStringImpl
& assign(const wxStringImpl
& str
, size_t pos
, size_t n
)
384 { clear(); return append(str
, pos
, n
); }
385 // same as `= first n (or all if n == npos) characters of sz'
386 wxStringImpl
& assign(const wxStringCharType
*sz
)
387 { clear(); return append(sz
, wxStrlen(sz
)); }
388 wxStringImpl
& assign(const wxStringCharType
*sz
, size_t n
)
389 { clear(); return append(sz
, n
); }
390 // same as `= n copies of ch'
391 wxStringImpl
& assign(size_t n
, wxStringCharType ch
)
392 { clear(); return append(n
, ch
); }
393 // assign from first to last
394 wxStringImpl
& assign(const_iterator first
, const_iterator last
)
395 { clear(); return append(first
, last
); }
397 // first valid index position
398 const_iterator
begin() const { return m_pchData
; }
400 // position one after the last valid one
401 const_iterator
end() const { return m_pchData
+ length(); }
404 // insert another string
405 wxStringImpl
& insert(size_t nPos
, const wxStringImpl
& str
)
407 wxASSERT( str
.GetStringData()->IsValid() );
408 return insert(nPos
, str
.c_str(), str
.length());
410 // insert n chars of str starting at nStart (in str)
411 wxStringImpl
& insert(size_t nPos
, const wxStringImpl
& str
, size_t nStart
, size_t n
)
413 wxASSERT( str
.GetStringData()->IsValid() );
414 wxASSERT( nStart
< str
.length() );
415 size_t strLen
= str
.length() - nStart
;
416 n
= strLen
< n
? strLen
: n
;
417 return insert(nPos
, str
.c_str() + nStart
, n
);
419 // insert first n (or all if n == npos) characters of sz
420 wxStringImpl
& insert(size_t nPos
, const wxStringCharType
*sz
, size_t n
= npos
);
421 // insert n copies of ch
422 wxStringImpl
& insert(size_t nPos
, size_t n
, wxStringCharType ch
)// FIXME-UTF8: tricky
423 { return insert(nPos
, wxStringImpl(n
, ch
)); }
424 iterator
insert(iterator it
, wxStringCharType ch
) // FIXME-UTF8: tricky
425 { size_t idx
= it
- begin(); insert(idx
, 1, ch
); return begin() + idx
; }
426 void insert(iterator it
, const_iterator first
, const_iterator last
)
427 { insert(it
- begin(), first
, last
- first
); }
428 void insert(iterator it
, size_type n
, wxStringCharType ch
)
429 { insert(it
- begin(), n
, ch
); }
431 // delete characters from nStart to nStart + nLen
432 wxStringImpl
& erase(size_type pos
= 0, size_type n
= npos
);
433 iterator
erase(iterator first
, iterator last
)
435 size_t idx
= first
- begin();
436 erase(idx
, last
- first
);
437 return begin() + idx
;
439 iterator
erase(iterator first
);
441 // explicit conversion to C string (use this with printf()!)
442 const wxStringCharType
* c_str() const { return m_pchData
; }
443 const wxStringCharType
* data() const { return m_pchData
; }
445 // replaces the substring of length nLen starting at nStart
446 wxStringImpl
& replace(size_t nStart
, size_t nLen
, const wxStringCharType
* sz
);
447 // replaces the substring of length nLen starting at nStart
448 wxStringImpl
& replace(size_t nStart
, size_t nLen
, const wxStringImpl
& str
)
449 { return replace(nStart
, nLen
, str
.c_str()); }
450 // replaces the substring with nCount copies of ch
451 wxStringImpl
& replace(size_t nStart
, size_t nLen
, size_t nCount
, wxStringCharType ch
);
452 // replaces a substring with another substring
453 wxStringImpl
& replace(size_t nStart
, size_t nLen
,
454 const wxStringImpl
& str
, size_t nStart2
, size_t nLen2
);
455 // replaces the substring with first nCount chars of sz
456 wxStringImpl
& replace(size_t nStart
, size_t nLen
,
457 const wxStringCharType
* sz
, size_t nCount
);
458 wxStringImpl
& replace(iterator first
, iterator last
, const_pointer s
)
459 { return replace(first
- begin(), last
- first
, s
); }
460 wxStringImpl
& replace(iterator first
, iterator last
, const_pointer s
,
462 { return replace(first
- begin(), last
- first
, s
, n
); }
463 wxStringImpl
& replace(iterator first
, iterator last
, const wxStringImpl
& s
)
464 { return replace(first
- begin(), last
- first
, s
); }
465 wxStringImpl
& replace(iterator first
, iterator last
, size_type n
, wxStringCharType c
)
466 { return replace(first
- begin(), last
- first
, n
, c
); }
467 wxStringImpl
& replace(iterator first
, iterator last
,
468 const_iterator first1
, const_iterator last1
)
469 { return replace(first
- begin(), last
- first
, first1
, last1
- first1
); }
472 void swap(wxStringImpl
& str
);
474 // All find() functions take the nStart argument which specifies the
475 // position to start the search on, the default value is 0. All functions
476 // return npos if there were no match.
479 size_t find(const wxStringImpl
& str
, size_t nStart
= 0) const;
481 // find first n characters of sz
482 size_t find(const wxStringCharType
* sz
, size_t nStart
= 0, size_t n
= npos
) const;
484 // find the first occurrence of character ch after nStart
485 size_t find(wxStringCharType ch
, size_t nStart
= 0) const;
487 // rfind() family is exactly like find() but works right to left
489 // as find, but from the end
490 size_t rfind(const wxStringImpl
& str
, size_t nStart
= npos
) const;
492 // as find, but from the end
493 size_t rfind(const wxStringCharType
* sz
, size_t nStart
= npos
,
494 size_t n
= npos
) const;
495 // as find, but from the end
496 size_t rfind(wxStringCharType ch
, size_t nStart
= npos
) const;
498 size_type
copy(wxStringCharType
* s
, size_type n
, size_type pos
= 0);
500 // substring extraction
501 wxStringImpl
substr(size_t nStart
= 0, size_t nLen
= npos
) const;
504 wxStringImpl
& operator+=(const wxStringImpl
& s
) { return append(s
); }
505 // string += C string
506 wxStringImpl
& operator+=(const wxStringCharType
*psz
) { return append(psz
); }
508 wxStringImpl
& operator+=(wxStringCharType ch
) { return append(1, ch
); }
510 #if !wxUSE_UNICODE_UTF8
511 // helpers for wxStringBuffer and wxStringBufferLength
512 wxStringCharType
*DoGetWriteBuf(size_t nLen
);
513 void DoUngetWriteBuf();
514 void DoUngetWriteBuf(size_t nLen
);
517 friend class WXDLLIMPEXP_BASE wxString
;
520 #endif // !wxUSE_STL_BASED_WXSTRING
522 // don't pollute the library user's name space
523 #undef wxASSERT_VALID_INDEX
525 #endif // _WX_WXSTRINGIMPL_H__