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