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