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