]> git.saurik.com Git - wxWidgets.git/blob - include/wx/list.h
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
small cleanup, removed unused headers
[wxWidgets.git] / include / wx / list.h
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 public: \
185 decl compatibility_iterator \
186 { \
187 private: \
188 /* Workaround for broken VC6 nested class name resolution */ \
189 typedef std::list<elT>::iterator iterator; \
190 friend class liT; \
191 private: \
192 iterator m_iter; \
193 liT * m_list; \
194 public: \
195 compatibility_iterator() \
196 : m_iter(EmptyList.end()), m_list( NULL ) {} \
197 compatibility_iterator( liT* li, iterator i ) \
198 : m_iter( i ), m_list( li ) {} \
199 compatibility_iterator( const liT* li, iterator i ) \
200 : m_iter( i ), m_list( const_cast< liT* >( li ) ) {} \
201 \
202 compatibility_iterator* operator->() { return this; } \
203 const compatibility_iterator* operator->() const { return this; } \
204 \
205 bool operator==(const compatibility_iterator& i) const \
206 { \
207 wxASSERT_MSG( m_list && i.m_list, \
208 _T("comparing invalid iterators is illegal") ); \
209 return (m_list == i.m_list) && (m_iter == i.m_iter); \
210 } \
211 bool operator!=(const compatibility_iterator& i) const \
212 { return !( operator==( i ) ); } \
213 operator bool() const \
214 { return m_list ? m_iter != m_list->end() : false; } \
215 bool operator !() const \
216 { return !( operator bool() ); } \
217 \
218 elT GetData() const \
219 { return *m_iter; } \
220 void SetData( elT e ) \
221 { *m_iter = e; } \
222 \
223 compatibility_iterator GetNext() const \
224 { \
225 iterator i = m_iter; \
226 return compatibility_iterator( m_list, ++i ); \
227 } \
228 compatibility_iterator GetPrevious() const \
229 { \
230 if ( m_iter == m_list->begin() ) \
231 return compatibility_iterator(); \
232 \
233 iterator i = m_iter; \
234 return compatibility_iterator( m_list, --i ); \
235 } \
236 int IndexOf() const \
237 { \
238 return *this ? std::distance( m_list->begin(), m_iter ) \
239 : wxNOT_FOUND; \
240 } \
241 }; \
242 public: \
243 liT() : m_destroy( false ) {} \
244 \
245 compatibility_iterator Find( const elT e ) const \
246 { \
247 liT* _this = const_cast< liT* >( this ); \
248 return compatibility_iterator( _this, \
249 std::find( _this->begin(), _this->end(), e ) ); \
250 } \
251 \
252 bool IsEmpty() const \
253 { return empty(); } \
254 size_t GetCount() const \
255 { return size(); } \
256 int Number() const \
257 { return static_cast< int >( GetCount() ); } \
258 \
259 compatibility_iterator Item( size_t idx ) const \
260 { \
261 iterator i = const_cast< liT* >(this)->begin(); \
262 std::advance( i, idx ); \
263 return compatibility_iterator( this, i ); \
264 } \
265 elT operator[](size_t idx) const \
266 { \
267 return Item(idx).GetData(); \
268 } \
269 \
270 compatibility_iterator GetFirst() const \
271 { \
272 return compatibility_iterator( this, \
273 const_cast< liT* >(this)->begin() ); \
274 } \
275 compatibility_iterator GetLast() const \
276 { \
277 iterator i = const_cast< liT* >(this)->end(); \
278 return compatibility_iterator( this, !empty() ? --i : i ); \
279 } \
280 compatibility_iterator Member( elT e ) const \
281 { return Find( e ); } \
282 compatibility_iterator Nth( int n ) const \
283 { return Item( n ); } \
284 int IndexOf( elT e ) const \
285 { return Find( e ).IndexOf(); } \
286 \
287 compatibility_iterator Append( elT e ) \
288 { \
289 push_back( e ); \
290 return GetLast(); \
291 } \
292 compatibility_iterator Insert( elT e ) \
293 { \
294 push_front( e ); \
295 return compatibility_iterator( this, begin() ); \
296 } \
297 compatibility_iterator Insert( compatibility_iterator & i, elT e ) \
298 { \
299 return compatibility_iterator( this, insert( i.m_iter, e ) ); \
300 } \
301 compatibility_iterator Insert( size_t idx, elT e ) \
302 { \
303 return compatibility_iterator( this, \
304 insert( Item( idx ).m_iter, e ) ); \
305 } \
306 \
307 void DeleteContents( bool destroy ) \
308 { m_destroy = destroy; } \
309 bool GetDeleteContents() const \
310 { return m_destroy; } \
311 void Erase( const compatibility_iterator& i ) \
312 { \
313 if ( m_destroy ) \
314 _WX_LIST_HELPER_##liT::DeleteFunction( i->GetData() ); \
315 erase( i.m_iter ); \
316 } \
317 bool DeleteNode( const compatibility_iterator& i ) \
318 { \
319 if( i ) \
320 { \
321 Erase( i ); \
322 return true; \
323 } \
324 return false; \
325 } \
326 bool DeleteObject( elT e ) \
327 { \
328 return DeleteNode( Find( e ) ); \
329 } \
330 void Clear() \
331 { \
332 if ( m_destroy ) \
333 std::for_each( begin(), end(), \
334 _WX_LIST_HELPER_##liT::DeleteFunction ); \
335 clear(); \
336 } \
337 /* Workaround for broken VC6 std::list::sort() see above */ \
338 void Sort( wxSortCompareFunction compfunc ) \
339 { sort( WX_LIST_SORTFUNCTION( elT, compfunc ) ); } \
340 ~liT() { Clear(); } \
341 }
342
343 #define WX_DECLARE_LIST(elementtype, listname) \
344 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class)
345 #define WX_DECLARE_LIST_PTR(elementtype, listname) \
346 WX_DECLARE_LIST(elementtype, listname)
347
348 #define WX_DECLARE_EXPORTED_LIST(elementtype, listname) \
349 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class WXDLLEXPORT)
350 #define WX_DECLARE_EXPORTED_LIST_PTR(elementtype, listname) \
351 WX_DECLARE_EXPORTED_LIST(elementtype, listname)
352
353 #define WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo) \
354 WX_DECLARE_LIST_WITH_DECL(elementtype, listname, class usergoo)
355 #define WX_DECLARE_USER_EXPORTED_LIST_PTR(elementtype, listname, usergoo) \
356 WX_DECLARE_USER_EXPORTED_LIST(elementtype, listname, usergoo)
357
358 // this macro must be inserted in your program after
359 // #include "wx/listimpl.cpp"
360 #define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!"
361
362 #define WX_DEFINE_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
363 #define WX_DEFINE_USER_EXPORTED_LIST(name) WX_DEFINE_LIST(name)
364
365 #else // if !wxUSE_STL
366
367 // due to circular header dependencies this function has to be declared here
368 // (normally it's found in utils.h which includes itself list.h...)
369 #if WXWIN_COMPATIBILITY_2_4
370 extern WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
371 #endif
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__
wxWidgets (Impactor)