include/wx/dynarray.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        dynarray.h
   3 // Purpose:     auto-resizable (i.e. dynamic) array support
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     12.09.97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef   _DYNARRAY_H
  13 #define   _DYNARRAY_H
  14
  15 #if defined(__GNUG__) && !defined(__APPLE__)
  16 #pragma interface "dynarray.h"
  17 #endif
  18
  19 #include "wx/defs.h"
  20
  21 /*
  22   This header defines the dynamic arrays and object arrays (i.e. arrays which
  23   own their elements). Dynamic means that the arrays grow automatically as
  24   needed.
  25
  26   These macros are ugly (especially if you look in the sources ;-), but they
  27   allow us to define "template" classes without actually using templates and so
  28   this works with all compilers (and may be also much faster to compile even
  29   with a compiler which does support templates). The arrays defined with these
  30   macros are type-safe.
  31
  32   Range checking is performed in debug build for both arrays and objarrays but
  33   not in release build - so using an invalid index will just lead to a crash
  34   then.
  35
  36   Note about memory usage: arrays never shrink automatically (although you may
  37   use Shrink() function explicitly), they only grow, so loading 10 millions in
  38   an array only to delete them 2 lines below might be a bad idea if the array
  39   object is not going to be destroyed soon. However, as it does free memory
  40   when destroyed, it is ok if the array is a local variable.
  41  */
  42
  43 // ----------------------------------------------------------------------------
  44 // constants
  45 // ----------------------------------------------------------------------------
  46
  47 /*
  48    The initial size by which an array grows when an element is added default
  49    value avoids allocate one or two bytes when the array is created which is
  50    rather inefficient
  51 */
  52 #define WX_ARRAY_DEFAULT_INITIAL_SIZE    (16)
  53
  54 // ----------------------------------------------------------------------------
  55 // types
  56 // ----------------------------------------------------------------------------
  57
  58 /*
  59     Callback compare function for quick sort.
  60
  61     It must return negative value, 0 or positive value if the first item is
  62     less than, equal to or greater than the second one.
  63  */
  64 extern "C"
  65 {
  66 typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
  67 }
  68
  69 // ----------------------------------------------------------------------------
  70 // Base class managing data having size of type 'long' (not used directly)
  71 //
  72 // NB: for efficiency this often used class has no virtual functions (hence no
  73 //     virtual table), even dtor is *not* virtual. If used as expected it
  74 //     won't create any problems because ARRAYs from DEFINE_ARRAY have no dtor
  75 //     at all, so it's not too important if it's not called (this happens when
  76 //     you cast "SomeArray *" as "BaseArray *" and then delete it)
  77 // ----------------------------------------------------------------------------
  78
  79 #define  _WX_DECLARE_BASEARRAY(T, name, classexp)                   \
  80 classexp name                                                       \
  81 {                                                                   \
  82 public:                                                             \
  83   name();                                                           \
  84   name(const name& array);                                          \
  85   name& operator=(const name& src);                                 \
  86   ~name();                                                          \
  87                                                                     \
  88   void Empty() { m_nCount = 0; }                                    \
  89   void Clear();                                                     \
  90   void Alloc(size_t uiSize);                                        \
  91   void Shrink();                                                    \
  92                                                                     \
  93   size_t GetCount() const { return m_nCount; }                      \
  94   void SetCount(size_t n, T defval = T(0));                         \
  95   bool IsEmpty() const { return m_nCount == 0; }                    \
  96   size_t Count() const { return m_nCount; }                         \
  97                                                                     \
  98   typedef T base_type;                                              \
  99                                                                     \
 100 protected:                                                          \
 101   T& Item(size_t uiIndex) const                                     \
 102     { wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; }   \
 103   T& operator[](size_t uiIndex) const { return Item(uiIndex); }     \
 104                                                                     \
 105   int Index(T lItem, bool bFromEnd = FALSE) const;                  \
 106   int Index(T lItem, CMPFUNC fnCompare) const;                      \
 107   size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const;          \
 108   void Add(T lItem, size_t nInsert = 1);                            \
 109   void Add(T lItem, CMPFUNC fnCompare);                             \
 110   void Insert(T lItem, size_t uiIndex, size_t nInsert = 1);         \
 111   void Remove(T lItem);                                             \
 112   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                \
 113                                                                     \
 114   void Sort(CMPFUNC fnCompare);                                     \
 115                                                                     \
 116 private:                                                            \
 117   void Grow(size_t nIncrement = 0);                                 \
 118   bool Realloc(size_t nSize);                                       \
 119                                                                     \
 120   size_t  m_nSize,                                                  \
 121           m_nCount;                                                 \
 122                                                                     \
 123   T      *m_pItems;                                                 \
 124 }
 125
 126 // ============================================================================
 127 // The private helper macros containing the core of the array classes
 128 // ============================================================================
 129
 130 // Implementation notes:
 131 //
 132 // JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
 133 //          { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 134 //       so using a temporary variable instead.
 135 //
 136 // The classes need a (even trivial) ~name() to link under Mac X
 137 //
 138 // _WX_ERROR_REMOVE is needed to resolve the name conflict between the wxT()
 139 // macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
 140
 141 #define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
 142
 143 // ----------------------------------------------------------------------------
 144 // _WX_DEFINE_TYPEARRAY: array for simple types
 145 // ----------------------------------------------------------------------------
 146
 147 #define  _WX_DEFINE_TYPEARRAY(T, name, base, classexp)                \
 148 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type),          \
 149                        TypeTooBigToBeStoredIn##base,                  \
 150                        name);                                         \
 151 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);         \
 152 classexp name : public base                                           \
 153 {                                                                     \
 154 public:                                                               \
 155   name() { }                                                          \
 156   ~name() { }                                                         \
 157                                                                       \
 158   name& operator=(const name& src)                                    \
 159     { base* temp = (base*) this;                                      \
 160       (*temp) = ((const base&)src);                                   \
 161       return *this; }                                                 \
 162                                                                       \
 163   T& operator[](size_t uiIndex) const                                 \
 164     { return (T&)(base::Item(uiIndex)); }                             \
 165   T& Item(size_t uiIndex) const                                       \
 166     { return (T&)(base::Item(uiIndex)); }                             \
 167   T& Last() const                                                     \
 168     { return (T&)(base::Item(Count() - 1)); }                         \
 169                                                                       \
 170   int Index(T Item, bool bFromEnd = FALSE) const                      \
 171     { return base::Index((base_type)Item, bFromEnd); }                \
 172                                                                       \
 173   void Add(T Item, size_t nInsert = 1)                                \
 174     { base::Add((base_type)Item, nInsert); }                          \
 175   void Insert(T Item, size_t uiIndex, size_t nInsert = 1)             \
 176     { base::Insert((base_type)Item, uiIndex, nInsert) ; }             \
 177                                                                       \
 178   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 179     { base::RemoveAt(uiIndex, nRemove); }                             \
 180   void Remove(T Item)                                                 \
 181     { int iIndex = Index(Item);                                       \
 182       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 183          _WX_ERROR_REMOVE);                                           \
 184       base::RemoveAt((size_t)iIndex); }                               \
 185                                                                       \
 186   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); }           \
 187 }
 188
 189 // ----------------------------------------------------------------------------
 190 // _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
 191 //    cannot handle types with size greater than pointer because of sorting
 192 // ----------------------------------------------------------------------------
 193
 194 #define _WX_DEFINE_SORTED_TYPEARRAY(T, name, base, defcomp, classexp) \
 195 wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *),                   \
 196                        TypeTooBigToBeStoredInSorted##base,            \
 197                        name);                                         \
 198 typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);          \
 199 classexp name : public base                                           \
 200 {                                                                     \
 201 public:                                                               \
 202   name(SCMPFUNC##T fn defcomp) { m_fnCompare = fn; }                  \
 203                                                                       \
 204   name& operator=(const name& src)                                    \
 205     { base* temp = (base*) this;                                      \
 206       (*temp) = ((const base&)src);                                   \
 207       m_fnCompare = src.m_fnCompare;                                  \
 208       return *this; }                                                 \
 209                                                                       \
 210   T& operator[](size_t uiIndex) const                                 \
 211     { return (T&)(base::Item(uiIndex)); }                             \
 212   T& Item(size_t uiIndex) const                                       \
 213     { return (T&)(base::Item(uiIndex)); }                             \
 214   T& Last() const                                                     \
 215     { return (T&)(base::Item(Count() - 1)); }                         \
 216                                                                       \
 217   int Index(T Item) const                                             \
 218     { return base::Index(Item, (CMPFUNC)m_fnCompare); }               \
 219                                                                       \
 220   size_t IndexForInsert(T Item) const                                 \
 221     { return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); }      \
 222                                                                       \
 223   void AddAt(T item, size_t index)                                    \
 224     { base::Insert(item, index); }                                    \
 225                                                                       \
 226   void Add(T Item)                                                    \
 227     { base::Add(Item, (CMPFUNC)m_fnCompare); }                        \
 228                                                                       \
 229   void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
 230     { base::RemoveAt(uiIndex, nRemove); }                             \
 231   void Remove(T Item)                                                 \
 232     { int iIndex = Index(Item);                                       \
 233       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
 234         _WX_ERROR_REMOVE );                                           \
 235       base::RemoveAt((size_t)iIndex); }                               \
 236                                                                       \
 237 private:                                                              \
 238   SCMPFUNC##T m_fnCompare;                                            \
 239 }
 240
 241 // ----------------------------------------------------------------------------
 242 // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
 243 // ----------------------------------------------------------------------------
 244
 245 #define _WX_DECLARE_OBJARRAY(T, name, base, classexp)                    \
 246 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2);          \
 247 classexp name : public base                                              \
 248 {                                                                        \
 249 typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
 250 public:                                                                  \
 251   name() { }                                                             \
 252   name(const name& src);                                                 \
 253   name& operator=(const name& src);                                      \
 254                                                                          \
 255   ~name();                                                               \
 256                                                                          \
 257   T& operator[](size_t uiIndex) const                                    \
 258     { return *(T*)base::Item(uiIndex); }                                 \
 259   T& Item(size_t uiIndex) const                                          \
 260     { return *(T*)base::Item(uiIndex); }                                 \
 261   T& Last() const                                                        \
 262     { return *(T*)(base::Item(Count() - 1)); }                           \
 263                                                                          \
 264   int Index(const T& Item, bool bFromEnd = FALSE) const;                 \
 265                                                                          \
 266   void Add(const T& Item, size_t nInsert = 1);                           \
 267   void Add(const T* pItem)                                               \
 268     { base::Add((T*)pItem); }                                            \
 269                                                                          \
 270   void Insert(const T& Item,  size_t uiIndex, size_t nInsert = 1);       \
 271   void Insert(const T* pItem, size_t uiIndex)                            \
 272     { base::Insert((T*)pItem, uiIndex); }                                \
 273                                                                          \
 274   void Empty() { DoEmpty(); base::Empty(); }                             \
 275   void Clear() { DoEmpty(); base::Clear(); }                             \
 276                                                                          \
 277   T* Detach(size_t uiIndex)                                              \
 278     { T* p = (T*)base::Item(uiIndex);                                    \
 279       base::RemoveAt(uiIndex); return p; }                               \
 280   void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
 281                                                                          \
 282   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
 283                                                                          \
 284 private:                                                                 \
 285   void DoEmpty();                                                        \
 286   void DoCopy(const name& src);                                          \
 287 }
 288
 289 // ============================================================================
 290 // The public macros for declaration and definition of the dynamic arrays
 291 // ============================================================================
 292
 293 // Please note that for each macro WX_FOO_ARRAY we also have
 294 // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
 295 // same except that they use an additional __declspec(dllexport) or equivalent
 296 // under Windows if needed.
 297 //
 298 // The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
 299 // and so must be used used inside the library. The second kind (USER_EXPORTED)
 300 // allow the user code to do it when it wants. This is needed if you have a dll
 301 // that wants to export a wxArray daubed with your own import/export goo.
 302 //
 303 // Finally, you can define the macro below as something special to modify the
 304 // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
 305 #define wxARRAY_DEFAULT_EXPORT
 306
 307 // ----------------------------------------------------------------------------
 308 // WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
 309 // the elements of type T
 310 // ----------------------------------------------------------------------------
 311
 312 #define WX_DECLARE_BASEARRAY(T, name)                             \
 313     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 314
 315 #define WX_DECLARE_EXPORTED_BASEARRAY(T, name)                    \
 316     WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
 317
 318 #define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode)      \
 319     typedef T _wxArray##name;                                     \
 320     _WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
 321
 322 // ----------------------------------------------------------------------------
 323 // WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
 324 // from class "base" containing the elements of type T
 325 //
 326 // Note that the class defined has only inline function and doesn't take any
 327 // space at all so there is no size penalty for defining multiple array classes
 328 // ----------------------------------------------------------------------------
 329
 330 #define WX_DEFINE_TYPEARRAY(T, name, base)                        \
 331     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class wxARRAY_DEFAULT_EXPORT)
 332
 333 #define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base)               \
 334     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class WXDLLEXPORT)
 335
 336 #define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expdecl) \
 337     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, class expdecl)
 338
 339 #define WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, base, classdecl) \
 340     typedef T _wxArray##name;                                     \
 341     _WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, classdecl)
 342
 343 // ----------------------------------------------------------------------------
 344 // WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
 345 // defines a sorted array.
 346 //
 347 // Differences:
 348 //  1) it must be given a COMPARE function in ctor which takes 2 items of type
 349 //     T* and should return -1, 0 or +1 if the first one is less/greater
 350 //     than/equal to the second one.
 351 //  2) the Add() method inserts the item in such was that the array is always
 352 //     sorted (it uses the COMPARE function)
 353 //  3) it has no Sort() method because it's always sorted
 354 //  4) Index() method is much faster (the sorted arrays use binary search
 355 //     instead of linear one), but Add() is slower.
 356 //  5) there is no Insert() method because you can't insert an item into the
 357 //     given position in a sorted array but there is IndexForInsert()/AddAt()
 358 //     pair which may be used to optimize a common operation of "insert only if
 359 //     not found"
 360 //
 361 // Note that you have to specify the comparison function when creating the
 362 // objects of this array type. If, as in 99% of cases, the comparison function
 363 // is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
 364 // is more convenient.
 365 //
 366 // Summary: use this class when the speed of Index() function is important, use
 367 // the normal arrays otherwise.
 368 // ----------------------------------------------------------------------------
 369
 370 #define wxARRAY_EMPTY_CMP
 371
 372 #define WX_DEFINE_SORTED_TYPEARRAY(T, name, base)                         \
 373     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base,               \
 374                                              wxARRAY_DEFAULT_EXPORT)
 375
 376 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base)                \
 377     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
 378
 379 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode)  \
 380     typedef T _wxArray##name;                                             \
 381     _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base,               \
 382                                 wxARRAY_EMPTY_CMP, class expmode)
 383
 384 // ----------------------------------------------------------------------------
 385 // WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
 386 // function is provided by this macro and the objects of this class have a
 387 // default constructor which just uses it.
 388 //
 389 // The arguments are: the element type, the comparison function and the array
 390 // name
 391 //
 392 // NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
 393 //     from the very beginning - unfortunately I didn't think about this earlier
 394 // ----------------------------------------------------------------------------
 395
 396 #define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)               \
 397     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 398                                                  wxARRAY_DEFAULT_EXPORT)
 399
 400 #define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base)      \
 401     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base,     \
 402                                                  WXDLLEXPORT)
 403
 404 #define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
 405                                                      expmode)                \
 406     typedef T _wxArray##name;                                                \
 407     _WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, = cmpfunc,       \
 408                                 class expmode)
 409
 410 // ----------------------------------------------------------------------------
 411 // WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
 412 // named "name" which owns the objects of type T it contains, i.e. it will
 413 // delete them when it is destroyed.
 414 //
 415 // An element is of type T*, but arguments of type T& are taken (see below!)
 416 // and T& is returned.
 417 //
 418 // Don't use this for simple types such as "int" or "long"!
 419 //
 420 // Note on Add/Insert functions:
 421 //  1) function(T*) gives the object to the array, i.e. it will delete the
 422 //     object when it's removed or in the array's dtor
 423 //  2) function(T&) will create a copy of the object and work with it
 424 //
 425 // Also:
 426 //  1) Remove() will delete the object after removing it from the array
 427 //  2) Detach() just removes the object from the array (returning pointer to it)
 428 //
 429 // NB1: Base type T should have an accessible copy ctor if Add(T&) is used
 430 // NB2: Never ever cast a array to it's base type: as dtor is not virtual
 431 //      and so you risk having at least the memory leaks and probably worse
 432 //
 433 // Some functions of this class are not inline, so it takes some space to
 434 // define new class from this template even if you don't use it - which is not
 435 // the case for the simple (non-object) array classes
 436 //
 437 // To use an objarray class you must
 438 //      #include "dynarray.h"
 439 //      WX_DECLARE_OBJARRAY(element_type, list_class_name)
 440 //      #include "arrimpl.cpp"
 441 //      WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
 442 //
 443 // This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
 444 // element_type must be fully defined (i.e. forward declaration is not
 445 // enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
 446 // two allows to break cicrcular dependencies with classes which have member
 447 // variables of objarray type.
 448 // ----------------------------------------------------------------------------
 449
 450 #define WX_DECLARE_OBJARRAY(T, name)                        \
 451     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
 452
 453 #define WX_DECLARE_EXPORTED_OBJARRAY(T, name)               \
 454     WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
 455
 456 #define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
 457     typedef T _wxObjArray##name;                            \
 458     _WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
 459
 460 // WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
 461 // try to provoke a human-understandable error if it used incorrectly.
 462 //
 463 // there is no real need for 3 different macros in the DEFINE case but do it
 464 // anyhow for consistency
 465 #define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
 466 #define WX_DEFINE_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 467 #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name)   WX_DEFINE_OBJARRAY(name)
 468
 469 // ----------------------------------------------------------------------------
 470 // Some commonly used predefined base arrays
 471 // ----------------------------------------------------------------------------
 472
 473 WX_DECLARE_USER_EXPORTED_BASEARRAY(const void *, wxBaseArrayPtrVoid,
 474                                    WXDLLIMPEXP_BASE);
 475 WX_DECLARE_USER_EXPORTED_BASEARRAY(short,        wxBaseArrayShort,
 476                                    WXDLLIMPEXP_BASE);
 477 WX_DECLARE_USER_EXPORTED_BASEARRAY(int,          wxBaseArrayInt,
 478                                    WXDLLIMPEXP_BASE);
 479 WX_DECLARE_USER_EXPORTED_BASEARRAY(long,         wxBaseArrayLong,
 480                                    WXDLLIMPEXP_BASE);
 481 WX_DECLARE_USER_EXPORTED_BASEARRAY(double,       wxBaseArrayDouble,
 482                                    WXDLLIMPEXP_BASE);
 483
 484 // ----------------------------------------------------------------------------
 485 // Convenience macros to define arrays from base arrays
 486 // ----------------------------------------------------------------------------
 487
 488 #define WX_DEFINE_ARRAY(T, name)                                       \
 489     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 490 #define WX_DEFINE_EXPORTED_ARRAY(T, name)                              \
 491     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 492 #define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode)                \
 493     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayPtrVoid, expmode)
 494
 495 #define WX_DEFINE_ARRAY_SHORT(T, name)                                 \
 496     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort)
 497 #define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name)                        \
 498     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 499 #define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)          \
 500     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayShort, expmode)
 501
 502 #define WX_DEFINE_ARRAY_INT(T, name)                                   \
 503     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt)
 504 #define WX_DEFINE_EXPORTED_ARRAY_INT(T, name)                          \
 505     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 506 #define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode)            \
 507     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayInt, expmode)
 508
 509 #define WX_DEFINE_ARRAY_LONG(T, name)                                  \
 510     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong)
 511 #define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name)                         \
 512     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 513 #define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode)           \
 514     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayLong, expmode)
 515
 516 #define WX_DEFINE_ARRAY_DOUBLE(T, name)                                \
 517     WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble)
 518 #define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name)                       \
 519     WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble)
 520 #define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode)         \
 521     WX_DEFINE_TYPEARRAY_WITH_DECL(T, name, wxBaseArrayDouble, expmode)
 522
 523 // ----------------------------------------------------------------------------
 524 // Convenience macros to define sorted arrays from base arrays
 525 // ----------------------------------------------------------------------------
 526
 527 #define WX_DEFINE_SORTED_ARRAY(T, name)                                \
 528     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 529 #define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)                       \
 530     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
 531 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode)         \
 532     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
 533
 534 #define WX_DEFINE_SORTED_ARRAY_SHORT(T, name)                          \
 535     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 536 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name)                 \
 537     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
 538 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode)   \
 539     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
 540
 541 #define WX_DEFINE_SORTED_ARRAY_INT(T, name)                            \
 542     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 543 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name)                   \
 544     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
 545 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode)     \
 546     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
 547
 548 #define WX_DEFINE_SORTED_ARRAY_LONG(T, name)                           \
 549     WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 550 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name)                  \
 551     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
 552 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode)    \
 553     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
 554
 555 // ----------------------------------------------------------------------------
 556 // Convenience macros to define sorted arrays from base arrays
 557 // ----------------------------------------------------------------------------
 558
 559 #define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name)                   \
 560     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 561 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name)          \
 562     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
 563 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc,           \
 564                                                      name, expmode)    \
 565     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 566                                                  wxBaseArrayPtrVoid, expmode)
 567
 568 #define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)             \
 569     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 570 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name)    \
 571     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
 572 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc,     \
 573                                                        name, expmode)  \
 574     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 575                                                  wxBaseArrayShort, expmode)
 576
 577 #define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name)               \
 578     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 579 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name)      \
 580     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
 581 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc,       \
 582                                                      name, expmode)    \
 583     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 584                                                  wxBaseArrayInt, expmode)
 585
 586 #define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name)              \
 587     WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 588 #define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name)     \
 589     WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
 590 #define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc,      \
 591                                                       name, expmode)   \
 592     WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name,     \
 593                                                  wxBaseArrayLong, expmode)
 594
 595 // ----------------------------------------------------------------------------
 596 // Some commonly used predefined arrays
 597 // ----------------------------------------------------------------------------
 598
 599 WX_DEFINE_USER_EXPORTED_ARRAY_SHORT (short,  wxArrayShort,   class WXDLLIMPEXP_BASE);
 600 WX_DEFINE_USER_EXPORTED_ARRAY_INT   (int,    wxArrayInt,     class WXDLLIMPEXP_BASE);
 601 WX_DEFINE_USER_EXPORTED_ARRAY_LONG  (long,   wxArrayLong,    class WXDLLIMPEXP_BASE);
 602 WX_DEFINE_USER_EXPORTED_ARRAY       (void *, wxArrayPtrVoid, class WXDLLIMPEXP_BASE);
 603
 604 // -----------------------------------------------------------------------------
 605 // convenience macros
 606 // -----------------------------------------------------------------------------
 607
 608 // append all element of one array to another one
 609 #define WX_APPEND_ARRAY(array, other)                                         \
 610     {                                                                         \
 611         size_t count = (other).Count();                                       \
 612         for ( size_t n = 0; n < count; n++ )                                  \
 613         {                                                                     \
 614             (array).Add((other)[n]);                                          \
 615         }                                                                     \
 616     }
 617
 618 // delete all array elements
 619 //
 620 // NB: the class declaration of the array elements must be visible from the
 621 //     place where you use this macro, otherwise the proper destructor may not
 622 //     be called (a decent compiler should give a warning about it, but don't
 623 //     count on it)!
 624 #define WX_CLEAR_ARRAY(array)                                                 \
 625     {                                                                         \
 626         size_t count = (array).Count();                                       \
 627         for ( size_t n = 0; n < count; n++ )                                  \
 628         {                                                                     \
 629             delete (array)[n];                                                \
 630         }                                                                     \
 631                                                                               \
 632         (array).Empty();                                                      \
 633     }
 634
 635 #endif // _DYNARRAY_H
 636