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) { assign(n, value_type()); }                      \
 442   name(size_type n, const_reference v) { assign(n, v); }              \
 443   name(const_iterator first, const_iterator last)                     \
 444     { assign(first, last); }                                          \
 445   void assign(const_iterator first, const_iterator last)              \
 446     { base::assign((bconst_iterator)first, (bconst_iterator)last); }  \
 447   void assign(size_type n, const_reference v)                         \
 448     { base::assign(n, (bconst_reference)v); }                         \
 449   reference back() { return *(end() - 1); }                           \
 450   const_reference back() const { return *(end() - 1); }               \
 451   iterator begin() { return (iterator)base::begin(); }                \
 452   const_iterator begin() const { return (const_iterator)base::begin(); }\
 453   size_type capacity() const { return base::capacity(); }             \
 454   iterator end() { return (iterator)base::end(); }                    \
 455   const_iterator end() const { return (const_iterator)base::end(); }  \
 456   iterator erase(iterator first, iterator last)                       \
 457     { return (iterator)base::erase((biterator)first, (biterator)last); }\
 458   iterator erase(iterator it)                                         \
 459     { return (iterator)base::erase((biterator)it); }                  \
 460   reference front() { return *begin(); }                              \
 461   const_reference front() const { return *begin(); }                  \
 462   void insert(iterator it, size_type n, const_reference v)            \
 463     { base::insert((biterator)it, n, (bconst_reference)v); }          \
 464   iterator insert(iterator it, const_reference v = value_type())      \
 465     { return (iterator)base::insert((biterator)it, (bconst_reference)v); }\
 466   void insert(iterator it, const_iterator first, const_iterator last) \
 467     { base::insert((biterator)it, (bconst_iterator)first,             \
 468                    (bconst_iterator)last); }                          \
 469   void pop_back() { base::pop_back(); }                               \
 470   void push_back(const_reference v)                                   \
 471     { base::push_back((bconst_reference)v); }                         \
 472   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }   \
 473   const_reverse_iterator rbegin() const;                              \
 474   reverse_iterator rend() { return reverse_iterator(begin() - 1); }   \
 475   const_reverse_iterator rend() const;                                \
 476   void reserve(size_type n) { base::reserve(n); }                     \
 477   void resize(size_type n, value_type v = value_type())               \
 478     { base::resize(n, v); }                                           \
 479 }
 480
 481 #define _WX_PTROP pointer operator->() const { return m_ptr; }
 482 #define _WX_PTROP_NONE
 483
 484 #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp)                 \
 485     _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP)
 486 #define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp)          \
 487     _WX_DEFINE_TYPEARRAY_HELPER(T, name, base, classexp, _WX_PTROP_NONE)
 488
 489 #endif // !wxUSE_STL
 490
 491 // ----------------------------------------------------------------------------
 492 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
 493 //    cannot handle types with size greater than pointer because of sorting
 494 // ----------------------------------------------------------------------------
 495
 496 #define _WX_DEFINE_SORTED_TYPEARRAY_2(T, name, base, defcomp, classexp, comptype)\
 497 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
 498                        TypeTooBigToBeStoredInSorted##base,            \
 499                        name);                                         \
 500 classexp name : public base                                           \
 501 {                                                                     \
 502   typedef comptype SCMPFUNC;                                          \
 503 public:                                                               \
 504   name(comptype fn defcomp) { m_fnCompare = fn; }                     \
 505                                                                       \
 506   name& operator=(const name& src)                                    \
 507     { base* temp = (base*) this;                                      \
 508       (*temp) = ((const base&)src);                                   \
 509       m_fnCompare = src.m_fnCompare;                                  \
 510       return *this; }                                                 \
 511                                                                       \
 512   T& operator[](size_t uiIndex) const                                 \
 513     { return (T&)(base::operator[](uiIndex)); }                       \
 514   T& Item(size_t uiIndex) const                                       \
 515     { return (T&)(base::operator[](uiIndex)); }                       \
 516   T& Last() const                                                     \
 517     { return (T&)(base::operator[](size() - 1)); }                    \
 518                                                                       \
 519   int Index(T lItem) const                                            \
 520     { return base::Index(lItem, (CMPFUNC)m_fnCompare); }              \
 521                                                                       \
 522   size_t IndexForInsert(T lItem) const                                \
 523     { return base::IndexForInsert(lItem, (CMPFUNC)m_fnCompare); }     \
 524                                                                       \
 525   void AddAt(T item, size_t index)                                    \
 526     { base::insert(begin() + index, item); }                          \
 527                                                                       \
 528   size_t Add(T lItem)                                                 \
 529     { return base::Add(lItem, (CMPFUNC)m_fnCompare); }                \
 530                                                                       \
 531   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 532     { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); }  \
 533   void Remove(T lItem)                                                \
 534     { int iIndex = Index(lItem);                                      \
 535       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 536         _WX_ERROR_REMOVE );                                           \
 537       base::erase(begin() + iIndex); }                                \
 538                                                                       \
 539 private:                                                              \
 540   comptype m_fnCompare;                                               \
 541 }
 542
 543
 544 // ----------------------------------------------------------------------------
 545 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
 546 // ----------------------------------------------------------------------------
 547
 548 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp)                    \
 549 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2);          \
 550 classexp name : protected base                                           \
 551 {                                                                        \
 552 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
 553 typedef base base_array;                                                 \
 554 public:                                                                  \
 555   name() { }                                                             \
 556   name(const name& src);                                                 \
 557   name& operator=(const name& src);                                      \
 558                                                                          \
 559   ~name();                                                               \
 560                                                                          \
 561   void Alloc(size_t count) { base::reserve(count); }                     \
 562   void reserve(size_t count) { base::reserve(count); }                   \
 563   size_t GetCount() const { return base_array::size(); }                 \
 564   size_t size() const { return base_array::size(); }                     \
 565   bool IsEmpty() const { return base_array::empty(); }                   \
 566   bool empty() const { return base_array::empty(); }                     \
 567   size_t Count() const { return base_array::size(); }                    \
 568   void Shrink() { base::Shrink(); }                                      \
 569                                                                          \
 570   T& operator[](size_t uiIndex) const                                    \
 571     { return *(T*)base::operator[](uiIndex); }                           \
 572   T& Item(size_t uiIndex) const                                          \
 573     { return *(T*)base::operator[](uiIndex); }                           \
 574   T& Last() const                                                        \
 575     { return *(T*)(base::operator[](size() - 1)); }                      \
 576                                                                          \
 577   int Index(const T& lItem, bool bFromEnd = false) const;                \
 578                                                                          \
 579   void Add(const T& lItem, size_t nInsert = 1);                          \
 580   void Add(const T* pItem)                                               \
 581     { base::push_back((T*)pItem); }                                      \
 582   void push_back(const T* pItem)                                         \
 583     { base::push_back((T*)pItem); }                                      \
 584   void push_back(const T& lItem)                                         \
 585     { Add(lItem); }                                                      \
 586                                                                          \
 587   void Insert(const T& lItem,  size_t uiIndex, size_t nInsert = 1);      \
 588   void Insert(const T* pItem, size_t uiIndex)                            \
 589     { base::insert(begin() + uiIndex, (T*)pItem); }                      \
 590                                                                          \
 591   void Empty() { DoEmpty(); base::clear(); }                             \
 592   void Clear() { DoEmpty(); base::clear(); }                             \
 593                                                                          \
 594   T* Detach(size_t uiIndex)                                              \
 595     { T* p = (T*)base::operator[](uiIndex);                              \
 596       base::erase(begin() + uiIndex); return p; }                        \
 597   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
 598                                                                          \
 599   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
 600                                                                          \
 601 private:                                                                 \
 602   void DoEmpty();                                                        \
 603   void DoCopy(const name& src);                                          \
 604 }
 605
 606 // ============================================================================
 607 // The public macros for declaration and definition of the dynamic arrays
 608 // ============================================================================
 609
 610 // Please note that for each macro WX_FOO_ARRAY we also have
 611 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
 612 // same except that they use an additional __declspec(dllexport) or equivalent
 613 // under Windows if needed.
 614 //
 615 // The first (just EXPORTED) macros do it if wxWidgets was compiled as a DLL
 616 // and so must be used used inside the library. The second kind (USER_EXPORTED)
 617 // allow the user code to do it when it wants. This is needed if you have a dll
 618 // that wants to export a wxArray daubed with your own import/export goo.
 619 //
 620 // Finally, you can define the macro below as something special to modify the
 621 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
 622 #define wxARRAY_DEFAULT_EXPORT
 623
 624 // ----------------------------------------------------------------------------
 625 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
 626 // the elements of type T
 627 // ----------------------------------------------------------------------------
 628
 629 #define WX_DECLARE_BASEARRAY(T, name)                             \
 630     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 631
 632 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name)                    \
 633     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
 634
 635 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode)      \
 636     typedef T _wxArray##name;                                     \
 637     _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
 638
 639 // ----------------------------------------------------------------------------
 640 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
 641 // from class "base" containing the elements of type T
 642 //
 643 // Note that the class defined has only inline function and doesn't take any
 644 // space at all so there is no size penalty for defining multiple array classes
 645 // ----------------------------------------------------------------------------
 646
 647 #define WX_DEFINE_TYPEARRAY(T, name, base)                        \
 648     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 649
 650 #define WX_DEFINE_TYPEARRAY_PTR(T, name, base)                        \
 651     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 652
 653 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base)               \
 654     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
 655
 656 #define WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, base)               \
 657     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class WXDLLEXPORT)
 658
 659 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
 660     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
 661
 662 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY_PTR(T, name, base, expdecl) \
 663     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, class expdecl)
 664
 665 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
 666     typedef T _wxArray##name;                                   \
 667     _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
 668
 669 #define WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, base, classdecl) \
 670     typedef T _wxArray##name;                                          \
 671     _WX_DEFINE_TYPEARRAY_PTR(_wxArray##name, name, base, classdecl)
 672
 673 // ----------------------------------------------------------------------------
 674 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
 675 // defines a sorted array.
 676 //
 677 // Differences:
 678 //  1) it must be given a COMPARE function in ctor which takes 2 items of type
 679 //     T* and should return -1, 0 or +1 if the first one is less/greater
 680 //     than/equal to the second one.
 681 //  2) the Add() method inserts the item in such was that the array is always
 682 //     sorted (it uses the COMPARE function)
 683 //  3) it has no Sort() method because it's always sorted
 684 //  4) Index() method is much faster (the sorted arrays use binary search
 685 //     instead of linear one), but Add() is slower.
 686 //  5) there is no Insert() method because you can't insert an item into the
 687 //     given position in a sorted array but there is IndexForInsert()/AddAt()
 688 //     pair which may be used to optimize a common operation of "insert only if
 689 //     not found"
 690 //
 691 // Note that you have to specify the comparison function when creating the
 692 // objects of this array type. If, as in 99% of cases, the comparison function
 693 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
 694 // is more convenient.
 695 //
 696 // Summary: use this class when the speed of Index() function is important, use
 697 // the normal arrays otherwise.
 698 // ----------------------------------------------------------------------------
 699
 700 // we need a macro which expands to nothing to pass correct number of
 701 // parameters to a nested macro invocation even when we don't have anything to
 702 // pass it
 703 #define wxARRAY_EMPTY
 704
 705 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 706     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 707                                              wxARRAY_DEFAULT_EXPORT)
 708
 709 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 710     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 711
 712 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 713     typedef T _wxArray##name;                                             \
 714     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);       \
 715     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base,             \
 716                                 wxARRAY_EMPTY, class expmode, SCMPFUNC##name)
 717
 718 // ----------------------------------------------------------------------------
 719 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 720 // function is provided by this macro and the objects of this class have a
 721 // default constructor which just uses it.
 722 //
 723 // The arguments are: the element type, the comparison function and the array
 724 // name
 725 //
 726 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 727 //     from the very beginning - unfortunately I didn't think about this earlier
 728 // ----------------------------------------------------------------------------
 729
 730 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 731     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 732                                                  wxARRAY_DEFAULT_EXPORT)
 733
 734 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 735     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 736                                                  WXDLLEXPORT)
 737
 738 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 739                                                      expmode)                \
 740     typedef T _wxArray##name;                                                \
 741     typedef int (CMPFUNC_CONV *SCMPFUNC##name)(T pItem1, T pItem2);          \
 742     _WX_DEFINE_SORTED_TYPEARRAY_2(_wxArray##name, name, base, = cmpfunc,     \
 743                                 class expmode, SCMPFUNC##name)
 744
 745 // ----------------------------------------------------------------------------
 746 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
 747 // named "name" which owns the objects of type T it contains, i.e. it will
 748 // delete them when it is destroyed.
 749 //
 750 // An element is of type T*, but arguments of type T& are taken (see below!)
 751 // and T& is returned.
 752 //
 753 // Don't use this for simple types such as "int" or "long"!
 754 //
 755 // Note on Add/Insert functions:
 756 //  1) function(T*) gives the object to the array, i.e. it will delete the
 757 //     object when it's removed or in the array's dtor
 758 //  2) function(T&) will create a copy of the object and work with it
 759 //
 760 // Also:
 761 //  1) Remove() will delete the object after removing it from the array
 762 //  2) Detach() just removes the object from the array (returning pointer to it)
 763 //
 764 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
 765 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
 766 //      and so you risk having at least the memory leaks and probably worse
 767 //
 768 // Some functions of this class are not inline, so it takes some space to
 769 // define new class from this template even if you don't use it - which is not
 770 // the case for the simple (non-object) array classes
 771 //
 772 // To use an objarray class you must
 773 //      #include "dynarray.h"
 774 //      WX_DECLARE_OBJARRAY(element_type, list_class_name)
 775 //      #include "arrimpl.cpp"
 776 //      WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
 777 //
 778 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
 779 // element_type must be fully defined (i.e. forward declaration is not
 780 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
 781 // two allows to break cicrcular dependencies with classes which have member
 782 // variables of objarray type.
 783 // ----------------------------------------------------------------------------
 784
 785 #define WX_DECLARE_OBJARRAY(T, name)                        \
 786     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 787
 788 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name)               \
 789     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
 790
 791 #define WX_DECLARE_OBJARRAY_WITH_DECL(T, name, decl) \
 792     typedef T _wxObjArray##name;                            \
 793     _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, decl)
 794
 795 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
 796     WX_DECLARE_OBJARRAY_WITH_DECL(T, name, class expmode)
 797
 798 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
 799 // try to provoke a human-understandable error if it used incorrectly.
 800 //
 801 // there is no real need for 3 different macros in the DEFINE case but do it
 802 // anyhow for consistency
 803 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
 804 #define WX_DEFINE_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 805 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 806
 807 // ----------------------------------------------------------------------------
 808 // Some commonly used predefined base arrays
 809 // ----------------------------------------------------------------------------
 810
 811 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
 812                                    WXDLLIMPEXP_BASE);
 813 WX_DECLARE_USER_EXPORTED_BASEARRAY(char, wxBaseArrayChar, WXDLLIMPEXP_BASE);
 814 WX_DECLARE_USER_EXPORTED_BASEARRAY(short, wxBaseArrayShort, WXDLLIMPEXP_BASE);
 815 WX_DECLARE_USER_EXPORTED_BASEARRAY(int, wxBaseArrayInt, WXDLLIMPEXP_BASE);
 816 WX_DECLARE_USER_EXPORTED_BASEARRAY(long, wxBaseArrayLong, WXDLLIMPEXP_BASE);
 817 WX_DECLARE_USER_EXPORTED_BASEARRAY(size_t, wxBaseArraySizeT, WXDLLIMPEXP_BASE);
 818 WX_DECLARE_USER_EXPORTED_BASEARRAY(double, wxBaseArrayDouble, WXDLLIMPEXP_BASE);
 819
 820 // ----------------------------------------------------------------------------
 821 // Convenience macros to define arrays from base arrays
 822 // ----------------------------------------------------------------------------
 823
 824 #define WX_DEFINE_ARRAY(T, name)                                       \
 825     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 826 #define WX_DEFINE_ARRAY_PTR(T, name)                                \
 827     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 828 #define WX_DEFINE_EXPORTED_ARRAY(T, name)                              \
 829     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 830 #define WX_DEFINE_EXPORTED_ARRAY_PTR(T, name)                       \
 831     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayPtrVoid)
 832 #define WX_DEFINE_ARRAY_WITH_DECL_PTR(T, name, decl)                \
 833     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, decl)
 834 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode)                \
 835     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 836 #define WX_DEFINE_USER_EXPORTED_ARRAY_PTR(T, name, expmode)         \
 837     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 838
 839 #define WX_DEFINE_ARRAY_CHAR(T, name)                                 \
 840     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayChar)
 841 #define WX_DEFINE_EXPORTED_ARRAY_CHAR(T, name)                        \
 842     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayChar)
 843 #define WX_DEFINE_USER_EXPORTED_ARRAY_CHAR(T, name, expmode)          \
 844     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayChar, wxARRAY_EMPTY expmode)
 845
 846 #define WX_DEFINE_ARRAY_SHORT(T, name)                                 \
 847     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 848 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name)                        \
 849     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayShort)
 850 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)          \
 851     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayShort, wxARRAY_EMPTY expmode)
 852
 853 #define WX_DEFINE_ARRAY_INT(T, name)                                   \
 854     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 855 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name)                          \
 856     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayInt)
 857 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode)            \
 858     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayInt, wxARRAY_EMPTY expmode)
 859
 860 #define WX_DEFINE_ARRAY_LONG(T, name)                                  \
 861     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 862 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name)                         \
 863     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayLong)
 864 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode)           \
 865     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayLong, wxARRAY_EMPTY expmode)
 866
 867 #define WX_DEFINE_ARRAY_SIZE_T(T, name)                                  \
 868     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 869 #define WX_DEFINE_EXPORTED_ARRAY_SIZE_T(T, name)                         \
 870     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArraySizeT)
 871 #define WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)           \
 872     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArraySizeT, wxARRAY_EMPTY expmode)
 873
 874 #define WX_DEFINE_ARRAY_DOUBLE(T, name)                                \
 875     WX_DEFINE_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 876 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name)                       \
 877     WX_DEFINE_EXPORTED_TYPEARRAY_PTR(T, name, wxBaseArrayDouble)
 878 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode)         \
 879     WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(T, name, wxBaseArrayDouble, wxARRAY_EMPTY expmode)
 880
 881 // ----------------------------------------------------------------------------
 882 // Convenience macros to define sorted arrays from base arrays
 883 // ----------------------------------------------------------------------------
 884
 885 #define WX_DEFINE_SORTED_ARRAY(T, name)                                \
 886     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 887 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)                       \
 888     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 889 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode)         \
 890     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, wxARRAY_EMPTY expmode)
 891
 892 #define WX_DEFINE_SORTED_ARRAY_CHAR(T, name)                          \
 893     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayChar)
 894 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CHAR(T, name)                 \
 895     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayChar)
 896 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CHAR(T, name, expmode)   \
 897     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayChar, wxARRAY_EMPTY expmode)
 898
 899 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name)                          \
 900     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 901 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name)                 \
 902     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 903 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)   \
 904     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, wxARRAY_EMPTY expmode)
 905
 906 #define WX_DEFINE_SORTED_ARRAY_INT(T, name)                            \
 907     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 908 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name)                   \
 909     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 910 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode)     \
 911     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
 912
 913 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name)                           \
 914     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 915 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name)                  \
 916     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 917 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode)    \
 918     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
 919
 920 #define WX_DEFINE_SORTED_ARRAY_SIZE_T(T, name)                           \
 921     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 922 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SIZE_T(T, name)                  \
 923     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT)
 924 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(T, name, expmode)    \
 925     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArraySizeT, wxARRAY_EMPTY expmode)
 926
 927 // ----------------------------------------------------------------------------
 928 // Convenience macros to define sorted arrays from base arrays
 929 // ----------------------------------------------------------------------------
 930
 931 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name)                   \
 932     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 933 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name)          \
 934     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 935 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc,           \
 936                                                      name, expmode)    \
 937     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 938                                                  wxBaseArrayPtrVoid,   \
 939                                                  wxARRAY_EMPTY expmode)
 940
 941 #define WX_DEFINE_SORTED_ARRAY_CMP_CHAR(T, cmpfunc, name)             \
 942     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayChar)
 943 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_CHAR(T, cmpfunc, name)    \
 944     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayChar)
 945 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_CHAR(T, cmpfunc,      \
 946                                                        name, expmode)  \
 947     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 948                                                  wxBaseArrayChar,      \
 949                                                  wxARRAY_EMPTY expmode)
 950
 951 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)             \
 952     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 953 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)    \
 954     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 955 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc,     \
 956                                                        name, expmode)  \
 957     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 958                                                  wxBaseArrayShort,     \
 959                                                  wxARRAY_EMPTY expmode)
 960
 961 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name)               \
 962     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 963 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name)      \
 964     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 965 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc,       \
 966                                                      name, expmode)    \
 967     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 968                                                  wxBaseArrayInt,       \
 969                                                  wxARRAY_EMPTY expmode)
 970
 971 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name)              \
 972     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 973 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name)     \
 974     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 975 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc,      \
 976                                                       name, expmode)   \
 977     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 978                                                  wxBaseArrayLong,      \
 979                                                  wxARRAY_EMPTY expmode)
 980
 981 #define WX_DEFINE_SORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)              \
 982     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 983 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc, name)     \
 984     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArraySizeT)
 985 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SIZE_T(T, cmpfunc,      \
 986                                                       name, expmode)   \
 987     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 988                                                  wxBaseArraySizeT,     \
 989                                                  wxARRAY_EMPTY expmode)
 990
 991 // ----------------------------------------------------------------------------
 992 // Some commonly used predefined arrays
 993 // ----------------------------------------------------------------------------
 994
 995 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(short, wxArrayShort, class WXDLLIMPEXP_BASE);
 996 WX_DEFINE_USER_EXPORTED_ARRAY_INT(int, wxArrayInt, class WXDLLIMPEXP_BASE);
 997 WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(double, wxArrayDouble, class WXDLLIMPEXP_BASE);
 998 WX_DEFINE_USER_EXPORTED_ARRAY_LONG(long, wxArrayLong, class WXDLLIMPEXP_BASE);
 999 WX_DEFINE_USER_EXPORTED_ARRAY_PTR(void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
1000
1001 // -----------------------------------------------------------------------------
1002 // convenience macros
1003 // -----------------------------------------------------------------------------
1004
1005 // prepend all element of one array to another one; e.g. if first array contains
1006 // elements X,Y,Z and the second contains A,B,C (in those orders), then the
1007 // first array will be result as A,B,C,X,Y,Z
1008 #define WX_PREPEND_ARRAY(array, other)                                        \
1009     {                                                                         \
1010         size_t wxAAcnt = (other).size();                                      \
1011         (array).reserve(wxAAcnt);                                             \
1012         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1013         {                                                                     \
1014             (array).Insert((other)[wxAAn], wxAAn);                            \
1015         }                                                                     \
1016     }
1017
1018 // append all element of one array to another one
1019 #define WX_APPEND_ARRAY(array, other)                                         \
1020     {                                                                         \
1021         size_t wxAAcnt = (other).size();                                      \
1022         (array).reserve(wxAAcnt);                                             \
1023         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1024         {                                                                     \
1025             (array).push_back((other)[wxAAn]);                                \
1026         }                                                                     \
1027     }
1028
1029 // delete all array elements
1030 //
1031 // NB: the class declaration of the array elements must be visible from the
1032 //     place where you use this macro, otherwise the proper destructor may not
1033 //     be called (a decent compiler should give a warning about it, but don't
1034 //     count on it)!
1035 #define WX_CLEAR_ARRAY(array)                                                 \
1036     {                                                                         \
1037         size_t wxAAcnt = (array).size();                                      \
1038         for ( size_t wxAAn = 0; wxAAn < wxAAcnt; wxAAn++ )                    \
1039         {                                                                     \
1040             delete (array)[wxAAn];                                            \
1041         }                                                                     \
1042                                                                               \
1043         (array).clear();                                                      \
1044     }
1045
1046 #endif // _DYNARRAY_H