lib/base/eptrlist.h

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