4.2.7r1
[enigma2.git] / usr / include / enigma2 / lib / base / eptrlist.h
1 #ifndef _E_PTRLIST_
2 #define _E_PTRLIST_
3
4 #include <list>
5 #include <vector>
6 #include <algorithm>
7 #include <lib/base/smartptr.h>
8 #include <lib/base/eerror.h>
9
10 template <class T>
11 class ePtrList : public std::list<T*>
12 {
13 public:
14         typedef typename std::list<T*, std::allocator<T*> >::iterator std_list_T_iterator;  // to remove compiler warnings
15         typedef typename std::list<T*, std::allocator<T*> >::const_iterator std_list_T_const_iterator;
16         typedef typename std::list<T*, std::allocator<T*> >::reverse_iterator std_list_T_reverse_iterator;
17         typedef typename std::list<T*, std::allocator<T*> >::const_reverse_iterator std_list_T_const_reverse_iterator;
18         typedef typename ePtrList<T>::iterator T_iterator;
19         typedef typename ePtrList<T>::const_iterator T_const_iterator;
20         typedef typename ePtrList<T>::reverse_iterator T_reverse_iterator;
21         typedef typename ePtrList<T>::const_reverse_iterator T_const_reverse_iterator;
22
23 // Iterator classes
24         class iterator : public std::list<T*>::iterator
25         {
26         public:
27                 // Constructors
28                 iterator(const std_list_T_iterator& Q)          : std_list_T_iterator(Q)        {       }
29
30                 // changed operator for pointer
31                 T* operator->() const
32                 {
33                         return *std::list<T*>::iterator::operator->();
34                 }
35
36                 operator T&() const
37                 {
38                         return *operator->();
39                 }
40
41                 operator T*() const
42                 {
43                         return operator->();
44                 }
45
46                 iterator& operator++()
47                 {
48                         std::list<T*>::iterator::operator++();
49                         return *this;
50                 }
51
52                 iterator operator++(int)
53                 {
54                         return std::list<T*>::iterator::operator++(0);
55                 }
56
57                 iterator& operator--()
58                 {
59                         std::list<T*>::iterator::operator--();
60                         return *this;
61                 }
62
63                 iterator operator--(int)
64                 {
65                         return std::list<T*>::iterator::operator--(0);
66                 }
67         };
68
69         class const_iterator;
70         class reverse_iterator;
71         class const_reverse_iterator;
72
73 // Constructors
74         inline ePtrList();
75         inline ePtrList(const ePtrList&);
76         inline ~ePtrList();
77
78 // overwritted sort method
79         inline void sort();
80
81 // changed methods for autodelete and current implementation
82         inline void remove(T* t);
83         inline void clear();
84         inline void pop_back();
85         inline void pop_front();
86         inline void push_back(T*);
87         inline void push_front(T*);
88
89 // added methods for current implementation
90         inline T* take();
91         inline void take(T* t);
92         inline T* current();
93         inline T* next();
94         inline T* prev();
95         inline T* first();
96         inline T* last();
97         inline T* setCurrent(const T*);
98         inline const T* current() const;
99         inline const T* next() const;
100         inline const T* prev() const;
101         inline const T* first() const;
102         inline const T* last() const;
103
104 // added operator methods
105         inline operator bool() const;
106         inline bool operator!() const;
107
108 // added compare struct ... to sort
109         struct less;
110 private:
111         iterator cur;
112 public:
113         iterator begin()
114         {                               
115         //      makes implicit type conversion form std::list::iterator to ePtrList::iterator
116                 return std::list<T*>::begin();          
117         }
118
119         iterator end()
120         {                               
121         //      makes implicit type conversion form std::list::iterator to ePtrList::iterator
122                 return std::list<T*>::end();            
123         }
124
125         const_iterator begin() const
126         {                               
127         //      makes implicit type conversion form std::list::const_iterator to ePtrList::const_iterator
128                 return std::list<T*>::begin();          
129         }
130
131         const_iterator end() const
132         {                               
133         //      makes implicit type conversion form std::list::const_iterator to ePtrList::const_iterator
134                 return std::list<T*>::end();            
135         }
136
137         reverse_iterator rbegin()
138         {                               
139         //      makes implicit type conversion form std::list::reverse:_iterator to ePtrList::reverse_iterator
140                 return std::list<T*>::rbegin();         
141         }
142
143         reverse_iterator rend()
144         {                               
145         //      makes implicit type conversion form std::list::reverse_iterator to ePtrList::reverse_iterator
146                 return std::list<T*>::rend();           
147         }
148
149         const_reverse_iterator rbegin() const
150         {                               
151         //      makes implicit type conversion form std::list::const_reverse_iterator to ePtrList::const_reverse_iterator
152                 return std::list<T*>::rbegin();         
153         }
154
155         const_reverse_iterator rend() const
156         {                               
157         //      makes implicit type conversion form std::list::const_reverse_iterator to ePtrList::const_reverse_iterator
158                 return std::list<T*>::rend();           
159         }
160
161         iterator erase(iterator it)
162         {
163         //      Remove the item it, if auto-deletion is enabled, than the list call delete for this item
164         //  If current is equal to the item that was removed, current is set to the next item in the list
165                 if (cur == it)
166                         return cur = std::list<T*>::erase(it);
167                 else
168                         return std::list<T*>::erase(it);
169         }
170
171         iterator erase(iterator from, iterator to)
172         {
173         //      Remove all items between the to iterators from and to
174         //      If auto-deletion is enabled, than the list call delete for all removed items
175                 while (from != to)
176                         from = erase(from);
177         
178                 return from;
179         }
180
181         operator iterator()     
182         {
183         //      Returns a iterator that equal to begin() of the list
184                 return begin(); 
185         }
186
187         operator const_iterator() const
188         {
189         //      Returns a const_iterator that equal to begin() of the list
190                 return begin(); 
191         }
192
193         operator reverse_iterator()
194         {
195         //      Returns a reverse_iterator that equal to rbegin() of the list
196                 return rbegin();        
197         }
198
199         operator const_reverse_iterator() const 
200         {
201         //      Returns a const_reverse_iterator that equal to rbegin() of the list
202                 return rbegin();        
203         }
204
205         std::vector<T>* getVector()
206         {
207                 // Creates an vector and copys all elements to this vector
208                 // returns a pointer to this new vector ( the reserved memory must deletet from the receiver !! )
209                 std::vector<T>* v=new std::vector<T>();
210                 v->reserve( std::list<T>::size() );
211                 for ( std_list_T_iterator it( std::list<T*>::begin() ); it != std::list<T*>::end(); it++)
212                         v->push_back( **it );
213
214                 return v;
215         }
216
217         inline iterator insert_in_order( T* e )
218         {
219                 // added a new item to the list... in order
220                 // returns a iterator to the new item
221                 // this-> is required as of gcc 4.7, which would raise the following without it
222                 // "declarations in dependent base ‘std::list<eTimer*, std::allocator<eTimer*> >’ are not found by unqualified lookup"
223                 return this->insert( std::lower_bound( std::list<T*>::begin(), std::list<T*>::end(), e, less()), e );
224         }
225
226 };
227
228 /////////////////// const_iterator class /////////////////////////////
229 template <class T>
230 class ePtrList<T>::const_iterator : public std::list<T*>::const_iterator
231 {
232 public:
233         // Constructors
234         const_iterator(const std_list_T_const_iterator& Q)              :std_list_T_const_iterator(Q)   {       }
235
236         // changed operator for pointer
237         T* operator->() const
238         {
239                 return *std::list<T*>::const_iterator::operator->();
240         }
241
242         operator T&() const
243         {
244                 return *operator->();
245         }
246
247         operator T*() const
248         {
249                 return operator->();
250         }
251
252         const_iterator& operator++()
253         {
254                 std::list<T*>::const_iterator::operator++();
255                 return *this;
256         }
257
258         const_iterator operator++(int)
259         {
260                 return std::list<T*>::const_iterator::operator++(0);
261         }
262
263         const_iterator& operator--()
264         {
265                 std::list<T*>::const_iterator::operator--();
266                 return *this;
267         }
268
269         const_iterator operator--(int)
270         {
271                 return std::list<T*>::const_iterator::operator--(0);
272         }
273 };
274
275 /////////////////// reverse_iterator class /////////////////////////////
276 template <class T>
277 class ePtrList<T>::reverse_iterator : public std::list<T*>::reverse_iterator
278 {
279 public:
280         // Constructors
281         reverse_iterator(const std_list_T_reverse_iterator& Q)          :std_list_T_reverse_iterator(Q) {       }
282
283         // changed operators for pointer
284         T* operator->() const
285         {
286                 return *std::list<T*>::reverse_iterator::operator->();
287         }
288
289         operator T&() const
290         {
291                 return *operator->();
292         }
293
294         operator T*() const
295         {
296                 return operator->();
297         }
298
299         reverse_iterator& operator++()
300         {
301                 std::list<T*>::reverse_iterator::operator++();
302                 return *this;
303         }
304
305         reverse_iterator operator++(int)
306         {
307                 return std::list<T*>::reverse_iterator::operator++(0);
308         }
309
310         reverse_iterator& operator--()
311         {
312                 std::list<T*>::reverse_iterator::operator--();
313                 return *this;
314         }
315
316         reverse_iterator operator--(int)
317         {
318                 return std::list<T*>::reverse_iterator::operator--(0);
319         }
320 };
321
322 /////////////////// const_reverse_iterator class /////////////////////////////
323 template <class T>
324 class ePtrList<T>::const_reverse_iterator : public std::list<T*>::const_reverse_iterator
325 {
326 public:
327         // Constructors
328         const_reverse_iterator(const std_list_T_const_reverse_iterator& Q)              :std_list_T_const_reverse_iterator(Q)   {       }
329
330         // changed operators for pointer
331         T* operator->() const
332         {
333                 return *std::list<T*>::const_reverse_iterator::operator->();
334         }
335
336         operator T&() const
337         {
338                 return *operator->();
339         }
340
341         operator T*() const
342         {
343                 return operator->();
344         }
345
346         const_reverse_iterator& operator++()
347         {
348                 std::list<T*>::const_reverse_iterator::operator++();
349                 return *this;
350         }
351
352         const_reverse_iterator operator++(int)
353         {
354                 return std::list<T*>::const_reverse_iterator::operator++(0);
355         }
356
357         const_reverse_iterator& operator--()
358         {
359                 std::list<T*>::const_reverse_iterator::operator--();
360                 return *this;
361         }
362
363         const_reverse_iterator operator--(int)
364         {
365                 return std::list<T*>::const_reverse_iterator::operator--(0);
366         }
367 };
368
369 /////////////////// Default Constructor /////////////////////////////
370 template <class T>
371 ePtrList<T>::ePtrList()
372     :cur(std::list<T*>::begin())
373 {               
374
375 }
376
377 /////////////////// Copy Constructor /////////////////////////////
378 template <class T>
379 ePtrList<T>::ePtrList(const ePtrList& e)
380         :std::list<T*>(e), cur(e.cur)
381 {               
382 }
383
384 /////////////////// ePtrList Destructor /////////////////////////////
385 template <class T>
386 inline ePtrList<T>::~ePtrList()
387 {
388 }
389
390 /////////////////// ePtrList sort() /////////////////////////
391 template <class T>
392 inline void ePtrList<T>::sort()
393 {               
394 //      Sorts all items in the list.
395 //      The type T must have a operator <.
396         std::list<T*>::sort(typename ePtrList<T>::less());
397 }       
398
399 /////////////////// ePtrList remove(T*) /////////////////////////
400 template <class T>
401 inline void ePtrList<T>::remove(T* t)
402 {
403 //      Remove all items that, equals to t, if auto-deletion is enabled, than the list call delete for the removed items
404 //  If current is equal to one of the removed items, current is set to the next valid item
405         T_iterator it(std::list<T*>::begin());
406
407         while (it != std::list<T*>::end())
408                 if (*it == t)
409                 {
410                         it=erase(it);
411                         break;  // one item is complete removed an deleted
412                 }
413                 else
414                         it++;
415         
416         while (it != std::list<T*>::end())
417                 if (*it == t)
418                         it = std::list<T*>::erase(it);  // remove all other items that equals to t (no delete is called..)
419                 else
420                         it++;
421                         
422 }
423
424 /////////////////// ePtrList clear() //////////////////
425 template <class T>
426 inline void ePtrList<T>::clear()        
427 {               
428 //      Remove all items from the list
429 //      If auto-deletion is enabled, than the list call delete for all items in the list
430         erase(std::list<T*>::begin(), std::list<T*>::end());    
431 }
432
433 /////////////////// ePtrList pop_back() ////////////////////
434 template <class T>
435 inline void ePtrList<T>::pop_back()
436 {
437 //      Removes the last item from the list. If the current item ist the last, than the current is set to the new
438 //      last item in the list;
439 //      The removed item is deleted if auto-deletion is enabled.
440         erase(--end());
441 }
442
443 /////////////////// ePtrList pop_front() ////////////////////
444 template <class T>
445 inline void ePtrList<T>::pop_front()
446 {
447 //      Removes the first item from the list. If the current item ist the first, than the current is set to the new
448 //      first item in the list;
449 //      The removed item is deleted if auto-deletion is enabled.
450         erase(begin());
451 }
452
453 /////////////////// ePtrList push_back(T*) ////////////////////
454 template <class T>
455 inline void ePtrList<T>::push_back(T* x)        
456 {               
457 // Add a new item at the end of the list.
458 // The current item is set to the last item;
459         std::list<T*>::push_back(x);
460         last(); 
461 }
462
463 /////////////////// ePtrList push_front(T*) ////////////////////
464 template <class T>
465 inline void ePtrList<T>::push_front(T* x)       
466 {               
467 // Add a new item at the begin of the list.
468 // The current item is set to the first item;
469         std::list<T*>::push_front(x);
470         first();        
471 }
472
473 /////////////////// ePtrList take() ////////////////////
474 template <class T>
475 inline T* ePtrList<T>::take()
476 {
477 // Takes the current item out of the list without deleting it (even if auto-deletion is enabled).
478 // Returns a pointer to the item taken out of the list, or null if the index is out of range.
479 // The item after the taken item becomes the new current list item if the taken item is not the last item in the list. If the last item is taken, the new last item becomes the current item.
480 // The current item is set to null if the list becomes empty.
481         T* tmp = *cur;
482         cur = std::list<T*>::erase(cur);
483         return tmp;
484 }
485
486 /////////////////// ePtrList take(T*) ////////////////////
487 template <class T>
488 inline void ePtrList<T>::take(T* t)
489 {
490 // Takes all item with T* out of the list without deleting it (even if auto-deletion is enabled).
491         std::list<T*>::remove(t);
492 }
493
494 /////////////////// ePtrList setCurrent(T*) ////////////////////
495 template <class T>
496 inline T* ePtrList<T>::setCurrent(const T* t)
497 {
498         // Sets the internal current iterator to the first element that equals to t, and returns t when a item is found,
499         // otherwise it returns 0 !
500         for (T_iterator it(std::list<T*>::begin()); it != std::list<T*>::end(); ++it)
501                 if (*it == t)
502                 {
503                         cur = it;
504                         return *it;
505                 }
506
507         return 0;
508 }
509
510 /////////////////// ePtrList current() ////////////////////
511 template <class T>
512 inline T* ePtrList<T>::current()
513 {
514 //      Returns a pointer to the current list item. The current item may be null (implies that the current index is -1).
515         return cur==end() ? 0 : *cur;   
516 }
517
518 /////////////////// ePtrList next() ////////////////////
519 template <class T>
520 inline T* ePtrList<T>::next()
521 {
522 //      Returns a pointer to the item succeeding the current item. Returns null if the current items is null or equal to the last item.
523 //      Makes the succeeding item current. If the current item before this function call was the last item, the current item will be set to null. If the current item was null, this function does nothing.
524         if (cur == end())
525                 return 0;
526         else
527                 if (++cur == end())
528                         return 0;
529                 else
530                         return *cur;
531 }
532
533 /////////////////// ePtrList prev() ////////////////////
534 template <class T>
535 inline T* ePtrList<T>::prev()
536 {
537 //      Returns a pointer to the item preceding the current item. Returns null if the current items is null or equal to the first item.
538 //      Makes the preceding item current. If the current item before this function call was the first item, the current item will be set to null. If the current item was null, this function does nothing.
539         if (cur == begin())
540                 return 0;
541         else
542                 return *--cur;
543 }
544
545 /////////////////// ePtrList first() ////////////////////
546 template <class T>
547 inline T* ePtrList<T>::first()
548 {
549 // Returns a pointer to the first item in the list and makes this the current list item, or null if the list is empty.
550         return *(cur = begin());        
551 }
552
553 /////////////////// ePtrList last() ////////////////////
554 template <class T>
555 inline T* ePtrList<T>::last()
556 {
557 //      Returns a pointer to the last item in the list and makes this the current list item, or null if the list is empty.
558         return *(cur = --end());
559 }
560
561 /////////////////// const ePtrList current() ////////////////////
562 template <class T>
563 inline const T* ePtrList<T>::current() const
564 {
565 //      Returns a pointer to the current list item. The current item may be null (implies that the current index is not valid)
566         return cur==end() ? 0 : *cur;   
567 }
568
569 /////////////////// const ePtrList next() ////////////////////
570 template <class T>
571 inline const T* ePtrList<T>::next() const
572 {
573 //      Returns a pointer to the item succeeding the current item. Returns null if the current items is null or equal to the last item.
574 //      Makes the succeeding item current. If the current item before this function call was the last item, the current item will be set to null. If the current item was null, this function does nothing.
575         if (cur == end())
576                 return 0;
577         else
578                 if (++cur == end())
579                         return 0;
580                 else
581                         return *cur;
582 }
583
584 /////////////////// const ePtrList prev() ////////////////////
585 template <class T>
586 inline const T* ePtrList<T>::prev() const
587 {
588 //      Returns a pointer to the item preceding the current item. Returns null if the current items is null or equal to the first item.
589 //      Makes the preceding item current. If the current item before this function call was the first item, the current item will be set to null. If the current item was null, this function does nothing.
590         if (cur == begin())
591                 return 0;
592         else
593                 return *--cur;
594 }
595
596 /////////////////// const ePtrList first() ////////////////////
597 template <class T>
598 inline const T* ePtrList<T>::first() const
599 {
600 // Returns a pointer to the first item in the list and makes this the current list item, or null if the list is empty.
601         return *(cur = begin());        
602 }
603
604 /////////////////// const ePtrList last() ////////////////////
605 template <class T>
606 inline const T* ePtrList<T>::last() const
607 {
608 //      Returns a pointer to the last item in the list and makes this the current list item, or null if the list is empty.
609         return *(cur = --end());
610 }
611
612 ////////////////// struct less //////////////////////////////
613 template <class T>
614 struct ePtrList<T>::less
615 {
616 //      operator() is used internal from the list to sort them
617         bool operator() (const T* t1, const T* t2)
618         {
619                 return (*t1 < *t2);
620         }
621 };
622
623 /////////////////// ePtrList operator bool ////////////////////
624 template <class T>
625 ePtrList<T>::operator bool() const
626 {
627 //      Returns a bool that contains true, when the list is NOT empty otherwise false
628         return !std::list<T*>::empty(); 
629 }
630
631 template <class T>
632 bool ePtrList<T>::operator!() const
633 {
634 //      Returns a bool that contains true, when the list is empty otherwise false
635         return std::list<T*>::empty();  
636 }
637
638 template <class T>
639 class eSmartPtrList : public std::list<ePtr<T> >
640 {
641 public:
642         typedef typename std::list<ePtr<T>, std::allocator<ePtr<T> > >::iterator std_list_T_iterator;  // to remove compiler warnings
643         typedef typename std::list<ePtr<T>, std::allocator<ePtr<T> > >::const_iterator std_list_T_const_iterator;
644         typedef typename std::list<ePtr<T>, std::allocator<ePtr<T> > >::reverse_iterator std_list_T_reverse_iterator;
645         typedef typename std::list<ePtr<T>, std::allocator<ePtr<T> > >::const_reverse_iterator std_list_T_const_reverse_iterator;
646         typedef typename eSmartPtrList<T>::iterator T_iterator;
647         typedef typename eSmartPtrList<T>::const_iterator T_const_iterator;
648         typedef typename eSmartPtrList<T>::reverse_iterator T_reverse_iterator;
649         typedef typename eSmartPtrList<T>::const_reverse_iterator T_const_reverse_iterator;
650
651 // Iterator classes
652         class iterator : public std::list<ePtr<T> >::iterator
653         {
654         public:
655                 // Constructors
656                 iterator(const std_list_T_iterator& Q)          : std_list_T_iterator(Q)        {       }
657
658                 // changed operator for pointer
659                 T* operator->() const
660                 {
661                         return *std::list<ePtr<T> >::iterator::operator->();
662                 }
663
664                 operator T&() const
665                 {
666                         return *operator->();
667                 }
668
669                 operator T*() const
670                 {
671                         return operator->();
672                 }
673
674                 iterator& operator++()
675                 {
676                         std::list<ePtr<T> >::iterator::operator++();
677                         return *this;
678                 }
679
680                 iterator operator++(int)
681                 {
682                         return std::list<ePtr<T> >::iterator::operator++(0);
683                 }
684
685                 iterator& operator--()
686                 {
687                         std::list<ePtr<T> >::iterator::operator--();
688                         return *this;
689                 }
690
691                 iterator operator--(int)
692                 {
693                         return std::list<ePtr<T> >::iterator::operator--(0);
694                 }
695         };
696
697         class const_iterator;
698         class reverse_iterator;
699         class const_reverse_iterator;
700
701 // Constructors
702         inline eSmartPtrList();
703         inline eSmartPtrList(const eSmartPtrList&);
704         inline ~eSmartPtrList();
705
706 // overwritted sort method
707         inline void sort();
708
709 // changed methods for autodelete and current implementation
710         inline void remove(T* t);
711         inline void clear();
712         inline void pop_back();
713         inline void pop_front();
714         inline void push_back(T*);
715         inline void push_front(T*);
716
717 // added methods for current implementation
718 //      inline T* take();
719 //      inline void take(T* t);
720         inline T* current();
721         inline T* next();
722         inline T* prev();
723         inline T* first();
724         inline T* last();
725         inline T* setCurrent(const T*);
726         inline const T* current() const;
727         inline const T* next() const;
728         inline const T* prev() const;
729         inline const T* first() const;
730         inline const T* last() const;
731
732 // added operator methods
733         inline operator bool() const;
734         inline bool operator!() const;
735
736 // added compare struct ... to sort
737         struct less;
738 private:
739         iterator cur;
740 public:
741         iterator begin()
742         {                               
743         //      makes implicit type conversion form std::list::iterator to eSmartPtrList::iterator
744                 return std::list<ePtr<T> >::begin();            
745         }
746
747         iterator end()
748         {                               
749         //      makes implicit type conversion form std::list::iterator to eSmartPtrList::iterator
750                 return std::list<ePtr<T> >::end();              
751         }
752
753         const_iterator begin() const
754         {                               
755         //      makes implicit type conversion form std::list::const_iterator to eSmartPtrList::const_iterator
756                 return std::list<ePtr<T> >::begin();            
757         }
758
759         const_iterator end() const
760         {                               
761         //      makes implicit type conversion form std::list::const_iterator to eSmartPtrList::const_iterator
762                 return std::list<ePtr<T> >::end();              
763         }
764
765         reverse_iterator rbegin()
766         {                               
767         //      makes implicit type conversion form std::list::reverse:_iterator to eSmartPtrList::reverse_iterator
768                 return std::list<ePtr<T> >::rbegin();           
769         }
770
771         reverse_iterator rend()
772         {                               
773         //      makes implicit type conversion form std::list::reverse_iterator to eSmartPtrList::reverse_iterator
774                 return std::list<ePtr<T> >::rend();             
775         }
776
777         const_reverse_iterator rbegin() const
778         {                               
779         //      makes implicit type conversion form std::list::const_reverse_iterator to eSmartPtrList::const_reverse_iterator
780                 return std::list<ePtr<T> >::rbegin();           
781         }
782
783         const_reverse_iterator rend() const
784         {                               
785         //      makes implicit type conversion form std::list::const_reverse_iterator to eSmartPtrList::const_reverse_iterator
786                 return std::list<ePtr<T> >::rend();             
787         }
788
789         iterator erase(iterator it)
790         {
791         //      Remove the item it, if auto-deletion is enabled, than the list call delete for this item
792         //  If current is equal to the item that was removed, current is set to the next item in the list
793
794                 if (cur == it)
795                         return cur = std::list<ePtr<T> >::erase(it);
796                 else
797                         return std::list<ePtr<T> >::erase(it);
798         }
799
800         iterator erase(iterator from, iterator to)
801         {
802         //      Remove all items between the to iterators from and to
803         //      If auto-deletion is enabled, than the list call delete for all removed items
804                 while (from != to)
805                         from = erase(from);
806         
807                 return from;
808         }
809
810         operator iterator()     
811         {
812         //      Returns a iterator that equal to begin() of the list
813                 return begin(); 
814         }
815
816         operator const_iterator() const
817         {
818         //      Returns a const_iterator that equal to begin() of the list
819                 return begin(); 
820         }
821
822         operator reverse_iterator()
823         {
824         //      Returns a reverse_iterator that equal to rbegin() of the list
825                 return rbegin();        
826         }
827
828         operator const_reverse_iterator() const 
829         {
830         //      Returns a const_reverse_iterator that equal to rbegin() of the list
831                 return rbegin();        
832         }
833
834         std::vector<T>* getVector()
835         {
836                 // Creates an vector and copys all elements to this vector
837                 // returns a pointer to this new vector ( the reserved memory must deletet from the receiver !! )
838                 std::vector<T>* v=new std::vector<T>();
839                 v->reserve( std::list<T>::size() );
840     for ( std_list_T_iterator it( std::list<ePtr<T> >::begin() ); it != std::list<ePtr<T> >::end(); it++)
841                         v->push_back( **it );
842
843                 return v;
844         }
845
846         inline iterator insert_in_order( T* e )
847         {
848                 // added a new item to the list... in order
849                 // returns a iterator to the new item
850                 return insert( std::lower_bound( std::list<ePtr<T> >::begin(), e, std::list<ePtr<T> >::end()), e );
851         }
852
853 };
854
855 /////////////////// const_iterator class /////////////////////////////
856 template <class T>
857 class eSmartPtrList<T>::const_iterator : public std::list<ePtr<T> >::const_iterator
858 {
859 public:
860         // Constructors
861         const_iterator(const std_list_T_const_iterator& Q)              :std_list_T_const_iterator(Q)   {       }
862
863         // changed operator for pointer
864         T* operator->() const
865         {
866                 return *std::list<ePtr<T> >::const_iterator::operator->();
867         }
868
869         operator T&() const
870         {
871                 return *operator->();
872         }
873
874         operator T*() const
875         {
876                 return operator->();
877         }
878
879         const_iterator& operator++()
880         {
881                 std::list<ePtr<T> >::const_iterator::operator++();
882                 return *this;
883         }
884
885         const_iterator operator++(int)
886         {
887                 return std::list<ePtr<T> >::const_iterator::operator++(0);
888         }
889
890         const_iterator& operator--()
891         {
892                 std::list<ePtr<T> >::const_iterator::operator--();
893                 return *this;
894         }
895
896         const_iterator operator--(int)
897         {
898                 return std::list<ePtr<T> >::const_iterator::operator--(0);
899         }
900 };
901
902 /////////////////// reverse_iterator class /////////////////////////////
903 template <class T>
904 class eSmartPtrList<T>::reverse_iterator : public std::list<ePtr<T> >::reverse_iterator
905 {
906 public:
907         // Constructors
908         reverse_iterator(const std_list_T_reverse_iterator& Q)          :std_list_T_reverse_iterator(Q) {       }
909
910         // changed operators for pointer
911         T* operator->() const
912         {
913                 return *std::list<ePtr<T> >::reverse_iterator::operator->();
914         }
915
916         operator T&() const
917         {
918                 return *operator->();
919         }
920
921         operator T*() const
922         {
923                 return operator->();
924         }
925
926         reverse_iterator& operator++()
927         {
928                 std::list<ePtr<T> >::reverse_iterator::operator++();
929                 return *this;
930         }
931
932         reverse_iterator operator++(int)
933         {
934                 return std::list<ePtr<T> >::reverse_iterator::operator++(0);
935         }
936
937         reverse_iterator& operator--()
938         {
939                 std::list<ePtr<T> >::reverse_iterator::operator--();
940                 return *this;
941         }
942
943         reverse_iterator operator--(int)
944         {
945                 return std::list<ePtr<T> >::reverse_iterator::operator--(0);
946         }
947 };
948
949 /////////////////// const_reverse_iterator class /////////////////////////////
950 template <class T>
951 class eSmartPtrList<T>::const_reverse_iterator : public std::list<ePtr<T> >::const_reverse_iterator
952 {
953 public:
954         // Constructors
955         const_reverse_iterator(const std_list_T_const_reverse_iterator& Q)              :std_list_T_const_reverse_iterator(Q)   {       }
956
957         // changed operators for pointer
958         T* operator->() const
959         {
960                 return *std::list<ePtr<T> >::const_reverse_iterator::operator->();
961         }
962
963         operator T&() const
964         {
965                 return *operator->();
966         }
967
968         operator T*() const
969         {
970                 return operator->();
971         }
972
973         const_reverse_iterator& operator++()
974         {
975                 std::list<ePtr<T> >::const_reverse_iterator::operator++();
976                 return *this;
977         }
978
979         const_reverse_iterator operator++(int)
980         {
981                 return std::list<ePtr<T> >::const_reverse_iterator::operator++(0);
982         }
983
984         const_reverse_iterator& operator--()
985         {
986                 std::list<ePtr<T> >::const_reverse_iterator::operator--();
987                 return *this;
988         }
989
990         const_reverse_iterator operator--(int)
991         {
992                 return std::list<ePtr<T> >::const_reverse_iterator::operator--(0);
993         }
994 };
995
996 /////////////////// Default Constructor /////////////////////////////
997 template <class T>
998 eSmartPtrList<T>::eSmartPtrList()
999     :cur(std::list<ePtr<T> >::begin())
1000 {               
1001
1002 }
1003
1004 /////////////////// Copy Constructor /////////////////////////////
1005 template <class T>
1006 eSmartPtrList<T>::eSmartPtrList(const eSmartPtrList& e)
1007         :std::list<ePtr<T> >(e), cur(e.cur)
1008 {               
1009 }
1010
1011 /////////////////// eSmartPtrList Destructor /////////////////////////////
1012 template <class T>
1013 inline eSmartPtrList<T>::~eSmartPtrList()
1014 {
1015 }
1016
1017
1018 /////////////////// eSmartPtrList sort() /////////////////////////
1019 template <class T>
1020 inline void eSmartPtrList<T>::sort()
1021 {               
1022 //      Sorts all items in the list.
1023 //      The type T must have a operator <.
1024         std::list<ePtr<T> >::sort(eSmartPtrList<T>::less());
1025 }       
1026
1027 /////////////////// eSmartPtrList remove(T*) /////////////////////////
1028 template <class T>
1029 inline void eSmartPtrList<T>::remove(T* t)
1030 {
1031 //      Remove all items that, equals to t, if auto-deletion is enabled, than the list call delete for the removed items
1032 //  If current is equal to one of the removed items, current is set to the next valid item
1033         T_iterator it(std::list<ePtr<T> >::begin());
1034
1035         while (it != std::list<ePtr<T> >::end())
1036                 if (*it == t)
1037                 {
1038                         it=erase(it);
1039                         break;  // one item is complete removed an deleted
1040                 }
1041                 else
1042                         it++;
1043         
1044         while (it != std::list<ePtr<T> >::end())
1045                 if (*it == t)
1046                         it = std::list<ePtr<T> >::erase(it);  // remove all other items that equals to t (no delete is called..)
1047                 else
1048                         it++;
1049                         
1050 }
1051
1052 /////////////////// eSmartPtrList clear() //////////////////
1053 template <class T>
1054 inline void eSmartPtrList<T>::clear()   
1055 {               
1056 //      Remove all items from the list
1057 //      If auto-deletion is enabled, than the list call delete for all items in the list
1058         erase(std::list<ePtr<T> >::begin(), std::list<ePtr<T> >::end());        
1059 }
1060
1061 /////////////////// eSmartPtrList pop_back() ////////////////////
1062 template <class T>
1063 inline void eSmartPtrList<T>::pop_back()
1064 {
1065 //      Removes the last item from the list. If the current item ist the last, than the current is set to the new
1066 //      last item in the list;
1067 //      The removed item is deleted if auto-deletion is enabled.
1068         erase(--end());
1069 }
1070
1071 /////////////////// eSmartPtrList pop_front() ////////////////////
1072 template <class T>
1073 inline void eSmartPtrList<T>::pop_front()
1074 {
1075 //      Removes the first item from the list. If the current item ist the first, than the current is set to the new
1076 //      first item in the list;
1077 //      The removed item is deleted if auto-deletion is enabled.
1078         erase(begin());
1079 }
1080
1081 /////////////////// eSmartPtrList push_back(T*) ////////////////////
1082 template <class T>
1083 inline void eSmartPtrList<T>::push_back(T* x)   
1084 {               
1085 // Add a new item at the end of the list.
1086 // The current item is set to the last item;
1087         std::list<ePtr<T> >::push_back(x);
1088         last(); 
1089 }
1090
1091 /////////////////// eSmartPtrList push_front(T*) ////////////////////
1092 template <class T>
1093 inline void eSmartPtrList<T>::push_front(T* x)  
1094 {               
1095 // Add a new item at the begin of the list.
1096 // The current item is set to the first item;
1097         std::list<ePtr<T> >::push_front(x);
1098         first();        
1099 }
1100
1101 /////////////////// eSmartPtrList setCurrent(T*) ////////////////////
1102 template <class T>
1103 inline T* eSmartPtrList<T>::setCurrent(const T* t)
1104 {
1105         // Sets the internal current iterator to the first element that equals to t, and returns t when a item is found,
1106         // otherwise it returns 0 !
1107         for (T_iterator it(std::list<ePtr<T> >::begin()); it != std::list<ePtr<T> >::end(); ++it)
1108                 if (*it == t)
1109                 {
1110                         cur = it;
1111                         return *it;
1112                 }
1113
1114         return 0;
1115 }
1116
1117 /////////////////// eSmartPtrList current() ////////////////////
1118 template <class T>
1119 inline T* eSmartPtrList<T>::current()
1120 {
1121 //      Returns a pointer to the current list item. The current item may be null (implies that the current index is -1).
1122         return cur==end() ? 0 : *cur;   
1123 }
1124
1125 /////////////////// eSmartPtrList next() ////////////////////
1126 template <class T>
1127 inline T* eSmartPtrList<T>::next()
1128 {
1129 //      Returns a pointer to the item succeeding the current item. Returns null if the current items is null or equal to the last item.
1130 //      Makes the succeeding item current. If the current item before this function call was the last item, the current item will be set to null. If the current item was null, this function does nothing.
1131         if (cur == end())
1132                 return 0;
1133         else
1134                 if (++cur == end())
1135                         return 0;
1136                 else
1137                         return *cur;
1138 }
1139
1140 /////////////////// eSmartPtrList prev() ////////////////////
1141 template <class T>
1142 inline T* eSmartPtrList<T>::prev()
1143 {
1144 //      Returns a pointer to the item preceding the current item. Returns null if the current items is null or equal to the first item.
1145 //      Makes the preceding item current. If the current item before this function call was the first item, the current item will be set to null. If the current item was null, this function does nothing.
1146         if (cur == begin())
1147                 return 0;
1148         else
1149                 return *--cur;
1150 }
1151
1152 /////////////////// eSmartPtrList first() ////////////////////
1153 template <class T>
1154 inline T* eSmartPtrList<T>::first()
1155 {
1156 // Returns a pointer to the first item in the list and makes this the current list item, or null if the list is empty.
1157         return *(cur = begin());        
1158 }
1159
1160 /////////////////// eSmartPtrList last() ////////////////////
1161 template <class T>
1162 inline T* eSmartPtrList<T>::last()
1163 {
1164 //      Returns a pointer to the last item in the list and makes this the current list item, or null if the list is empty.
1165         return *(cur = --end());
1166 }
1167
1168 /////////////////// const eSmartPtrList current() ////////////////////
1169 template <class T>
1170 inline const T* eSmartPtrList<T>::current() const
1171 {
1172 //      Returns a pointer to the current list item. The current item may be null (implies that the current index is not valid)
1173         return cur==end() ? 0 : *cur;   
1174 }
1175
1176 /////////////////// const eSmartPtrList next() ////////////////////
1177 template <class T>
1178 inline const T* eSmartPtrList<T>::next() const
1179 {
1180 //      Returns a pointer to the item succeeding the current item. Returns null if the current items is null or equal to the last item.
1181 //      Makes the succeeding item current. If the current item before this function call was the last item, the current item will be set to null. If the current item was null, this function does nothing.
1182         if (cur == end())
1183                 return 0;
1184         else
1185                 if (++cur == end())
1186                         return 0;
1187                 else
1188                         return *cur;
1189 }
1190
1191 /////////////////// const eSmartPtrList prev() ////////////////////
1192 template <class T>
1193 inline const T* eSmartPtrList<T>::prev() const
1194 {
1195 //      Returns a pointer to the item preceding the current item. Returns null if the current items is null or equal to the first item.
1196 //      Makes the preceding item current. If the current item before this function call was the first item, the current item will be set to null. If the current item was null, this function does nothing.
1197         if (cur == begin())
1198                 return 0;
1199         else
1200                 return *--cur;
1201 }
1202
1203 /////////////////// const eSmartPtrList first() ////////////////////
1204 template <class T>
1205 inline const T* eSmartPtrList<T>::first() const
1206 {
1207 // Returns a pointer to the first item in the list and makes this the current list item, or null if the list is empty.
1208         return *(cur = begin());        
1209 }
1210
1211 /////////////////// const eSmartPtrList last() ////////////////////
1212 template <class T>
1213 inline const T* eSmartPtrList<T>::last() const
1214 {
1215 //      Returns a pointer to the last item in the list and makes this the current list item, or null if the list is empty.
1216         return *(cur = --end());
1217 }
1218
1219 ////////////////// struct less //////////////////////////////
1220 template <class T>
1221 struct eSmartPtrList<T>::less
1222 {
1223 //      operator() is used internal from the list to sort them
1224         bool operator() (const T* t1, const T* t2)
1225         {
1226                 return (*t1 < *t2);
1227         }
1228 };
1229
1230 /////////////////// eSmartPtrList operator bool ////////////////////
1231 template <class T>
1232 eSmartPtrList<T>::operator bool() const
1233 {
1234 //      Returns a bool that contains true, when the list is NOT empty otherwise false
1235         return !std::list<T>::empty();  
1236 }
1237
1238 template <class T>
1239 bool eSmartPtrList<T>::operator!() const
1240 {
1241 //      Returns a bool that contains true, when the list is empty otherwise false
1242         return std::list<T>::empty();   
1243 }
1244
1245 #endif // _E_PTRLIST