| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: wx/list.h |
| 3 | // Purpose: wxList, wxStringList classes |
| 4 | // Author: Julian Smart |
| 5 | // Modified by: VZ at 16/11/98: WX_DECLARE_LIST() and typesafe lists added |
| 6 | // Created: 29/01/98 |
| 7 | // RCS-ID: $Id$ |
| 8 | // Copyright: (c) 1998 Julian Smart |
| 9 | // Licence: wxWindows licence |
| 10 | ///////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | /* |
| 13 | All this is quite ugly but serves two purposes: |
| 14 | 1. Be almost 100% compatible with old, untyped, wxList class |
| 15 | 2. Ensure compile-time type checking for the linked lists |
| 16 | |
| 17 | The idea is to have one base class (wxListBase) working with "void *" data, |
| 18 | but to hide these untyped functions - i.e. make them protected, so they |
| 19 | can only be used from derived classes which have inline member functions |
| 20 | working with right types. This achieves the 2nd goal. As for the first one, |
| 21 | we provide a special derivation of wxListBase called wxList which looks just |
| 22 | like the old class. |
| 23 | */ |
| 24 | |
| 25 | #ifndef _WX_LIST_H_ |
| 26 | #define _WX_LIST_H_ |
| 27 | |
| 28 | // ----------------------------------------------------------------------------- |
| 29 | // headers |
| 30 | // ----------------------------------------------------------------------------- |
| 31 | |
| 32 | #include "wx/defs.h" |
| 33 | #include "wx/object.h" |
| 34 | #include "wx/string.h" |
| 35 | |
| 36 | #if wxUSE_STL |
| 37 | #include "wx/beforestd.h" |
| 38 | #include <algorithm> |
| 39 | #include <iterator> |
| 40 | #include <list> |
| 41 | #include "wx/afterstd.h" |
| 42 | #endif |
| 43 | |
| 44 | // ---------------------------------------------------------------------------- |
| 45 | // types |
| 46 | // ---------------------------------------------------------------------------- |
| 47 | |
| 48 | class WXDLLIMPEXP_FWD_BASE wxObjectListNode; |
| 49 | typedef wxObjectListNode wxNode; |
| 50 | |
| 51 | #if wxUSE_STL |
| 52 | |
| 53 | #define wxLIST_COMPATIBILITY |
| 54 | |
| 55 | #define WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) \ |
| 56 | WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) |
| 57 | #define WX_DECLARE_LIST_PTR_3(elT, dummy1, liT, dummy2, decl) \ |
| 58 | WX_DECLARE_LIST_3(elT, dummy1, liT, dummy2, decl) |
| 59 | |
| 60 | #define WX_DECLARE_LIST_2(elT, liT, dummy, decl) \ |
| 61 | WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) |
| 62 | #define WX_DECLARE_LIST_PTR_2(elT, liT, dummy, decl) \ |
| 63 | WX_DECLARE_LIST_2(elT, liT, dummy, decl) \ |
| 64 | |
| 65 | #define WX_DECLARE_LIST_WITH_DECL(elT, liT, decl) \ |
| 66 | WX_DECLARE_LIST_XO(elT*, liT, decl) |
| 67 | |
| 68 | #if !defined(__VISUALC__) || __VISUALC__ >= 1300 // == !VC6 |
| 69 | |
| 70 | template<class T> |
| 71 | class wxList_SortFunction |
| 72 | { |
| 73 | public: |
| 74 | wxList_SortFunction(wxSortCompareFunction f) : m_f(f) { } |
| 75 | bool operator()(const T& i1, const T& i2) |
| 76 | { return m_f((T*)&i1, (T*)&i2) < 0; } |
| 77 | private: |
| 78 | wxSortCompareFunction m_f; |
| 79 | }; |
| 80 | |
| 81 | #define WX_LIST_SORTFUNCTION( elT, f ) wxList_SortFunction<elT>(f) |
| 82 | #define WX_LIST_VC6_WORKAROUND(elT, liT, decl) |
| 83 | |
| 84 | #else // if defined( __VISUALC__ ) && __VISUALC__ < 1300 // == VC6 |
| 85 | |
| 86 | #define WX_LIST_SORTFUNCTION( elT, f ) std::greater<elT>( f ) |
| 87 | #define WX_LIST_VC6_WORKAROUND(elT, liT, decl) \ |
| 88 | decl liT; \ |
| 89 | \ |
| 90 | /* Workaround for broken VC6 STL incorrectly requires a std::greater<> */ \ |
| 91 | /* to be passed into std::list::sort() */ \ |
| 92 | template <> \ |
| 93 | struct std::greater<elT> \ |
| 94 | { \ |
| 95 | private: \ |
| 96 | wxSortCompareFunction m_CompFunc; \ |
| 97 | public: \ |
| 98 | greater( wxSortCompareFunction compfunc = NULL ) \ |
| 99 | : m_CompFunc( compfunc ) {} \ |
| 100 | bool operator()(const elT X, const elT Y) const \ |
| 101 | { \ |
| 102 | return m_CompFunc ? \ |
| 103 | ( m_CompFunc( wxListCastElementToVoidPtr(X), \ |
| 104 | wxListCastElementToVoidPtr(Y) ) < 0 ) : \ |
| 105 | ( X > Y ); \ |
| 106 | } \ |
| 107 | }; |
| 108 | |
| 109 | // helper for std::greater<elT> above: |
| 110 | template<typename T> |
| 111 | inline const void *wxListCastElementToVoidPtr(const T* ptr) { return ptr; } |
| 112 | inline const void *wxListCastElementToVoidPtr(const wxString& str) |
| 113 | { return (const char*)str; } |
| 114 | |
| 115 | #endif // VC6/!VC6 |
| 116 | |
| 117 | /* |
| 118 | Note 1: the outer helper class _WX_LIST_HELPER_##liT below is a workaround |
| 119 | for mingw 3.2.3 compiler bug that prevents a static function of liT class |
| 120 | from being exported into dll. A minimal code snippet reproducing the bug: |
| 121 | |
| 122 | struct WXDLLIMPEXP_CORE Foo |
| 123 | { |
| 124 | static void Bar(); |
| 125 | struct SomeInnerClass |
| 126 | { |
| 127 | friend class Foo; // comment this out to make it link |
| 128 | }; |
| 129 | ~Foo() |
| 130 | { |
| 131 | Bar(); |
| 132 | } |
| 133 | }; |
| 134 | |
| 135 | The program does not link under mingw_gcc 3.2.3 producing undefined |
| 136 | reference to Foo::Bar() function |
| 137 | |
| 138 | |
| 139 | Note 2: the EmptyList is needed to allow having a NULL pointer-like |
| 140 | invalid iterator. We used to use just an uninitialized iterator object |
| 141 | instead but this fails with some debug/checked versions of STL, notably the |
| 142 | glibc version activated with _GLIBCXX_DEBUG, so we need to have a separate |
| 143 | invalid iterator. |
| 144 | */ |
| 145 | |
| 146 | // the real wxList-class declaration |
| 147 | #define WX_DECLARE_LIST_XO(elT, liT, decl) \ |
| 148 | decl _WX_LIST_HELPER_##liT \ |
| 149 | { \ |
| 150 | typedef elT _WX_LIST_ITEM_TYPE_##liT; \ |
| 151 | public: \ |
| 152 | static void DeleteFunction( _WX_LIST_ITEM_TYPE_##liT X ); \ |
| 153 | }; \ |
| 154 | \ |
| 155 | WX_LIST_VC6_WORKAROUND(elT, liT, decl) \ |
| 156 | decl liT : public std::list<elT> \ |
| 157 | { \ |
| 158 | private: \ |
| 159 | typedef std::list<elT> BaseListType; \ |
| 160 | static BaseListType EmptyList; \ |
| 161 | \ |
| 162 | bool m_destroy; \ |
| 163 | \ |
| 164 | public: \ |
| 165 | decl compatibility_iterator \ |
| 166 | { \ |
| 167 | private: \ |
| 168 | /* Workaround for broken VC6 nested class name resolution */ \ |
| 169 | typedef std::list<elT>::iterator iterator; \ |
| 170 | friend class liT; \ |
| 171 | \ |
| 172 | iterator m_iter; \ |
| 173 | liT * m_list; \ |
| 174 | \ |
| 175 | public: \ |
| 176 | compatibility_iterator() \ |
| 177 | : m_iter(EmptyList.end()), m_list( NULL ) {} \ |
| 178 | compatibility_iterator( liT* li, iterator i ) \ |
| 179 | : m_iter( i ), m_list( li ) {} \ |
| 180 | compatibility_iterator( const liT* li, iterator i ) \ |
| 181 | : m_iter( i ), m_list( const_cast< liT* >( li ) ) {} \ |
| 182 | \ |
| 183 | compatibility_iterator* operator->() { return this; } \ |
| 184 | const compatibility_iterator* operator->() const { return this; } \ |
| 185 | \ |
| 186 | bool operator==(const compatibility_iterator& i) const \ |
| 187 | { \ |
| 188 | wxASSERT_MSG( m_list && i.m_list, \ |
| 189 | _T("comparing invalid iterators is illegal") ); \ |
| 190 | return (m_list == i.m_list) && (m_iter == i.m_iter); \ |
| 191 | } \ |
| 192 | bool operator!=(const compatibility_iterator& i) const \ |
| 193 | { return !( operator==( i ) ); } \ |
| 194 | operator bool() const \ |
| 195 | { return m_list ? m_iter != m_list->end() : false; } \ |
| 196 | bool operator !() const \ |
| 197 | { return !( operator bool() ); } \ |
| 198 | \ |
| 199 | elT GetData() const \ |
| 200 | { return *m_iter; } \ |
| 201 | void SetData( elT e ) \ |
| 202 | { *m_iter = e; } \ |
| 203 | \ |
| 204 | compatibility_iterator GetNext() const \ |
| 205 | { \ |
| 206 | iterator i = m_iter; \ |
| 207 | return compatibility_iterator( m_list, ++i ); \ |
| 208 | } \ |
| 209 | compatibility_iterator GetPrevious() const \ |
| 210 | { \ |
| 211 | if ( m_iter == m_list->begin() ) \ |
| 212 | return compatibility_iterator(); \ |
| 213 | \ |
| 214 | iterator i = m_iter; \ |
| 215 | return compatibility_iterator( m_list, --i ); \ |
| 216 | } \ |
| 217 | int IndexOf() const \ |
| 218 | { \ |
| 219 | return *this ? std::distance( m_list->begin(), m_iter ) \ |
| 220 | : wxNOT_FOUND; \ |
| 221 | } \ |
| 222 | }; \ |
| 223 | public: \ |
| 224 | liT() : m_destroy( false ) {} \ |
| 225 | \ |
| 226 | compatibility_iterator Find( const elT e ) const \ |
| 227 | { \ |
| 228 | liT* _this = const_cast< liT* >( this ); \ |
| 229 | return compatibility_iterator( _this, \ |
| 230 | std::find( _this->begin(), _this->end(), e ) ); \ |
| 231 | } \ |
| 232 | \ |
| 233 | bool IsEmpty() const \ |
| 234 | { return empty(); } \ |
| 235 | size_t GetCount() const \ |
| 236 | { return size(); } \ |
| 237 | int Number() const \ |
| 238 | { return static_cast< int >( GetCount() ); } \ |
| 239 | \ |
| 240 | compatibility_iterator Item( size_t idx ) const \ |
| 241 | { \ |
| 242 | iterator i = const_cast< liT* >(this)->begin(); \ |
| 243 | std::advance( i, idx ); \ |
| 244 | return compatibility_iterator( this, i ); \ |
| 245 | } \ |
| 246 | elT operator[](size_t idx) const \ |
| 247 | { \ |
| 248 | return Item(idx).GetData(); \ |
| 249 | } \ |
| 250 | \ |
| 251 | compatibility_iterator GetFirst() const \ |
| 252 | { \ |
| 253 | return compatibility_iterator( this, \ |
| 254 | const_cast< liT* >(this)->begin() ); \ |
| 255 | } \ |
| 256 | compatibility_iterator GetLast() const \ |
| 257 | { \ |
| 258 | iterator i = const_cast< liT* >(this)->end(); \ |
| 259 | return compatibility_iterator( this, !empty() ? --i : i ); \ |
| 260 | } \ |
| 261 | compatibility_iterator Member( elT e ) const \ |
| 262 | { return Find( e ); } \ |
| 263 | compatibility_iterator Nth( int n ) const \ |
| 264 | { return Item( n ); } \ |
| 265 | int IndexOf( elT e ) const \ |
| 266 | { return Find( e ).IndexOf(); } \ |
| 267 | \ |
| 268 | compatibility_iterator Append( elT e ) \ |
| 269 | { \ |
| 270 | push_back( e ); \ |
| 271 | return GetLast(); \ |
| 272 | } \ |
| 273 | compatibility_iterator Insert( elT e ) \ |
| 274 | { \ |
| 275 | push_front( e ); \ |
| 276 | return compatibility_iterator( this, begin() ); \ |
| 277 | } \ |
| 278 | compatibility_iterator Insert(const compatibility_iterator & i, elT e)\ |
| 279 | { \ |
| 280 | return compatibility_iterator( this, insert( i.m_iter, e ) ); \ |
| 281 | } \ |
| 282 | compatibility_iterator Insert( size_t idx, elT e ) \ |
| 283 | { \ |
| 284 | return compatibility_iterator( this, \ |
| 285 | insert( Item( idx ).m_iter, e ) ); \ |
| 286 | } \ |
| 287 | \ |
| 288 | void DeleteContents( bool destroy ) \ |
| 289 | { m_destroy = destroy; } \ |
| 290 | bool GetDeleteContents() const \ |
| 291 | { return m_destroy; } \ |
| 292 | void Erase( const compatibility_iterator& i ) \ |
| 293 | { \ |
| 294 | if ( m_destroy ) \ |
| 295 | _WX_LIST_HELPER_##liT::DeleteFunction( i->GetData() ); \ |
| 296 | erase( i.m_iter ); \ |
| 297 | } \ |
| 298 | bool DeleteNode( const compatibility_iterator& i ) \ |
| 299 | { \ |
| 300 | if( i ) \ |
| 301 | { \ |
| 302 | Erase( i ); \ |
| 303 | return true; \ |
| 304 | } \ |
| 305 | return false; \ |
| 306 | } \ |
| 307 | bool DeleteObject( elT e ) \ |
| 308 | { \ |
| 309 | return DeleteNode( Find( e ) ); \ |
| 310 | } \ |
| 311 | void Clear() \ |
| 312 | { \ |
| 313 | if ( m_destroy ) \ |
| 314 | std::for_each( begin(), end(), \ |
| 315 | _WX_LIST_HELPER_##liT::DeleteFunction ); \ |
| 316 | clear(); \ |
| 317 | } \ |
| 318 | /* Workaround for broken VC6 std::list::sort() see above */ \ |
| 319 | void Sort( wxSortCompareFunction compfunc ) \ |
| 320 | { sort( WX_LIST_SORTFUNCTION( elT, compfunc ) ); } \ |
| 321 | ~liT() { Clear(); } \ |
| 322 | \ |
| 323 | /* It needs access to our EmptyList */ \ |
| 324 | friend class compatibility_iterator; \ |
| 325 | } |
| 326 | |
| 327 | #define WX_DECLARE_LIST(elementtype, listname) \ |
| 328 | WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class) |
| 329 | #define WX_DECLARE_LIST_PTR(elementtype, listname) \ |
| 330 | WX_DECLARE_LIST(elementtype, listname) |
| 331 | |
| 332 | #define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \ |
| 333 | WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE) |
| 334 | #define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \ |
| 335 | WX_DECLARE_EXPORTED_LIST(elementtype, listname) |
| 336 | |
| 337 | #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \ |
| 338 | WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class usergoo) |
| 339 | #define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \ |
| 340 | WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) |
| 341 | |
| 342 | // this macro must be inserted in your program after |
| 343 | // #include "wx/listimpl.cpp" |
| 344 | #define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!" |
| 345 | |
| 346 | #define WX_DEFINE_EXPORTED_LIST(name) WX_DEFINE_LIST(name) |
| 347 | #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name) |
| 348 | |
| 349 | #else // if !wxUSE_STL |
| 350 | |
| 351 | |
| 352 | // undef it to get rid of old, deprecated functions |
| 353 | #define wxLIST_COMPATIBILITY |
| 354 | |
| 355 | // ----------------------------------------------------------------------------- |
| 356 | // key stuff: a list may be optionally keyed on integer or string key |
| 357 | // ----------------------------------------------------------------------------- |
| 358 | |
| 359 | union wxListKeyValue |
| 360 | { |
| 361 | long integer; |
| 362 | wxString *string; |
| 363 | }; |
| 364 | |
| 365 | // a struct which may contain both types of keys |
| 366 | // |
| 367 | // implementation note: on one hand, this class allows to have only one function |
| 368 | // for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to |
| 369 | // resolve ambiguity which we would otherwise have with wxStringList::Find() and |
| 370 | // wxList::Find(const char *). |
| 371 | class WXDLLIMPEXP_BASE wxListKey |
| 372 | { |
| 373 | public: |
| 374 | // implicit ctors |
| 375 | wxListKey() : m_keyType(wxKEY_NONE) |
| 376 | { } |
| 377 | wxListKey(long i) : m_keyType(wxKEY_INTEGER) |
| 378 | { m_key.integer = i; } |
| 379 | wxListKey(const wxString& s) : m_keyType(wxKEY_STRING) |
| 380 | { m_key.string = new wxString(s); } |
| 381 | wxListKey(const char *s) : m_keyType(wxKEY_STRING) |
| 382 | { m_key.string = new wxString(s); } |
| 383 | wxListKey(const wchar_t *s) : m_keyType(wxKEY_STRING) |
| 384 | { m_key.string = new wxString(s); } |
| 385 | |
| 386 | // accessors |
| 387 | wxKeyType GetKeyType() const { return m_keyType; } |
| 388 | const wxString GetString() const |
| 389 | { wxASSERT( m_keyType == wxKEY_STRING ); return *m_key.string; } |
| 390 | long GetNumber() const |
| 391 | { wxASSERT( m_keyType == wxKEY_INTEGER ); return m_key.integer; } |
| 392 | |
| 393 | // comparison |
| 394 | // Note: implementation moved to list.cpp to prevent BC++ inline |
| 395 | // expansion warning. |
| 396 | bool operator==(wxListKeyValue value) const ; |
| 397 | |
| 398 | // dtor |
| 399 | ~wxListKey() |
| 400 | { |
| 401 | if ( m_keyType == wxKEY_STRING ) |
| 402 | delete m_key.string; |
| 403 | } |
| 404 | |
| 405 | private: |
| 406 | wxKeyType m_keyType; |
| 407 | wxListKeyValue m_key; |
| 408 | }; |
| 409 | |
| 410 | // ----------------------------------------------------------------------------- |
| 411 | // wxNodeBase class is a (base for) node in a double linked list |
| 412 | // ----------------------------------------------------------------------------- |
| 413 | |
| 414 | extern WXDLLIMPEXP_DATA_BASE(wxListKey) wxDefaultListKey; |
| 415 | |
| 416 | class WXDLLIMPEXP_FWD_BASE wxListBase; |
| 417 | |
| 418 | class WXDLLIMPEXP_BASE wxNodeBase |
| 419 | { |
| 420 | friend class wxListBase; |
| 421 | public: |
| 422 | // ctor |
| 423 | wxNodeBase(wxListBase *list = (wxListBase *)NULL, |
| 424 | wxNodeBase *previous = (wxNodeBase *)NULL, |
| 425 | wxNodeBase *next = (wxNodeBase *)NULL, |
| 426 | void *data = NULL, |
| 427 | const wxListKey& key = wxDefaultListKey); |
| 428 | |
| 429 | virtual ~wxNodeBase(); |
| 430 | |
| 431 | // FIXME no check is done that the list is really keyed on strings |
| 432 | wxString GetKeyString() const { return *m_key.string; } |
| 433 | long GetKeyInteger() const { return m_key.integer; } |
| 434 | |
| 435 | // Necessary for some existing code |
| 436 | void SetKeyString(const wxString& s) { m_key.string = new wxString(s); } |
| 437 | void SetKeyInteger(long i) { m_key.integer = i; } |
| 438 | |
| 439 | #ifdef wxLIST_COMPATIBILITY |
| 440 | // compatibility methods, use Get* instead. |
| 441 | wxDEPRECATED( wxNode *Next() const ); |
| 442 | wxDEPRECATED( wxNode *Previous() const ); |
| 443 | wxDEPRECATED( wxObject *Data() const ); |
| 444 | #endif // wxLIST_COMPATIBILITY |
| 445 | |
| 446 | protected: |
| 447 | // all these are going to be "overloaded" in the derived classes |
| 448 | wxNodeBase *GetNext() const { return m_next; } |
| 449 | wxNodeBase *GetPrevious() const { return m_previous; } |
| 450 | |
| 451 | void *GetData() const { return m_data; } |
| 452 | void SetData(void *data) { m_data = data; } |
| 453 | |
| 454 | // get 0-based index of this node within the list or wxNOT_FOUND |
| 455 | int IndexOf() const; |
| 456 | |
| 457 | virtual void DeleteData() { } |
| 458 | public: |
| 459 | // for wxList::iterator |
| 460 | void** GetDataPtr() const { return &(const_cast<wxNodeBase*>(this)->m_data); } |
| 461 | private: |
| 462 | // optional key stuff |
| 463 | wxListKeyValue m_key; |
| 464 | |
| 465 | void *m_data; // user data |
| 466 | wxNodeBase *m_next, // next and previous nodes in the list |
| 467 | *m_previous; |
| 468 | |
| 469 | wxListBase *m_list; // list we belong to |
| 470 | |
| 471 | DECLARE_NO_COPY_CLASS(wxNodeBase) |
| 472 | }; |
| 473 | |
| 474 | // ----------------------------------------------------------------------------- |
| 475 | // a double-linked list class |
| 476 | // ----------------------------------------------------------------------------- |
| 477 | |
| 478 | class WXDLLIMPEXP_FWD_BASE wxList; |
| 479 | |
| 480 | class WXDLLIMPEXP_BASE wxListBase |
| 481 | { |
| 482 | friend class wxNodeBase; // should be able to call DetachNode() |
| 483 | friend class wxHashTableBase; // should be able to call untyped Find() |
| 484 | |
| 485 | public: |
| 486 | // default ctor & dtor |
| 487 | wxListBase(wxKeyType keyType = wxKEY_NONE) |
| 488 | { Init(keyType); } |
| 489 | virtual ~wxListBase(); |
| 490 | |
| 491 | // accessors |
| 492 | // count of items in the list |
| 493 | size_t GetCount() const { return m_count; } |
| 494 | |
| 495 | // return true if this list is empty |
| 496 | bool IsEmpty() const { return m_count == 0; } |
| 497 | |
| 498 | // operations |
| 499 | |
| 500 | // delete all nodes |
| 501 | void Clear(); |
| 502 | |
| 503 | // instruct it to destroy user data when deleting nodes |
| 504 | void DeleteContents(bool destroy) { m_destroy = destroy; } |
| 505 | |
| 506 | // query if to delete |
| 507 | bool GetDeleteContents() const |
| 508 | { return m_destroy; } |
| 509 | |
| 510 | // get the keytype |
| 511 | wxKeyType GetKeyType() const |
| 512 | { return m_keyType; } |
| 513 | |
| 514 | // set the keytype (required by the serial code) |
| 515 | void SetKeyType(wxKeyType keyType) |
| 516 | { wxASSERT( m_count==0 ); m_keyType = keyType; } |
| 517 | |
| 518 | #ifdef wxLIST_COMPATIBILITY |
| 519 | // compatibility methods from old wxList |
| 520 | wxDEPRECATED( int Number() const ); // use GetCount instead. |
| 521 | wxDEPRECATED( wxNode *First() const ); // use GetFirst |
| 522 | wxDEPRECATED( wxNode *Last() const ); // use GetLast |
| 523 | wxDEPRECATED( wxNode *Nth(size_t n) const ); // use Item |
| 524 | |
| 525 | // kludge for typesafe list migration in core classes. |
| 526 | wxDEPRECATED( operator wxList&() const ); |
| 527 | #endif // wxLIST_COMPATIBILITY |
| 528 | |
| 529 | protected: |
| 530 | |
| 531 | // all methods here are "overloaded" in derived classes to provide compile |
| 532 | // time type checking |
| 533 | |
| 534 | // create a node for the list of this type |
| 535 | virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, |
| 536 | void *data, |
| 537 | const wxListKey& key = wxDefaultListKey) = 0; |
| 538 | |
| 539 | |
| 540 | // ctors |
| 541 | // from an array |
| 542 | wxListBase(size_t count, void *elements[]); |
| 543 | // from a sequence of objects |
| 544 | wxListBase(void *object, ... /* terminate with NULL */); |
| 545 | |
| 546 | protected: |
| 547 | void Assign(const wxListBase& list) |
| 548 | { Clear(); DoCopy(list); } |
| 549 | |
| 550 | // get list head/tail |
| 551 | wxNodeBase *GetFirst() const { return m_nodeFirst; } |
| 552 | wxNodeBase *GetLast() const { return m_nodeLast; } |
| 553 | |
| 554 | // by (0-based) index |
| 555 | wxNodeBase *Item(size_t index) const; |
| 556 | |
| 557 | // get the list item's data |
| 558 | void *operator[](size_t n) const |
| 559 | { |
| 560 | wxNodeBase *node = Item(n); |
| 561 | |
| 562 | return node ? node->GetData() : (wxNodeBase *)NULL; |
| 563 | } |
| 564 | |
| 565 | // operations |
| 566 | // append to end of list |
| 567 | wxNodeBase *Prepend(void *object) |
| 568 | { return (wxNodeBase *)wxListBase::Insert(object); } |
| 569 | // append to beginning of list |
| 570 | wxNodeBase *Append(void *object); |
| 571 | // insert a new item at the beginning of the list |
| 572 | wxNodeBase *Insert(void *object) { return Insert( (wxNodeBase*)NULL, object); } |
| 573 | // insert a new item at the given position |
| 574 | wxNodeBase *Insert(size_t pos, void *object) |
| 575 | { return pos == GetCount() ? Append(object) |
| 576 | : Insert(Item(pos), object); } |
| 577 | // insert before given node or at front of list if prev == NULL |
| 578 | wxNodeBase *Insert(wxNodeBase *prev, void *object); |
| 579 | |
| 580 | // keyed append |
| 581 | wxNodeBase *Append(long key, void *object); |
| 582 | wxNodeBase *Append(const wxString& key, void *object); |
| 583 | |
| 584 | // removes node from the list but doesn't delete it (returns pointer |
| 585 | // to the node or NULL if it wasn't found in the list) |
| 586 | wxNodeBase *DetachNode(wxNodeBase *node); |
| 587 | // delete element from list, returns false if node not found |
| 588 | bool DeleteNode(wxNodeBase *node); |
| 589 | // finds object pointer and deletes node (and object if DeleteContents |
| 590 | // is on), returns false if object not found |
| 591 | bool DeleteObject(void *object); |
| 592 | |
| 593 | // search (all return NULL if item not found) |
| 594 | // by data |
| 595 | wxNodeBase *Find(const void *object) const; |
| 596 | |
| 597 | // by key |
| 598 | wxNodeBase *Find(const wxListKey& key) const; |
| 599 | |
| 600 | // get 0-based index of object or wxNOT_FOUND |
| 601 | int IndexOf( void *object ) const; |
| 602 | |
| 603 | // this function allows the sorting of arbitrary lists by giving |
| 604 | // a function to compare two list elements. The list is sorted in place. |
| 605 | void Sort(const wxSortCompareFunction compfunc); |
| 606 | |
| 607 | // functions for iterating over the list |
| 608 | void *FirstThat(wxListIterateFunction func); |
| 609 | void ForEach(wxListIterateFunction func); |
| 610 | void *LastThat(wxListIterateFunction func); |
| 611 | |
| 612 | // for STL interface, "last" points to one after the last node |
| 613 | // of the controlled sequence (NULL for the end of the list) |
| 614 | void Reverse(); |
| 615 | void DeleteNodes(wxNodeBase* first, wxNodeBase* last); |
| 616 | private: |
| 617 | |
| 618 | // common part of all ctors |
| 619 | void Init(wxKeyType keyType = wxKEY_NONE); |
| 620 | |
| 621 | // helpers |
| 622 | // common part of copy ctor and assignment operator |
| 623 | void DoCopy(const wxListBase& list); |
| 624 | // common part of all Append()s |
| 625 | wxNodeBase *AppendCommon(wxNodeBase *node); |
| 626 | // free node's data and node itself |
| 627 | void DoDeleteNode(wxNodeBase *node); |
| 628 | |
| 629 | size_t m_count; // number of elements in the list |
| 630 | bool m_destroy; // destroy user data when deleting list items? |
| 631 | wxNodeBase *m_nodeFirst, // pointers to the head and tail of the list |
| 632 | *m_nodeLast; |
| 633 | |
| 634 | wxKeyType m_keyType; // type of our keys (may be wxKEY_NONE) |
| 635 | }; |
| 636 | |
| 637 | // ----------------------------------------------------------------------------- |
| 638 | // macros for definition of "template" list type |
| 639 | // ----------------------------------------------------------------------------- |
| 640 | |
| 641 | // and now some heavy magic... |
| 642 | |
| 643 | // declare a list type named 'name' and containing elements of type 'T *' |
| 644 | // (as a by product of macro expansion you also get wx##name##Node |
| 645 | // wxNode-derived type) |
| 646 | // |
| 647 | // implementation details: |
| 648 | // 1. We define _WX_LIST_ITEM_TYPE_##name typedef to save in it the item type |
| 649 | // for the list of given type - this allows us to pass only the list name |
| 650 | // to WX_DEFINE_LIST() even if it needs both the name and the type |
| 651 | // |
| 652 | // 2. We redefine all non-type-safe wxList functions with type-safe versions |
| 653 | // which don't take any space (everything is inline), but bring compile |
| 654 | // time error checking. |
| 655 | // |
| 656 | // 3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of |
| 657 | // a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most |
| 658 | // generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes |
| 659 | // interesting capability to store polymorphic objects in the list and is |
| 660 | // particularly useful with, for example, "wxWindow *" list where the |
| 661 | // wxWindowBase pointers are put into the list, but wxWindow pointers are |
| 662 | // retrieved from it. |
| 663 | // |
| 664 | // 4. final hack is that WX_DECLARE_LIST_3 is defined in terms of |
| 665 | // WX_DECLARE_LIST_4 to allow defining classes without operator->() as |
| 666 | // it results in compiler warnings when this operator doesn't make sense |
| 667 | // (i.e. stored elements are not pointers) |
| 668 | |
| 669 | // common part of WX_DECLARE_LIST_3 and WX_DECLARE_LIST_PTR_3 |
| 670 | #define WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, ptrop) \ |
| 671 | typedef int (*wxSortFuncFor_##name)(const T **, const T **); \ |
| 672 | \ |
| 673 | classexp nodetype : public wxNodeBase \ |
| 674 | { \ |
| 675 | public: \ |
| 676 | nodetype(wxListBase *list = (wxListBase *)NULL, \ |
| 677 | nodetype *previous = (nodetype *)NULL, \ |
| 678 | nodetype *next = (nodetype *)NULL, \ |
| 679 | T *data = (T *)NULL, \ |
| 680 | const wxListKey& key = wxDefaultListKey) \ |
| 681 | : wxNodeBase(list, previous, next, data, key) { } \ |
| 682 | \ |
| 683 | nodetype *GetNext() const \ |
| 684 | { return (nodetype *)wxNodeBase::GetNext(); } \ |
| 685 | nodetype *GetPrevious() const \ |
| 686 | { return (nodetype *)wxNodeBase::GetPrevious(); } \ |
| 687 | \ |
| 688 | T *GetData() const \ |
| 689 | { return (T *)wxNodeBase::GetData(); } \ |
| 690 | void SetData(T *data) \ |
| 691 | { wxNodeBase::SetData(data); } \ |
| 692 | \ |
| 693 | protected: \ |
| 694 | virtual void DeleteData(); \ |
| 695 | \ |
| 696 | DECLARE_NO_COPY_CLASS(nodetype) \ |
| 697 | }; \ |
| 698 | \ |
| 699 | classexp name : public wxListBase \ |
| 700 | { \ |
| 701 | public: \ |
| 702 | typedef nodetype Node; \ |
| 703 | classexp compatibility_iterator \ |
| 704 | { \ |
| 705 | public: \ |
| 706 | compatibility_iterator(Node *ptr = NULL) : m_ptr(ptr) { } \ |
| 707 | \ |
| 708 | Node *operator->() const { return m_ptr; } \ |
| 709 | operator Node *() const { return m_ptr; } \ |
| 710 | \ |
| 711 | private: \ |
| 712 | Node *m_ptr; \ |
| 713 | }; \ |
| 714 | \ |
| 715 | name(wxKeyType keyType = wxKEY_NONE) : wxListBase(keyType) \ |
| 716 | { } \ |
| 717 | name(const name& list) : wxListBase(list.GetKeyType()) \ |
| 718 | { Assign(list); } \ |
| 719 | name(size_t count, T *elements[]) \ |
| 720 | : wxListBase(count, (void **)elements) { } \ |
| 721 | \ |
| 722 | name& operator=(const name& list) \ |
| 723 | { if (&list != this) Assign(list); return *this; } \ |
| 724 | \ |
| 725 | nodetype *GetFirst() const \ |
| 726 | { return (nodetype *)wxListBase::GetFirst(); } \ |
| 727 | nodetype *GetLast() const \ |
| 728 | { return (nodetype *)wxListBase::GetLast(); } \ |
| 729 | \ |
| 730 | nodetype *Item(size_t index) const \ |
| 731 | { return (nodetype *)wxListBase::Item(index); } \ |
| 732 | \ |
| 733 | T *operator[](size_t index) const \ |
| 734 | { \ |
| 735 | nodetype *node = Item(index); \ |
| 736 | return node ? (T*)(node->GetData()) : (T*)NULL; \ |
| 737 | } \ |
| 738 | \ |
| 739 | nodetype *Append(Tbase *object) \ |
| 740 | { return (nodetype *)wxListBase::Append(object); } \ |
| 741 | nodetype *Insert(Tbase *object) \ |
| 742 | { return (nodetype *)Insert((nodetype*)NULL, object); } \ |
| 743 | nodetype *Insert(size_t pos, Tbase *object) \ |
| 744 | { return (nodetype *)wxListBase::Insert(pos, object); } \ |
| 745 | nodetype *Insert(nodetype *prev, Tbase *object) \ |
| 746 | { return (nodetype *)wxListBase::Insert(prev, object); } \ |
| 747 | \ |
| 748 | nodetype *Append(long key, void *object) \ |
| 749 | { return (nodetype *)wxListBase::Append(key, object); } \ |
| 750 | nodetype *Append(const wxChar *key, void *object) \ |
| 751 | { return (nodetype *)wxListBase::Append(key, object); } \ |
| 752 | \ |
| 753 | nodetype *DetachNode(nodetype *node) \ |
| 754 | { return (nodetype *)wxListBase::DetachNode(node); } \ |
| 755 | bool DeleteNode(nodetype *node) \ |
| 756 | { return wxListBase::DeleteNode(node); } \ |
| 757 | bool DeleteObject(Tbase *object) \ |
| 758 | { return wxListBase::DeleteObject(object); } \ |
| 759 | void Erase(nodetype *it) \ |
| 760 | { DeleteNode(it); } \ |
| 761 | \ |
| 762 | nodetype *Find(const Tbase *object) const \ |
| 763 | { return (nodetype *)wxListBase::Find(object); } \ |
| 764 | \ |
| 765 | virtual nodetype *Find(const wxListKey& key) const \ |
| 766 | { return (nodetype *)wxListBase::Find(key); } \ |
| 767 | \ |
| 768 | int IndexOf(Tbase *object) const \ |
| 769 | { return wxListBase::IndexOf(object); } \ |
| 770 | \ |
| 771 | void Sort(wxSortCompareFunction func) \ |
| 772 | { wxListBase::Sort(func); } \ |
| 773 | void Sort(wxSortFuncFor_##name func) \ |
| 774 | { Sort((wxSortCompareFunction)func); } \ |
| 775 | \ |
| 776 | protected: \ |
| 777 | virtual wxNodeBase *CreateNode(wxNodeBase *prev, wxNodeBase *next, \ |
| 778 | void *data, \ |
| 779 | const wxListKey& key = wxDefaultListKey) \ |
| 780 | { \ |
| 781 | return new nodetype(this, \ |
| 782 | (nodetype *)prev, (nodetype *)next, \ |
| 783 | (T *)data, key); \ |
| 784 | } \ |
| 785 | /* STL interface */ \ |
| 786 | public: \ |
| 787 | typedef size_t size_type; \ |
| 788 | typedef int difference_type; \ |
| 789 | typedef T* value_type; \ |
| 790 | typedef Tbase* base_value_type; \ |
| 791 | typedef value_type& reference; \ |
| 792 | typedef const value_type& const_reference; \ |
| 793 | typedef base_value_type& base_reference; \ |
| 794 | typedef const base_value_type& const_base_reference; \ |
| 795 | \ |
| 796 | classexp iterator \ |
| 797 | { \ |
| 798 | typedef name list; \ |
| 799 | public: \ |
| 800 | typedef nodetype Node; \ |
| 801 | typedef iterator itor; \ |
| 802 | typedef T* value_type; \ |
| 803 | typedef value_type* ptr_type; \ |
| 804 | typedef value_type& reference; \ |
| 805 | \ |
| 806 | Node* m_node; \ |
| 807 | Node* m_init; \ |
| 808 | public: \ |
| 809 | typedef reference reference_type; \ |
| 810 | typedef ptr_type pointer_type; \ |
| 811 | \ |
| 812 | iterator(Node* node, Node* init) : m_node(node), m_init(init) {}\ |
| 813 | iterator() : m_node(NULL), m_init(NULL) { } \ |
| 814 | reference_type operator*() const \ |
| 815 | { return *(pointer_type)m_node->GetDataPtr(); } \ |
| 816 | ptrop \ |
| 817 | itor& operator++() { m_node = m_node->GetNext(); return *this; }\ |
| 818 | const itor operator++(int) \ |
| 819 | { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\ |
| 820 | itor& operator--() \ |
| 821 | { \ |
| 822 | m_node = m_node ? m_node->GetPrevious() : m_init; \ |
| 823 | return *this; \ |
| 824 | } \ |
| 825 | const itor operator--(int) \ |
| 826 | { \ |
| 827 | itor tmp = *this; \ |
| 828 | m_node = m_node ? m_node->GetPrevious() : m_init; \ |
| 829 | return tmp; \ |
| 830 | } \ |
| 831 | bool operator!=(const itor& it) const \ |
| 832 | { return it.m_node != m_node; } \ |
| 833 | bool operator==(const itor& it) const \ |
| 834 | { return it.m_node == m_node; } \ |
| 835 | }; \ |
| 836 | classexp const_iterator \ |
| 837 | { \ |
| 838 | typedef name list; \ |
| 839 | public: \ |
| 840 | typedef nodetype Node; \ |
| 841 | typedef T* value_type; \ |
| 842 | typedef const value_type& const_reference; \ |
| 843 | typedef const_iterator itor; \ |
| 844 | typedef value_type* ptr_type; \ |
| 845 | \ |
| 846 | Node* m_node; \ |
| 847 | Node* m_init; \ |
| 848 | public: \ |
| 849 | typedef const_reference reference_type; \ |
| 850 | typedef const ptr_type pointer_type; \ |
| 851 | \ |
| 852 | const_iterator(Node* node, Node* init) \ |
| 853 | : m_node(node), m_init(init) { } \ |
| 854 | const_iterator() : m_node(NULL), m_init(NULL) { } \ |
| 855 | const_iterator(const iterator& it) \ |
| 856 | : m_node(it.m_node), m_init(it.m_init) { } \ |
| 857 | reference_type operator*() const \ |
| 858 | { return *(pointer_type)m_node->GetDataPtr(); } \ |
| 859 | ptrop \ |
| 860 | itor& operator++() { m_node = m_node->GetNext(); return *this; }\ |
| 861 | const itor operator++(int) \ |
| 862 | { itor tmp = *this; m_node = m_node->GetNext(); return tmp; }\ |
| 863 | itor& operator--() \ |
| 864 | { \ |
| 865 | m_node = m_node ? m_node->GetPrevious() : m_init; \ |
| 866 | return *this; \ |
| 867 | } \ |
| 868 | const itor operator--(int) \ |
| 869 | { \ |
| 870 | itor tmp = *this; \ |
| 871 | m_node = m_node ? m_node->GetPrevious() : m_init; \ |
| 872 | return tmp; \ |
| 873 | } \ |
| 874 | bool operator!=(const itor& it) const \ |
| 875 | { return it.m_node != m_node; } \ |
| 876 | bool operator==(const itor& it) const \ |
| 877 | { return it.m_node == m_node; } \ |
| 878 | }; \ |
| 879 | classexp reverse_iterator \ |
| 880 | { \ |
| 881 | typedef name list; \ |
| 882 | public: \ |
| 883 | typedef nodetype Node; \ |
| 884 | typedef T* value_type; \ |
| 885 | typedef reverse_iterator itor; \ |
| 886 | typedef value_type* ptr_type; \ |
| 887 | typedef value_type& reference; \ |
| 888 | \ |
| 889 | Node* m_node; \ |
| 890 | Node* m_init; \ |
| 891 | public: \ |
| 892 | typedef reference reference_type; \ |
| 893 | typedef ptr_type pointer_type; \ |
| 894 | \ |
| 895 | reverse_iterator(Node* node, Node* init) \ |
| 896 | : m_node(node), m_init(init) { } \ |
| 897 | reverse_iterator() : m_node(NULL), m_init(NULL) { } \ |
| 898 | reference_type operator*() const \ |
| 899 | { return *(pointer_type)m_node->GetDataPtr(); } \ |
| 900 | ptrop \ |
| 901 | itor& operator++() \ |
| 902 | { m_node = m_node->GetPrevious(); return *this; } \ |
| 903 | const itor operator++(int) \ |
| 904 | { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\ |
| 905 | itor& operator--() \ |
| 906 | { m_node = m_node ? m_node->GetNext() : m_init; return *this; } \ |
| 907 | const itor operator--(int) \ |
| 908 | { \ |
| 909 | itor tmp = *this; \ |
| 910 | m_node = m_node ? m_node->GetNext() : m_init; \ |
| 911 | return tmp; \ |
| 912 | } \ |
| 913 | bool operator!=(const itor& it) const \ |
| 914 | { return it.m_node != m_node; } \ |
| 915 | bool operator==(const itor& it) const \ |
| 916 | { return it.m_node == m_node; } \ |
| 917 | }; \ |
| 918 | classexp const_reverse_iterator \ |
| 919 | { \ |
| 920 | typedef name list; \ |
| 921 | public: \ |
| 922 | typedef nodetype Node; \ |
| 923 | typedef T* value_type; \ |
| 924 | typedef const_reverse_iterator itor; \ |
| 925 | typedef value_type* ptr_type; \ |
| 926 | typedef const value_type& const_reference; \ |
| 927 | \ |
| 928 | Node* m_node; \ |
| 929 | Node* m_init; \ |
| 930 | public: \ |
| 931 | typedef const_reference reference_type; \ |
| 932 | typedef const ptr_type pointer_type; \ |
| 933 | \ |
| 934 | const_reverse_iterator(Node* node, Node* init) \ |
| 935 | : m_node(node), m_init(init) { } \ |
| 936 | const_reverse_iterator() : m_node(NULL), m_init(NULL) { } \ |
| 937 | const_reverse_iterator(const reverse_iterator& it) \ |
| 938 | : m_node(it.m_node), m_init(it.m_init) { } \ |
| 939 | reference_type operator*() const \ |
| 940 | { return *(pointer_type)m_node->GetDataPtr(); } \ |
| 941 | ptrop \ |
| 942 | itor& operator++() \ |
| 943 | { m_node = m_node->GetPrevious(); return *this; } \ |
| 944 | const itor operator++(int) \ |
| 945 | { itor tmp = *this; m_node = m_node->GetPrevious(); return tmp; }\ |
| 946 | itor& operator--() \ |
| 947 | { m_node = m_node ? m_node->GetNext() : m_init; return *this;}\ |
| 948 | const itor operator--(int) \ |
| 949 | { \ |
| 950 | itor tmp = *this; \ |
| 951 | m_node = m_node ? m_node->GetNext() : m_init; \ |
| 952 | return tmp; \ |
| 953 | } \ |
| 954 | bool operator!=(const itor& it) const \ |
| 955 | { return it.m_node != m_node; } \ |
| 956 | bool operator==(const itor& it) const \ |
| 957 | { return it.m_node == m_node; } \ |
| 958 | }; \ |
| 959 | \ |
| 960 | wxEXPLICIT name(size_type n, const_reference v = value_type()) \ |
| 961 | { assign(n, v); } \ |
| 962 | name(const const_iterator& first, const const_iterator& last) \ |
| 963 | { assign(first, last); } \ |
| 964 | iterator begin() { return iterator(GetFirst(), GetLast()); } \ |
| 965 | const_iterator begin() const \ |
| 966 | { return const_iterator(GetFirst(), GetLast()); } \ |
| 967 | iterator end() { return iterator(NULL, GetLast()); } \ |
| 968 | const_iterator end() const { return const_iterator(NULL, GetLast()); }\ |
| 969 | reverse_iterator rbegin() \ |
| 970 | { return reverse_iterator(GetLast(), GetFirst()); } \ |
| 971 | const_reverse_iterator rbegin() const \ |
| 972 | { return const_reverse_iterator(GetLast(), GetFirst()); } \ |
| 973 | reverse_iterator rend() { return reverse_iterator(NULL, GetFirst()); }\ |
| 974 | const_reverse_iterator rend() const \ |
| 975 | { return const_reverse_iterator(NULL, GetFirst()); } \ |
| 976 | void resize(size_type n, value_type v = value_type()) \ |
| 977 | { \ |
| 978 | while (n < size()) \ |
| 979 | pop_back(); \ |
| 980 | while (n > size()) \ |
| 981 | push_back(v); \ |
| 982 | } \ |
| 983 | size_type size() const { return GetCount(); } \ |
| 984 | size_type max_size() const { return INT_MAX; } \ |
| 985 | bool empty() const { return IsEmpty(); } \ |
| 986 | reference front() { return *begin(); } \ |
| 987 | const_reference front() const { return *begin(); } \ |
| 988 | reference back() { iterator tmp = end(); return *--tmp; } \ |
| 989 | const_reference back() const { const_iterator tmp = end(); return *--tmp; }\ |
| 990 | void push_front(const_reference v = value_type()) \ |
| 991 | { Insert(GetFirst(), (const_base_reference)v); } \ |
| 992 | void pop_front() { DeleteNode(GetFirst()); } \ |
| 993 | void push_back(const_reference v = value_type()) \ |
| 994 | { Append((const_base_reference)v); } \ |
| 995 | void pop_back() { DeleteNode(GetLast()); } \ |
| 996 | void assign(const_iterator first, const const_iterator& last) \ |
| 997 | { \ |
| 998 | clear(); \ |
| 999 | for(; first != last; ++first) \ |
| 1000 | Append((const_base_reference)*first); \ |
| 1001 | } \ |
| 1002 | void assign(size_type n, const_reference v = value_type()) \ |
| 1003 | { \ |
| 1004 | clear(); \ |
| 1005 | for(size_type i = 0; i < n; ++i) \ |
| 1006 | Append((const_base_reference)v); \ |
| 1007 | } \ |
| 1008 | iterator insert(const iterator& it, const_reference v) \ |
| 1009 | { \ |
| 1010 | if ( it == end() ) \ |
| 1011 | Append((const_base_reference)v); \ |
| 1012 | else \ |
| 1013 | Insert(it.m_node, (const_base_reference)v); \ |
| 1014 | iterator itprev(it); \ |
| 1015 | return itprev--; \ |
| 1016 | } \ |
| 1017 | void insert(const iterator& it, size_type n, const_reference v) \ |
| 1018 | { \ |
| 1019 | for(size_type i = 0; i < n; ++i) \ |
| 1020 | Insert(it.m_node, (const_base_reference)v); \ |
| 1021 | } \ |
| 1022 | void insert(const iterator& it, \ |
| 1023 | const_iterator first, const const_iterator& last) \ |
| 1024 | { \ |
| 1025 | for(; first != last; ++first) \ |
| 1026 | Insert(it.m_node, (const_base_reference)*first); \ |
| 1027 | } \ |
| 1028 | iterator erase(const iterator& it) \ |
| 1029 | { \ |
| 1030 | iterator next = iterator(it.m_node->GetNext(), GetLast()); \ |
| 1031 | DeleteNode(it.m_node); return next; \ |
| 1032 | } \ |
| 1033 | iterator erase(const iterator& first, const iterator& last) \ |
| 1034 | { \ |
| 1035 | iterator next = last; ++next; \ |
| 1036 | DeleteNodes(first.m_node, last.m_node); \ |
| 1037 | return next; \ |
| 1038 | } \ |
| 1039 | void clear() { Clear(); } \ |
| 1040 | void splice(const iterator& it, name& l, const iterator& first, const iterator& last)\ |
| 1041 | { insert(it, first, last); l.erase(first, last); } \ |
| 1042 | void splice(const iterator& it, name& l) \ |
| 1043 | { splice(it, l, l.begin(), l.end() ); } \ |
| 1044 | void splice(const iterator& it, name& l, const iterator& first) \ |
| 1045 | { \ |
| 1046 | iterator tmp = first; ++tmp; \ |
| 1047 | if(it == first || it == tmp) return; \ |
| 1048 | insert(it, *first); \ |
| 1049 | l.erase(first); \ |
| 1050 | } \ |
| 1051 | void remove(const_reference v) \ |
| 1052 | { DeleteObject((const_base_reference)v); } \ |
| 1053 | void reverse() \ |
| 1054 | { Reverse(); } \ |
| 1055 | /* void swap(name& l) \ |
| 1056 | { \ |
| 1057 | { size_t t = m_count; m_count = l.m_count; l.m_count = t; } \ |
| 1058 | { bool t = m_destroy; m_destroy = l.m_destroy; l.m_destroy = t; }\ |
| 1059 | { wxNodeBase* t = m_nodeFirst; m_nodeFirst = l.m_nodeFirst; l.m_nodeFirst = t; }\ |
| 1060 | { wxNodeBase* t = m_nodeLast; m_nodeLast = l.m_nodeLast; l.m_nodeLast = t; }\ |
| 1061 | { wxKeyType t = m_keyType; m_keyType = l.m_keyType; l.m_keyType = t; }\ |
| 1062 | } */ \ |
| 1063 | } |
| 1064 | |
| 1065 | #define WX_LIST_PTROP \ |
| 1066 | pointer_type operator->() const \ |
| 1067 | { return (pointer_type)m_node->GetDataPtr(); } |
| 1068 | #define WX_LIST_PTROP_NONE |
| 1069 | |
| 1070 | #define WX_DECLARE_LIST_3(T, Tbase, name, nodetype, classexp) \ |
| 1071 | WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP_NONE) |
| 1072 | #define WX_DECLARE_LIST_PTR_3(T, Tbase, name, nodetype, classexp) \ |
| 1073 | WX_DECLARE_LIST_4(T, Tbase, name, nodetype, classexp, WX_LIST_PTROP) |
| 1074 | |
| 1075 | #define WX_DECLARE_LIST_2(elementtype, listname, nodename, classexp) \ |
| 1076 | WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename, classexp) |
| 1077 | #define WX_DECLARE_LIST_PTR_2(elementtype, listname, nodename, classexp) \ |
| 1078 | WX_DECLARE_LIST_PTR_3(elementtype, elementtype, listname, nodename, classexp) |
| 1079 | |
| 1080 | #define WX_DECLARE_LIST(elementtype, listname) \ |
| 1081 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1082 | WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class) |
| 1083 | #define WX_DECLARE_LIST_PTR(elementtype, listname) \ |
| 1084 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1085 | WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class) |
| 1086 | |
| 1087 | #define WX_DECLARE_LIST_WITH_DECL(elementtype, listname, decl) \ |
| 1088 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1089 | WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, decl) |
| 1090 | |
| 1091 | #define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \ |
| 1092 | WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLIMPEXP_CORE) |
| 1093 | |
| 1094 | #define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \ |
| 1095 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1096 | WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class WXDLLIMPEXP_CORE) |
| 1097 | |
| 1098 | #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \ |
| 1099 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1100 | WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node, class usergoo) |
| 1101 | #define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \ |
| 1102 | typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \ |
| 1103 | WX_DECLARE_LIST_PTR_2(elementtype, listname, wx##listname##Node, class usergoo) |
| 1104 | |
| 1105 | // this macro must be inserted in your program after |
| 1106 | // #include "wx/listimpl.cpp" |
| 1107 | #define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!" |
| 1108 | |
| 1109 | #define WX_DEFINE_EXPORTED_LIST(name) WX_DEFINE_LIST(name) |
| 1110 | #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name) |
| 1111 | |
| 1112 | #endif // !wxUSE_STL |
| 1113 | |
| 1114 | // ============================================================================ |
| 1115 | // now we can define classes 100% compatible with the old ones |
| 1116 | // ============================================================================ |
| 1117 | |
| 1118 | // ---------------------------------------------------------------------------- |
| 1119 | // commonly used list classes |
| 1120 | // ---------------------------------------------------------------------------- |
| 1121 | |
| 1122 | #if defined(wxLIST_COMPATIBILITY) |
| 1123 | |
| 1124 | // inline compatibility functions |
| 1125 | |
| 1126 | #if !wxUSE_STL |
| 1127 | |
| 1128 | // ---------------------------------------------------------------------------- |
| 1129 | // wxNodeBase deprecated methods |
| 1130 | // ---------------------------------------------------------------------------- |
| 1131 | |
| 1132 | inline wxNode *wxNodeBase::Next() const { return (wxNode *)GetNext(); } |
| 1133 | inline wxNode *wxNodeBase::Previous() const { return (wxNode *)GetPrevious(); } |
| 1134 | inline wxObject *wxNodeBase::Data() const { return (wxObject *)GetData(); } |
| 1135 | |
| 1136 | // ---------------------------------------------------------------------------- |
| 1137 | // wxListBase deprecated methods |
| 1138 | // ---------------------------------------------------------------------------- |
| 1139 | |
| 1140 | inline int wxListBase::Number() const { return (int)GetCount(); } |
| 1141 | inline wxNode *wxListBase::First() const { return (wxNode *)GetFirst(); } |
| 1142 | inline wxNode *wxListBase::Last() const { return (wxNode *)GetLast(); } |
| 1143 | inline wxNode *wxListBase::Nth(size_t n) const { return (wxNode *)Item(n); } |
| 1144 | inline wxListBase::operator wxList&() const { return *(wxList*)this; } |
| 1145 | |
| 1146 | #endif |
| 1147 | |
| 1148 | // define this to make a lot of noise about use of the old wxList classes. |
| 1149 | //#define wxWARN_COMPAT_LIST_USE |
| 1150 | |
| 1151 | // ---------------------------------------------------------------------------- |
| 1152 | // wxList compatibility class: in fact, it's a list of wxObjects |
| 1153 | // ---------------------------------------------------------------------------- |
| 1154 | |
| 1155 | WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, |
| 1156 | class WXDLLIMPEXP_BASE); |
| 1157 | |
| 1158 | class WXDLLIMPEXP_BASE wxList : public wxObjectList |
| 1159 | { |
| 1160 | public: |
| 1161 | #if defined(wxWARN_COMPAT_LIST_USE) && !wxUSE_STL |
| 1162 | wxList() { }; |
| 1163 | wxDEPRECATED( wxList(int key_type) ); |
| 1164 | #elif !wxUSE_STL |
| 1165 | wxList(int key_type = wxKEY_NONE); |
| 1166 | #endif |
| 1167 | |
| 1168 | // this destructor is required for Darwin |
| 1169 | ~wxList() { } |
| 1170 | |
| 1171 | #if !wxUSE_STL |
| 1172 | wxList& operator=(const wxList& list) |
| 1173 | { if (&list != this) Assign(list); return *this; } |
| 1174 | |
| 1175 | // compatibility methods |
| 1176 | void Sort(wxSortCompareFunction compfunc) { wxListBase::Sort(compfunc); } |
| 1177 | #endif |
| 1178 | |
| 1179 | #if wxUSE_STL |
| 1180 | #else |
| 1181 | wxNode *Member(wxObject *object) const { return (wxNode *)Find(object); } |
| 1182 | #endif |
| 1183 | }; |
| 1184 | |
| 1185 | #if !wxUSE_STL |
| 1186 | |
| 1187 | // ----------------------------------------------------------------------------- |
| 1188 | // wxStringList class for compatibility with the old code |
| 1189 | // ----------------------------------------------------------------------------- |
| 1190 | WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLIMPEXP_BASE); |
| 1191 | |
| 1192 | class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase |
| 1193 | { |
| 1194 | public: |
| 1195 | // ctors and such |
| 1196 | // default |
| 1197 | #ifdef wxWARN_COMPAT_LIST_USE |
| 1198 | wxStringList(); |
| 1199 | wxDEPRECATED( wxStringList(const wxChar *first ...) ); // FIXME-UTF8 |
| 1200 | #else |
| 1201 | wxStringList(); |
| 1202 | wxStringList(const wxChar *first ...); // FIXME-UTF8 |
| 1203 | #endif |
| 1204 | |
| 1205 | // copying the string list: the strings are copied, too (extremely |
| 1206 | // inefficient!) |
| 1207 | wxStringList(const wxStringList& other) : wxStringListBase() { DeleteContents(true); DoCopy(other); } |
| 1208 | wxStringList& operator=(const wxStringList& other) |
| 1209 | { |
| 1210 | if (&other != this) |
| 1211 | { |
| 1212 | Clear(); |
| 1213 | DoCopy(other); |
| 1214 | } |
| 1215 | return *this; |
| 1216 | } |
| 1217 | |
| 1218 | // operations |
| 1219 | // makes a copy of the string |
| 1220 | wxNode *Add(const wxChar *s); |
| 1221 | |
| 1222 | // Append to beginning of list |
| 1223 | wxNode *Prepend(const wxChar *s); |
| 1224 | |
| 1225 | bool Delete(const wxChar *s); |
| 1226 | |
| 1227 | wxChar **ListToArray(bool new_copies = false) const; |
| 1228 | bool Member(const wxChar *s) const; |
| 1229 | |
| 1230 | // alphabetic sort |
| 1231 | void Sort(); |
| 1232 | |
| 1233 | private: |
| 1234 | void DoCopy(const wxStringList&); // common part of copy ctor and operator= |
| 1235 | }; |
| 1236 | |
| 1237 | #else // if wxUSE_STL |
| 1238 | |
| 1239 | WX_DECLARE_LIST_XO(wxString, wxStringListBase, class WXDLLIMPEXP_BASE); |
| 1240 | |
| 1241 | class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase |
| 1242 | { |
| 1243 | public: |
| 1244 | compatibility_iterator Append(wxChar* s) |
| 1245 | { wxString tmp = s; delete[] s; return wxStringListBase::Append(tmp); } |
| 1246 | compatibility_iterator Insert(wxChar* s) |
| 1247 | { wxString tmp = s; delete[] s; return wxStringListBase::Insert(tmp); } |
| 1248 | compatibility_iterator Insert(size_t pos, wxChar* s) |
| 1249 | { |
| 1250 | wxString tmp = s; |
| 1251 | delete[] s; |
| 1252 | return wxStringListBase::Insert(pos, tmp); |
| 1253 | } |
| 1254 | compatibility_iterator Add(const wxChar* s) |
| 1255 | { push_back(s); return GetLast(); } |
| 1256 | compatibility_iterator Prepend(const wxChar* s) |
| 1257 | { push_front(s); return GetFirst(); } |
| 1258 | }; |
| 1259 | |
| 1260 | #endif // wxUSE_STL |
| 1261 | |
| 1262 | #endif // wxLIST_COMPATIBILITY |
| 1263 | |
| 1264 | // delete all list elements |
| 1265 | // |
| 1266 | // NB: the class declaration of the list elements must be visible from the |
| 1267 | // place where you use this macro, otherwise the proper destructor may not |
| 1268 | // be called (a decent compiler should give a warning about it, but don't |
| 1269 | // count on it)! |
| 1270 | #define WX_CLEAR_LIST(type, list) \ |
| 1271 | { \ |
| 1272 | type::iterator it, en; \ |
| 1273 | for( it = (list).begin(), en = (list).end(); it != en; ++it ) \ |
| 1274 | delete *it; \ |
| 1275 | (list).clear(); \ |
| 1276 | } |
| 1277 | |
| 1278 | #endif // _WX_LISTH__ |