include/wx/dynarray.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/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 n) { if ( n > m_nSize ) Realloc(n); }           \
 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) { Alloc(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(GetCount() - 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[](GetCount() - 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 // we need a macro which expands to nothing to pass correct number of
 699 // parameters to a nested macro invocation even when we don't have anything to
 700 // pass it
 701 #define wxARRAY_EMPTY
 702
 703 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 704     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 705                                              wxARRAY_DEFAULT_EXPORT)
 706
 707 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 708     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 709
 710 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 711     typedef T _wxArray##name;                                             \
 712     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);       \
 713     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base,             \
 714                                 wxARRAY_EMPTY, class expmode, SCMPFUNC##name)
 715
 716 // ----------------------------------------------------------------------------
 717 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 718 // function is provided by this macro and the objects of this class have a
 719 // default constructor which just uses it.
 720 //
 721 // The arguments are: the element type, the comparison function and the array
 722 // name
 723 //
 724 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 725 //     from the very beginning - unfortunately I didn't think about this earlier
 726 // ----------------------------------------------------------------------------
 727
 728 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 729     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 730                                                  wxARRAY_DEFAULT_EXPORT)
 731
 732 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 733     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 734                                                  WXDLLEXPORT)
 735
 736 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 737                                                      expmode)                \
 738     typedef T _wxArray##name;                                                \
 739     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);          \
 740     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, = cmpfunc,     \
 741                                 class expmode, SCMPFUNC##name)
 742
 743 // ----------------------------------------------------------------------------
 744 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
 745 // named "name" which owns the objects of type T it contains, i.e. it will
 746 // delete them when it is destroyed.
 747 //
 748 // An element is of type T*, but arguments of type T& are taken (see below!)
 749 // and T& is returned.
 750 //
 751 // Don't use this for simple types such as "int" or "long"!
 752 //
 753 // Note on Add/Insert functions:
 754 //  1) function(T*) gives the object to the array, i.e. it will delete the
 755 //     object when it's removed or in the array's dtor
 756 //  2) function(T&) will create a copy of the object and work with it
 757 //
 758 // Also:
 759 //  1) Remove() will delete the object after removing it from the array
 760 //  2) Detach() just removes the object from the array (returning pointer to it)
 761 //
 762 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
 763 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
 764 //      and so you risk having at least the memory leaks and probably worse
 765 //
 766 // Some functions of this class are not inline, so it takes some space to
 767 // define new class from this template even if you don't use it - which is not
 768 // the case for the simple (non-object) array classes
 769 //
 770 // To use an objarray class you must
 771 //      #include "dynarray.h"
 772 //      WX_DECLARE_OBJARRAY(element_type, list_class_name)
 773 //      #include "arrimpl.cpp"
 774 //      WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
 775 //
 776 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
 777 // element_type must be fully defined (i.e. forward declaration is not
 778 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
 779 // two allows to break cicrcular dependencies with classes which have member
 780 // variables of objarray type.
 781 // ----------------------------------------------------------------------------
 782
 783 #define WX_DECLARE_OBJARRAY(T, name)                        \
 784     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 785
 786 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name)               \
 787     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
 788
 789 #define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \
 790     typedef T _wxObjArray##name;                            \
 791     _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl)
 792
 793 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
 794     WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode)
 795
 796 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
 797 // try to provoke a human-understandable error if it used incorrectly.
 798 //
 799 // there is no real need for 3 different macros in the DEFINE case but do it
 800 // anyhow for consistency
 801 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
 802 #define WX_DEFINE_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 803 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 804
 805 // ----------------------------------------------------------------------------
 806 // Some commonly used predefined base arrays
 807 // ----------------------------------------------------------------------------
 808
 809 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
 810                                    WXDLLIMPEXP_BASE);
 811 WX_DECLARE_USER_EXPORTED_BASEARRAY(char, wxBaseArrayChar, WXDLLIMPEXP_BASE);
 812 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE);
 813 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE);
 814 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE);
 815 WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE);
 816 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
 817
 818 // ----------------------------------------------------------------------------
 819 // Convenience macros to define arrays from base arrays
 820 // ----------------------------------------------------------------------------
 821
 822 #define WX_DEFINE_ARRAY(T, name)                                       \
 823     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 824 #define WX_DEFINE_ARRAY_PTR(T, name)                                \
 825     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 826 #define WX_DEFINE_EXPORTED_ARRAY(T, name)                              \
 827     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 828 #define WX_DEFINE_EXPORTED_ARRAY_PTR(T, name)                       \
 829     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 830 #define WX_DEFINE_ARRAY_WITH_DECL_PTR(T, name, decl)                \
 831     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, decl)
 832 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode)                \
 833     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 834 #define WX_DEFINE_USER_EXPORTED_ARRAY_PTR(T, name, expmode)         \
 835     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 836
 837 #define WX_DEFINE_ARRAY_CHAR(T, name)                                 \
 838     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayChar)
 839 #define WX_DEFINE_EXPORTED_ARRAY_CHAR(T, name)                        \
 840     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayChar)
 841 #define WX_DEFINE_USER_EXPORTED_ARRAY_CHAR(T, name, expmode)          \
 842     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayChar, wxARRAY_EMPTY expmode)
 843
 844 #define WX_DEFINE_ARRAY_SHORT(T, name)                                 \
 845     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 846 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name)                        \
 847     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 848 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)          \
 849     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayShort, wxARRAY_EMPTY expmode)
 850
 851 #define WX_DEFINE_ARRAY_INT(T, name)                                   \
 852     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 853 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name)                          \
 854     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 855 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode)            \
 856     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayInt, wxARRAY_EMPTY expmode)
 857
 858 #define WX_DEFINE_ARRAY_LONG(T, name)                                  \
 859     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 860 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name)                         \
 861     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 862 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode)           \
 863     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, wxARRAY_EMPTY expmode)
 864
 865 #define WX_DEFINE_ARRAY_SIZE_T(T, name)                                  \
 866     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 867 #define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name)                         \
 868     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 869 #define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)           \
 870     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, wxARRAY_EMPTY expmode)
 871
 872 #define WX_DEFINE_ARRAY_DOUBLE(T, name)                                \
 873     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 874 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name)                       \
 875     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 876 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode)         \
 877     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayDouble, wxARRAY_EMPTY expmode)
 878
 879 // ----------------------------------------------------------------------------
 880 // Convenience macros to define sorted arrays from base arrays
 881 // ----------------------------------------------------------------------------
 882
 883 #define WX_DEFINE_SORTED_ARRAY(T, name)                                \
 884     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 885 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)                       \
 886     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 887 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode)         \
 888     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 889
 890 #define WX_DEFINE_SORTED_ARRAY_CHAR(T, name)                          \
 891     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayChar)
 892 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CHAR(T, name)                 \
 893     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayChar)
 894 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CHAR(T, name, expmode)   \
 895     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayChar, wxARRAY_EMPTY expmode)
 896
 897 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name)                          \
 898     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 899 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name)                 \
 900     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 901 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)   \
 902     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, wxARRAY_EMPTY expmode)
 903
 904 #define WX_DEFINE_SORTED_ARRAY_INT(T, name)                            \
 905     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 906 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name)                   \
 907     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 908 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode)     \
 909     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
 910
 911 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name)                           \
 912     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 913 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name)                  \
 914     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 915 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode)    \
 916     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
 917
 918 #define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name)                           \
 919     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 920 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name)                  \
 921     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 922 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)    \
 923     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, wxARRAY_EMPTY expmode)
 924
 925 // ----------------------------------------------------------------------------
 926 // Convenience macros to define sorted arrays from base arrays
 927 // ----------------------------------------------------------------------------
 928
 929 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name)                   \
 930     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 931 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name)          \
 932     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 933 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc,           \
 934                                                      name, expmode)    \
 935     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 936                                                  wxBaseArrayPtrVoid,   \
 937                                                  wxARRAY_EMPTY expmode)
 938
 939 #define WX_DEFINE_SORTED_ARRAY_CMP_CHAR(T, cmpfunc, name)             \
 940     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayChar)
 941 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_CHAR(T, cmpfunc, name)    \
 942     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayChar)
 943 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_CHAR(T, cmpfunc,      \
 944                                                        name, expmode)  \
 945     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 946                                                  wxBaseArrayChar,      \
 947                                                  wxARRAY_EMPTY expmode)
 948
 949 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)             \
 950     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 951 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)    \
 952     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 953 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc,     \
 954                                                        name, expmode)  \
 955     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 956                                                  wxBaseArrayShort,     \
 957                                                  wxARRAY_EMPTY expmode)
 958
 959 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name)               \
 960     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 961 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name)      \
 962     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 963 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc,       \
 964                                                      name, expmode)    \
 965     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 966                                                  wxBaseArrayInt,       \
 967                                                  wxARRAY_EMPTY expmode)
 968
 969 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name)              \
 970     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 971 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name)     \
 972     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 973 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc,      \
 974                                                       name, expmode)   \
 975     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 976                                                  wxBaseArrayLong,      \
 977                                                  wxARRAY_EMPTY expmode)
 978
 979 #define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)              \
 980     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 981 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)     \
 982     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 983 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc,      \
 984                                                       name, expmode)   \
 985     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 986                                                  wxBaseArraySizeT,     \
 987                                                  wxARRAY_EMPTY expmode)
 988
 989 // ----------------------------------------------------------------------------
 990 // Some commonly used predefined arrays
 991 // ----------------------------------------------------------------------------
 992
 993 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
 994 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);
 995 WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(double, wxArrayDouble, class WXDLLIMPEXP_BASE);
 996 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
 997 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 998
 999 // -----------------------------------------------------------------------------
