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   size_t 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   size_t 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 inline itor operator+(int o, const itor& it)               \
 354         { return it.m_ptr - o; }                                      \
 355     friend inline itor operator+(const itor& it, int o)               \
 356         { return it.m_ptr - o; }                                      \
 357     friend inline itor operator-(const itor& it, int o)               \
 358         { return it.m_ptr + o; }                                      \
 359     friend inline difference_type operator-(const itor& i1,           \
 360                                             const itor& i2)           \
 361         { return i1.m_ptr - i2.m_ptr; }                               \
 362                                                                       \
 363   public:                                                             \
 364     pointer m_ptr;                                                    \
 365     reverse_iterator() : m_ptr(NULL) { }                              \
 366     reverse_iterator(pointer ptr) : m_ptr(ptr) { }                    \
 367     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }            \
 368     reference operator*() const { return *m_ptr; }                    \
 369     pointer operator->() const { return m_ptr; }                      \
 370     itor operator++() { --m_ptr; return *this; }                      \
 371     itor operator++(int)                                              \
 372       { reverse_iterator tmp = *this; --m_ptr; return tmp; }          \
 373     itor operator--() { ++m_ptr; return *this; }                      \
 374     itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
 375     bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
 376     bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
 377   };                                                                  \
 378                                                                       \
 379   class const_reverse_iterator                                        \
 380   {                                                                   \
 381     typedef T value_type;                                             \
 382     typedef const value_type& reference;                              \
 383     typedef const value_type* pointer;                                \
 384     typedef const_reverse_iterator itor;                              \
 385     friend inline itor operator+(int o, const itor& it)               \
 386         { return it.m_ptr - o; }                                      \
 387     friend inline itor operator+(const itor& it, int o)               \
 388         { return it.m_ptr - o; }                                      \
 389     friend inline itor operator-(const itor& it, int o)               \
 390         { return it.m_ptr + o; }                                      \
 391     friend inline difference_type operator-(const itor& i1,           \
 392                                             const itor& i2)           \
 393         { return i1.m_ptr - i2.m_ptr; }                               \
 394                                                                       \
 395   public:                                                             \
 396     pointer m_ptr;                                                    \
 397     const_reverse_iterator() : m_ptr(NULL) { }                        \
 398     const_reverse_iterator(pointer ptr) : m_ptr(ptr) { }              \
 399     const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }      \
 400     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
 401     reference operator*() const { return *m_ptr; }                    \
 402     pointer operator->() const { return m_ptr; }                      \
 403     itor operator++() { --m_ptr; return *this; }                      \
 404     itor operator++(int)                                              \
 405       { itor tmp = *this; --m_ptr; return tmp; }                      \
 406     itor operator--() { ++m_ptr; return *this; }                      \
 407     itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }   \
 408     bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }    \
 409     bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }    \
 410   };                                                                  \
 411                                                                       \
 412   void assign(const_iterator first, const_iterator last)              \
 413     { base::assign((bconst_iterator)first, (bconst_iterator)last); }  \
 414   void assign(size_type n, const_reference v)                         \
 415     { base::assign(n, (bconst_reference)v); }                         \
 416   reference back() { return *(end() - 1); }                           \
 417   const_reference back() const { return *(end() - 1); }               \
 418   iterator begin() { return (iterator)base::begin(); }                \
 419   const_iterator begin() const { return (const_iterator)base::begin(); }\
 420   size_type capacity() const { return base::capacity(); }             \
 421   void clear() { base::clear(); }                                     \
 422   bool empty() const { return base::empty(); }                        \
 423   iterator end() { return (iterator)base::end(); }                    \
 424   const_iterator end() const { return (const_iterator)base::end(); }  \
 425   iterator erase(iterator first, iterator last)                       \
 426     { return (iterator)base::erase((biterator)first, (biterator)last); }\
 427   iterator erase(iterator it)                                         \
 428     { return (iterator)base::erase((biterator)it); }                  \
 429   reference front() { return *begin(); }                              \
 430   const_reference front() const { return *begin(); }                  \
 431   void insert(iterator it, size_type n, const_reference v)            \
 432     { base::insert((biterator)it, n, (bconst_reference)v); }          \
 433   iterator insert(iterator it, const_reference v = value_type())      \
 434     { return (iterator)base::insert((biterator)it, (bconst_reference)v); }\
 435   void insert(iterator it, const_iterator first, const_iterator last) \
 436     { base::insert((biterator)it, (bconst_iterator)first,             \
 437                    (bconst_iterator)last); }                          \
 438   size_type max_size() const { return base::max_size(); }             \
 439   void pop_back() { base::pop_back(); }                               \
 440   void push_back(const_reference v)                                   \
 441     { base::push_back((bconst_reference)v); }                         \
 442   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }   \
 443   const_reverse_iterator rbegin() const;                              \
 444   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
 445   const_reverse_iterator rend() const;                                \
 446   void reserve(size_type n) { base::reserve(n); };                    \
 447   void resize(size_type n, value_type v = value_type());              \
 448   size_type size() const { return base::size(); }                     \
 449 }
 450
 451
 452 #endif // !wxUSE_STL
 453
 454 // ----------------------------------------------------------------------------
 455 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
 456 //    cannot handle types with size greater than pointer because of sorting
 457 // ----------------------------------------------------------------------------
 458
 459 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
 460 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *),                   \
 461                        TypeTooBigToBeStoredInSorted##base,            \
 462                        name);                                         \
 463 classexp name : public base                                           \
 464 {                                                                     \
 465 public:                                                               \
 466   name(comptype fn defcomp) { m_fnCompare = fn; }                     \
 467                                                                       \
 468   name& operator=(const name& src)                                    \
 469     { base* temp = (base*) this;                                      \
 470       (*temp) = ((const base&)src);                                   \
 471       m_fnCompare = src.m_fnCompare;                                  \
 472       return *this; }                                                 \
 473                                                                       \
 474   T& operator[](size_t uiIndex) const                                 \
 475     { return (T&)(base::operator[](uiIndex)); }                       \
 476   T& Item(size_t uiIndex) const                                       \
 477     { return (T&)(base::operator[](uiIndex)); }                       \
 478   T& Last() const                                                     \
 479     { return (T&)(base::operator[](size() - 1)); }                    \
 480                                                                       \
 481   int Index(T Item) const                                             \
 482     { return base::Index(Item, (CMPFUNC)m_fnCompare); }               \
 483                                                                       \
 484   size_t IndexForInsert(T Item) const                                 \
 485     { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); }      \
 486                                                                       \
 487   void AddAt(T item, size_t index)                                    \
 488     { base::insert(begin() + index, item); }                          \
 489                                                                       \
 490   size_t Add(T Item)                                                  \
 491     { return base::Add(Item, (CMPFUNC)m_fnCompare); }                 \
 492                                                                       \
 493   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 494     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \
 495   void Remove(T Item)                                                 \
 496     { int iIndex = Index(Item);                                       \
 497       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 498         _WX_ERROR_REMOVE );                                           \
 499       base::erase(begin() + iIndex); }                                \
 500                                                                       \
 501 private:                                                              \
 502   comptype m_fnCompare;                                               \
 503 }
 504
 505
 506 // ----------------------------------------------------------------------------
 507 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
 508 // ----------------------------------------------------------------------------
 509
 510 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp)                    \
 511 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2);          \
 512 classexp name : protected base                                           \
 513 {                                                                        \
 514 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
 515 typedef base base_array;                                                 \
 516 public:                                                                  \
 517   name() { }                                                             \
 518   name(const name& src);                                                 \
 519   name& operator=(const name& src);                                      \
 520                                                                          \
 521   ~name();                                                               \
 522                                                                          \
 523   void Alloc(size_t count) { reserve(count); }                           \
 524   size_t GetCount() const { return base_array::size(); }                 \
 525   size_t size() const { return base_array::size(); }                     \
 526   bool IsEmpty() const { return base_array::empty(); }                   \
 527   size_t Count() const { return base_array::size(); }                    \
 528   void Shrink() { base::Shrink(); }                                      \
 529                                                                          \
 530   T& operator[](size_t uiIndex) const                                    \
 531     { return *(T*)base::operator[](uiIndex); }                           \
 532   T& Item(size_t uiIndex) const                                          \
 533     { return *(T*)base::operator[](uiIndex); }                           \
 534   T& Last() const                                                        \
 535     { return *(T*)(base::operator[](size() - 1)); }                      \
 536                                                                          \
 537   int Index(const T& Item, bool bFromEnd = FALSE) const;                 \
 538                                                                          \
 539   void Add(const T& Item, size_t nInsert = 1);                           \
 540   void Add(const T* pItem)                                               \
 541     { base::push_back((T*)pItem); }                                      \
 542   void push_back(const T* pItem)                                         \
 543     { base::push_back((T*)pItem); }                                      \
 544   void push_back(const T& Item)                                          \
 545     { Add(Item); }                                                       \
 546                                                                          \
 547   void Insert(const T& Item,  size_t uiIndex, size_t nInsert = 1);       \
 548   void Insert(const T* pItem, size_t uiIndex)                            \
 549     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
 550                                                                          \
 551   void Empty() { DoEmpty(); base::clear(); }                             \
 552   void Clear() { DoEmpty(); base::clear(); }                             \
 553                                                                          \
 554   T* Detach(size_t uiIndex)                                              \
 555     { T* p = (T*)base::operator[](uiIndex);                              \
 556       base::erase(begin() + uiIndex); return p; }                        \
 557   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
 558                                                                          \
 559   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
 560                                                                          \
 561 private:                                                                 \
 562   void DoEmpty();                                                        \
 563   void DoCopy(const name& src);                                          \
 564 }
 565
 566 // ============================================================================
 567 // The public macros for declaration and definition of the dynamic arrays
 568 // ============================================================================
 569
 570 // Please note that for each macro WX_FOO_ARRAY we also have
 571 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
 572 // same except that they use an additional __declspec(dllexport) or equivalent
 573 // under Windows if needed.
 574 //
 575 // The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
 576 // and so must be used used inside the library. The second kind (USER_EXPORTED)
 577 // allow the user code to do it when it wants. This is needed if you have a dll
 578 // that wants to export a wxArray daubed with your own import/export goo.
 579 //
 580 // Finally, you can define the macro below as something special to modify the
 581 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
 582 #define wxARRAY_DEFAULT_EXPORT
 583
 584 // ----------------------------------------------------------------------------
 585 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
 586 // the elements of type T
 587 // ----------------------------------------------------------------------------
 588
 589 #define WX_DECLARE_BASEARRAY(T, name)                             \
 590     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 591
 592 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name)                    \
 593     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
 594
 595 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode)      \
 596     typedef T _wxArray##name;                                     \
 597     _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
 598
 599 // ----------------------------------------------------------------------------
 600 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
 601 // from class "base" containing the elements of type T
 602 //
 603 // Note that the class defined has only inline function and doesn't take any
 604 // space at all so there is no size penalty for defining multiple array classes
 605 // ----------------------------------------------------------------------------
 606
 607 #define WX_DEFINE_TYPEARRAY(T, name, base)                        \
 608     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 609
 610 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base)               \
 611     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
 612
 613 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
 614     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
 615
 616 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
 617     typedef T _wxArray##name;                                   \
 618     _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
 619
 620 // ----------------------------------------------------------------------------
 621 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
 622 // defines a sorted array.
 623 //
 624 // Differences:
 625 //  1) it must be given a COMPARE function in ctor which takes 2 items of type
 626 //     T* and should return -1, 0 or +1 if the first one is less/greater
 627 //     than/equal to the second one.
 628 //  2) the Add() method inserts the item in such was that the array is always
 629 //     sorted (it uses the COMPARE function)
 630 //  3) it has no Sort() method because it's always sorted
 631 //  4) Index() method is much faster (the sorted arrays use binary search
 632 //     instead of linear one), but Add() is slower.
 633 //  5) there is no Insert() method because you can't insert an item into the
 634 //     given position in a sorted array but there is IndexForInsert()/AddAt()
 635 //     pair which may be used to optimize a common operation of "insert only if
 636 //     not found"
 637 //
 638 // Note that you have to specify the comparison function when creating the
 639 // objects of this array type. If, as in 99% of cases, the comparison function
 640 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
 641 // is more convenient.
 642 //
 643 // Summary: use this class when the speed of Index() function is important, use
 644 // the normal arrays otherwise.
 645 // ----------------------------------------------------------------------------
 646
 647 #define wxARRAY_EMPTY_CMP
 648
 649 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 650     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 651                                              wxARRAY_DEFAULT_EXPORT)
 652
 653 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 654     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 655
 656 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 657     typedef T _wxArray##name;                                             \
 658     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);       \
 659     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base,             \
 660                                 wxARRAY_EMPTY_CMP, class expmode, SCMPFUNC##name)
 661
 662 // ----------------------------------------------------------------------------
 663 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 664 // function is provided by this macro and the objects of this class have a
 665 // default constructor which just uses it.
 666 //
 667 // The arguments are: the element type, the comparison function and the array
 668 // name
 669 //
 670 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 671 //     from the very beginning - unfortunately I didn't think about this earlier
 672 // ----------------------------------------------------------------------------
 673
 674 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 675     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 676                                                  wxARRAY_DEFAULT_EXPORT)
 677
 678 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 679     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 680                                                  WXDLLEXPORT)
 681
 682 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 683                                                      expmode)                \
 684     typedef T _wxArray##name;                                                \
 685     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);          \
 686     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, = cmpfunc,     \
 687                                 class expmode, SCMPFUNC##name)
 688
 689 // ----------------------------------------------------------------------------
 690 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
 691 // named "name" which owns the objects of type T it contains, i.e. it will
 692 // delete them when it is destroyed.
 693 //
 694 // An element is of type T*, but arguments of type T& are taken (see below!)
 695 // and T& is returned.
 696 //
 697 // Don't use this for simple types such as "int" or "long"!
 698 //
 699 // Note on Add/Insert functions:
 700 //  1) function(T*) gives the object to the array, i.e. it will delete the
 701 //     object when it's removed or in the array's dtor
 702 //  2) function(T&) will create a copy of the object and work with it
 703 //
 704 // Also:
 705 //  1) Remove() will delete the object after removing it from the array
 706 //  2) Detach() just removes the object from the array (returning pointer to it)
 707 //
 708 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
 709 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
 710 //      and so you risk having at least the memory leaks and probably worse
 711 //
 712 // Some functions of this class are not inline, so it takes some space to
 713 // define new class from this template even if you don't use it - which is not
 714 // the case for the simple (non-object) array classes
 715 //
 716 // To use an objarray class you must
 717 //      #include "dynarray.h"
 718 //      WX_DECLARE_OBJARRAY(element_type, list_class_name)
 719 //      #include "arrimpl.cpp"
 720 //      WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
 721 //
 722 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
 723 // element_type must be fully defined (i.e. forward declaration is not
 724 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
 725 // two allows to break cicrcular dependencies with classes which have member
 726 // variables of objarray type.
 727 // ----------------------------------------------------------------------------
 728
 729 #define WX_DECLARE_OBJARRAY(T, name)                        \
 730     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 731
 732 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name)               \
 733     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
 734
 735 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
 736     typedef T _wxObjArray##name;                            \
 737     _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
 738
 739 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
 740 // try to provoke a human-understandable error if it used incorrectly.
 741 //
 742 // there is no real need for 3 different macros in the DEFINE case but do it
 743 // anyhow for consistency
 744 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
 745 #define WX_DEFINE_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 746 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 747
 748 // ----------------------------------------------------------------------------
 749 // Some commonly used predefined base arrays
 750 // ----------------------------------------------------------------------------
 751
 752 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
 753                                    WXDLLIMPEXP_BASE);
 754 WX_DECLARE_USER_EXPORTED_BASEARRAY(short,        wxBaseArrayShort,
 755                                    WXDLLIMPEXP_BASE);
 756 WX_DECLARE_USER_EXPORTED_BASEARRAY(int,          wxBaseArrayInt,
 757                                    WXDLLIMPEXP_BASE);
 758 WX_DECLARE_USER_EXPORTED_BASEARRAY(long,         wxBaseArrayLong,
 759                                    WXDLLIMPEXP_BASE);
 760 WX_DECLARE_USER_EXPORTED_BASEARRAY(double,       wxBaseArrayDouble,
 761                                    WXDLLIMPEXP_BASE);
 762
 763 // ----------------------------------------------------------------------------
 764 // Convenience macros to define arrays from base arrays
 765 // ----------------------------------------------------------------------------
 766
 767 #define WX_DEFINE_ARRAY(T, name)                                       \
 768     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 769 #define WX_DEFINE_EXPORTED_ARRAY(T, name)                              \
 770     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 771 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode)                \
 772     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
 773
 774 #define WX_DEFINE_ARRAY_SHORT(T, name)                                 \
 775     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort)
 776 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name)                        \
 777     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 778 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)          \
 779     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayShort, expmode)
 780
 781 #define WX_DEFINE_ARRAY_INT(T, name)                                   \
 782     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt)
 783 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name)                          \
 784     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 785 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode)            \
 786     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayInt, expmode)
 787
 788 #define WX_DEFINE_ARRAY_LONG(T, name)                                  \
 789     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong)
 790 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name)                         \
 791     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 792 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode)           \
 793     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayLong, expmode)
 794
 795 #define WX_DEFINE_ARRAY_DOUBLE(T, name)                                \
 796     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble)
 797 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name)                       \
 798     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble)
 799 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode)         \
 800     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayDouble, expmode)
 801
 802 // ----------------------------------------------------------------------------
 803 // Convenience macros to define sorted arrays from base arrays
 804 // ----------------------------------------------------------------------------
 805
 806 #define WX_DEFINE_SORTED_ARRAY(T, name)                                \
 807     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 808 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)                       \
 809     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 810 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode)         \
 811     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
 812
 813 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name)                          \
 814     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 815 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name)                 \
 816     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 817 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)   \
 818     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
 819
 820 #define WX_DEFINE_SORTED_ARRAY_INT(T, name)                            \
 821     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 822 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name)                   \
 823     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 824 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode)     \
 825     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
 826
 827 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name)                           \
 828     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 829 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name)                  \
 830     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 831 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode)    \
 832     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
 833
 834 // ----------------------------------------------------------------------------
 835 // Convenience macros to define sorted arrays from base arrays
 836 // ----------------------------------------------------------------------------
 837
 838 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name)                   \
 839     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 840 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name)          \
 841     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 842 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc,           \
 843                                                      name, expmode)    \
 844     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 845                                                  wxBaseArrayPtrVoid, expmode)
 846
 847 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)             \
 848     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 849 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)    \
 850     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 851 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc,     \
 852                                                        name, expmode)  \
 853     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 854                                                  wxBaseArrayShort, expmode)
 855
 856 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name)               \
 857     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 858 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name)      \
 859     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 860 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc,       \
 861                                                      name, expmode)    \
 862     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 863                                                  wxBaseArrayInt, expmode)
 864
 865 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name)              \
 866     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 867 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name)     \
 868     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 869 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc,      \
 870                                                       name, expmode)   \
 871     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 872                                                  wxBaseArrayLong, expmode)
 873
 874 // ----------------------------------------------------------------------------
 875 // Some commonly used predefined arrays
 876 // ----------------------------------------------------------------------------
 877
 878 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT (short,  wxArrayShort,   class WXDLLIMPEXP_BASE);
 879 WX_DEFINE_USER_EXPORTED_ARRAY_INT   (int,    wxArrayInt,     class WXDLLIMPEXP_BASE);
 880 WX_DEFINE_USER_EXPORTED_ARRAY_LONG  (long,   wxArrayLong,    class WXDLLIMPEXP_BASE);
 881 WX_DEFINE_USER_EXPORTED_ARRAY       (void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 882
 883 // -----------------------------------------------------------------------------
 884 // convenience macros
 885 // -----------------------------------------------------------------------------
 886
 887 // append all element of one array to another one
 888 #define WX_APPEND_ARRAY(array, other)                                         \
 889     {                                                                         \
 890         size_t count = (other).size();                                        \
 891         for ( size_t n = 0; n < count; n++ )                                  \
 892         {                                                                     \
 893             (array).push_back((other)[n]);                                    \
 894         }                                                                     \
 895     }
 896
 897 // delete all array elements
 898 //
 899 // NB: the class declaration of the array elements must be visible from the
 900 //     place where you use this macro, otherwise the proper destructor may not
 901 //     be called (a decent compiler should give a warning about it, but don't
 902 //     count on it)!
 903 #define WX_CLEAR_ARRAY(array)                                                 \
 904     {                                                                         \
 905         size_t count = (array).size();                                        \
 906         for ( size_t n = 0; n < count; n++ )                                  \
 907         {                                                                     \
 908             delete (array)[n];                                                \
 909         }                                                                     \
 910                                                                               \
 911         (array).clear();                                                      \
 912     }
 913
 914 #endif // _DYNARRAY_H
 915