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