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