]> git.saurik.com Git - wxWidgets.git/blob - include/wx/dynarray.h
projects / wxWidgets.git / blob
? search:


b6ff097b0447d0efd4680607d75621672b81a1d4
[wxWidgets.git] / include / wx / dynarray.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: dynarray.h
3 // Purpose: auto-resizable (i.e. dynamic) array support
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 12.09.97
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _DYNARRAY_H
13 #define _DYNARRAY_H
14
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && \
16 !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
17 #pragma interface "dynarray.h"
18 #endif
19
20 #include "wx/defs.h"
21
22 #if wxUSE_STL
23 #include "wx/beforestd.h"
24 #include <vector>
25 #include <algorithm>
26 #include "wx/afterstd.h"
27 #endif
28
29 /*
30 This header defines the dynamic arrays and object arrays (i.e. arrays which
31 own their elements). Dynamic means that the arrays grow automatically as
32 needed.
33
34 These macros are ugly (especially if you look in the sources ;-), but they
35 allow us to define "template" classes without actually using templates and so
36 this works with all compilers (and may be also much faster to compile even
37 with a compiler which does support templates). The arrays defined with these
38 macros are type-safe.
39
40 Range checking is performed in debug build for both arrays and objarrays but
41 not in release build - so using an invalid index will just lead to a crash
42 then.
43
44 Note about memory usage: arrays never shrink automatically (although you may
45 use Shrink() function explicitly), they only grow, so loading 10 millions in
46 an array only to delete them 2 lines below might be a bad idea if the array
47 object is not going to be destroyed soon. However, as it does free memory
48 when destroyed, it is ok if the array is a local variable.
49 */
50
51 // ----------------------------------------------------------------------------
52 // constants
53 // ----------------------------------------------------------------------------
54
55 /*
56 The initial size by which an array grows when an element is added default
57 value avoids allocate one or two bytes when the array is created which is
58 rather inefficient
59 */
60 #define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
61
62 // ----------------------------------------------------------------------------
63 // types
64 // ----------------------------------------------------------------------------
65
66 /*
67 Callback compare function for quick sort.
68
69 It must return negative value, 0 or positive value if the first item is
70 less than, equal to or greater than the second one.
71 */
72 extern "C"
73 {
74 typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
75 }
76
77 // ----------------------------------------------------------------------------
78 // Base class managing data having size of type 'long' (not used directly)
79 //
80 // NB: for efficiency this often used class has no virtual functions (hence no
81 // virtual table), even dtor is *not* virtual. If used as expected it
82 // won't create any problems because ARRAYs from DEFINE_ARRAY have no dtor
83 // at all, so it's not too important if it's not called (this happens when
84 // you cast "SomeArray *" as "BaseArray *" and then delete it)
85 // ----------------------------------------------------------------------------
86
87 #if wxUSE_STL
88
89 template<class T>
90 class WXDLLIMPEXP_BASE wxArray_SortFunction
91 {
92 public:
93 typedef int (wxCMPFUNC_CONV *CMPFUNC)(T* pItem1, T* pItem2);
94
95 wxArray_SortFunction(CMPFUNC f) : m_f(f) { }
96 bool operator()(const T& i1, const T& i2)
97 { return m_f((T*)&i1, (T*)&i2) < 0; }
98 private:
99 CMPFUNC m_f;
100 };
101
102 template<class T, typename F>
103 class WXDLLIMPEXP_BASE wxSortedArray_SortFunction
104 {
105 public:
106 typedef F CMPFUNC;
107
108 wxSortedArray_SortFunction(CMPFUNC f) : m_f(f) { }
109 bool operator()(const T& i1, const T& i2)
110 { return m_f(i1, i2) < 0; }
111 private:
112 CMPFUNC m_f;
113 };
114
115 #define _WX_DECLARE_BASEARRAY(T, name, classexp) \
116 typedef int (wxCMPFUNC_CONV *CMPFUN##name)(T pItem1, T pItem2); \
117 typedef wxSortedArray_SortFunction<T, CMPFUN##name> name##_Predicate; \
118 _WX_DECLARE_BASEARRAY_2(T, name, name##_Predicate, classexp)
119
120 #define _WX_DECLARE_BASEARRAY_2(T, name, predicate, classexp) \
121 classexp name : public std::vector<T> \
122 { \
123 typedef predicate Predicate; \
124 typedef predicate::CMPFUNC SCMPFUNC; \
125 public: \
126 typedef wxArray_SortFunction<T>::CMPFUNC CMPFUNC; \
127 public: \
128 void Empty() { clear(); } \
129 void Clear() { clear(); } \
130 void Alloc(size_t uiSize) { reserve(uiSize); } \
131 void Shrink(); \
132 \
133 size_t GetCount() const { return size(); } \
134 void SetCount(size_t n, T v = T()) { resize(n, v); } \
135 bool IsEmpty() const { return empty(); } \
136 size_t Count() const { return size(); } \
137 \
138 typedef T base_type; \
139 \
140 protected: \
141 T& Item(size_t uiIndex) const \
142 { wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); } \
143 \
144 int Index(T e, bool bFromEnd = false) const; \
145 int Index(T lItem, CMPFUNC fnCompare) const; \
146 size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
147 void Add(T lItem, size_t nInsert = 1) \
148 { insert(end(), nInsert, lItem); } \
149 size_t Add(T lItem, CMPFUNC fnCompare); \
150 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
151 { insert(begin() + uiIndex, nInsert, lItem); } \
152 void Remove(T lItem); \
153 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
154 { erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
155 \
156 void Sort(CMPFUNC fCmp) \
157 { \
158 wxArray_SortFunction<T> p(fCmp); \
159 std::sort(begin(), end(), p); \
160 } \
161 }
162
163 #else // if !wxUSE_STL
164
165 #define _WX_DECLARE_BASEARRAY(T, name, classexp) \
166 classexp name \
167 { \
168 typedef CMPFUNC SCMPFUNC; /* for compatibility wuth wxUSE_STL */ \
169 public: \
170 name(); \
171 name(const name& array); \
172 name& operator=(const name& src); \
173 ~name(); \
174 \
175 void Empty() { m_nCount = 0; } \
176 void Clear(); \
177 void Alloc(size_t uiSize); \
178 void Shrink(); \
179 \
180 size_t GetCount() const { return m_nCount; } \
181 void SetCount(size_t n, T defval = T()); \
182 bool IsEmpty() const { return m_nCount == 0; } \
183 size_t Count() const { return m_nCount; } \
184 \
185 typedef T base_type; \
186 \
187 protected: \
188 T& Item(size_t uiIndex) const \
189 { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; } \
190 T& operator[](size_t uiIndex) const { return Item(uiIndex); } \
191 \
192 int Index(T lItem, bool bFromEnd = false) const; \
193 int Index(T lItem, CMPFUNC fnCompare) const; \
194 size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
195 void Add(T lItem, size_t nInsert = 1); \
196 size_t Add(T lItem, CMPFUNC fnCompare); \
197 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1); \
198 void Remove(T lItem); \
199 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
200 \
201 void Sort(CMPFUNC fnCompare); \
202 \
203 /* *minimal* STL-ish interface, for derived classes */ \
204 typedef T value_type; \
205 typedef value_type* iterator; \
206 typedef const value_type* const_iterator; \
207 typedef value_type& reference; \
208 typedef const value_type& const_reference; \
209 typedef int difference_type; \
210 typedef size_t size_type; \
211 \
212 void assign(const_iterator first, const_iterator last); \
213 void assign(size_type n, const_reference v); \
214 size_type capacity() const { return m_nSize; } \
215 iterator erase(iterator first, iterator last) \
216 { \
217 size_type idx = first - begin(); \
218 RemoveAt(idx, last - first); \
219 return begin() + idx; \
220 } \
221 iterator erase(iterator it) { return erase(it, it + 1); } \
222 void insert(iterator it, size_type n, const value_type& v) \
223 { Insert(v, it - begin(), n); } \
224 iterator insert(iterator it, const value_type& v = value_type()) \
225 { \
226 size_type idx = it - begin(); \
227 Insert(v, idx); \
228 return begin() + idx; \
229 } \
230 void insert(iterator it, const_iterator first, const_iterator last);\
231 void pop_back() { RemoveAt(size() - 1); } \
232 void push_back(const value_type& v) { Add(v); } \
233 void reserve(size_type n) { if(n > m_nSize) Realloc(n); } \
234 void resize(size_type n, value_type v = value_type()); \
235 \
236 iterator begin() { return m_pItems; } \
237 iterator end() { return m_pItems + m_nCount; } \
238 const_iterator begin() const { return m_pItems; } \
239 const_iterator end() const { return m_pItems + m_nCount; } \
240 \
241 /* the following functions may be made directly public because */ \
242 /* they don't use the type of the elements at all */ \
243 public: \
244 void clear() { Clear(); } \
245 bool empty() const { return IsEmpty(); } \
246 size_type max_size() const { return INT_MAX; } \
247 size_type size() const { return GetCount(); } \
248 \
249 private: \
250 void Grow(size_t nIncrement = 0); \
251 bool Realloc(size_t nSize); \
252 \
253 size_t m_nSize, \
254 m_nCount; \
255 \
256 T *m_pItems; \
257 }
258
259 #endif // !wxUSE_STL
260
261 // ============================================================================
262 // The private helper macros containing the core of the array classes
263 // ============================================================================
264
265 // Implementation notes:
266 //
267 // JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
268 // { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
269 // so using a temporary variable instead.
270 //
271 // The classes need a (even trivial) ~name() to link under Mac X
272 //
273 // _WX_ERROR_REMOVE is needed to resolve the name conflict between the wxT()
274 // macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
275
276 #define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
277
278 // ----------------------------------------------------------------------------
279 // _WX_DEFINE_TYPEARRAY: array for simple types
280 // ----------------------------------------------------------------------------
281
282 #if wxUSE_STL
283
284 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
285 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
286 classexp name : public base \
287 { \
288 public: \
289 T& operator[](size_t uiIndex) const \
290 { return (T&)(base::operator[](uiIndex)); } \
291 T& Item(size_t uiIndex) const \
292 { return (T&)/*const cast*/base::operator[](uiIndex); } \
293 T& Last() const \
294 { return Item(Count() - 1); } \
295 \
296 int Index(T e, bool bFromEnd = false) const \
297 { return base::Index(e, bFromEnd); } \
298 \
299 void Add(T lItem, size_t nInsert = 1) \
300 { insert(end(), nInsert, lItem); } \
301 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
302 { insert(begin() + uiIndex, nInsert, lItem); } \
303 \
304 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
305 { base::RemoveAt(uiIndex, nRemove); } \
306 void Remove(T lItem) \
307 { int iIndex = Index(lItem); \
308 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
309 _WX_ERROR_REMOVE); \
310 RemoveAt((size_t)iIndex); } \
311 \
312 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
313 }
314
315 #define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \
316 _WX_DEFINE_TYPEARRAY(T, name, base, classexp)
317
318 #else // if !wxUSE_STL
319
320 // common declaration used by both _WX_DEFINE_TYPEARRAY and
321 // _WX_DEFINE_TYPEARRAY_PTR
322 #define _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, ptrop) \
323 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \
324 TypeTooBigToBeStoredIn##base, \
325 name); \
326 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
327 classexp name : public base \
328 { \
329 public: \
330 name() { } \
331 ~name() { } \
332 \
333 name& operator=(const name& src) \
334 { base* temp = (base*) this; \
335 (*temp) = ((const base&)src); \
336 return *this; } \
337 \
338 T& operator[](size_t uiIndex) const \
339 { return (T&)(base::operator[](uiIndex)); } \
340 T& Item(size_t uiIndex) const \
341 { return (T&)(base::operator[](uiIndex)); } \
342 T& Last() const \
343 { return (T&)(base::operator[](Count() - 1)); } \
344 \
345 int Index(T lItem, bool bFromEnd = false) const \
346 { return base::Index((base_type)lItem, bFromEnd); } \
347 \
348 void Add(T lItem, size_t nInsert = 1) \
349 { base::Add((base_type)lItem, nInsert); } \
350 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
351 { base::Insert((base_type)lItem, uiIndex, nInsert) ; } \
352 \
353 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
354 { base::RemoveAt(uiIndex, nRemove); } \
355 void Remove(T lItem) \
356 { int iIndex = Index(lItem); \
357 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
358 _WX_ERROR_REMOVE); \
359 base::RemoveAt((size_t)iIndex); } \
360 \
361 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
362 \
363 /* STL-like interface */ \
364 private: \
365 typedef base::iterator biterator; \
366 typedef base::const_iterator bconst_iterator; \
367 typedef base::value_type bvalue_type; \
368 typedef base::const_reference bconst_reference; \
369 public: \
370 typedef T value_type; \
371 typedef value_type* pointer; \
372 typedef const value_type* const_pointer; \
373 typedef value_type* iterator; \
374 typedef const value_type* const_iterator; \
375 typedef value_type& reference; \
376 typedef const value_type& const_reference; \
377 typedef base::difference_type difference_type; \
378 typedef base::size_type size_type; \
379 \
380 class reverse_iterator \
381 { \
382 typedef T value_type; \
383 typedef value_type& reference; \
384 typedef value_type* pointer; \
385 typedef reverse_iterator itor; \
386 friend inline itor operator+(int o, const itor& it) \
387 { return it.m_ptr - o; } \
388 friend inline itor operator+(const itor& it, int o) \
389 { return it.m_ptr - o; } \
390 friend inline itor operator-(const itor& it, int o) \
391 { return it.m_ptr + o; } \
392 friend inline difference_type operator-(const itor& i1, \
393 const itor& i2) \
394 { return i1.m_ptr - i2.m_ptr; } \
395 \
396 public: \
397 pointer m_ptr; \
398 reverse_iterator() : m_ptr(NULL) { } \
399 reverse_iterator(pointer ptr) : m_ptr(ptr) { } \
400 reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } \
401 reference operator*() const { return *m_ptr; } \
402 ptrop \
403 itor& operator++() { --m_ptr; return *this; } \
404 const itor operator++(int) \
405 { reverse_iterator tmp = *this; --m_ptr; return tmp; } \
406 itor& operator--() { ++m_ptr; return *this; } \
407 const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
408 bool operator ==(const itor& it) { return m_ptr == it.m_ptr; } \
409 bool operator !=(const itor& it) { return m_ptr != it.m_ptr; } \
410 }; \
411 \
412 class const_reverse_iterator \
413 { \
414 typedef T value_type; \
415 typedef const value_type& reference; \
416 typedef const value_type* pointer; \
417 typedef const_reverse_iterator itor; \
418 friend inline itor operator+(int o, const itor& it) \
419 { return it.m_ptr - o; } \
420 friend inline itor operator+(const itor& it, int o) \
421 { return it.m_ptr - o; } \
422 friend inline itor operator-(const itor& it, int o) \
423 { return it.m_ptr + o; } \
424 friend inline difference_type operator-(const itor& i1, \
425 const itor& i2) \
426 { return i1.m_ptr - i2.m_ptr; } \
427 \
428 public: \
429 pointer m_ptr; \
430 const_reverse_iterator() : m_ptr(NULL) { } \
431 const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } \
432 const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } \
433 const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
434 reference operator*() const { return *m_ptr; } \
435 ptrop \
436 itor& operator++() { --m_ptr; return *this; } \
437 const itor operator++(int) \
438 { itor tmp = *this; --m_ptr; return tmp; } \
439 itor& operator--() { ++m_ptr; return *this; } \
440 const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
441 bool operator ==(const itor& it) { return m_ptr == it.m_ptr; } \
442 bool operator !=(const itor& it) { return m_ptr != it.m_ptr; } \
443 }; \
444 \
445 name(size_type n, const_reference v) { assign(n, v); } \
446 name(const_iterator first, const_iterator last) \
447 { assign(first, last); } \
448 void assign(const_iterator first, const_iterator last) \
449 { base::assign((bconst_iterator)first, (bconst_iterator)last); } \
450 void assign(size_type n, const_reference v) \
451 { base::assign(n, (bconst_reference)v); } \
452 reference back() { return *(end() - 1); } \
453 const_reference back() const { return *(end() - 1); } \
454 iterator begin() { return (iterator)base::begin(); } \
455 const_iterator begin() const { return (const_iterator)base::begin(); }\
456 size_type capacity() const { return base::capacity(); } \
457 iterator end() { return (iterator)base::end(); } \
458 const_iterator end() const { return (const_iterator)base::end(); } \
459 iterator erase(iterator first, iterator last) \
460 { return (iterator)base::erase((biterator)first, (biterator)last); }\
461 iterator erase(iterator it) \
462 { return (iterator)base::erase((biterator)it); } \
463 reference front() { return *begin(); } \
464 const_reference front() const { return *begin(); } \
465 void insert(iterator it, size_type n, const_reference v) \
466 { base::insert((biterator)it, n, (bconst_reference)v); } \
467 iterator insert(iterator it, const_reference v = value_type()) \
468 { return (iterator)base::insert((biterator)it, (bconst_reference)v); }\
469 void insert(iterator it, const_iterator first, const_iterator last) \
470 { base::insert((biterator)it, (bconst_iterator)first, \
471 (bconst_iterator)last); } \
472 void pop_back() { base::pop_back(); } \
473 void push_back(const_reference v) \
474 { base::push_back((bconst_reference)v); } \
475 reverse_iterator rbegin() { return reverse_iterator(end() - 1); } \
476 const_reverse_iterator rbegin() const; \
477 reverse_iterator rend() { return reverse_iterator(begin() - 1); } \
478 const_reverse_iterator rend() const; \
479 void reserve(size_type n) { base::reserve(n); }; \
480 void resize(size_type n, value_type v = value_type()); \
481 }
482
483 #define _WX_PTROP pointer operator->() const { return m_ptr; }
484 #define _WX_PTROP_NONE
485
486 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
487 _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP)
488 #define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \
489 _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP_NONE)
490
491 #endif // !wxUSE_STL
492
493 // ----------------------------------------------------------------------------
494 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
495 // cannot handle types with size greater than pointer because of sorting
496 // ----------------------------------------------------------------------------
497
498 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
499 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \
500 TypeTooBigToBeStoredInSorted##base, \
501 name); \
502 classexp name : public base \
503 { \
504 typedef comptype SCMPFUNC; \
505 public: \
506 name(comptype fn defcomp) { m_fnCompare = fn; } \
507 \
508 name& operator=(const name& src) \
509 { base* temp = (base*) this; \
510 (*temp) = ((const base&)src); \
511 m_fnCompare = src.m_fnCompare; \
512 return *this; } \
513 \
514 T& operator[](size_t uiIndex) const \
515 { return (T&)(base::operator[](uiIndex)); } \
516 T& Item(size_t uiIndex) const \
517 { return (T&)(base::operator[](uiIndex)); } \
518 T& Last() const \
519 { return (T&)(base::operator[](size() - 1)); } \
520 \
521 int Index(T lItem) const \
522 { return base::Index(lItem, (CMPFUNC)m_fnCompare); } \
523 \
524 size_t IndexForInsert(T lItem) const \
525 { return base::IndexForInsert(lItem, (CMPFUNC)m_fnCompare); } \
526 \
527 void AddAt(T item, size_t index) \
528 { base::insert(begin() + index, item); } \
529 \
530 size_t Add(T lItem) \
531 { return base::Add(lItem, (CMPFUNC)m_fnCompare); } \
532 \
533 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
534 { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
535 void Remove(T lItem) \
536 { int iIndex = Index(lItem); \
537 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
538 _WX_ERROR_REMOVE ); \
539 base::erase(begin() + iIndex); } \
540 \
541 private: \
542 comptype m_fnCompare; \
543 }
544
545
546 // ----------------------------------------------------------------------------
547 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
548 // ----------------------------------------------------------------------------
549
550 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp) \
551 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2); \
552 classexp name : protected base \
553 { \
554 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
555 typedef base base_array; \
556 public: \
557 name() { } \
558 name(const name& src); \
559 name& operator=(const name& src); \
560 \
561 ~name(); \
562 \
563 void Alloc(size_t count) { reserve(count); } \
564 size_t GetCount() const { return base_array::size(); } \
565 size_t size() const { return base_array::size(); } \
566 bool IsEmpty() const { return base_array::empty(); } \
567 bool empty() const { return base_array::empty(); } \
568 size_t Count() const { return base_array::size(); } \
569 void Shrink() { base::Shrink(); } \
570 \
571 T& operator[](size_t uiIndex) const \
572 { return *(T*)base::operator[](uiIndex); } \
573 T& Item(size_t uiIndex) const \
574 { return *(T*)base::operator[](uiIndex); } \
575 T& Last() const \
576 { return *(T*)(base::operator[](size() - 1)); } \
577 \
578 int Index(const T& lItem, bool bFromEnd = false) const; \
579 \
580 void Add(const T& lItem, size_t nInsert = 1); \
581 void Add(const T* pItem) \
582 { base::push_back((T*)pItem); } \
583 void push_back(const T* pItem) \
584 { base::push_back((T*)pItem); } \
585 void push_back(const T& lItem) \
586 { Add(lItem); } \
587 \
588 void Insert(const T& lItem, size_t uiIndex, size_t nInsert = 1); \
589 void Insert(const T* pItem, size_t uiIndex) \
590 { base::insert(begin() + uiIndex, (T*)pItem); } \
591 \
592 void Empty() { DoEmpty(); base::clear(); } \
593 void Clear() { DoEmpty(); base::clear(); } \
594 \
595 T* Detach(size_t uiIndex) \
596 { T* p = (T*)base::operator[](uiIndex); \
597 base::erase(begin() + uiIndex); return p; } \
598 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
599 \
600 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); } \
601 \
602 private: \
603 void DoEmpty(); \
604 void DoCopy(const name& src); \
605 }
606
607 // ============================================================================
608 // The public macros for declaration and definition of the dynamic arrays
609 // ============================================================================
610
611 // Please note that for each macro WX_FOO_ARRAY we also have
612 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
613 // same except that they use an additional __declspec(dllexport) or equivalent
614 // under Windows if needed.
615 //
616 // The first (just EXPORTED) macros do it if wxWidgets was compiled as a DLL
617 // and so must be used used inside the library. The second kind (USER_EXPORTED)
618 // allow the user code to do it when it wants. This is needed if you have a dll
619 // that wants to export a wxArray daubed with your own import/export goo.
620 //
621 // Finally, you can define the macro below as something special to modify the
622 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
623 #define wxARRAY_DEFAULT_EXPORT
624
625 // ----------------------------------------------------------------------------
626 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
627 // the elements of type T
628 // ----------------------------------------------------------------------------
629
630 #define WX_DECLARE_BASEARRAY(T, name) \
631 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
632
633 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name) \
634 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
635
636 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode) \
637 typedef T _wxArray##name; \
638 _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
639
640 // ----------------------------------------------------------------------------
641 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
642 // from class "base" containing the elements of type T
643 //
644 // Note that the class defined has only inline function and doesn't take any
645 // space at all so there is no size penalty for defining multiple array classes
646 // ----------------------------------------------------------------------------
647
648 #define WX_DEFINE_TYPEARRAY(T, name, base) \
649 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
650
651 #define WX_DEFINE_TYPEARRAY_PTR(T, name, base) \
652 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class wxARRAY_DEFAULT_EXPORT)
653
654 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \
655 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
656
657 #define WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, base) \
658 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class WXDLLEXPORT)
659
660 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
661 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
662
663 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY_PTR(T, name, base, expdecl) \
664 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class expdecl)
665
666 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
667 typedef T _wxArray##name; \
668 _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
669
670 #define WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, classdecl) \
671 typedef T _wxArray##name; \
672 _WX_DEFINE_TYPEARRAY_PTR(_wxArray##name, name, base, classdecl)
673
674 // ----------------------------------------------------------------------------
675 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
676 // defines a sorted array.
677 //
678 // Differences:
679 // 1) it must be given a COMPARE function in ctor which takes 2 items of type
680 // T* and should return -1, 0 or +1 if the first one is less/greater
681 // than/equal to the second one.
682 // 2) the Add() method inserts the item in such was that the array is always
683 // sorted (it uses the COMPARE function)
684 // 3) it has no Sort() method because it's always sorted
685 // 4) Index() method is much faster (the sorted arrays use binary search
686 // instead of linear one), but Add() is slower.
687 // 5) there is no Insert() method because you can't insert an item into the
688 // given position in a sorted array but there is IndexForInsert()/AddAt()
689 // pair which may be used to optimize a common operation of "insert only if
690 // not found"
691 //
692 // Note that you have to specify the comparison function when creating the
693 // objects of this array type. If, as in 99% of cases, the comparison function
694 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
695 // is more convenient.
696 //
697 // Summary: use this class when the speed of Index() function is important, use
698 // the normal arrays otherwise.
699 // ----------------------------------------------------------------------------
700
701 #define wxARRAY_EMPTY_CMP
702
703 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base) \
704 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, \
705 wxARRAY_DEFAULT_EXPORT)
706
707 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base) \
708 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
709
710 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
711 typedef T _wxArray##name; \
712 typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2); \
713 _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, \
714 wxARRAY_EMPTY_CMP, class expmode, SCMPFUNC##name)
715
716 // ----------------------------------------------------------------------------
717 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
718 // function is provided by this macro and the objects of this class have a
719 // default constructor which just uses it.
720 //
721 // The arguments are: the element type, the comparison function and the array
722 // name
723 //
724 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
725 // from the very beginning - unfortunately I didn't think about this earlier
726 // ----------------------------------------------------------------------------
727
728 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
729 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
730 wxARRAY_DEFAULT_EXPORT)
731
732 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
733 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
734 WXDLLEXPORT)
735
736 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
737 expmode) \
738 typedef T _wxArray##name; \
739 typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2); \
740 _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, = cmpfunc, \
741 class expmode, SCMPFUNC##name)
742
743 // ----------------------------------------------------------------------------
744 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
745 // named "name" which owns the objects of type T it contains, i.e. it will
746 // delete them when it is destroyed.
747 //
748 // An element is of type T*, but arguments of type T& are taken (see below!)
749 // and T& is returned.
750 //
751 // Don't use this for simple types such as "int" or "long"!
752 //
753 // Note on Add/Insert functions:
754 // 1) function(T*) gives the object to the array, i.e. it will delete the
755 // object when it's removed or in the array's dtor
756 // 2) function(T&) will create a copy of the object and work with it
757 //
758 // Also:
759 // 1) Remove() will delete the object after removing it from the array
760 // 2) Detach() just removes the object from the array (returning pointer to it)
761 //
762 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
763 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
764 // and so you risk having at least the memory leaks and probably worse
765 //
766 // Some functions of this class are not inline, so it takes some space to
767 // define new class from this template even if you don't use it - which is not
768 // the case for the simple (non-object) array classes
769 //
770 // To use an objarray class you must
771 // #include "dynarray.h"
772 // WX_DECLARE_OBJARRAY(element_type, list_class_name)
773 // #include "arrimpl.cpp"
774 // WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
775 //
776 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
777 // element_type must be fully defined (i.e. forward declaration is not
778 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
779 // two allows to break cicrcular dependencies with classes which have member
780 // variables of objarray type.
781 // ----------------------------------------------------------------------------
782
783 #define WX_DECLARE_OBJARRAY(T, name) \
784 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
785
786 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \
787 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
788
789 #define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \
790 typedef T _wxObjArray##name; \
791 _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl)
792
793 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
794 WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode)
795
796 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
797 // try to provoke a human-understandable error if it used incorrectly.
798 //
799 // there is no real need for 3 different macros in the DEFINE case but do it
800 // anyhow for consistency
801 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
802 #define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
803 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
804
805 // ----------------------------------------------------------------------------
806 // Some commonly used predefined base arrays
807 // ----------------------------------------------------------------------------
808
809 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
810 WXDLLIMPEXP_BASE);
811 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE);
812 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE);
813 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE);
814 WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE);
815 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
816
817 // ----------------------------------------------------------------------------
818 // Convenience macros to define arrays from base arrays
819 // ----------------------------------------------------------------------------
820
821 #define WX_DEFINE_ARRAY(T, name) \
822 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
823 #define WX_DEFINE_ARRAY_PTR(T, name) \
824 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
825 #define WX_DEFINE_EXPORTED_ARRAY(T, name) \
826 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
827 #define WX_DEFINE_EXPORTED_ARRAY_PTR(T, name) \
828 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
829 #define WX_DEFINE_ARRAY_WITH_DECL_PTR(T, name, decl) \
830 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, decl)
831 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
832 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
833 #define WX_DEFINE_USER_EXPORTED_ARRAY_PTR(T, name, expmode) \
834 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, expmode)
835
836 #define WX_DEFINE_ARRAY_SHORT(T, name) \
837 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
838 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name) \
839 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
840 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
841 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayShort, expmode)
842
843 #define WX_DEFINE_ARRAY_INT(T, name) \
844 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
845 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name) \
846 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
847 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
848 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayInt, expmode)
849
850 #define WX_DEFINE_ARRAY_LONG(T, name) \
851 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
852 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name) \
853 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
854 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
855 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, expmode)
856
857 #define WX_DEFINE_ARRAY_SIZE_T(T, name) \
858 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
859 #define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name) \
860 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
861 #define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \
862 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, expmode)
863
864 #define WX_DEFINE_ARRAY_DOUBLE(T, name) \
865 WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
866 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \
867 WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
868 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode) \
869 WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayDouble, expmode)
870
871 // ----------------------------------------------------------------------------
872 // Convenience macros to define sorted arrays from base arrays
873 // ----------------------------------------------------------------------------
874
875 #define WX_DEFINE_SORTED_ARRAY(T, name) \
876 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
877 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
878 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
879 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
880 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
881
882 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name) \
883 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
884 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name) \
885 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
886 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
887 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
888
889 #define WX_DEFINE_SORTED_ARRAY_INT(T, name) \
890 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
891 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name) \
892 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
893 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
894 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
895
896 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name) \
897 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
898 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name) \
899 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
900 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
901 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
902
903 #define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name) \
904 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
905 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name) \
906 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
907 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode) \
908 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, expmode)
909
910 // ----------------------------------------------------------------------------
911 // Convenience macros to define sorted arrays from base arrays
912 // ----------------------------------------------------------------------------
913
914 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name) \
915 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
916 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
917 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
918 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, \
919 name, expmode) \
920 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
921 wxBaseArrayPtrVoid, expmode)
922
923 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
924 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
925 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
926 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
927 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, \
928 name, expmode) \
929 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
930 wxBaseArrayShort, expmode)
931
932 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
933 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
934 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
935 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
936 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, \
937 name, expmode) \
938 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
939 wxBaseArrayInt, expmode)
940
941 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
942 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
943 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
944 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
945 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, \
946 name, expmode) \
947 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
948 wxBaseArrayLong, expmode)
949
950 #define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \
951 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
952 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name) \
953 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
954 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, \
955 name, expmode) \
956 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
957 wxBaseArraySizeT, expmode)
958
959 // ----------------------------------------------------------------------------
960 // Some commonly used predefined arrays
961 // ----------------------------------------------------------------------------
962
963 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
964 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);
965 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
966 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
967
968 // -----------------------------------------------------------------------------
969 // convenience macros
970 // -----------------------------------------------------------------------------
971
972 // append all element of one array to another one
973 #define WX_APPEND_ARRAY(array, other) \
974 { \
975 size_t count = (other).size(); \
976 for ( size_t n = 0; n < count; n++ ) \
977 { \
978 (array).push_back((other)[n]); \
979 } \
980 }
981
982 // delete all array elements
983 //
984 // NB: the class declaration of the array elements must be visible from the
985 // place where you use this macro, otherwise the proper destructor may not
986 // be called (a decent compiler should give a warning about it, but don't
987 // count on it)!
988 #define WX_CLEAR_ARRAY(array) \
989 { \
990 size_t count = (array).size(); \
991 for ( size_t n = 0; n < count; n++ ) \
992 { \
993 delete (array)[n]; \
994 } \
995 \
996 (array).clear(); \
997 }
998
999 #endif // _DYNARRAY_H
1000
wxWidgets (Impactor)