1000 // convenience macros
1001 // -----------------------------------------------------------------------------
1002
1003 // prepend all element of one array to another one; e.g. if first array contains
1004 // elements X,Y,Z and the second contains A,B,C (in those orders), then the
1005 // first array will be result as A,B,C,X,Y,Z
1006 #define WX_PREPEND_ARRAY(array, other)                                        \
1007     {                                                                         \
1008         size_t wxAAcnt = (other).size();                                      \
1009         (array).Alloc(wxAAcnt);                                               \
1010         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1011         {                                                                     \
1012             (array).Insert((other)[wxAAn], wxAAn);                            \
1013         }                                                                     \
1014     }
1015
1016 // append all element of one array to another one
1017 #define WX_APPEND_ARRAY(array, other)                                         \
1018     {                                                                         \
1019         size_t wxAAcnt = (other).size();                                      \
1020         (array).Alloc(wxAAcnt);                                               \
1021         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1022         {                                                                     \
1023             (array).push_back((other)[wxAAn]);                                \
1024         }                                                                     \
1025     }
1026
1027 // delete all array elements
1028 //
1029 // NB: the class declaration of the array elements must be visible from the
1030 //     place where you use this macro, otherwise the proper destructor may not
1031 //     be called (a decent compiler should give a warning about it, but don't
1032 //     count on it)!
1033 #define WX_CLEAR_ARRAY(array)                                                 \
1034     {                                                                         \
1035         size_t wxAAcnt = (array).size();                                      \
1036         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1037         {                                                                     \
1038             delete (array)[wxAAn];                                            \
1039         }                                                                     \
1040                                                                               \
1041         (array).clear();                                                      \
1042     }
1043
1044 #endif // _DYNARRAY_H