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