projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Blind fix for MSVC.
[wxWidgets.git] / include / wx / dynarray.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: dynarray.h
3 // Purpose: auto-resizable (i.e. dynamic) array support
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 12.09.97
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _DYNARRAY_H
13 #define _DYNARRAY_H
14
15 #if defined(__GNUG__) && !defined(__APPLE__) && \
16 !(defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
17 #pragma interface "dynarray.h"
18 #endif
19
20 #include "wx/defs.h"
21
22 #if wxUSE_STL
23 #include "wx/beforestd.h"
24 #include <vector>
25 #include <algorithm>
26 #include "wx/afterstd.h"
27 #if defined(__WXMSW__) && defined(__MINGW32__)
28 #include "wx/msw/winundef.h"
29 #endif
30 #endif
31
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 */
53
54 // ----------------------------------------------------------------------------
55 // constants
56 // ----------------------------------------------------------------------------
57
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
62 */
63 #define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
64
65 // ----------------------------------------------------------------------------
66 // types
67 // ----------------------------------------------------------------------------
68
69 /*
70 Callback compare function for quick sort.
71
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.
74 */
75 extern "C"
76 {
77 typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
78 }
79
80 // ----------------------------------------------------------------------------
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)
88 // ----------------------------------------------------------------------------
89
90 #if wxUSE_STL
91
92 #define _WX_DECLARE_BASEARRAY(T, name, classexp) \
93 classexp name : public std::vector<T> \
94 { \
95 public: \
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 \
108 protected: \
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 } \
129 private: \
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
143 #define _WX_DECLARE_BASEARRAY(T, name, classexp) \
144 classexp name \
145 { \
146 public: \
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 \
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; } \
161 \
162 typedef T base_type; \
163 \
164 protected: \
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; \
172 void Add(T lItem, size_t nInsert = 1); \
173 void Add(T lItem, CMPFUNC fnCompare); \
174 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1); \
175 void Remove(T lItem); \
176 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
177 \
178 void Sort(CMPFUNC fnCompare); \
179 \
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; } \
221 private: \
222 void Grow(size_t nIncrement = 0); \
223 bool Realloc(size_t nSize); \
224 \
225 size_t m_nSize, \
226 m_nCount; \
227 \
228 T *m_pItems; \
229 }
230
231 #endif // !wxUSE_STL
232
233 // ============================================================================
234 // The private helper macros containing the core of the array classes
235 // ============================================================================
236
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()
246 // macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
247
248 #define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
249
250 // ----------------------------------------------------------------------------
251 // _WX_DEFINE_TYPEARRAY: array for simple types
252 // ----------------------------------------------------------------------------
253
254 #if wxUSE_STL
255
256 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
257 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
258 classexp name : public base \
259 { \
260 public: \
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
289 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
290 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \
291 TypeTooBigToBeStoredIn##base, \
292 name); \
293 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
294 classexp name : public base \
295 { \
296 public: \
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 \
306 { return (T&)(base::operator[](uiIndex)); } \
307 T& Item(size_t uiIndex) const \
308 { return (T&)(base::operator[](uiIndex)); } \
309 T& Last() const \
310 { return (T&)(base::operator[](Count() - 1)); } \
311 \
312 int Index(T Item, bool bFromEnd = FALSE) const \
313 { return base::Index((base_type)Item, bFromEnd); } \
314 \
315 void Add(T Item, size_t nInsert = 1) \
316 { base::Add((base_type)Item, nInsert); } \
317 void Insert(T Item, size_t uiIndex, size_t nInsert = 1) \
318 { base::Insert((base_type)Item, uiIndex, nInsert) ; } \
319 \
320 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
321 { base::RemoveAt(uiIndex, nRemove); } \
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); } \
329 \
330 /* STL-like interface */ \
331 private: \
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; \
336 public: \
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 { \
349 typedef T value_type; \
350 typedef value_type& reference; \
351 typedef value_type* pointer; \
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 { \
375 typedef T value_type; \
376 typedef const value_type& reference; \
377 typedef const value_type* pointer; \
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 \
439 inline name::reverse_iterator operator+(int o, const name::reverse_iterator& it) { return it.m_ptr - o; } \
440 inline name::reverse_iterator operator+(const name::reverse_iterator& it, int o) { return it.m_ptr - o; } \
441 inline name::reverse_iterator operator-(const name::reverse_iterator& it, int o) { return it.m_ptr + o; } \
442 inline name::difference_type operator -(const name::reverse_iterator& i1, \
443 const name::reverse_iterator& i2) \
444 { return i1.m_ptr - i2.m_ptr; } \
445 \
446 inline name::const_reverse_iterator operator+(int o, const name::const_reverse_iterator& it) { return it.m_ptr - o; } \
447 inline name::const_reverse_iterator operator+(const name::const_reverse_iterator& it, int o) { return it.m_ptr - o; } \
448 inline name::const_reverse_iterator operator-(const name::const_reverse_iterator& it, int o) { return it.m_ptr + o; } \
449 inline 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
454
455 // ----------------------------------------------------------------------------
456 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
457 // cannot handle types with size greater than pointer because of sorting
458 // ----------------------------------------------------------------------------
459
460 #define _WX_DEFINE_SORTED_TYPEARRAY(T, name, base, defcomp, classexp) \
461 typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
462 _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, SCMPFUNC##T)
463
464 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
465 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *), \
466 TypeTooBigToBeStoredInSorted##base, \
467 name); \
468 classexp name : public base \
469 { \
470 public: \
471 name(comptype fn defcomp) { m_fnCompare = fn; } \
472 \
473 name& operator=(const name& src) \
474 { base* temp = (base*) this; \
475 (*temp) = ((const base&)src); \
476 m_fnCompare = src.m_fnCompare; \
477 return *this; } \
478 \
479 T& operator[](size_t uiIndex) const \
480 { return (T&)(base::operator[](uiIndex)); } \
481 T& Item(size_t uiIndex) const \
482 { return (T&)(base::operator[](uiIndex)); } \
483 T& Last() const \
484 { return (T&)(base::operator[](size() - 1)); } \
485 \
486 int Index(T Item) const \
487 { return base::Index(Item, (CMPFUNC)m_fnCompare); } \
488 \
489 size_t IndexForInsert(T Item) const \
490 { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); } \
491 \
492 void AddAt(T item, size_t index) \
493 { base::insert(begin() + index, item); } \
494 \
495 void Add(T Item) \
496 { base::Add(Item, (CMPFUNC)m_fnCompare); } \
497 \
498 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
499 { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
500 void Remove(T Item) \
501 { int iIndex = Index(Item); \
502 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
503 _WX_ERROR_REMOVE ); \
504 base::erase(begin() + iIndex); } \
505 \
506 private: \
507 comptype m_fnCompare; \
508 }
509
510
511 // ----------------------------------------------------------------------------
512 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
513 // ----------------------------------------------------------------------------
514
515 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp) \
516 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2); \
517 classexp name : protected base \
518 { \
519 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
520 typedef base base_array; \
521 public: \
522 name() { } \
523 name(const name& src); \
524 name& operator=(const name& src); \
525 \
526 ~name(); \
527 \
528 void Alloc(size_t count) { reserve(count); } \
529 size_t GetCount() const { return base_array::size(); } \
530 size_t size() const { return base_array::size(); } \
531 bool IsEmpty() const { return base_array::empty(); } \
532 size_t Count() const { return base_array::size(); } \
533 void Shrink() { base::Shrink(); } \
534 \
535 T& operator[](size_t uiIndex) const \
536 { return *(T*)base::operator[](uiIndex); } \
537 T& Item(size_t uiIndex) const \
538 { return *(T*)base::operator[](uiIndex); } \
539 T& Last() const \
540 { return *(T*)(base::operator[](size() - 1)); } \
541 \
542 int Index(const T& Item, bool bFromEnd = FALSE) const; \
543 \
544 void Add(const T& Item, size_t nInsert = 1); \
545 void Add(const T* pItem) \
546 { base::push_back((T*)pItem); } \
547 void push_back(const T* pItem) \
548 { base::push_back((T*)pItem); } \
549 void push_back(const T& Item) \
550 { Add(Item); } \
551 \
552 void Insert(const T& Item, size_t uiIndex, size_t nInsert = 1); \
553 void Insert(const T* pItem, size_t uiIndex) \
554 { base::insert(begin() + uiIndex, (T*)pItem); } \
555 \
556 void Empty() { DoEmpty(); base::clear(); } \
557 void Clear() { DoEmpty(); base::clear(); } \
558 \
559 T* Detach(size_t uiIndex) \
560 { T* p = (T*)base::operator[](uiIndex); \
561 base::erase(begin() + uiIndex); return p; } \
562 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
563 \
564 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); } \
565 \
566 private: \
567 void DoEmpty(); \
568 void DoCopy(const name& src); \
569 }
570
571 // ============================================================================
572 // The public macros for declaration and definition of the dynamic arrays
573 // ============================================================================
574
575 // Please note that for each macro WX_FOO_ARRAY we also have
576 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
577 // same except that they use an additional __declspec(dllexport) or equivalent
578 // under Windows if needed.
579 //
580 // The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
581 // and so must be used used inside the library. The second kind (USER_EXPORTED)
582 // allow the user code to do it when it wants. This is needed if you have a dll
583 // that wants to export a wxArray daubed with your own import/export goo.
584 //
585 // Finally, you can define the macro below as something special to modify the
586 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
587 #define wxARRAY_DEFAULT_EXPORT
588
589 // ----------------------------------------------------------------------------
590 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
591 // the elements of type T
592 // ----------------------------------------------------------------------------
593
594 #define WX_DECLARE_BASEARRAY(T, name) \
595 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
596
597 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name) \
598 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
599
600 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode) \
601 typedef T _wxArray##name; \
602 _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
603
604 // ----------------------------------------------------------------------------
605 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
606 // from class "base" containing the elements of type T
607 //
608 // Note that the class defined has only inline function and doesn't take any
609 // space at all so there is no size penalty for defining multiple array classes
610 // ----------------------------------------------------------------------------
611
612 #define WX_DEFINE_TYPEARRAY(T, name, base) \
613 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
614
615 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \
616 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
617
618 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
619 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
620
621 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
622 typedef T _wxArray##name; \
623 _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
624
625 // ----------------------------------------------------------------------------
626 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
627 // defines a sorted array.
628 //
629 // Differences:
630 // 1) it must be given a COMPARE function in ctor which takes 2 items of type
631 // T* and should return -1, 0 or +1 if the first one is less/greater
632 // than/equal to the second one.
633 // 2) the Add() method inserts the item in such was that the array is always
634 // sorted (it uses the COMPARE function)
635 // 3) it has no Sort() method because it's always sorted
636 // 4) Index() method is much faster (the sorted arrays use binary search
637 // instead of linear one), but Add() is slower.
638 // 5) there is no Insert() method because you can't insert an item into the
639 // given position in a sorted array but there is IndexForInsert()/AddAt()
640 // pair which may be used to optimize a common operation of "insert only if
641 // not found"
642 //
643 // Note that you have to specify the comparison function when creating the
644 // objects of this array type. If, as in 99% of cases, the comparison function
645 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
646 // is more convenient.
647 //
648 // Summary: use this class when the speed of Index() function is important, use
649 // the normal arrays otherwise.
650 // ----------------------------------------------------------------------------
651
652 #define wxARRAY_EMPTY_CMP
653
654 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base) \
655 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, \
656 wxARRAY_DEFAULT_EXPORT)
657
658 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base) \
659 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
660
661 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
662 typedef T _wxArray##name; \
663 _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, \
664 wxARRAY_EMPTY_CMP, class expmode)
665
666 // ----------------------------------------------------------------------------
667 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
668 // function is provided by this macro and the objects of this class have a
669 // default constructor which just uses it.
670 //
671 // The arguments are: the element type, the comparison function and the array
672 // name
673 //
674 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
675 // from the very beginning - unfortunately I didn't think about this earlier
676 // ----------------------------------------------------------------------------
677
678 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
679 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
680 wxARRAY_DEFAULT_EXPORT)
681
682 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
683 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
684 WXDLLEXPORT)
685
686 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
687 expmode) \
688 typedef T _wxArray##name; \
689 _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, = cmpfunc, \
690 class expmode)
691
692 // ----------------------------------------------------------------------------
693 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
694 // named "name" which owns the objects of type T it contains, i.e. it will
695 // delete them when it is destroyed.
696 //
697 // An element is of type T*, but arguments of type T& are taken (see below!)
698 // and T& is returned.
699 //
700 // Don't use this for simple types such as "int" or "long"!
701 //
702 // Note on Add/Insert functions:
703 // 1) function(T*) gives the object to the array, i.e. it will delete the
704 // object when it's removed or in the array's dtor
705 // 2) function(T&) will create a copy of the object and work with it
706 //
707 // Also:
708 // 1) Remove() will delete the object after removing it from the array
709 // 2) Detach() just removes the object from the array (returning pointer to it)
710 //
711 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
712 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
713 // and so you risk having at least the memory leaks and probably worse
714 //
715 // Some functions of this class are not inline, so it takes some space to
716 // define new class from this template even if you don't use it - which is not
717 // the case for the simple (non-object) array classes
718 //
719 // To use an objarray class you must
720 // #include "dynarray.h"
721 // WX_DECLARE_OBJARRAY(element_type, list_class_name)
722 // #include "arrimpl.cpp"
723 // WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
724 //
725 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
726 // element_type must be fully defined (i.e. forward declaration is not
727 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
728 // two allows to break cicrcular dependencies with classes which have member
729 // variables of objarray type.
730 // ----------------------------------------------------------------------------
731
732 #define WX_DECLARE_OBJARRAY(T, name) \
733 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
734
735 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \
736 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
737
738 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
739 typedef T _wxObjArray##name; \
740 _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
741
742 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
743 // try to provoke a human-understandable error if it used incorrectly.
744 //
745 // there is no real need for 3 different macros in the DEFINE case but do it
746 // anyhow for consistency
747 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
748 #define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
749 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
750
751 // ----------------------------------------------------------------------------
752 // Some commonly used predefined base arrays
753 // ----------------------------------------------------------------------------
754
755 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
756 WXDLLIMPEXP_BASE);
757 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort,
758 WXDLLIMPEXP_BASE);
759 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt,
760 WXDLLIMPEXP_BASE);
761 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong,
762 WXDLLIMPEXP_BASE);
763 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble,
764 WXDLLIMPEXP_BASE);
765
766 // ----------------------------------------------------------------------------
767 // Convenience macros to define arrays from base arrays
768 // ----------------------------------------------------------------------------
769
770 #define WX_DEFINE_ARRAY(T, name) \
771 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
772 #define WX_DEFINE_EXPORTED_ARRAY(T, name) \
773 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
774 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
775 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
776
777 #define WX_DEFINE_ARRAY_SHORT(T, name) \
778 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort)
779 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name) \
780 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
781 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
782 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayShort, expmode)
783
784 #define WX_DEFINE_ARRAY_INT(T, name) \
785 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt)
786 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name) \
787 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
788 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
789 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayInt, expmode)
790
791 #define WX_DEFINE_ARRAY_LONG(T, name) \
792 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong)
793 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name) \
794 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
795 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
796 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayLong, expmode)
797
798 #define WX_DEFINE_ARRAY_DOUBLE(T, name) \
799 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble)
800 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \
801 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble)
802 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode) \
803 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayDouble, expmode)
804
805 // ----------------------------------------------------------------------------
806 // Convenience macros to define sorted arrays from base arrays
807 // ----------------------------------------------------------------------------
808
809 #define WX_DEFINE_SORTED_ARRAY(T, name) \
810 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
811 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
812 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
813 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
814 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
815
816 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name) \
817 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
818 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name) \
819 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
820 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
821 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
822
823 #define WX_DEFINE_SORTED_ARRAY_INT(T, name) \
824 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
825 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name) \
826 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
827 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
828 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
829
830 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name) \
831 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
832 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name) \
833 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
834 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
835 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
836
837 // ----------------------------------------------------------------------------
838 // Convenience macros to define sorted arrays from base arrays
839 // ----------------------------------------------------------------------------
840
841 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name) \
842 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
843 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
844 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
845 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, \
846 name, expmode) \
847 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
848 wxBaseArrayPtrVoid, expmode)
849
850 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
851 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
852 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
853 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
854 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, \
855 name, expmode) \
856 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
857 wxBaseArrayShort, expmode)
858
859 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
860 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
861 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
862 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
863 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, \
864 name, expmode) \
865 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
866 wxBaseArrayInt, expmode)
867
868 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
869 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
870 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
871 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
872 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, \
873 name, expmode) \
874 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
875 wxBaseArrayLong, expmode)
876
877 // ----------------------------------------------------------------------------
878 // Some commonly used predefined arrays
879 // ----------------------------------------------------------------------------
880
881 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT (short, wxArrayShort, class WXDLLIMPEXP_BASE);
882 WX_DEFINE_USER_EXPORTED_ARRAY_INT (int, wxArrayInt, class WXDLLIMPEXP_BASE);
883 WX_DEFINE_USER_EXPORTED_ARRAY_LONG (long, wxArrayLong, class WXDLLIMPEXP_BASE);
884 WX_DEFINE_USER_EXPORTED_ARRAY (void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
885
886 // -----------------------------------------------------------------------------
887 // convenience macros
888 // -----------------------------------------------------------------------------
889
890 // append all element of one array to another one
891 #define WX_APPEND_ARRAY(array, other) \
892 { \
893 size_t count = (other).size(); \
894 for ( size_t n = 0; n < count; n++ ) \
895 { \
896 (array).push_back((other)[n]); \
897 } \
898 }
899
900 // delete all array elements
901 //
902 // NB: the class declaration of the array elements must be visible from the
903 // place where you use this macro, otherwise the proper destructor may not
904 // be called (a decent compiler should give a warning about it, but don't
905 // count on it)!
906 #define WX_CLEAR_ARRAY(array) \
907 { \
908 size_t count = (array).size(); \
909 for ( size_t n = 0; n < count; n++ ) \
910 { \
911 delete (array)[n]; \
912 } \
913 \
914 (array).clear(); \
915 }
916
917 #endif // _DYNARRAY_H
918
wxWidgets (Impactor)