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