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