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