]> git.saurik.com Git - wxWidgets.git/blame - include/wx/dynarray.h
Added simplistic makefile/project files for wxWinCE.
[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>
9// Licence: wxWindows license
10///////////////////////////////////////////////////////////////////////////////
11
12#ifndef _DYNARRAY_H
13#define _DYNARRAY_H
14
af49c4b8 15#if defined(__GNUG__) && !defined(__APPLE__)
c801d85f
KB
16#pragma interface "dynarray.h"
17#endif
18
19#include "wx/defs.h"
c801d85f 20
1a931653
VZ
21/*
22 This header defines the dynamic arrays and object arrays (i.e. arrays which
23 own their elements). Dynamic means that the arrays grow automatically as
24 needed.
25
26 These macros are ugly (especially if you look in the sources ;-), but they
27 allow us to define "template" classes without actually using templates and so
28 this works with all compilers (and may be also much faster to compile even
29 with a compiler which does support templates). The arrays defined with these
30 macros are type-safe.
31
32 Range checking is performed in debug build for both arrays and objarrays but
33 not in release build - so using an invalid index will just lead to a crash
34 then.
35
36 Note about memory usage: arrays never shrink automatically (although you may
37 use Shrink() function explicitly), they only grow, so loading 10 millions in
38 an array only to delete them 2 lines below might be a bad idea if the array
39 object is not going to be destroyed soon. However, as it does free memory
40 when destroyed, it is ok if the array is a local variable.
41 */
c801d85f
KB
42
43// ----------------------------------------------------------------------------
44// constants
45// ----------------------------------------------------------------------------
46
1a931653
VZ
47/*
48 The initial size by which an array grows when an element is added default
49 value avoids allocate one or two bytes when the array is created which is
50 rather inefficient
c801d85f 51*/
1a931653 52#define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
c801d85f
KB
53
54// ----------------------------------------------------------------------------
55// types
56// ----------------------------------------------------------------------------
57
1a931653
VZ
58/*
59 Callback compare function for quick sort.
3b0b5f13 60
1a931653
VZ
61 It must return negative value, 0 or positive value if the first item is
62 less than, equal to or greater than the second one.
c801d85f 63 */
90350682
VZ
64extern "C"
65{
0661ec39 66typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
90350682 67}
c801d85f
KB
68
69// ----------------------------------------------------------------------------
1a931653
VZ
70// Base class managing data having size of type 'long' (not used directly)
71//
72// NB: for efficiency this often used class has no virtual functions (hence no
73// virtual table), even dtor is *not* virtual. If used as expected it
74// won't create any problems because ARRAYs from DEFINE_ARRAY have no dtor
75// at all, so it's not too important if it's not called (this happens when
76// you cast "SomeArray *" as "BaseArray *" and then delete it)
c801d85f 77// ----------------------------------------------------------------------------
1a931653 78
5a1cad6e
GD
79#define _WX_DECLARE_BASEARRAY(T, name, classexp) \
80classexp name \
81{ \
82public: \
83 name(); \
84 name(const name& array); \
85 name& operator=(const name& src); \
86 ~name(); \
87 \
88 void Empty() { m_nCount = 0; } \
89 void Clear(); \
90 void Alloc(size_t uiSize); \
91 void Shrink(); \
92 \
93 size_t GetCount() const { return m_nCount; } \
94 bool IsEmpty() const { return m_nCount == 0; } \
95 size_t Count() const { return m_nCount; } \
96 \
75d7ef36 97 typedef T base_type; \
5a1cad6e
GD
98protected: \
99 T& Item(size_t uiIndex) const \
100 { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; } \
101 T& operator[](size_t uiIndex) const { return Item(uiIndex); } \
102 \
103 int Index(T lItem, bool bFromEnd = FALSE) const; \
104 int Index(T lItem, CMPFUNC fnCompare) const; \
105 size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
3b0b5f13 106 void Add(T lItem, size_t nInsert = 1); \
5a1cad6e 107 void Add(T lItem, CMPFUNC fnCompare); \
3b0b5f13 108 void Insert(T lItem, size_t uiIndex, size_t nInsert = 1); \
5a1cad6e 109 void Remove(T lItem); \
3b0b5f13 110 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
5a1cad6e
GD
111 \
112 void Sort(CMPFUNC fnCompare); \
113 \
114private: \
5a1cad6e 115 \
3b0b5f13 116 void Grow(size_t nIncrement = 0); \
5a1cad6e
GD
117 \
118 size_t m_nSize, \
119 m_nCount; \
120 \
121 T *m_pItems; \
e9bb94cf 122}
c801d85f
KB
123
124// ============================================================================
1a931653 125// The private helper macros containing the core of the array classes
c801d85f
KB
126// ============================================================================
127
1a931653
VZ
128// Implementation notes:
129//
130// JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
131// { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
132// so using a temporary variable instead.
133//
134// The classes need a (even trivial) ~name() to link under Mac X
135//
136// _WX_ERROR_REMOVE is needed to resolve the name conflict between the wxT()
5a1cad6e 137// macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
1a931653
VZ
138
139#define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
e90c1d2a 140
c801d85f 141// ----------------------------------------------------------------------------
5a1cad6e 142// _WX_DEFINE_TYPEARRAY: array for simple types
c801d85f 143// ----------------------------------------------------------------------------
1a931653 144
5a1cad6e
GD
145#define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
146wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \
147 TypeTooBigToBeStoredIn##base, \
148 name); \
149typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
150classexp name : public base \
151{ \
152public: \
153 name() { } \
154 ~name() { } \
155 \
156 name& operator=(const name& src) \
157 { base* temp = (base*) this; \
158 (*temp) = ((const base&)src); \
159 return *this; } \
160 \
161 T& operator[](size_t uiIndex) const \
162 { return (T&)(base::Item(uiIndex)); } \
163 T& Item(size_t uiIndex) const \
164 { return (T&)(base::Item(uiIndex)); } \
165 T& Last() const \
166 { return (T&)(base::Item(Count() - 1)); } \
167 \
168 int Index(T Item, bool bFromEnd = FALSE) const \
169 { return base::Index(Item, bFromEnd); } \
170 \
3b0b5f13
VZ
171 void Add(T Item, size_t nInsert = 1) \
172 { base::Add(Item, nInsert); } \
173 void Insert(T Item, size_t uiIndex, size_t nInsert = 1) \
174 { base::Insert(Item, uiIndex, nInsert) ; } \
5a1cad6e 175 \
3b0b5f13
VZ
176 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
177 { base::RemoveAt(uiIndex, nRemove); } \
5a1cad6e
GD
178 void Remove(T Item) \
179 { int iIndex = Index(Item); \
180 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
181 _WX_ERROR_REMOVE); \
182 base::RemoveAt((size_t)iIndex); } \
183 \
184 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
c801d85f
KB
185}
186
3bfa4402 187// ----------------------------------------------------------------------------
5a1cad6e
GD
188// _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
189// cannot handle types with size greater than pointer because of sorting
3bfa4402 190// ----------------------------------------------------------------------------
1a931653 191
5a1cad6e
GD
192#define _WX_DEFINE_SORTED_TYPEARRAY(T, name, base, defcomp, classexp) \
193wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *), \
194 TypeTooBigToBeStoredInSorted##base, \
195 name); \
196typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
197classexp name : public base \
198{ \
199public: \
200 name(SCMPFUNC##T fn defcomp) { m_fnCompare = fn; } \
201 \
202 name& operator=(const name& src) \
203 { base* temp = (base*) this; \
204 (*temp) = ((const base&)src); \
205 m_fnCompare = src.m_fnCompare; \
206 return *this; } \
207 \
208 T& operator[](size_t uiIndex) const \
209 { return (T&)(base::Item(uiIndex)); } \
210 T& Item(size_t uiIndex) const \
211 { return (T&)(base::Item(uiIndex)); } \
212 T& Last() const \
213 { return (T&)(base::Item(Count() - 1)); } \
214 \
215 int Index(T Item) const \
216 { return base::Index(Item, (CMPFUNC)m_fnCompare); } \
217 \
218 size_t IndexForInsert(T Item) const \
219 { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); } \
220 \
221 void AddAt(T item, size_t index) \
222 { base::Insert(item, index); } \
223 \
224 void Add(T Item) \
225 { base::Add(Item, (CMPFUNC)m_fnCompare); } \
226 \
3b0b5f13
VZ
227 void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
228 { base::RemoveAt(uiIndex, nRemove); } \
5a1cad6e
GD
229 void Remove(T Item) \
230 { int iIndex = Index(Item); \
231 wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
232 _WX_ERROR_REMOVE ); \
233 base::RemoveAt((size_t)iIndex); } \
234 \
235private: \
236 SCMPFUNC##T m_fnCompare; \
3bfa4402
VZ
237}
238
c801d85f 239// ----------------------------------------------------------------------------
1a931653 240// _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
c801d85f 241// ----------------------------------------------------------------------------
1a931653 242
5a1cad6e
GD
243#define _WX_DECLARE_OBJARRAY(T, name, base, classexp) \
244typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2); \
245classexp name : public base \
246{ \
247typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
248public: \
249 name() { } \
250 name(const name& src); \
251 name& operator=(const name& src); \
252 \
253 ~name(); \
254 \
255 T& operator[](size_t uiIndex) const \
256 { return *(T*)base::Item(uiIndex); } \
257 T& Item(size_t uiIndex) const \
258 { return *(T*)base::Item(uiIndex); } \
259 T& Last() const \
260 { return *(T*)(base::Item(Count() - 1)); } \
261 \
262 int Index(const T& Item, bool bFromEnd = FALSE) const; \
263 \
3b0b5f13 264 void Add(const T& Item, size_t nInsert = 1); \
5a1cad6e
GD
265 void Add(const T* pItem) \
266 { base::Add((T*)pItem); } \
267 \
3b0b5f13 268 void Insert(const T& Item, size_t uiIndex, size_t nInsert = 1); \
5a1cad6e
GD
269 void Insert(const T* pItem, size_t uiIndex) \
270 { base::Insert((T*)pItem, uiIndex); } \
271 \
272 void Empty() { DoEmpty(); base::Empty(); } \
273 void Clear() { DoEmpty(); base::Clear(); } \
274 \
275 T* Detach(size_t uiIndex) \
276 { T* p = (T*)base::Item(uiIndex); \
277 base::RemoveAt(uiIndex); return p; } \
3b0b5f13 278 void RemoveAt(size_t uiIndex, size_t nRemove = 1); \
5a1cad6e
GD
279 \
280 void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); } \
281 \
282private: \
283 void DoEmpty(); \
284 void DoCopy(const name& src); \
c801d85f
KB
285}
286
1a931653
VZ
287// ============================================================================
288// The public macros for declaration and definition of the dynamic arrays
289// ============================================================================
290
291// Please note that for each macro WX_FOO_ARRAY we also have
292// WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
293// same except that they use an additional __declspec(dllexport) or equivalent
294// under Windows if needed.
295//
296// The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
297// and so must be used used inside the library. The second kind (USER_EXPORTED)
298// allow the user code to do it when it wants. This is needed if you have a dll
299// that wants to export a wxArray daubed with your own import/export goo.
300//
301// Finally, you can define the macro below as something special to modify the
302// arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
303#define wxARRAY_DEFAULT_EXPORT
304
305// ----------------------------------------------------------------------------
5a1cad6e
GD
306// WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
307// the elements of type T
308// ----------------------------------------------------------------------------
309
310#define WX_DECLARE_BASEARRAY(T, name) \
311 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
312
313#define WX_DECLARE_EXPORTED_BASEARRAY(T, name) \
314 WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
315
316#define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode) \
317 typedef T _wxArray##name; \
318 _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
319
320// ----------------------------------------------------------------------------
321// WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
322// from class "base" containing the elements of type T
1a931653
VZ
323//
324// Note that the class defined has only inline function and doesn't take any
325// space at all so there is no size penalty for defining multiple array classes
c801d85f 326// ----------------------------------------------------------------------------
c801d85f 327
5a1cad6e
GD
328#define WX_DEFINE_TYPEARRAY(T, name, base) \
329 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, wxARRAY_DEFAULT_EXPORT)
1a931653 330
5a1cad6e
GD
331#define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \
332 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
1a931653 333
5a1cad6e
GD
334#define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
335 typedef T _wxArray##name; \
336 _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, class expmode)
1a931653
VZ
337
338// ----------------------------------------------------------------------------
5a1cad6e 339// WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
1a931653
VZ
340// defines a sorted array.
341//
342// Differences:
343// 1) it must be given a COMPARE function in ctor which takes 2 items of type
344// T* and should return -1, 0 or +1 if the first one is less/greater
345// than/equal to the second one.
346// 2) the Add() method inserts the item in such was that the array is always
347// sorted (it uses the COMPARE function)
348// 3) it has no Sort() method because it's always sorted
349// 4) Index() method is much faster (the sorted arrays use binary search
350// instead of linear one), but Add() is slower.
351// 5) there is no Insert() method because you can't insert an item into the
352// given position in a sorted array but there is IndexForInsert()/AddAt()
353// pair which may be used to optimize a common operation of "insert only if
354// not found"
355//
356// Note that you have to specify the comparison function when creating the
357// objects of this array type. If, as in 99% of cases, the comparison function
5a1cad6e
GD
358// is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
359// is more convenient.
1a931653
VZ
360//
361// Summary: use this class when the speed of Index() function is important, use
362// the normal arrays otherwise.
c801d85f
KB
363// ----------------------------------------------------------------------------
364
17e656b0
VZ
365#define wxARRAY_EMPTY_CMP
366
5a1cad6e
GD
367#define WX_DEFINE_SORTED_TYPEARRAY(T, name, base) \
368 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, \
369 wxARRAY_DEFAULT_EXPORT)
a497618a 370
5a1cad6e
GD
371#define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base) \
372 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
a497618a 373
5a1cad6e
GD
374#define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
375 typedef T _wxArray##name; \
376 _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, \
377 wxARRAY_EMPTY_CMP, class expmode)
1a931653
VZ
378
379// ----------------------------------------------------------------------------
5a1cad6e 380// WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
1a931653
VZ
381// function is provided by this macro and the objects of this class have a
382// default constructor which just uses it.
383//
384// The arguments are: the element type, the comparison function and the array
385// name
386//
5a1cad6e
GD
387// NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
388// from the very beginning - unfortunately I didn't think about this earlier
1a931653 389// ----------------------------------------------------------------------------
76314141 390
5a1cad6e
GD
391#define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
392 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
393 wxARRAY_DEFAULT_EXPORT)
76314141 394
5a1cad6e
GD
395#define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
396 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
397 WXDLLEXPORT)
1a931653 398
5a1cad6e
GD
399#define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
400 expmode) \
1a931653 401 typedef T _wxArray##name; \
5a1cad6e
GD
402 _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, = cmpfunc, \
403 class expmode)
1a931653
VZ
404
405// ----------------------------------------------------------------------------
406// WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
407// named "name" which owns the objects of type T it contains, i.e. it will
408// delete them when it is destroyed.
409//
410// An element is of type T*, but arguments of type T& are taken (see below!)
411// and T& is returned.
412//
413// Don't use this for simple types such as "int" or "long"!
1a931653
VZ
414//
415// Note on Add/Insert functions:
416// 1) function(T*) gives the object to the array, i.e. it will delete the
417// object when it's removed or in the array's dtor
418// 2) function(T&) will create a copy of the object and work with it
419//
420// Also:
421// 1) Remove() will delete the object after removing it from the array
422// 2) Detach() just removes the object from the array (returning pointer to it)
423//
424// NB1: Base type T should have an accessible copy ctor if Add(T&) is used
425// NB2: Never ever cast a array to it's base type: as dtor is not virtual
426// and so you risk having at least the memory leaks and probably worse
427//
428// Some functions of this class are not inline, so it takes some space to
429// define new class from this template even if you don't use it - which is not
430// the case for the simple (non-object) array classes
431//
1a931653
VZ
432// To use an objarray class you must
433// #include "dynarray.h"
434// WX_DECLARE_OBJARRAY(element_type, list_class_name)
435// #include "arrimpl.cpp"
436// WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
437//
438// This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
439// element_type must be fully defined (i.e. forward declaration is not
440// enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
441// two allows to break cicrcular dependencies with classes which have member
442// variables of objarray type.
443// ----------------------------------------------------------------------------
444
445#define WX_DECLARE_OBJARRAY(T, name) \
446 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
447
448#define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \
449 WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
450
451#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
452 typedef T _wxObjArray##name; \
5a1cad6e 453 _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
1a931653
VZ
454
455// WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
456// try to provoke a human-understandable error if it used incorrectly.
457//
458// there is no real need for 3 different macros in the DEFINE case but do it
459// anyhow for consistency
460#define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
461#define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
76314141 462#define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
76314141 463
5a1cad6e
GD
464// ----------------------------------------------------------------------------
465// Some commonly used predefined base arrays
466// ----------------------------------------------------------------------------
467
f1322419
VZ
468WX_DECLARE_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid);
469WX_DECLARE_EXPORTED_BASEARRAY(short, wxBaseArrayShort);
470WX_DECLARE_EXPORTED_BASEARRAY(int, wxBaseArrayInt);
471WX_DECLARE_EXPORTED_BASEARRAY(long, wxBaseArrayLong);
472WX_DECLARE_EXPORTED_BASEARRAY(double, wxBaseArrayDouble);
5a1cad6e
GD
473
474// ----------------------------------------------------------------------------
475// Convenience macros to define arrays from base arrays
476// ----------------------------------------------------------------------------
477
478#define WX_DEFINE_ARRAY(T, name) \
479 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
480#define WX_DEFINE_EXPORTED_ARRAY(T, name) \
481 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
482#define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
483 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
484
485#define WX_DEFINE_ARRAY_SHORT(T, name) \
486 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort)
487#define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name) \
488 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
489#define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
490 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
491
492#define WX_DEFINE_ARRAY_INT(T, name) \
493 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt)
494#define WX_DEFINE_EXPORTED_ARRAY_INT(T, name) \
495 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
496#define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
497 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
498
499#define WX_DEFINE_ARRAY_LONG(T, name) \
500 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong)
501#define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name) \
502 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
503#define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
504 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
505
506#define WX_DEFINE_ARRAY_DOUBLE(T, name) \
507 WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble)
508#define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \
509 WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble)
510#define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode) \
511 WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble, expmode)
512
513// ----------------------------------------------------------------------------
514// Convenience macros to define sorted arrays from base arrays
515// ----------------------------------------------------------------------------
516
517#define WX_DEFINE_SORTED_ARRAY(T, name) \
518 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
519#define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
520 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
521#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
522 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
523
524#define WX_DEFINE_SORTED_ARRAY_SHORT(T, name) \
525 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
526#define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name) \
527 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
528#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
529 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
530
531#define WX_DEFINE_SORTED_ARRAY_INT(T, name) \
532 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
533#define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name) \
534 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
535#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
536 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
537
538#define WX_DEFINE_SORTED_ARRAY_LONG(T, name) \
539 WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
540#define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name) \
541 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
542#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
543 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
544
545// ----------------------------------------------------------------------------
546// Convenience macros to define sorted arrays from base arrays
547// ----------------------------------------------------------------------------
548
549#define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name) \
550 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
551#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
552 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
553#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, \
554 name, expmode) \
555 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
556 wxBaseArrayPtrVoid, expmode)
557
558#define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
559 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
560#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
561 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
562#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, \
563 name, expmode) \
564 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
565 wxBaseArrayShort, expmode)
566
567#define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
568 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
569#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
570 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
571#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, \
572 name, expmode) \
573 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
574 wxBaseArrayInt, expmode)
575
576#define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
577 WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
578#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
579 WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
580#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, \
581 name, expmode) \
582 WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
583 wxBaseArrayLong, expmode)
584
c801d85f 585// ----------------------------------------------------------------------------
1a931653 586// Some commonly used predefined arrays
c801d85f
KB
587// ----------------------------------------------------------------------------
588
5a1cad6e
GD
589WX_DEFINE_EXPORTED_ARRAY_SHORT (short, wxArrayShort);
590WX_DEFINE_EXPORTED_ARRAY_INT (int, wxArrayInt);
591WX_DEFINE_EXPORTED_ARRAY_LONG (long, wxArrayLong);
592WX_DEFINE_EXPORTED_ARRAY (void *, wxArrayPtrVoid);
c801d85f 593
2b9bd418 594// -----------------------------------------------------------------------------
0cbff120 595// convenience macros
2b9bd418
VZ
596// -----------------------------------------------------------------------------
597
4f6aed9c
VZ
598// append all element of one array to another one
599#define WX_APPEND_ARRAY(array, other) \
600 { \
5d5b1c0c 601 size_t count = (other).Count(); \
4f6aed9c
VZ
602 for ( size_t n = 0; n < count; n++ ) \
603 { \
5d5b1c0c 604 (array).Add((other)[n]); \
4f6aed9c
VZ
605 } \
606 }
607
2b9bd418
VZ
608// delete all array elements
609//
610// NB: the class declaration of the array elements must be visible from the
611// place where you use this macro, otherwise the proper destructor may not
612// be called (a decent compiler should give a warning about it, but don't
613// count on it)!
614#define WX_CLEAR_ARRAY(array) \
615 { \
5d5b1c0c 616 size_t count = (array).Count(); \
2b9bd418
VZ
617 for ( size_t n = 0; n < count; n++ ) \
618 { \
5d5b1c0c 619 delete (array)[n]; \
2b9bd418 620 } \
2c356747 621 \
5d5b1c0c 622 (array).Empty(); \
2b9bd418 623 }
a497618a 624
c801d85f
KB
625#endif // _DYNARRAY_H
626