1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: include/wx/arrstr.h
3 // Purpose: wxArrayString class
4 // Author: Mattia Barbon and Vadim Zeitlin
8 // Copyright: (c) 2003 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
16 #include "wx/string.h"
18 // these functions are only used in STL build now but we define them in any
19 // case for compatibility with the existing code outside of the library which
20 // could be using them
21 inline int wxCMPFUNC_CONV
wxStringSortAscending(wxString
* s1
, wxString
* s2
)
26 inline int wxCMPFUNC_CONV
wxStringSortDescending(wxString
* s1
, wxString
* s2
)
28 return wxStringSortAscending(s2
, s1
);
33 #include "wx/dynarray.h"
35 typedef int (wxCMPFUNC_CONV
*CMPFUNCwxString
)(wxString
*, wxString
*);
36 typedef wxString _wxArraywxBaseArrayStringBase
;
37 _WX_DECLARE_BASEARRAY_2(_wxArraywxBaseArrayStringBase
, wxBaseArrayStringBase
,
38 wxArray_SortFunction
<wxString
>,
39 class WXDLLIMPEXP_BASE
);
40 WX_DEFINE_USER_EXPORTED_TYPEARRAY(wxString
, wxArrayStringBase
,
41 wxBaseArrayStringBase
, WXDLLIMPEXP_BASE
);
42 _WX_DEFINE_SORTED_TYPEARRAY_2(wxString
, wxSortedArrayStringBase
,
43 wxBaseArrayStringBase
, = wxStringSortAscending
,
44 class WXDLLIMPEXP_BASE
, CMPFUNCwxString
);
46 class WXDLLIMPEXP_BASE wxArrayString
: public wxArrayStringBase
49 // type of function used by wxArrayString::Sort()
50 typedef int (wxCMPFUNC_CONV
*CompareFunction
)(const wxString
& first
,
51 const wxString
& second
);
54 wxArrayString(const wxArrayString
& a
) : wxArrayStringBase(a
) { }
55 wxArrayString(size_t sz
, const char** a
);
56 wxArrayString(size_t sz
, const wchar_t** a
);
57 wxArrayString(size_t sz
, const wxString
* a
);
59 int Index(const wxString
& str
, bool bCase
= true, bool bFromEnd
= false) const;
61 void Sort(bool reverseOrder
= false);
62 void Sort(CompareFunction function
);
63 void Sort(CMPFUNCwxString function
) { wxArrayStringBase::Sort(function
); }
65 size_t Add(const wxString
& string
, size_t copies
= 1)
67 wxArrayStringBase::Add(string
, copies
);
68 return size() - copies
;
72 class WXDLLIMPEXP_BASE wxSortedArrayString
: public wxSortedArrayStringBase
75 wxSortedArrayString() : wxSortedArrayStringBase(wxStringSortAscending
)
77 wxSortedArrayString(const wxSortedArrayString
& array
)
78 : wxSortedArrayStringBase(array
)
80 wxSortedArrayString(const wxArrayString
& src
)
81 : wxSortedArrayStringBase(wxStringSortAscending
)
85 for ( size_t n
= 0; n
< src
.size(); n
++ )
89 int Index(const wxString
& str
, bool bCase
= true, bool bFromEnd
= false) const;
94 wxFAIL_MSG( "wxSortedArrayString::Insert() is not to be used" );
99 wxFAIL_MSG( "wxSortedArrayString::Sort() is not to be used" );
103 #else // if !wxUSE_STL
105 // this shouldn't be defined for compilers not supporting template methods or
106 // without std::distance()
108 // FIXME-VC6: currently it's only not defined for VC6 in DLL build as it
109 // doesn't export template methods from DLL correctly so even though
110 // it compiles them fine, we get link errors when using wxArrayString
111 #if !defined(__VISUALC6__) || !(defined(WXMAKINGDLL) || defined(WXUSINGDLL))
112 #define wxHAS_VECTOR_TEMPLATE_ASSIGN
115 #ifdef wxHAS_VECTOR_TEMPLATE_ASSIGN
116 #include "wx/beforestd.h"
118 #include "wx/afterstd.h"
119 #endif // wxHAS_VECTOR_TEMPLATE_ASSIGN
121 class WXDLLIMPEXP_BASE wxArrayString
124 // type of function used by wxArrayString::Sort()
125 typedef int (wxCMPFUNC_CONV
*CompareFunction
)(const wxString
& first
,
126 const wxString
& second
);
127 // type of function used by wxArrayString::Sort(), for compatibility with
129 typedef int (wxCMPFUNC_CONV
*CompareFunction2
)(wxString
* first
,
132 // constructors and destructor
134 wxArrayString() { Init(false); }
135 // if autoSort is true, the array is always sorted (in alphabetical order)
137 // NB: the reason for using int and not bool is that like this we can avoid
138 // using this ctor for implicit conversions from "const char *" (which
139 // we'd like to be implicitly converted to wxString instead!)
141 // of course, using explicit would be even better - if all compilers
143 wxArrayString(int autoSort
) { Init(autoSort
!= 0); }
144 // C string array ctor
145 wxArrayString(size_t sz
, const char** a
);
146 wxArrayString(size_t sz
, const wchar_t** a
);
147 // wxString string array ctor
148 wxArrayString(size_t sz
, const wxString
* a
);
150 wxArrayString(const wxArrayString
& array
);
151 // assignment operator
152 wxArrayString
& operator=(const wxArrayString
& src
);
153 // not virtual, this class should not be derived from
157 // empties the list, but doesn't release memory
159 // empties the list and releases memory
161 // preallocates memory for given number of items
162 void Alloc(size_t nCount
);
163 // minimzes the memory usage (by freeing all extra memory)
167 // number of elements in the array
168 size_t GetCount() const { return m_nCount
; }
170 bool IsEmpty() const { return m_nCount
== 0; }
171 // number of elements in the array (GetCount is preferred API)
172 size_t Count() const { return m_nCount
; }
174 // items access (range checking is done in debug version)
175 // get item at position uiIndex
176 wxString
& Item(size_t nIndex
) const
178 wxASSERT_MSG( nIndex
< m_nCount
,
179 _T("wxArrayString: index out of bounds") );
181 return m_pItems
[nIndex
];
185 wxString
& operator[](size_t nIndex
) const { return Item(nIndex
); }
187 wxString
& Last() const
189 wxASSERT_MSG( !IsEmpty(),
190 _T("wxArrayString: index out of bounds") );
191 return Item(GetCount() - 1);
196 // Search the element in the array, starting from the beginning if
197 // bFromEnd is false or from end otherwise. If bCase, comparison is case
198 // sensitive (default). Returns index of the first item matched or
200 int Index (const wxString
& str
, bool bCase
= true, bool bFromEnd
= false) const;
201 // add new element at the end (if the array is not sorted), return its
203 size_t Add(const wxString
& str
, size_t nInsert
= 1);
204 // add new element at given position
205 void Insert(const wxString
& str
, size_t uiIndex
, size_t nInsert
= 1);
206 // expand the array to have count elements
207 void SetCount(size_t count
);
208 // remove first item matching this value
209 void Remove(const wxString
& sz
);
210 // remove item by index
211 void RemoveAt(size_t nIndex
, size_t nRemove
= 1);
214 // sort array elements in alphabetical order (or reversed alphabetical
215 // order if reverseOrder parameter is true)
216 void Sort(bool reverseOrder
= false);
217 // sort array elements using specified comparison function
218 void Sort(CompareFunction compareFunction
);
219 void Sort(CompareFunction2 compareFunction
);
222 // compare two arrays case sensitively
223 bool operator==(const wxArrayString
& a
) const;
224 // compare two arrays case sensitively
225 bool operator!=(const wxArrayString
& a
) const { return !(*this == a
); }
227 // STL-like interface
228 typedef wxString value_type
;
229 typedef value_type
* pointer
;
230 typedef const value_type
* const_pointer
;
231 typedef value_type
* iterator
;
232 typedef const value_type
* const_iterator
;
233 typedef value_type
& reference
;
234 typedef const value_type
& const_reference
;
235 typedef int difference_type
;
236 typedef size_t size_type
;
238 // TODO: this code duplicates the one in dynarray.h
239 class reverse_iterator
241 typedef wxString value_type
;
242 typedef value_type
* pointer
;
243 typedef value_type
& reference
;
244 typedef reverse_iterator itor
;
245 friend itor
operator+(int o
, const itor
& it
);
246 friend itor
operator+(const itor
& it
, int o
);
247 friend itor
operator-(const itor
& it
, int o
);
248 friend difference_type
operator -(const itor
& i1
, const itor
& i2
);
251 reverse_iterator() : m_ptr(NULL
) { }
252 reverse_iterator(pointer ptr
) : m_ptr(ptr
) { }
253 reverse_iterator(const itor
& it
) : m_ptr(it
.m_ptr
) { }
254 reference
operator*() const { return *m_ptr
; }
255 pointer
operator->() const { return m_ptr
; }
256 itor
& operator++() { --m_ptr
; return *this; }
257 const itor
operator++(int)
258 { reverse_iterator tmp
= *this; --m_ptr
; return tmp
; }
259 itor
& operator--() { ++m_ptr
; return *this; }
260 const itor
operator--(int) { itor tmp
= *this; ++m_ptr
; return tmp
; }
261 bool operator ==(const itor
& it
) const { return m_ptr
== it
.m_ptr
; }
262 bool operator !=(const itor
& it
) const { return m_ptr
!= it
.m_ptr
; }
265 class const_reverse_iterator
267 typedef wxString value_type
;
268 typedef const value_type
* pointer
;
269 typedef const value_type
& reference
;
270 typedef const_reverse_iterator itor
;
271 friend itor
operator+(int o
, const itor
& it
);
272 friend itor
operator+(const itor
& it
, int o
);
273 friend itor
operator-(const itor
& it
, int o
);
274 friend difference_type
operator -(const itor
& i1
, const itor
& i2
);
277 const_reverse_iterator() : m_ptr(NULL
) { }
278 const_reverse_iterator(pointer ptr
) : m_ptr(ptr
) { }
279 const_reverse_iterator(const itor
& it
) : m_ptr(it
.m_ptr
) { }
280 const_reverse_iterator(const reverse_iterator
& it
) : m_ptr(it
.m_ptr
) { }
281 reference
operator*() const { return *m_ptr
; }
282 pointer
operator->() const { return m_ptr
; }
283 itor
& operator++() { --m_ptr
; return *this; }
284 const itor
operator++(int)
285 { itor tmp
= *this; --m_ptr
; return tmp
; }
286 itor
& operator--() { ++m_ptr
; return *this; }
287 const itor
operator--(int) { itor tmp
= *this; ++m_ptr
; return tmp
; }
288 bool operator ==(const itor
& it
) const { return m_ptr
== it
.m_ptr
; }
289 bool operator !=(const itor
& it
) const { return m_ptr
!= it
.m_ptr
; }
292 wxArrayString(const_iterator first
, const_iterator last
)
293 { Init(false); assign(first
, last
); }
294 wxArrayString(size_type n
, const_reference v
) { Init(false); assign(n
, v
); }
296 #ifdef wxHAS_VECTOR_TEMPLATE_ASSIGN
297 template <class Iterator
>
298 void assign(Iterator first
, Iterator last
)
301 reserve(std::distance(first
, last
));
302 for(; first
!= last
; ++first
)
305 #else // !wxHAS_VECTOR_TEMPLATE_ASSIGN
306 void assign(const_iterator first
, const_iterator last
)
309 reserve(last
- first
);
310 for(; first
!= last
; ++first
)
313 #endif // wxHAS_VECTOR_TEMPLATE_ASSIGN/!wxHAS_VECTOR_TEMPLATE_ASSIGN
315 void assign(size_type n
, const_reference v
)
316 { clear(); Add(v
, n
); }
317 reference
back() { return *(end() - 1); }
318 const_reference
back() const { return *(end() - 1); }
319 iterator
begin() { return m_pItems
; }
320 const_iterator
begin() const { return m_pItems
; }
321 size_type
capacity() const { return m_nSize
; }
322 void clear() { Clear(); }
323 bool empty() const { return IsEmpty(); }
324 iterator
end() { return begin() + GetCount(); }
325 const_iterator
end() const { return begin() + GetCount(); }
326 iterator
erase(iterator first
, iterator last
)
328 size_t idx
= first
- begin();
329 RemoveAt(idx
, last
- first
);
330 return begin() + idx
;
332 iterator
erase(iterator it
) { return erase(it
, it
+ 1); }
333 reference
front() { return *begin(); }
334 const_reference
front() const { return *begin(); }
335 void insert(iterator it
, size_type n
, const_reference v
)
336 { Insert(v
, it
- begin(), n
); }
337 iterator
insert(iterator it
, const_reference v
= value_type())
338 { size_t idx
= it
- begin(); Insert(v
, idx
); return begin() + idx
; }
339 void insert(iterator it
, const_iterator first
, const_iterator last
);
340 size_type
max_size() const { return INT_MAX
; }
341 void pop_back() { RemoveAt(GetCount() - 1); }
342 void push_back(const_reference v
) { Add(v
); }
343 reverse_iterator
rbegin() { return reverse_iterator(end() - 1); }
344 const_reverse_iterator
rbegin() const
345 { return const_reverse_iterator(end() - 1); }
346 reverse_iterator
rend() { return reverse_iterator(begin() - 1); }
347 const_reverse_iterator
rend() const
348 { return const_reverse_iterator(begin() - 1); }
349 void reserve(size_type n
) /* base::reserve*/;
350 void resize(size_type n
, value_type v
= value_type());
351 size_type
size() const { return GetCount(); }
352 void swap(wxArrayString
& other
)
354 wxSwap(m_nSize
, other
.m_nSize
);
355 wxSwap(m_nCount
, other
.m_nCount
);
356 wxSwap(m_pItems
, other
.m_pItems
);
357 wxSwap(m_autoSort
, other
.m_autoSort
);
361 void Init(bool autoSort
); // common part of all ctors
362 void Copy(const wxArrayString
& src
); // copies the contents of another array
365 void Grow(size_t nIncrement
= 0); // makes array bigger if needed
367 size_t m_nSize
, // current size of the array
368 m_nCount
; // current number of elements
370 wxString
*m_pItems
; // pointer to data
372 bool m_autoSort
; // if true, keep the array always sorted
375 class WXDLLIMPEXP_BASE wxSortedArrayString
: public wxArrayString
378 wxSortedArrayString() : wxArrayString(true)
380 wxSortedArrayString(const wxArrayString
& array
) : wxArrayString(true)
386 // this class provides a temporary wxString* from a
388 class WXDLLIMPEXP_BASE wxCArrayString
391 wxCArrayString( const wxArrayString
& array
)
392 : m_array( array
), m_strings( NULL
)
394 ~wxCArrayString() { delete[] m_strings
; }
396 size_t GetCount() const { return m_array
.GetCount(); }
397 wxString
* GetStrings()
399 if( m_strings
) return m_strings
;
400 size_t count
= m_array
.GetCount();
401 m_strings
= new wxString
[count
];
402 for( size_t i
= 0; i
< count
; ++i
)
403 m_strings
[i
] = m_array
[i
];
409 wxString
*r
= GetStrings();
415 const wxArrayString
& m_array
;
420 // ----------------------------------------------------------------------------
421 // helper functions for working with arrays
422 // ----------------------------------------------------------------------------
424 // by default, these functions use the escape character to escape the
425 // separators occuring inside the string to be joined, this can be disabled by
426 // passing '\0' as escape
428 WXDLLIMPEXP_BASE wxString
wxJoin(const wxArrayString
& arr
,
430 const wxChar escape
= wxT('\\'));
432 WXDLLIMPEXP_BASE wxArrayString
wxSplit(const wxString
& str
,
434 const wxChar escape
= wxT('\\'));
437 // ----------------------------------------------------------------------------
438 // This helper class allows to pass both C array of wxStrings or wxArrayString
439 // using the same interface.
441 // Use it when you have two methods taking wxArrayString or (int, wxString[]),
442 // that do the same thing. This class lets you iterate over input data in the
443 // same way whether it is a raw array of strings or wxArrayString.
445 // The object does not take ownership of the data -- internally it keeps
446 // pointers to the data, therefore the data must be disposed of by user
447 // and only after this object is destroyed. Usually it is not a problem as
448 // only temporary objects of this class are used.
449 // ----------------------------------------------------------------------------
451 class wxArrayStringsAdapter
454 // construct an adapter from a wxArrayString
455 wxArrayStringsAdapter(const wxArrayString
& strings
)
456 : m_type(wxSTRING_ARRAY
), m_size(strings
.size())
458 m_data
.array
= &strings
;
461 // construct an adapter from a wxString[]
462 wxArrayStringsAdapter(unsigned int n
, const wxString
*strings
)
463 : m_type(wxSTRING_POINTER
), m_size(n
)
465 m_data
.ptr
= strings
;
468 // construct an adapter from a single wxString
469 wxArrayStringsAdapter(const wxString
& s
)
470 : m_type(wxSTRING_POINTER
), m_size(1)
475 // default copy constructor is ok
477 // iteration interface
478 size_t GetCount() const { return m_size
; }
479 bool IsEmpty() const { return GetCount() == 0; }
480 const wxString
& operator[] (unsigned int i
) const
482 wxASSERT_MSG( i
< GetCount(), wxT("index out of bounds") );
483 if(m_type
== wxSTRING_POINTER
)
484 return m_data
.ptr
[i
];
485 return m_data
.array
->Item(i
);
487 wxArrayString
AsArrayString() const
489 if(m_type
== wxSTRING_ARRAY
)
490 return *m_data
.array
;
491 return wxArrayString(GetCount(), m_data
.ptr
);
495 // type of the data being held
496 enum wxStringContainerType
498 wxSTRING_ARRAY
, // wxArrayString
499 wxSTRING_POINTER
// wxString[]
502 wxStringContainerType m_type
;
506 const wxString
* ptr
;
507 const wxArrayString
* array
;
510 wxDECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter
);
513 #endif // _WX_ARRSTR_H