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