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