projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
More MSVC fixes .
[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_2(T, name, base, defcomp, classexp, comptype)\
461 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *), \
462 TypeTooBigToBeStoredInSorted##base, \
463 name); \
464 classexp name : public base \
465 { \
466 public: \
467 name(comptype fn defcomp) { m_fnCompare = fn; } \
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 \
476 { return (T&)(base::operator[](uiIndex)); } \
477 T& Item(size_t uiIndex) const \
478 { return (T&)(base::operator[](uiIndex)); } \
479 T& Last() const \
480 { return (T&)(base::operator[](size() - 1)); } \
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) \
489 { base::insert(begin() + index, item); } \
490 \
491 void Add(T Item) \
492 { base::Add(Item, (CMPFUNC)m_fnCompare); } \
493 \
494 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
495 { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
496 void Remove(T Item) \
497 { int iIndex = Index(Item); \
498 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
499 _WX_ERROR_REMOVE ); \
500 base::erase(begin() + iIndex); } \
501 \
502 private: \
503 comptype m_fnCompare; \
504 }
505
506
507 // ----------------------------------------------------------------------------
508 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
509 // ----------------------------------------------------------------------------
510
511 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp) \
512 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2); \
513 classexp name : protected base \
514 { \
515 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
516 typedef base base_array; \
517 public: \
518 name() { } \
519 name(const name& src); \
520 name& operator=(const name& src); \
521 \
522 ~name(); \
523 \
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 \
531 T& operator[](size_t uiIndex) const \
532 { return *(T*)base::operator[](uiIndex); } \
533 T& Item(size_t uiIndex) const \
534 { return *(T*)base::operator[](uiIndex); } \
535 T& Last() const \
536 { return *(T*)(base::operator[](size() - 1)); } \
537 \
538 int Index(const T& Item, bool bFromEnd = FALSE) const; \
539 \
540 void Add(const T& Item, size_t nInsert = 1); \
541 void Add(const T* pItem) \
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); } \
547 \
548 void Insert(const T& Item, size_t uiIndex, size_t nInsert = 1); \
549 void Insert(const T* pItem, size_t uiIndex) \
550 { base::insert(begin() + uiIndex, (T*)pItem); } \
551 \
552 void Empty() { DoEmpty(); base::clear(); } \
553 void Clear() { DoEmpty(); base::clear(); } \
554 \
555 T* Detach(size_t uiIndex) \
556 { T* p = (T*)base::operator[](uiIndex); \
557 base::erase(begin() + uiIndex); return p; } \
558 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
559 \
560 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); } \
561 \
562 private: \
563 void DoEmpty(); \
564 void DoCopy(const name& src); \
565 }
566
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 // ----------------------------------------------------------------------------
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
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
606 // ----------------------------------------------------------------------------
607
608 #define WX_DEFINE_TYPEARRAY(T, name, base) \
609 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
610
611 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \
612 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
613
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) \
618 typedef T _wxArray##name; \
619 _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
620
621 // ----------------------------------------------------------------------------
622 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
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
641 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
642 // is more convenient.
643 //
644 // Summary: use this class when the speed of Index() function is important, use
645 // the normal arrays otherwise.
646 // ----------------------------------------------------------------------------
647
648 #define wxARRAY_EMPTY_CMP
649
650 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base) \
651 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, \
652 wxARRAY_DEFAULT_EXPORT)
653
654 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base) \
655 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
656
657 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
658 typedef T _wxArray##name; \
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)
662
663 // ----------------------------------------------------------------------------
664 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
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 //
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
673 // ----------------------------------------------------------------------------
674
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)
678
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)
682
683 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
684 expmode) \
685 typedef T _wxArray##name; \
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)
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"!
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 //
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; \
738 _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
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)
747 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
748
749 // ----------------------------------------------------------------------------
750 // Some commonly used predefined base arrays
751 // ----------------------------------------------------------------------------
752
753 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
754 WXDLLIMPEXP_BASE);
755 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort,
756 WXDLLIMPEXP_BASE);
757 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt,
758 WXDLLIMPEXP_BASE);
759 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong,
760 WXDLLIMPEXP_BASE);
761 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble,
762 WXDLLIMPEXP_BASE);
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) \
773 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
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) \
780 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayShort, expmode)
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) \
787 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayInt, expmode)
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) \
794 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayLong, expmode)
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) \
801 WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayDouble, expmode)
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
875 // ----------------------------------------------------------------------------
876 // Some commonly used predefined arrays
877 // ----------------------------------------------------------------------------
878
879 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT (short, wxArrayShort, class WXDLLIMPEXP_BASE);
880 WX_DEFINE_USER_EXPORTED_ARRAY_INT (int, wxArrayInt, class WXDLLIMPEXP_BASE);
881 WX_DEFINE_USER_EXPORTED_ARRAY_LONG (long, wxArrayLong, class WXDLLIMPEXP_BASE);
882 WX_DEFINE_USER_EXPORTED_ARRAY (void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
883
884 // -----------------------------------------------------------------------------
885 // convenience macros
886 // -----------------------------------------------------------------------------
887
888 // append all element of one array to another one
889 #define WX_APPEND_ARRAY(array, other) \
890 { \
891 size_t count = (other).size(); \
892 for ( size_t n = 0; n < count; n++ ) \
893 { \
894 (array).push_back((other)[n]); \
895 } \
896 }
897
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 { \
906 size_t count = (array).size(); \
907 for ( size_t n = 0; n < count; n++ ) \
908 { \
909 delete (array)[n]; \
910 } \
911 \
912 (array).clear(); \
913 }
914
915 #endif // _DYNARRAY_H
916
wxWidgets (Impactor)