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 #include "wx/defs.h"
  16
  17 #if wxUSE_STL
  18     #include "wx/beforestd.h"
  19     #include <vector>
  20     #include <algorithm>
  21     #include "wx/afterstd.h"
  22 #endif
  23
  24 /*
  25   This header defines the dynamic arrays and object arrays (i.e. arrays which
  26   own their elements). Dynamic means that the arrays grow automatically as
  27   needed.
  28
  29   These macros are ugly (especially if you look in the sources ;-), but they
  30   allow us to define "template" classes without actually using templates and so
  31   this works with all compilers (and may be also much faster to compile even
  32   with a compiler which does support templates). The arrays defined with these
  33   macros are type-safe.
  34
  35   Range checking is performed in debug build for both arrays and objarrays but
  36   not in release build - so using an invalid index will just lead to a crash
  37   then.
  38
  39   Note about memory usage: arrays never shrink automatically (although you may
  40   use Shrink() function explicitly), they only grow, so loading 10 millions in
  41   an array only to delete them 2 lines below might be a bad idea if the array
  42   object is not going to be destroyed soon. However, as it does free memory
  43   when destroyed, it is ok if the array is a local variable.
  44  */
  45
  46 // ----------------------------------------------------------------------------
  47 // constants
  48 // ----------------------------------------------------------------------------
  49
  50 /*
  51    The initial size by which an array grows when an element is added default
  52    value avoids allocate one or two bytes when the array is created which is
  53    rather inefficient
  54 */
  55 #define WX_ARRAY_DEFAULT_INITIAL_SIZE    (16)
  56
  57 // ----------------------------------------------------------------------------
  58 // types
  59 // ----------------------------------------------------------------------------
  60
  61 /*
  62     Callback compare function for quick sort.
  63
  64     It must return negative value, 0 or positive value if the first item is
  65     less than, equal to or greater than the second one.
  66  */
  67 extern "C"
  68 {
  69 typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
  70 }
  71
  72 // ----------------------------------------------------------------------------
  73 // Base class managing data having size of type 'long' (not used directly)
  74 //
  75 // NB: for efficiency this often used class has no virtual functions (hence no
  76 //     virtual table), even dtor is *not* virtual. If used as expected it
  77 //     won't create any problems because ARRAYs from DEFINE_ARRAY have no dtor
  78 //     at all, so it's not too important if it's not called (this happens when
  79 //     you cast "SomeArray *" as "BaseArray *" and then delete it)
  80 // ----------------------------------------------------------------------------
  81
  82 #if wxUSE_STL
  83
  84 template<class T>
  85 class WXDLLIMPEXP_BASE wxArray_SortFunction
  86 {
  87 public:
  88     typedef int (wxCMPFUNC_CONV *CMPFUNC)(T* pItem1, T* pItem2);
  89
  90     wxArray_SortFunction(CMPFUNC f) : m_f(f) { }
  91     bool operator()(const T& i1, const T& i2)
  92       { return m_f((T*)&i1, (T*)&i2) < 0; }
  93 private:
  94     CMPFUNC m_f;
  95 };
  96
  97 template<class T, typename F>
  98 class WXDLLIMPEXP_BASE wxSortedArray_SortFunction
  99 {
 100 public:
 101     typedef F CMPFUNC;
 102
 103     wxSortedArray_SortFunction(CMPFUNC f) : m_f(f) { }
 104     bool operator()(const T& i1, const T& i2)
 105       { return m_f(i1, i2) < 0; }
 106 private:
 107     CMPFUNC m_f;
 108 };
 109
 110 #define  _WX_DECLARE_BASEARRAY(T, name, classexp)                   \
 111    typedef int (wxCMPFUNC_CONV *CMPFUN##name)(T pItem1, T pItem2);  \
 112    typedef wxSortedArray_SortFunction<T, CMPFUN##name> name##_Predicate; \
 113    _WX_DECLARE_BASEARRAY_2(T, name, name##_Predicate, classexp)
 114
 115 #define  _WX_DECLARE_BASEARRAY_2(T, name, predicate, classexp)      \
 116 classexp name : public std::vector<T>                               \
 117 {                                                                   \
 118   typedef predicate Predicate;                                      \
 119   typedef predicate::CMPFUNC SCMPFUNC;                              \
 120 public:                                                             \
 121   typedef wxArray_SortFunction<T>::CMPFUNC CMPFUNC;                 \
 122 public:                                                             \
 123   void Empty() { clear(); }                                         \
 124   void Clear() { clear(); }                                         \
 125   void Alloc(size_t uiSize) { reserve(uiSize); }                    \
 126   void Shrink();                                                    \
 127                                                                     \
 128   size_t GetCount() const { return size(); }                        \
 129   void SetCount(size_t n, T v = T()) { resize(n, v); }              \
 130   bool IsEmpty() const { return empty(); }                          \
 131   size_t Count() const { return size(); }                           \
 132                                                                     \
 133   typedef T base_type;                                              \
 134                                                                     \
 135 protected:                                                          \
 136   T& Item(size_t uiIndex) const                                     \
 137     { wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); }   \
 138                                                                     \
 139   int Index(T e, bool bFromEnd = false) const;                      \
 140   int Index(T lItem, CMPFUNC fnCompare) const;                      \
 141   size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const;          \
 142   void Add(T lItem, size_t nInsert = 1)                             \
 143     { insert(end(), nInsert, lItem); }                              \
 144   size_t Add(T lItem, CMPFUNC fnCompare);                           \
 145   void Insert(T lItem, size_t uiIndex, size_t nInsert = 1)          \
 146     { insert(begin() + uiIndex, nInsert, lItem); }                  \
 147   void Remove(T lItem);                                             \
 148   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                 \
 149     { erase(begin() + uiIndex, begin() + uiIndex + nRemove); }      \
 150                                                                     \
 151   void Sort(CMPFUNC fCmp)                                           \
 152   {                                                                 \
 153     wxArray_SortFunction<T> p(fCmp);                                \
 154     std::sort(begin(), end(), p);                                   \
 155   }                                                                 \
 156 }
 157
 158 #else // if !wxUSE_STL
 159
 160 #define  _WX_DECLARE_BASEARRAY(T, name, classexp)                   \
 161 classexp name                                                       \
 162 {                                                                   \
 163   typedef CMPFUNC SCMPFUNC; /* for compatibility wuth wxUSE_STL */  \
 164 public:                                                             \
 165   name();                                                           \
 166   name(const name& array);                                          \
 167   name& operator=(const name& src);                                 \
 168   ~name();                                                          \
 169                                                                     \
 170   void Empty() { m_nCount = 0; }                                    \
 171   void Clear();                                                     \
 172   void Alloc(size_t uiSize);                                        \
 173   void Shrink();                                                    \
 174                                                                     \
 175   size_t GetCount() const { return m_nCount; }                      \
 176   void SetCount(size_t n, T defval = T());                          \
 177   bool IsEmpty() const { return m_nCount == 0; }                    \
 178   size_t Count() const { return m_nCount; }                         \
 179                                                                     \
 180   typedef T base_type;                                              \
 181                                                                     \
 182 protected:                                                          \
 183   T& Item(size_t uiIndex) const                                     \
 184     { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; }   \
 185   T& operator[](size_t uiIndex) const { return Item(uiIndex); }     \
 186                                                                     \
 187   int Index(T lItem, bool bFromEnd = false) const;                  \
 188   int Index(T lItem, CMPFUNC fnCompare) const;                      \
 189   size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const;          \
 190   void Add(T lItem, size_t nInsert = 1);                            \
 191   size_t Add(T lItem, CMPFUNC fnCompare);                           \
 192   void Insert(T lItem, size_t uiIndex, size_t nInsert = 1);         \
 193   void Remove(T lItem);                                             \
 194   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                \
 195                                                                     \
 196   void Sort(CMPFUNC fnCompare);                                     \
 197                                                                     \
 198   /* *minimal* STL-ish interface, for derived classes */            \
 199   typedef T value_type;                                             \
 200   typedef value_type* iterator;                                     \
 201   typedef const value_type* const_iterator;                         \
 202   typedef value_type& reference;                                    \
 203   typedef const value_type& const_reference;                        \
 204   typedef int difference_type;                                      \
 205   typedef size_t size_type;                                         \
 206                                                                     \
 207   void assign(const_iterator first, const_iterator last);           \
 208   void assign(size_type n, const_reference v);                      \
 209   size_type capacity() const { return m_nSize; }                    \
 210   iterator erase(iterator first, iterator last)                     \
 211   {                                                                 \
 212     size_type idx = first - begin();                                \
 213     RemoveAt(idx, last - first);                                    \
 214     return begin() + idx;                                           \
 215   }                                                                 \
 216   iterator erase(iterator it) { return erase(it, it + 1); }         \
 217   void insert(iterator it, size_type n, const value_type& v)        \
 218     { Insert(v, it - begin(), n); }                                 \
 219   iterator insert(iterator it, const value_type& v = value_type())  \
 220   {                                                                 \
 221     size_type idx = it - begin();                                   \
 222     Insert(v, idx);                                                 \
 223     return begin() + idx;                                           \
 224   }                                                                 \
 225   void insert(iterator it, const_iterator first, const_iterator last);\
 226   void pop_back() { RemoveAt(size() - 1); }                         \
 227   void push_back(const value_type& v) { Add(v); }                   \
 228   void reserve(size_type n) { if(n > m_nSize) Realloc(n); }         \
 229   void resize(size_type n, value_type v = value_type())             \
 230     { SetCount(n, v); }                                             \
 231                                                                     \
 232   iterator begin() { return m_pItems; }                             \
 233   iterator end() { return m_pItems + m_nCount; }                    \
 234   const_iterator begin() const { return m_pItems; }                 \
 235   const_iterator end() const { return m_pItems + m_nCount; }        \
 236                                                                     \
 237   /* the following functions may be made directly public because */ \
 238   /* they don't use the type of the elements at all */              \
 239 public:                                                             \
 240   void clear() { Clear(); }                                         \
 241   bool empty() const { return IsEmpty(); }                          \
 242   size_type max_size() const { return INT_MAX; }                    \
 243   size_type size() const { return GetCount(); }                     \
 244                                                                     \
 245 private:                                                            \
 246   void Grow(size_t nIncrement = 0);                                 \
 247   bool Realloc(size_t nSize);                                       \
 248                                                                     \
 249   size_t  m_nSize,                                                  \
 250           m_nCount;                                                 \
 251                                                                     \
 252   T      *m_pItems;                                                 \
 253 }
 254
 255 #endif // !wxUSE_STL
 256
 257 // ============================================================================
 258 // The private helper macros containing the core of the array classes
 259 // ============================================================================
 260
 261 // Implementation notes:
 262 //
 263 // JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
 264 //          { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 265 //       so using a temporary variable instead.
 266 //
 267 // The classes need a (even trivial) ~name() to link under Mac X
 268 //
 269 // _WX_ERROR_REMOVE is needed to resolve the name conflict between the wxT()
 270 // macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
 271
 272 #define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
 273
 274 // ----------------------------------------------------------------------------
 275 // _WX_DEFINE_TYPEARRAY: array for simple types
 276 // ----------------------------------------------------------------------------
 277
 278 #if wxUSE_STL
 279
 280 #define  _WX_DEFINE_TYPEARRAY(T, name, base, classexp)                \
 281 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);         \
 282 classexp name : public base                                           \
 283 {                                                                     \
 284 public:                                                               \
 285   T& operator[](size_t uiIndex) const                                 \
 286     { return (T&)(base::operator[](uiIndex)); }                       \
 287   T& Item(size_t uiIndex) const                                       \
 288     { return (T&)/*const cast*/base::operator[](uiIndex); }           \
 289   T& Last() const                                                     \
 290     { return Item(Count() - 1); }                                     \
 291                                                                       \
 292   int Index(T e, bool bFromEnd = false) const                         \
 293     { return base::Index(e, bFromEnd); }                              \
 294                                                                       \
 295   void Add(T lItem, size_t nInsert = 1)                               \
 296     { insert(end(), nInsert, lItem); }                                \
 297   void Insert(T lItem, size_t uiIndex, size_t nInsert = 1)            \
 298     { insert(begin() + uiIndex, nInsert, lItem); }                    \
 299                                                                       \
 300   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 301     { base::RemoveAt(uiIndex, nRemove); }                             \
 302   void Remove(T lItem)                                                \
 303     { int iIndex = Index(lItem);                                      \
 304       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 305          _WX_ERROR_REMOVE);                                           \
 306       RemoveAt((size_t)iIndex); }                                     \
 307                                                                       \
 308   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); }           \
 309 }
 310
 311 #define  _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp)         \
 312          _WX_DEFINE_TYPEARRAY(T, name, base, classexp)
 313
 314 #else // if !wxUSE_STL
 315
 316 // common declaration used by both _WX_DEFINE_TYPEARRAY and
 317 // _WX_DEFINE_TYPEARRAY_PTR
 318 #define  _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, ptrop)  \
 319 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
 320                        TypeTooBigToBeStoredIn##base,                  \
 321                        name);                                         \
 322 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);         \
 323 classexp name : public base                                           \
 324 {                                                                     \
 325 public:                                                               \
 326   name() { }                                                          \
 327   ~name() { }                                                         \
 328                                                                       \
 329   name& operator=(const name& src)                                    \
 330     { base* temp = (base*) this;                                      \
 331       (*temp) = ((const base&)src);                                   \
 332       return *this; }                                                 \
 333                                                                       \
 334   T& operator[](size_t uiIndex) const                                 \
 335     { return (T&)(base::operator[](uiIndex)); }                       \
 336   T& Item(size_t uiIndex) const                                       \
 337     { return (T&)(base::operator[](uiIndex)); }                       \
 338   T& Last() const                                                     \
 339     { return (T&)(base::operator[](Count() - 1)); }                   \
 340                                                                       \
 341   int Index(T lItem, bool bFromEnd = false) const                     \
 342     { return base::Index((base_type)lItem, bFromEnd); }               \
 343                                                                       \
 344   void Add(T lItem, size_t nInsert = 1)                               \
 345     { base::Add((base_type)lItem, nInsert); }                         \
 346   void Insert(T lItem, size_t uiIndex, size_t nInsert = 1)            \
 347     { base::Insert((base_type)lItem, uiIndex, nInsert) ; }            \
 348                                                                       \
 349   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 350     { base::RemoveAt(uiIndex, nRemove); }                             \
 351   void Remove(T lItem)                                                \
 352     { int iIndex = Index(lItem);                                      \
 353       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 354          _WX_ERROR_REMOVE);                                           \
 355       base::RemoveAt((size_t)iIndex); }                               \
 356                                                                       \
 357   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); }           \
 358                                                                       \
 359   /* STL-like interface */                                            \
 360 private:                                                              \
 361   typedef base::iterator biterator;                                   \
 362   typedef base::const_iterator bconst_iterator;                       \
 363   typedef base::value_type bvalue_type;                               \
 364   typedef base::const_reference bconst_reference;                     \
 365 public:                                                               \
 366   typedef T value_type;                                               \
 367   typedef value_type* pointer;                                        \
 368   typedef const value_type* const_pointer;                            \
 369   typedef value_type* iterator;                                       \
 370   typedef const value_type* const_iterator;                           \
 371   typedef value_type& reference;                                      \
 372   typedef const value_type& const_reference;                          \
 373   typedef base::difference_type difference_type;                      \
 374   typedef base::size_type size_type;                                  \
 375                                                                       \
 376   class reverse_iterator                                              \
 377   {                                                                   \
 378     typedef T value_type;                                             \
 379     typedef value_type& reference;                                    \
 380     typedef value_type* pointer;                                      \
 381     typedef reverse_iterator itor;                                    \
 382     friend inline itor operator+(int o, const itor& it)               \
 383         { return it.m_ptr - o; }                                      \
 384     friend inline itor operator+(const itor& it, int o)               \
 385         { return it.m_ptr - o; }                                      \
 386     friend inline itor operator-(const itor& it, int o)               \
 387         { return it.m_ptr + o; }                                      \
 388     friend inline difference_type operator-(const itor& i1,           \
 389                                             const itor& i2)           \
 390         { return i1.m_ptr - i2.m_ptr; }                               \
 391                                                                       \
 392   public:                                                             \
 393     pointer m_ptr;                                                    \
 394     reverse_iterator() : m_ptr(NULL) { }                              \
 395     reverse_iterator(pointer ptr) : m_ptr(ptr) { }                    \
 396     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }            \
 397     reference operator*() const { return *m_ptr; }                    \
 398     ptrop                                                             \
 399     itor& operator++() { --m_ptr; return *this; }                     \
 400     const itor operator++(int)                                        \
 401       { reverse_iterator tmp = *this; --m_ptr; return tmp; }          \
 402     itor& operator--() { ++m_ptr; return *this; }                     \
 403     const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
 404     bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }\
 405     bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }\
 406   };                                                                  \
 407                                                                       \
 408   class const_reverse_iterator                                        \
 409   {                                                                   \
 410     typedef T value_type;                                             \
 411     typedef const value_type& reference;                              \
 412     typedef const value_type* pointer;                                \
 413     typedef const_reverse_iterator itor;                              \
 414     friend inline itor operator+(int o, const itor& it)               \
 415         { return it.m_ptr - o; }                                      \
 416     friend inline itor operator+(const itor& it, int o)               \
 417         { return it.m_ptr - o; }                                      \
 418     friend inline itor operator-(const itor& it, int o)               \
 419         { return it.m_ptr + o; }                                      \
 420     friend inline difference_type operator-(const itor& i1,           \
 421                                             const itor& i2)           \
 422         { return i1.m_ptr - i2.m_ptr; }                               \
 423                                                                       \
 424   public:                                                             \
 425     pointer m_ptr;                                                    \
 426     const_reverse_iterator() : m_ptr(NULL) { }                        \
 427     const_reverse_iterator(pointer ptr) : m_ptr(ptr) { }              \
 428     const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }      \
 429     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }\
 430     reference operator*() const { return *m_ptr; }                    \
 431     ptrop                                                             \
 432     itor& operator++() { --m_ptr; return *this; }                     \
 433     const itor operator++(int)                                        \
 434       { itor tmp = *this; --m_ptr; return tmp; }                      \
 435     itor& operator--() { ++m_ptr; return *this; }                     \
 436     const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }\
 437     bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }\
 438     bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }\
 439   };                                                                  \
 440                                                                       \
 441   name(size_type n, const_reference v) { assign(n, v); }              \
 442   name(const_iterator first, const_iterator last)                     \
 443     { assign(first, last); }                                          \
 444   void assign(const_iterator first, const_iterator last)              \
 445     { base::assign((bconst_iterator)first, (bconst_iterator)last); }  \
 446   void assign(size_type n, const_reference v)                         \
 447     { base::assign(n, (bconst_reference)v); }                         \
 448   reference back() { return *(end() - 1); }                           \
 449   const_reference back() const { return *(end() - 1); }               \
 450   iterator begin() { return (iterator)base::begin(); }                \
 451   const_iterator begin() const { return (const_iterator)base::begin(); }\
 452   size_type capacity() const { return base::capacity(); }             \
 453   iterator end() { return (iterator)base::end(); }                    \
 454   const_iterator end() const { return (const_iterator)base::end(); }  \
 455   iterator erase(iterator first, iterator last)                       \
 456     { return (iterator)base::erase((biterator)first, (biterator)last); }\
 457   iterator erase(iterator it)                                         \
 458     { return (iterator)base::erase((biterator)it); }                  \
 459   reference front() { return *begin(); }                              \
 460   const_reference front() const { return *begin(); }                  \
 461   void insert(iterator it, size_type n, const_reference v)            \
 462     { base::insert((biterator)it, n, (bconst_reference)v); }          \
 463   iterator insert(iterator it, const_reference v = value_type())      \
 464     { return (iterator)base::insert((biterator)it, (bconst_reference)v); }\
 465   void insert(iterator it, const_iterator first, const_iterator last) \
 466     { base::insert((biterator)it, (bconst_iterator)first,             \
 467                    (bconst_iterator)last); }                          \
 468   void pop_back() { base::pop_back(); }                               \
 469   void push_back(const_reference v)                                   \
 470     { base::push_back((bconst_reference)v); }                         \
 471   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }   \
 472   const_reverse_iterator rbegin() const;                              \
 473   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
 474   const_reverse_iterator rend() const;                                \
 475   void reserve(size_type n) { base::reserve(n); };                    \
 476   void resize(size_type n, value_type v = value_type())               \
 477     { base::resize(n, v); }                                           \
 478 }
 479
 480 #define _WX_PTROP pointer operator->() const { return m_ptr; }
 481 #define _WX_PTROP_NONE
 482
 483 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp)                 \
 484     _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP)
 485 #define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp)          \
 486     _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP_NONE)
 487
 488 #endif // !wxUSE_STL
 489
 490 // ----------------------------------------------------------------------------
 491 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
 492 //    cannot handle types with size greater than pointer because of sorting
 493 // ----------------------------------------------------------------------------
 494
 495 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
 496 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
 497                        TypeTooBigToBeStoredInSorted##base,            \
 498                        name);                                         \
 499 classexp name : public base                                           \
 500 {                                                                     \
 501   typedef comptype SCMPFUNC;                                          \
 502 public:                                                               \
 503   name(comptype fn defcomp) { m_fnCompare = fn; }                     \
 504                                                                       \
 505   name& operator=(const name& src)                                    \
 506     { base* temp = (base*) this;                                      \
 507       (*temp) = ((const base&)src);                                   \
 508       m_fnCompare = src.m_fnCompare;                                  \
 509       return *this; }                                                 \
 510                                                                       \
 511   T& operator[](size_t uiIndex) const                                 \
 512     { return (T&)(base::operator[](uiIndex)); }                       \
 513   T& Item(size_t uiIndex) const                                       \
 514     { return (T&)(base::operator[](uiIndex)); }                       \
 515   T& Last() const                                                     \
 516     { return (T&)(base::operator[](size() - 1)); }                    \
 517                                                                       \
 518   int Index(T lItem) const                                            \
 519     { return base::Index(lItem, (CMPFUNC)m_fnCompare); }              \
 520                                                                       \
 521   size_t IndexForInsert(T lItem) const                                \
 522     { return base::IndexForInsert(lItem, (CMPFUNC)m_fnCompare); }     \
 523                                                                       \
 524   void AddAt(T item, size_t index)                                    \
 525     { base::insert(begin() + index, item); }                          \
 526                                                                       \
 527   size_t Add(T lItem)                                                 \
 528     { return base::Add(lItem, (CMPFUNC)m_fnCompare); }                \
 529                                                                       \
 530   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 531     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \
 532   void Remove(T lItem)                                                \
 533     { int iIndex = Index(lItem);                                      \
 534       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 535         _WX_ERROR_REMOVE );                                           \
 536       base::erase(begin() + iIndex); }                                \
 537                                                                       \
 538 private:                                                              \
 539   comptype m_fnCompare;                                               \
 540 }
 541
 542
 543 // ----------------------------------------------------------------------------
 544 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
 545 // ----------------------------------------------------------------------------
 546
 547 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp)                    \
 548 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2);          \
 549 classexp name : protected base                                           \
 550 {                                                                        \
 551 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
 552 typedef base base_array;                                                 \
 553 public:                                                                  \
 554   name() { }                                                             \
 555   name(const name& src);                                                 \
 556   name& operator=(const name& src);                                      \
 557                                                                          \
 558   ~name();                                                               \
 559                                                                          \
 560   void Alloc(size_t count) { reserve(count); }                           \
 561   size_t GetCount() const { return base_array::size(); }                 \
 562   size_t size() const { return base_array::size(); }                     \
 563   bool IsEmpty() const { return base_array::empty(); }                   \
 564   bool empty() const { return base_array::empty(); }                     \
 565   size_t Count() const { return base_array::size(); }                    \
 566   void Shrink() { base::Shrink(); }                                      \
 567                                                                          \
 568   T& operator[](size_t uiIndex) const                                    \
 569     { return *(T*)base::operator[](uiIndex); }                           \
 570   T& Item(size_t uiIndex) const                                          \
 571     { return *(T*)base::operator[](uiIndex); }                           \
 572   T& Last() const                                                        \
 573     { return *(T*)(base::operator[](size() - 1)); }                      \
 574                                                                          \
 575   int Index(const T& lItem, bool bFromEnd = false) const;                \
 576                                                                          \
 577   void Add(const T& lItem, size_t nInsert = 1);                          \
 578   void Add(const T* pItem)                                               \
 579     { base::push_back((T*)pItem); }                                      \
 580   void push_back(const T* pItem)                                         \
 581     { base::push_back((T*)pItem); }                                      \
 582   void push_back(const T& lItem)                                         \
 583     { Add(lItem); }                                                      \
 584                                                                          \
 585   void Insert(const T& lItem,  size_t uiIndex, size_t nInsert = 1);      \
 586   void Insert(const T* pItem, size_t uiIndex)                            \
 587     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
 588                                                                          \
 589   void Empty() { DoEmpty(); base::clear(); }                             \
 590   void Clear() { DoEmpty(); base::clear(); }                             \
 591                                                                          \
 592   T* Detach(size_t uiIndex)                                              \
 593     { T* p = (T*)base::operator[](uiIndex);                              \
 594       base::erase(begin() + uiIndex); return p; }                        \
 595   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
 596                                                                          \
 597   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
 598                                                                          \
 599 private:                                                                 \
 600   void DoEmpty();                                                        \
 601   void DoCopy(const name& src);                                          \
 602 }
 603
 604 // ============================================================================
 605 // The public macros for declaration and definition of the dynamic arrays
 606 // ============================================================================
 607
 608 // Please note that for each macro WX_FOO_ARRAY we also have
 609 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
 610 // same except that they use an additional __declspec(dllexport) or equivalent
 611 // under Windows if needed.
 612 //
 613 // The first (just EXPORTED) macros do it if wxWidgets was compiled as a DLL
 614 // and so must be used used inside the library. The second kind (USER_EXPORTED)
 615 // allow the user code to do it when it wants. This is needed if you have a dll
 616 // that wants to export a wxArray daubed with your own import/export goo.
 617 //
 618 // Finally, you can define the macro below as something special to modify the
 619 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
 620 #define wxARRAY_DEFAULT_EXPORT
 621
 622 // ----------------------------------------------------------------------------
 623 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
 624 // the elements of type T
 625 // ----------------------------------------------------------------------------
 626
 627 #define WX_DECLARE_BASEARRAY(T, name)                             \
 628     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 629
 630 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name)                    \
 631     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
 632
 633 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode)      \
 634     typedef T _wxArray##name;                                     \
 635     _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
 636
 637 // ----------------------------------------------------------------------------
 638 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
 639 // from class "base" containing the elements of type T
 640 //
 641 // Note that the class defined has only inline function and doesn't take any
 642 // space at all so there is no size penalty for defining multiple array classes
 643 // ----------------------------------------------------------------------------
 644
 645 #define WX_DEFINE_TYPEARRAY(T, name, base)                        \
 646     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 647
 648 #define WX_DEFINE_TYPEARRAY_PTR(T, name, base)                        \
 649     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 650
 651 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base)               \
 652     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
 653
 654 #define WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, base)               \
 655     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class WXDLLEXPORT)
 656
 657 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
 658     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
 659
 660 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY_PTR(T, name, base, expdecl) \
 661     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class expdecl)
 662
 663 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
 664     typedef T _wxArray##name;                                   \
 665     _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
 666
 667 #define WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, classdecl) \
 668     typedef T _wxArray##name;                                          \
 669     _WX_DEFINE_TYPEARRAY_PTR(_wxArray##name, name, base, classdecl)
 670
 671 // ----------------------------------------------------------------------------
 672 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
 673 // defines a sorted array.
 674 //
 675 // Differences:
 676 //  1) it must be given a COMPARE function in ctor which takes 2 items of type
 677 //     T* and should return -1, 0 or +1 if the first one is less/greater
 678 //     than/equal to the second one.
 679 //  2) the Add() method inserts the item in such was that the array is always
 680 //     sorted (it uses the COMPARE function)
 681 //  3) it has no Sort() method because it's always sorted
 682 //  4) Index() method is much faster (the sorted arrays use binary search
 683 //     instead of linear one), but Add() is slower.
 684 //  5) there is no Insert() method because you can't insert an item into the
 685 //     given position in a sorted array but there is IndexForInsert()/AddAt()
 686 //     pair which may be used to optimize a common operation of "insert only if
 687 //     not found"
 688 //
 689 // Note that you have to specify the comparison function when creating the
 690 // objects of this array type. If, as in 99% of cases, the comparison function
 691 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
 692 // is more convenient.
 693 //
 694 // Summary: use this class when the speed of Index() function is important, use
 695 // the normal arrays otherwise.
 696 // ----------------------------------------------------------------------------
 697
 698 #define wxARRAY_EMPTY_CMP
 699
 700 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 701     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 702                                              wxARRAY_DEFAULT_EXPORT)
 703
 704 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 705     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 706
 707 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 708     typedef T _wxArray##name;                                             \
 709     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);       \
 710     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base,             \
 711                                 wxARRAY_EMPTY_CMP, class expmode, SCMPFUNC##name)
 712
 713 // ----------------------------------------------------------------------------
 714 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 715 // function is provided by this macro and the objects of this class have a
 716 // default constructor which just uses it.
 717 //
 718 // The arguments are: the element type, the comparison function and the array
 719 // name
 720 //
 721 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 722 //     from the very beginning - unfortunately I didn't think about this earlier
 723 // ----------------------------------------------------------------------------
 724
 725 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 726     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 727                                                  wxARRAY_DEFAULT_EXPORT)
 728
 729 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 730     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 731                                                  WXDLLEXPORT)
 732
 733 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 734                                                      expmode)                \
 735     typedef T _wxArray##name;                                                \
 736     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);          \
 737     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, = cmpfunc,     \
 738                                 class expmode, SCMPFUNC##name)
 739
 740 // ----------------------------------------------------------------------------
 741 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
 742 // named "name" which owns the objects of type T it contains, i.e. it will
 743 // delete them when it is destroyed.
 744 //
 745 // An element is of type T*, but arguments of type T& are taken (see below!)
 746 // and T& is returned.
 747 //
 748 // Don't use this for simple types such as "int" or "long"!
 749 //
 750 // Note on Add/Insert functions:
 751 //  1) function(T*) gives the object to the array, i.e. it will delete the
 752 //     object when it's removed or in the array's dtor
 753 //  2) function(T&) will create a copy of the object and work with it
 754 //
 755 // Also:
 756 //  1) Remove() will delete the object after removing it from the array
 757 //  2) Detach() just removes the object from the array (returning pointer to it)
 758 //
 759 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
 760 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
 761 //      and so you risk having at least the memory leaks and probably worse
 762 //
 763 // Some functions of this class are not inline, so it takes some space to
 764 // define new class from this template even if you don't use it - which is not
 765 // the case for the simple (non-object) array classes
 766 //
 767 // To use an objarray class you must
 768 //      #include "dynarray.h"
 769 //      WX_DECLARE_OBJARRAY(element_type, list_class_name)
 770 //      #include "arrimpl.cpp"
 771 //      WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
 772 //
 773 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
 774 // element_type must be fully defined (i.e. forward declaration is not
 775 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
 776 // two allows to break cicrcular dependencies with classes which have member
 777 // variables of objarray type.
 778 // ----------------------------------------------------------------------------
 779
 780 #define WX_DECLARE_OBJARRAY(T, name)                        \
 781     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 782
 783 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name)               \
 784     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
 785
 786 #define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \
 787     typedef T _wxObjArray##name;                            \
 788     _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl)
 789
 790 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
 791     WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode)
 792
 793 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
 794 // try to provoke a human-understandable error if it used incorrectly.
 795 //
 796 // there is no real need for 3 different macros in the DEFINE case but do it
 797 // anyhow for consistency
 798 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
 799 #define WX_DEFINE_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 800 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 801
 802 // ----------------------------------------------------------------------------
 803 // Some commonly used predefined base arrays
 804 // ----------------------------------------------------------------------------
 805
 806 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
 807                                    WXDLLIMPEXP_BASE);
 808 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE);
 809 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE);
 810 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE);
 811 WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE);
 812 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
 813
 814 // ----------------------------------------------------------------------------
 815 // Convenience macros to define arrays from base arrays
 816 // ----------------------------------------------------------------------------
 817
 818 #define WX_DEFINE_ARRAY(T, name)                                       \
 819     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 820 #define WX_DEFINE_ARRAY_PTR(T, name)                                \
 821     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 822 #define WX_DEFINE_EXPORTED_ARRAY(T, name)                              \
 823     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 824 #define WX_DEFINE_EXPORTED_ARRAY_PTR(T, name)                       \
 825     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 826 #define WX_DEFINE_ARRAY_WITH_DECL_PTR(T, name, decl)                \
 827     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, decl)
 828 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode)                \
 829     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
 830 #define WX_DEFINE_USER_EXPORTED_ARRAY_PTR(T, name, expmode)         \
 831     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, expmode)
 832
 833 #define WX_DEFINE_ARRAY_SHORT(T, name)                                 \
 834     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 835 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name)                        \
 836     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 837 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)          \
 838     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayShort, expmode)
 839
 840 #define WX_DEFINE_ARRAY_INT(T, name)                                   \
 841     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 842 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name)                          \
 843     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 844 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode)            \
 845     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayInt, expmode)
 846
 847 #define WX_DEFINE_ARRAY_LONG(T, name)                                  \
 848     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 849 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name)                         \
 850     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 851 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode)           \
 852     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, expmode)
 853
 854 #define WX_DEFINE_ARRAY_SIZE_T(T, name)                                  \
 855     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 856 #define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name)                         \
 857     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 858 #define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)           \
 859     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, expmode)
 860
 861 #define WX_DEFINE_ARRAY_DOUBLE(T, name)                                \
 862     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 863 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name)                       \
 864     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 865 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode)         \
 866     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayDouble, expmode)
 867
 868 // ----------------------------------------------------------------------------
 869 // Convenience macros to define sorted arrays from base arrays
 870 // ----------------------------------------------------------------------------
 871
 872 #define WX_DEFINE_SORTED_ARRAY(T, name)                                \
 873     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 874 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)                       \
 875     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 876 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode)         \
 877     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
 878
 879 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name)                          \
 880     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 881 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name)                 \
 882     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 883 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)   \
 884     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
 885
 886 #define WX_DEFINE_SORTED_ARRAY_INT(T, name)                            \
 887     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 888 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name)                   \
 889     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 890 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode)     \
 891     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
 892
 893 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name)                           \
 894     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 895 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name)                  \
 896     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 897 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode)    \
 898     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
 899
 900 #define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name)                           \
 901     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 902 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name)                  \
 903     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 904 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)    \
 905     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, expmode)
 906
 907 // ----------------------------------------------------------------------------
 908 // Convenience macros to define sorted arrays from base arrays
 909 // ----------------------------------------------------------------------------
 910
 911 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name)                   \
 912     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 913 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name)          \
 914     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 915 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc,           \
 916                                                      name, expmode)    \
 917     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 918                                                  wxBaseArrayPtrVoid, expmode)
 919
 920 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)             \
 921     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 922 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)    \
 923     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 924 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc,     \
 925                                                        name, expmode)  \
 926     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 927                                                  wxBaseArrayShort, expmode)
 928
 929 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name)               \
 930     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 931 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name)      \
 932     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 933 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc,       \
 934                                                      name, expmode)    \
 935     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 936                                                  wxBaseArrayInt, expmode)
 937
 938 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name)              \
 939     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 940 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name)     \
 941     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 942 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc,      \
 943                                                       name, expmode)   \
 944     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 945                                                  wxBaseArrayLong, expmode)
 946
 947 #define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)              \
 948     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 949 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)     \
 950     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 951 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc,      \
 952                                                       name, expmode)   \
 953     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 954                                                  wxBaseArraySizeT, expmode)
 955
 956 // ----------------------------------------------------------------------------
 957 // Some commonly used predefined arrays
 958 // ----------------------------------------------------------------------------
 959
 960 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
 961 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);
 962 WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(double, wxArrayDouble, class WXDLLIMPEXP_BASE);
 963 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
 964 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 965
 966 // -----------------------------------------------------------------------------
 967 // convenience macros
 968 // -----------------------------------------------------------------------------
 969
 970 // prepend all element of one array to another one; e.g. if first array contains
 971 // elements X,Y,Z and the second contains A,B,C (in those orders), then the
 972 // first array will be result as A,B,C,X,Y,Z
 973 #define WX_PREPEND_ARRAY(array, other)                                        \
 974     {                                                                         \
 975         size_t wxAAcnt = (other).size();                                      \
 976         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
 977         {                                                                     \
 978             (array).Insert((other)[wxAAn], wxAAn);                            \
 979         }                                                                     \
 980     }
 981
 982 // append all element of one array to another one
 983 #define WX_APPEND_ARRAY(array, other)                                         \
 984     {                                                                         \
 985         size_t wxAAcnt = (other).size();                                      \
 986         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
 987         {                                                                     \
 988             (array).push_back((other)[wxAAn]);                                \
 989         }                                                                     \
 990     }
 991
 992 // delete all array elements
 993 //
 994 // NB: the class declaration of the array elements must be visible from the
 995 //     place where you use this macro, otherwise the proper destructor may not
 996 //     be called (a decent compiler should give a warning about it, but don't
 997 //     count on it)!
 998 #define WX_CLEAR_ARRAY(array)                                                 \
 999     {                                                                         \
1000         size_t wxAAcnt = (array).size();                                      \
1001         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1002         {                                                                     \
1003             delete (array)[wxAAn];                                            \
1004         }                                                                     \
1005                                                                               \
1006         (array).clear();                                                      \
1007     }
1008
1009 #endif // _DYNARRAY_H
1010