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