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 name::reference reference;                                \
 350     typedef name::pointer pointer;                                    \
 351     typedef reverse_iterator itor;                                    \
 352     friend itor operator+(int o, const itor& it);                     \
 353     friend itor operator+(const itor& it, int o);                     \
 354     friend itor operator-(const itor& it, int o);                     \
 355     friend difference_type operator -(const itor& i1, const itor& i2);\
 356   public:                                                             \
 357     pointer m_ptr;                                                    \
 358     reverse_iterator() : m_ptr(NULL) { }                              \
 359     reverse_iterator(pointer ptr) : m_ptr(ptr) { }                    \
 360     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }            \
 361     reference operator*() const { return *m_ptr; }                    \
 362     pointer operator->() const { return m_ptr; }                      \
 363     itor operator++() { --m_ptr; return *this; }                      \
 364     itor operator++(int)                                              \
 365       { reverse_iterator tmp = *this; --m_ptr; return tmp; }          \
 366     itor operator--() { ++m_ptr; return *this; }                      \
 367     itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
 368     bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
 369     bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
 370   };                                                                  \
 371                                                                       \
 372   class const_reverse_iterator                                        \
 373   {                                                                   \
 374     typedef name::const_reference reference;                          \
 375     typedef name::const_pointer pointer;                              \
 376     typedef const_reverse_iterator itor;                              \
 377     friend itor operator+(int o, const itor& it);                     \
 378     friend itor operator+(const itor& it, int o);                     \
 379     friend itor operator-(const itor& it, int o);                     \
 380     friend difference_type operator -(const itor& i1, const itor& i2);\
 381   public:                                                             \
 382     pointer m_ptr;                                                    \
 383     const_reverse_iterator() : m_ptr(NULL) { }                        \
 384     const_reverse_iterator(pointer ptr) : m_ptr(ptr) { }              \
 385     const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }      \
 386     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
 387     reference operator*() const { return *m_ptr; }                    \
 388     pointer operator->() const { return m_ptr; }                      \
 389     itor operator++() { --m_ptr; return *this; }                      \
 390     itor operator++(int)                                              \
 391       { itor tmp = *this; --m_ptr; return tmp; }                      \
 392     itor operator--() { ++m_ptr; return *this; }                      \
 393     itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
 394     bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
 395     bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
 396   };                                                                  \
 397                                                                       \
 398   void assign(const_iterator first, const_iterator last)              \
 399     { base::assign((bconst_iterator)first, (bconst_iterator)last); }  \
 400   void assign(size_type n, const_reference v)                         \
 401     { base::assign(n, (bconst_reference)v); }                         \
 402   reference back() { return *(end() - 1); }                           \
 403   const_reference back() const { return *(end() - 1); }               \
 404   iterator begin() { return (iterator)base::begin(); }                \
 405   const_iterator begin() const { return (const_iterator)base::begin(); }\
 406   size_type capacity() const { return base::capacity(); }             \
 407   void clear() { base::clear(); }                                     \
 408   bool empty() const { return base::empty(); }                        \
 409   iterator end() { return (iterator)base::end(); }                    \
 410   const_iterator end() const { return (const_iterator)base::end(); }  \
 411   iterator erase(iterator first, iterator last)                       \
 412     { return (iterator)base::erase((biterator)first, (biterator)last); }\
 413   iterator erase(iterator it)                                         \
 414     { return (iterator)base::erase((biterator)it); }                  \
 415   reference front() { return *begin(); }                              \
 416   const_reference front() const { return *begin(); }                  \
 417   void insert(iterator it, size_type n, const_reference v)            \
 418     { base::insert((biterator)it, n, (bconst_reference)v); }          \
 419   iterator insert(iterator it, const_reference v = value_type())      \
 420     { return (iterator)base::insert((biterator)it, (bconst_reference)v); }\
 421   void insert(iterator it, const_iterator first, const_iterator last) \
 422     { base::insert((biterator)it, (bconst_iterator)first,             \
 423                    (bconst_iterator)last); }                          \
 424   size_type max_size() const { return base::max_size(); }             \
 425   void pop_back() { base::pop_back(); }                               \
 426   void push_back(const_reference v)                                   \
 427     { base::push_back((bconst_reference)v); }                         \
 428   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }   \
 429   const_reverse_iterator rbegin() const;                              \
 430   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
 431   const_reverse_iterator rend() const;                                \
 432   void reserve(size_type n) { base::reserve(n); };                    \
 433   void resize(size_type n, value_type v = value_type());              \
 434   size_type size() const { return base::size(); }                     \
 435 };                                                                    \
 436                                                                       \
 437 inline name::reverse_iterator operator+(int o, const name::reverse_iterator& it) { return it.m_ptr - o; } \
 438 inline name::reverse_iterator operator+(const name::reverse_iterator& it, int o) { return it.m_ptr - o; } \
 439 inline name::reverse_iterator operator-(const name::reverse_iterator& it, int o) { return it.m_ptr + o; } \
 440 inline name::difference_type operator -(const name::reverse_iterator& i1, \
 441                              const name::reverse_iterator& i2)            \
 442     { return i1.m_ptr - i2.m_ptr; }                                       \
 443                                                                       \
 444 inline name::const_reverse_iterator operator+(int o, const name::const_reverse_iterator& it) { return it.m_ptr - o; } \
 445 inline name::const_reverse_iterator operator+(const name::const_reverse_iterator& it, int o) { return it.m_ptr - o; } \
 446 inline name::const_reverse_iterator operator-(const name::const_reverse_iterator& it, int o) { return it.m_ptr + o; } \
 447 inline name::difference_type operator -(const name::const_reverse_iterator& i1,\
 448                              const name::const_reverse_iterator& i2)      \
 449     { return i1.m_ptr - i2.m_ptr; }                                       \
 450
 451 #endif // !wxUSE_STL
 452
 453 // ----------------------------------------------------------------------------
 454 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
 455 //    cannot handle types with size greater than pointer because of sorting
 456 // ----------------------------------------------------------------------------
 457
 458 #define _WX_DEFINE_SORTED_TYPEARRAY(T, name, base, defcomp, classexp) \
 459 typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);          \
 460 _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, SCMPFUNC##T)
 461
 462 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
 463 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *),                   \
 464                        TypeTooBigToBeStoredInSorted##base,            \
 465                        name);                                         \
 466 classexp name : public base                                           \
 467 {                                                                     \
 468 public:                                                               \
 469   name(comptype fn defcomp) { m_fnCompare = fn; }                     \
 470                                                                       \
 471   name& operator=(const name& src)                                    \
 472     { base* temp = (base*) this;                                      \
 473       (*temp) = ((const base&)src);                                   \
 474       m_fnCompare = src.m_fnCompare;                                  \
 475       return *this; }                                                 \
 476                                                                       \
 477   T& operator[](size_t uiIndex) const                                 \
 478     { return (T&)(base::operator[](uiIndex)); }                       \
 479   T& Item(size_t uiIndex) const                                       \
 480     { return (T&)(base::operator[](uiIndex)); }                       \
 481   T& Last() const                                                     \
 482     { return (T&)(base::operator[](size() - 1)); }                    \
 483                                                                       \
 484   int Index(T Item) const                                             \
 485     { return base::Index(Item, (CMPFUNC)m_fnCompare); }               \
 486                                                                       \
 487   size_t IndexForInsert(T Item) const                                 \
 488     { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); }      \
 489                                                                       \
 490   void AddAt(T item, size_t index)                                    \
 491     { base::insert(begin() + index, item); }                          \
 492                                                                       \
 493   void Add(T Item)                                                    \
 494     { base::Add(Item, (CMPFUNC)m_fnCompare); }                        \
 495                                                                       \
 496   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 497     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \
 498   void Remove(T Item)                                                 \
 499     { int iIndex = Index(Item);                                       \
 500       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 501         _WX_ERROR_REMOVE );                                           \
 502       base::erase(begin() + iIndex); }                                \
 503                                                                       \
 504 private:                                                              \
 505   comptype m_fnCompare;                                               \
 506 }
 507
 508
 509 // ----------------------------------------------------------------------------
 510 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
 511 // ----------------------------------------------------------------------------
 512
 513 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp)                    \
 514 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2);          \
 515 classexp name : protected base                                           \
 516 {                                                                        \
 517 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
 518 typedef base base_array;                                                 \
 519 public:                                                                  \
 520   name() { }                                                             \
 521   name(const name& src);                                                 \
 522   name& operator=(const name& src);                                      \
 523                                                                          \
 524   ~name();                                                               \
 525                                                                          \
 526   void Alloc(size_t count) { reserve(count); }                           \
 527   size_t GetCount() const { return base_array::size(); }                 \
 528   size_t size() const { return base_array::size(); }                     \
 529   bool IsEmpty() const { return base_array::empty(); }                   \
 530   size_t Count() const { return base_array::size(); }                    \
 531   void Shrink() { base::Shrink(); }                                      \
 532                                                                          \
 533   T& operator[](size_t uiIndex) const                                    \
 534     { return *(T*)base::operator[](uiIndex); }                           \
 535   T& Item(size_t uiIndex) const                                          \
 536     { return *(T*)base::operator[](uiIndex); }                           \
 537   T& Last() const                                                        \
 538     { return *(T*)(base::operator[](size() - 1)); }                      \
 539                                                                          \
 540   int Index(const T& Item, bool bFromEnd = FALSE) const;                 \
 541                                                                          \
 542   void Add(const T& Item, size_t nInsert = 1);                           \
 543   void Add(const T* pItem)                                               \
 544     { base::push_back((T*)pItem); }                                      \
 545   void push_back(const T* pItem)                                         \
 546     { base::push_back((T*)pItem); }                                      \
 547   void push_back(const T& Item)                                          \
 548     { Add(Item); }                                                       \
 549                                                                          \
 550   void Insert(const T& Item,  size_t uiIndex, size_t nInsert = 1);       \
 551   void Insert(const T* pItem, size_t uiIndex)                            \
 552     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
 553                                                                          \
 554   void Empty() { DoEmpty(); base::clear(); }                             \
 555   void Clear() { DoEmpty(); base::clear(); }                             \
 556                                                                          \
 557   T* Detach(size_t uiIndex)                                              \
 558     { T* p = (T*)base::operator[](uiIndex);                              \
 559       base::erase(begin() + uiIndex); return p; }                        \
 560   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
 561                                                                          \
 562   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
 563                                                                          \
 564 private:                                                                 \
 565   void DoEmpty();                                                        \
 566   void DoCopy(const name& src);                                          \
 567 }
 568
 569 // ============================================================================
 570 // The public macros for declaration and definition of the dynamic arrays
 571 // ============================================================================
 572
 573 // Please note that for each macro WX_FOO_ARRAY we also have
 574 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
 575 // same except that they use an additional __declspec(dllexport) or equivalent
 576 // under Windows if needed.
 577 //
 578 // The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
 579 // and so must be used used inside the library. The second kind (USER_EXPORTED)
 580 // allow the user code to do it when it wants. This is needed if you have a dll
 581 // that wants to export a wxArray daubed with your own import/export goo.
 582 //
 583 // Finally, you can define the macro below as something special to modify the
 584 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
 585 #define wxARRAY_DEFAULT_EXPORT
 586
 587 // ----------------------------------------------------------------------------
 588 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
 589 // the elements of type T
 590 // ----------------------------------------------------------------------------
 591
 592 #define WX_DECLARE_BASEARRAY(T, name)                             \
 593     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 594
 595 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name)                    \
 596     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
 597
 598 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode)      \
 599     typedef T _wxArray##name;                                     \
 600     _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
 601
 602 // ----------------------------------------------------------------------------
 603 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
 604 // from class "base" containing the elements of type T
 605 //
 606 // Note that the class defined has only inline function and doesn't take any
 607 // space at all so there is no size penalty for defining multiple array classes
 608 // ----------------------------------------------------------------------------
 609
 610 #define WX_DEFINE_TYPEARRAY(T, name, base)                        \
 611     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 612
 613 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base)               \
 614     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
 615
 616 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
 617     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
 618
 619 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
 620     typedef T _wxArray##name;                                   \
 621     _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
 622
 623 // ----------------------------------------------------------------------------
 624 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
 625 // defines a sorted array.
 626 //
 627 // Differences:
 628 //  1) it must be given a COMPARE function in ctor which takes 2 items of type
 629 //     T* and should return -1, 0 or +1 if the first one is less/greater
 630 //     than/equal to the second one.
 631 //  2) the Add() method inserts the item in such was that the array is always
 632 //     sorted (it uses the COMPARE function)
 633 //  3) it has no Sort() method because it's always sorted
 634 //  4) Index() method is much faster (the sorted arrays use binary search
 635 //     instead of linear one), but Add() is slower.
 636 //  5) there is no Insert() method because you can't insert an item into the
 637 //     given position in a sorted array but there is IndexForInsert()/AddAt()
 638 //     pair which may be used to optimize a common operation of "insert only if
 639 //     not found"
 640 //
 641 // Note that you have to specify the comparison function when creating the
 642 // objects of this array type. If, as in 99% of cases, the comparison function
 643 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
 644 // is more convenient.
 645 //
 646 // Summary: use this class when the speed of Index() function is important, use
 647 // the normal arrays otherwise.
 648 // ----------------------------------------------------------------------------
 649
 650 #define wxARRAY_EMPTY_CMP
 651
 652 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 653     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 654                                              wxARRAY_DEFAULT_EXPORT)
 655
 656 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 657     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 658
 659 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 660     typedef T _wxArray##name;                                             \
 661     _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base,               \
 662                                 wxARRAY_EMPTY_CMP, class expmode)
 663
 664 // ----------------------------------------------------------------------------
 665 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 666 // function is provided by this macro and the objects of this class have a
 667 // default constructor which just uses it.
 668 //
 669 // The arguments are: the element type, the comparison function and the array
 670 // name
 671 //
 672 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 673 //     from the very beginning - unfortunately I didn't think about this earlier
 674 // ----------------------------------------------------------------------------
 675
 676 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 677     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 678                                                  wxARRAY_DEFAULT_EXPORT)
 679
 680 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 681     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 682                                                  WXDLLEXPORT)
 683
 684 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 685                                                      expmode)                \
 686     typedef T _wxArray##name;                                                \
 687     _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, = cmpfunc,       \
 688                                 class expmode)
 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