SingleLinkedList.hpp
Go to the documentation of this file.
00001 /***************************************************************************** 00002 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch) 00003 ***************************************************************************** 00004 * Project : Zeus Base Library 00005 * Module : SingleLinkedList 00006 * Package : Zeus.ZeusBase.System 00007 * Author : Benjamin Hadorn 00008 * Date : 27.12.2011 00009 * System : Zeus-Framework 00010 ***************************************************************************** 00011 * Licence: * 00012 * This library is free software; you can redistribute it and/or modify * 00013 * it under the terms of the GNU Lesser General Public License as * 00014 * published by the Free Software Foundation; either version * 00015 * 2.1 of the License, or (at your option) any later version. * 00016 * * 00017 * This library is distributed in the hope that it will be useful, * 00018 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00020 * GNU Lesser General Public License for more details. * 00021 * * 00022 * You should have received a copy of the GNU Lesser General Public * 00023 * License along with this library; if not, write to the Free Software * 00024 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA * 00025 *****************************************************************************/ 00026 00027 /***************************************************************************** 00028 * Changes: 00029 * 27.12.2011 bha: created zeus 2.0 00030 *****************************************************************************/ 00031 00032 00033 #ifndef SingleLinkedListH 00034 #define SingleLinkedListH 00035 00036 #include <zeusbase/System/Interfaces/IList.hpp> 00037 #include <zeusbase/System/Iterators.hpp> 00038 #include <string.h> 00039 00040 BEGIN_NAMESPACE_Zeus 00041 00042 /*****************************************************************************/ 00046 /*****************************************************************************/ 00047 template <class T> class TSingleLinkedList : public IList<T> 00048 { 00049 public: 00050 //typename TSingleLinkedListElement; 00051 struct TSingleLinkedListElement; 00052 00053 TSingleLinkedList(); 00054 TSingleLinkedList(const TSingleLinkedList<T>& rList); 00055 virtual ~TSingleLinkedList(); 00056 00058 void setEmptyItem(const T& rEmptyItem); 00059 00060 //Methods of IList 00061 virtual Int MQUALIFIER add(const T& rItem); 00062 virtual Int MQUALIFIER addAll(const IList<T>& rlstItems); 00063 virtual Int MQUALIFIER addEmptyItem(); 00064 virtual void MQUALIFIER copyToList(IList<T>& rList) const; 00065 virtual void MQUALIFIER clear(); 00066 virtual Retval MQUALIFIER deleteItem(Int iIndex); 00067 virtual Retval MQUALIFIER remove(const T& rItem); 00068 virtual Retval MQUALIFIER removeAll(const IList<T>& rlstItems); 00069 virtual Int MQUALIFIER getCount() const; 00070 virtual T& MQUALIFIER getItem(Int iIndex); 00071 virtual const T& MQUALIFIER getItemConst(Int iIndex) const; 00072 virtual bool MQUALIFIER equalsItem(Int iIndex, const T& rItem) const; 00073 virtual bool MQUALIFIER equals(const IList<T>& rList) const; 00074 virtual Int MQUALIFIER indexOf(const T& rItem) const; 00075 virtual Int MQUALIFIER insert(Int iIndex, const T& rItem); 00076 virtual IListIterator<T>* MQUALIFIER getIterator() const; 00077 virtual const IListIterator<T>* MQUALIFIER getConstIterator() const; 00078 virtual void MQUALIFIER releaseIterator(const IListIterator<T>* pIterator) const; 00079 virtual bool MQUALIFIER isEmpty() const; 00080 virtual T& MQUALIFIER getFirstItem(); 00081 virtual const T& MQUALIFIER getFirstItemConst() const; 00082 virtual T& MQUALIFIER getLastItem(); 00083 virtual const T& MQUALIFIER getLastItemConst() const; 00084 virtual bool MQUALIFIER hasItem(const T& rItem) const; 00085 virtual bool MQUALIFIER hasAllItems(const IList<T>& rlstItems) const; 00086 00087 //Operators 00088 T& operator[] (Int iIndex); 00089 const T& operator[] (Int iIndex) const; 00090 TSingleLinkedList<T>& operator= (const TSingleLinkedList<T>& rList); 00091 bool operator== (const TSingleLinkedList<T>& rList) const; 00092 bool operator!= (const TSingleLinkedList<T>& rList) const; 00093 TSingleLinkedListElement* getHeadElement() const; 00094 T& getEmptyElement(); 00095 00097 // Container class must be public, because the class is needed by 00098 // public methods 00099 public : 00100 00101 /*********************************************************************/ 00104 /*********************************************************************/ 00105 struct TSingleLinkedListElement 00106 { 00107 /*****************************************************************/ 00111 /*****************************************************************/ 00112 inline TSingleLinkedListElement(const T& rData) 00113 : tData(const_cast<T&>(rData)) 00114 { 00115 pNext = NULL; 00116 } 00117 00118 /*****************************************************************/ 00121 /*****************************************************************/ 00122 inline TSingleLinkedListElement(const T& rData, TSingleLinkedListElement* pNextPtr) 00123 : tData(const_cast<T&>(rData)) 00124 { 00125 pNext = pNextPtr; 00126 } 00127 00129 T tData; 00131 TSingleLinkedListElement* pNext; 00132 }; 00133 //public 00135 00136 protected: 00137 void resetAllIterators(); 00138 00139 /*********************************************************************/ 00142 /*********************************************************************/ 00143 class TSingleListIterator : public IListIterator<T> 00144 { 00145 public: 00146 /*****************************************************************/ 00150 /*****************************************************************/ 00151 inline TSingleListIterator(TSingleLinkedList& rParent) 00152 { 00153 m_iRefCounter = 1; 00154 m_pParent = &rParent; 00155 m_pNextIterator = NULL; 00156 m_pActElement = m_pParent->getHeadElement(); 00157 } 00158 00159 /*****************************************************************/ 00163 /*****************************************************************/ 00164 inline TSingleListIterator(const TSingleLinkedList& rParent) 00165 { 00166 m_iRefCounter = 1; 00167 m_pParent = const_cast<TSingleLinkedList<T>*>(&rParent); 00168 m_pNextIterator = NULL; 00169 m_pActElement = m_pParent->getHeadElement(); 00170 } 00171 00172 /*****************************************************************/ 00175 /*****************************************************************/ 00176 inline virtual ~TSingleListIterator(){} 00177 00178 /*****************************************************************/ 00181 /*****************************************************************/ 00182 inline virtual void MQUALIFIER reset() const 00183 { 00184 m_pActElement = m_pParent->getHeadElement(); 00185 } 00186 00187 /*****************************************************************/ 00190 /*****************************************************************/ 00191 inline virtual T& MQUALIFIER getNextItem() const 00192 { 00193 if (this->hasNextItem()) 00194 { 00195 TSingleLinkedListElement* pTemp = m_pActElement; 00196 m_pActElement = m_pActElement->pNext; 00197 return pTemp->tData; 00198 } 00199 else 00200 { 00201 return m_pParent->getEmptyElement(); 00202 } 00203 } 00204 00205 00206 /*****************************************************************/ 00209 /*****************************************************************/ 00210 inline virtual const T& MQUALIFIER getNextItemConst() const 00211 { 00212 return (const T&)this->getNextItem(); 00213 } 00214 00215 /*****************************************************************/ 00218 /*****************************************************************/ 00219 inline virtual bool MQUALIFIER hasNextItem() const 00220 { 00221 return (m_pActElement != NULL); 00222 } 00223 00224 00225 /*****************************************************************/ 00228 /*****************************************************************/ 00229 inline Retval MQUALIFIER askForInterface(const InterfaceID& /*rInterfaceID*/, IZUnknown*& /*rpIface*/) 00230 { 00231 return RET_UNKNOWN_INTERFACE; 00232 } 00233 00234 /***************************************************************************/ 00237 /***************************************************************************/ 00238 inline void MQUALIFIER addRef() const 00239 { 00240 ++m_iRefCounter; 00241 } 00242 00243 /***************************************************************************/ 00246 /***************************************************************************/ 00247 void MQUALIFIER release() const 00248 { 00249 --m_iRefCounter; 00250 if (m_iRefCounter <= 0) 00251 { 00252 if (m_pParent != NULL) 00253 { 00254 m_pParent->releaseIterator(this); 00255 } 00256 else 00257 { 00258 delete this; 00259 } 00260 } 00261 } 00262 00263 /*****************************************************************/ 00266 /*****************************************************************/ 00267 inline TSingleListIterator* getNextIterator() const 00268 { 00269 return m_pNextIterator; 00270 } 00271 00272 /*****************************************************************/ 00275 /*****************************************************************/ 00276 inline void setNextIterator(TSingleListIterator* pIt) 00277 { 00278 m_pNextIterator = pIt; 00279 } 00280 00281 /*****************************************************************/ 00284 /*****************************************************************/ 00285 inline TSingleLinkedListElement* getActElement() const 00286 { 00287 return m_pActElement; 00288 } 00289 00290 /*****************************************************************/ 00293 /*****************************************************************/ 00294 inline void setActElement(TSingleLinkedListElement* pActElement) 00295 { 00296 m_pActElement = pActElement; 00297 } 00298 00299 /*****************************************************************/ 00302 /*****************************************************************/ 00303 inline void clearParent() 00304 { 00305 m_pParent = NULL; 00306 } 00307 00308 private: 00310 mutable TSingleLinkedList* m_pParent; 00312 mutable TSingleListIterator* m_pNextIterator; 00314 mutable TSingleLinkedListElement* m_pActElement; 00316 mutable Int m_iRefCounter; 00317 }; 00318 00319 private: 00321 TSingleLinkedListElement* m_pHead; 00323 TSingleLinkedListElement* m_pTail; 00325 mutable TSingleListIterator* m_pIterator; 00327 Int m_iCounter; 00328 00329 /*********************************************************************/ 00330 /* COMPILER PROBLEM: 00331 Change this if a compiler fails with : m_tEmpty(T()) (see constructors) 00332 00333 #ifdef A_COMPILER_TYPE 00334 static const T& getDefaultEmpty() 00335 { 00336 static const T Empty; // is initialized by compiler 00337 return Empty; 00338 } 00339 #endif 00340 00341 */ 00342 00343 protected: 00345 T m_tEmpty; 00346 }; 00347 00348 /******************************************************************************/ 00351 /******************************************************************************/ 00352 template <class T> inline TSingleLinkedList<T>::TSingleLinkedList() 00353 /* COMPILER PROBLEM*/ 00354 /*#ifdef A_COMPILER_TYPE 00355 : m_Empty(getDefaultEmpty()) 00356 #else 00357 : m_tEmpty(T()) 00358 #endif 00359 */ 00360 : m_tEmpty(T()) 00361 { 00362 m_iCounter = 0; 00363 m_pIterator = NULL; 00364 m_pTail = NULL; 00365 m_pHead = NULL; 00366 00367 // DO NOT USE MEMSET. This causes memory leaks on complex objects 00368 //memset(&m_tEmpty, 0, sizeof(T)); 00369 } 00370 00371 00372 /******************************************************************************/ 00376 /******************************************************************************/ 00377 template <class T> inline TSingleLinkedList<T>::TSingleLinkedList(const TSingleLinkedList<T>& rList) 00378 { 00379 m_iCounter = 0; 00380 m_pIterator = NULL; 00381 m_pTail = NULL; 00382 m_pHead = NULL; 00383 *this = rList; 00384 } 00385 00386 /******************************************************************************/ 00390 /******************************************************************************/ 00391 template <class T> TSingleLinkedList<T>::~TSingleLinkedList() 00392 { 00393 clear(); 00394 00395 //Reseten aller Iteratoren 00396 TSingleListIterator* pIt = m_pIterator; 00397 while (pIt != NULL) 00398 { 00399 pIt->clearParent(); 00400 pIt = pIt->getNextIterator(); 00401 } 00402 } 00403 00404 00405 /******************************************************************************/ 00407 /******************************************************************************/ 00408 template <class T> inline void TSingleLinkedList<T>::setEmptyItem(const T& rEmptyItem) 00409 { 00410 m_tEmpty = rEmptyItem; 00411 } 00412 00413 00414 /******************************************************************************/ 00417 /******************************************************************************/ 00418 template <class T> inline typename TSingleLinkedList<T>::TSingleLinkedListElement* TSingleLinkedList<T>::getHeadElement() const 00419 { 00420 return m_pHead; 00421 } 00422 00423 /******************************************************************************/ 00426 /******************************************************************************/ 00427 template <class T> inline T& TSingleLinkedList<T>::getEmptyElement() 00428 { 00429 return m_tEmpty; 00430 } 00431 00432 /******************************************************************************/ 00435 /******************************************************************************/ 00436 template <class T> inline Int MQUALIFIER TSingleLinkedList<T>::add(const T& rItem) 00437 { 00438 //Noch kein Item in der Liste 00439 if (m_pHead == NULL) 00440 { 00441 m_pHead = new TSingleLinkedListElement(rItem); 00442 m_pTail = m_pHead; 00443 00444 //notification of the new head element 00445 resetAllIterators(); 00446 } 00447 00448 //Anfuegen des Items 00449 else 00450 { 00451 TSingleLinkedListElement* pNewItem = new TSingleLinkedListElement(rItem); 00452 m_pTail->pNext = pNewItem; 00453 m_pTail = pNewItem; //Neuer Tail 00454 } 00455 m_iCounter++; 00456 return m_iCounter-1; 00457 } 00458 00459 /******************************************************************************/ 00462 /******************************************************************************/ 00463 template <class T> inline Int MQUALIFIER TSingleLinkedList<T>::addAll(const IList<T>& rlstItems) 00464 { 00465 TConstIterator<T> It = rlstItems.getConstIterator(); 00466 while(It.hasNextItem()) 00467 { 00468 this->add(It.getNextItemConst()); 00469 } 00470 00471 return m_iCounter-1; 00472 } 00473 00474 /******************************************************************************/ 00477 /******************************************************************************/ 00478 template <class T> inline Int MQUALIFIER TSingleLinkedList<T>::addEmptyItem() 00479 { 00480 return this->add(m_tEmpty); 00481 } 00482 00483 /******************************************************************************/ 00486 /******************************************************************************/ 00487 template <class T> void MQUALIFIER TSingleLinkedList<T>::copyToList(IList<T>& rList) const 00488 { 00489 rList.clear(); 00490 00491 //Copy of the data 00492 TSingleLinkedListElement* pItem = m_pHead; 00493 while (pItem != NULL) 00494 { 00495 rList.add(pItem->tData); 00496 pItem = pItem->pNext; 00497 } 00498 } 00499 00500 /******************************************************************************/ 00503 /******************************************************************************/ 00504 template <class T> void MQUALIFIER TSingleLinkedList<T>::clear() 00505 { 00506 while (m_pHead != NULL) 00507 { 00508 TSingleLinkedListElement* pNextItem = m_pHead->pNext; 00509 delete m_pHead; 00510 m_pHead = pNextItem; 00511 m_iCounter--; 00512 } 00513 00514 //Zuruecksetzen der Liste 00515 m_pHead = NULL; 00516 m_pTail = NULL; 00517 m_iCounter = 0; 00518 00519 //Loeschen des Iteratorreferenzen 00520 resetAllIterators(); 00521 } 00522 00523 /******************************************************************************/ 00526 /******************************************************************************/ 00527 template <class T> Retval MQUALIFIER TSingleLinkedList<T>::deleteItem(Int iIndex) 00528 { 00529 Retval retVal = RET_REQUEST_FAILED; 00530 if (m_pHead != NULL && iIndex >= 0 && iIndex < m_iCounter) 00531 { 00532 TSingleLinkedListElement* pItem = m_pHead; 00533 TSingleLinkedListElement* pPrevItem = NULL; 00534 Int iCounter =0; 00535 00536 while (pItem != NULL && iCounter < iIndex) 00537 { 00538 pPrevItem = pItem; 00539 pItem = pItem->pNext; 00540 iCounter++; 00541 } 00542 00543 //------------------------------------------------------------------------ 00544 //Fall 1: Item[0] (Head) soll geloescht werden. 00545 if(pItem == m_pHead) 00546 { 00547 //Anpassen der neuen Headers der Iteratoren 00548 TSingleListIterator* it = m_pIterator; 00549 while (it != NULL) 00550 { 00551 if (it->getActElement() == m_pHead) 00552 { 00553 it->setActElement(m_pHead->pNext); 00554 } 00555 it = it->getNextIterator(); 00556 } 00557 00558 pItem = m_pHead->pNext; 00559 delete m_pHead; 00560 m_pHead = pItem; 00561 m_iCounter--; 00562 00563 //Falls Nur ein Element existierte 00564 if (m_pHead == NULL) 00565 { 00566 m_pTail = NULL; 00567 } 00568 retVal = RET_NOERROR; 00569 } 00570 00571 //------------------------------------------------------------------------ 00572 //Fall 2: Letzes rItem wird geloescht 00573 else if (pItem == m_pTail) 00574 { 00575 //Anpassen des aktuellen Items der Iteratoren, wenn das Item das 00576 //geloeschte ist. 00577 TSingleListIterator* it = m_pIterator; 00578 while (it != NULL) 00579 { 00580 if (it->getActElement() == m_pTail) 00581 { 00582 it->setActElement(NULL); 00583 } 00584 it = it->getNextIterator(); 00585 } 00586 00587 //Loeschen des Letzten Items 00588 delete m_pTail; 00589 m_pTail = pPrevItem; 00590 pPrevItem->pNext = NULL; 00591 m_iCounter--; 00592 retVal = RET_NOERROR; 00593 } 00594 00595 //------------------------------------------------------------------------ 00596 //Fall 3 : Loeschen eines Item in der Mitte der Liste 00597 else if (pItem != NULL) 00598 { 00599 TSingleLinkedListElement* pNextItem = pItem->pNext; 00600 00601 //Anpassen des aktuellen Items der Iteratoren, wenn das Item das 00602 //geloeschte ist. 00603 TSingleListIterator* it = m_pIterator; 00604 while (it != NULL) 00605 { 00606 if (it->getActElement() == pItem) 00607 { 00608 it->setActElement(pNextItem); 00609 } 00610 it = it->getNextIterator(); 00611 } 00612 00613 delete pItem; 00614 pPrevItem->pNext = pNextItem; 00615 m_iCounter--; 00616 retVal = RET_NOERROR; 00617 } 00618 } 00619 return retVal; 00620 } 00621 00622 /******************************************************************************/ 00625 /******************************************************************************/ 00626 template <class T> Int MQUALIFIER TSingleLinkedList<T>::indexOf(const T& rItem) const 00627 { 00628 TSingleLinkedListElement* pItem = m_pHead; 00629 Int iCounter = INVALID_INDEX; 00630 while (pItem != NULL) 00631 { 00632 iCounter++; 00633 if (pItem->tData == rItem) 00634 { 00635 return iCounter; 00636 } 00637 pItem = pItem->pNext; 00638 } 00639 00640 return INVALID_INDEX; 00641 } 00642 00643 /******************************************************************************/ 00646 /******************************************************************************/ 00647 template <class T> Int MQUALIFIER TSingleLinkedList<T>::insert(Int iIndex, const T& rItem) 00648 { 00649 if (iIndex >= 0) 00650 { 00651 Int iCounter = 0; 00652 TSingleLinkedListElement* pItem = m_pHead; //Vor diesem Item Einfuegen 00653 TSingleLinkedListElement* pPrevItem = NULL; //Nach diesem Item Einfuegen 00654 00655 while(pItem != NULL && iCounter < iIndex) 00656 { 00657 pPrevItem = pItem; 00658 pItem = pItem->pNext; 00659 iCounter++; 00660 } 00661 00662 //Fall 1: Ein Element in der Mitte der Liste einfuegen 00663 if (pItem != NULL) 00664 { 00665 //Als HeadElement einfuegen 00666 if (pPrevItem == NULL) 00667 { 00668 m_pHead = new TSingleLinkedListElement(rItem, pItem); 00669 } 00670 else 00671 { 00672 pPrevItem->pNext = new TSingleLinkedListElement(rItem, pItem); 00673 } 00674 m_iCounter++; 00675 return iCounter; 00676 } 00677 00678 //Am Ende der Liste Anfuegen 00679 else if (pItem == NULL && iIndex == iCounter) 00680 { 00681 //List was empty 00682 if (pPrevItem == NULL) 00683 { 00684 m_pHead = new TSingleLinkedListElement(rItem); 00685 m_pTail = m_pHead; 00686 00687 //notification of the new head element 00688 resetAllIterators(); 00689 } 00690 00691 else 00692 { 00693 m_pTail = new TSingleLinkedListElement(rItem); 00694 pPrevItem->pNext = m_pTail; 00695 } 00696 m_iCounter++; 00697 return iCounter; 00698 } 00699 else 00700 { 00701 return INVALID_INDEX; 00702 } 00703 } 00704 else 00705 { 00706 return INVALID_INDEX; 00707 } 00708 } 00709 00710 /******************************************************************************/ 00713 /******************************************************************************/ 00714 template <class T> inline Retval MQUALIFIER TSingleLinkedList<T>::remove(const T& rItem) 00715 { 00716 return deleteItem(indexOf(rItem)); 00717 } 00718 00719 /***************************************************************************/ 00722 /***************************************************************************/ 00723 template <class T> Retval MQUALIFIER TSingleLinkedList<T>::removeAll(const IList<T>& rlstItems) 00724 { 00725 Retval retValue = RET_REQUEST_FAILED; 00726 bool bOK = false; 00727 TConstIterator<T> It = rlstItems.getConstIterator(); 00728 while(It.hasNextItem()) 00729 { 00730 bOK |= (this->remove(It.getNextItemConst()) == RET_NOERROR); 00731 } 00732 00733 if (bOK) 00734 { 00735 retValue = RET_NOERROR; 00736 } 00737 return retValue; 00738 } 00739 00740 /******************************************************************************/ 00743 /******************************************************************************/ 00744 template <class T> inline Int MQUALIFIER TSingleLinkedList<T>::getCount() const 00745 { 00746 return m_iCounter; 00747 } 00748 00749 /******************************************************************************/ 00752 /******************************************************************************/ 00753 template <class T> T& MQUALIFIER TSingleLinkedList<T>::getItem(Int iIndex) 00754 { 00755 Int iCounter = 0; 00756 TSingleLinkedListElement* pItem = m_pHead; //Start 00757 00758 while(pItem != NULL && iCounter < iIndex) 00759 { 00760 pItem = pItem->pNext; 00761 iCounter++; 00762 } 00763 00764 if (pItem != NULL && iIndex >= 0) 00765 { 00766 return pItem->tData; 00767 } 00768 else 00769 { 00770 return m_tEmpty; 00771 } 00772 } 00773 00774 /******************************************************************************/ 00777 /******************************************************************************/ 00778 template <class T> const T& MQUALIFIER TSingleLinkedList<T>::getItemConst(Int iIndex) const 00779 { 00780 Int iCounter = 0; 00781 TSingleLinkedListElement* pItem = m_pHead; //Start 00782 00783 while(pItem != NULL && iCounter < iIndex) 00784 { 00785 pItem = pItem->pNext; 00786 iCounter++; 00787 } 00788 00789 if (pItem != NULL && iIndex >= 0) 00790 { 00791 return pItem->tData; 00792 } 00793 else 00794 { 00795 return m_tEmpty; 00796 } 00797 } 00798 00799 /******************************************************************************/ 00802 /******************************************************************************/ 00803 template <class T> inline bool MQUALIFIER TSingleLinkedList<T>::equalsItem(Int iIndex, const T& rItem) const 00804 { 00805 return (iIndex >= 0 && 00806 iIndex < m_iCounter && 00807 getItemConst(iIndex) == rItem); 00808 } 00809 00810 /******************************************************************************/ 00813 /******************************************************************************/ 00814 template <class T> bool MQUALIFIER TSingleLinkedList<T>::equals(const IList<T>& rList) const 00815 { 00816 bool bRetval = (rList.getCount() == m_iCounter); 00817 00818 if (bRetval) 00819 { 00820 TSingleLinkedListElement* pItem = m_pHead; //Start 00821 Int iCounter = 0; 00822 00823 while (pItem != NULL && bRetval) 00824 { 00825 bRetval &= rList.equalsItem(iCounter, pItem->tData); 00826 pItem = pItem->pNext; 00827 ++iCounter; 00828 } 00829 } 00830 00831 return bRetval; 00832 } 00833 00834 /******************************************************************************/ 00837 /******************************************************************************/ 00838 template <class T> inline IListIterator<T>* MQUALIFIER TSingleLinkedList<T>::getIterator() const 00839 { 00840 TSingleListIterator* pIterator; 00841 CREATE_SAFE(pIterator, new TSingleListIterator(*this)); 00842 00843 pIterator->setNextIterator(m_pIterator); 00844 m_pIterator = pIterator; 00845 return m_pIterator; 00846 } 00847 00848 /******************************************************************************/ 00851 /******************************************************************************/ 00852 template <class T> inline const IListIterator<T>* MQUALIFIER TSingleLinkedList<T>::getConstIterator() const 00853 { 00854 TSingleListIterator* pIterator; 00855 CREATE_SAFE(pIterator, new TSingleListIterator(*this)); 00856 00857 pIterator->setNextIterator(m_pIterator); 00858 m_pIterator = pIterator; 00859 return m_pIterator; 00860 } 00861 00862 /******************************************************************************/ 00865 /******************************************************************************/ 00866 template <class T> void MQUALIFIER TSingleLinkedList<T>::releaseIterator(const IListIterator<T>* pIterator) const 00867 { 00868 TSingleListIterator* pIt = m_pIterator; 00869 TSingleListIterator* pItPrev = NULL; 00870 while (pIt != NULL) 00871 { 00872 if (pIt == pIterator) 00873 { 00874 //Erster Iterator loeschen 00875 if (pItPrev == NULL) 00876 { 00877 m_pIterator = pIt->getNextIterator(); 00878 delete pIt; 00879 } 00880 else 00881 { 00882 pItPrev->setNextIterator(pIt->getNextIterator()); 00883 delete pIt; 00884 } 00885 break; 00886 } 00887 pItPrev = pIt; 00888 pIt = pIt->getNextIterator(); 00889 } 00890 } 00891 00892 /******************************************************************************/ 00895 /******************************************************************************/ 00896 template <class T> inline bool MQUALIFIER TSingleLinkedList<T>::isEmpty() const 00897 { 00898 return (m_iCounter == 0); 00899 } 00900 00901 /******************************************************************************/ 00904 /******************************************************************************/ 00905 template <class T> inline T& MQUALIFIER TSingleLinkedList<T>::getFirstItem() 00906 { 00907 return this->getItem(0); 00908 } 00909 00910 /******************************************************************************/ 00913 /******************************************************************************/ 00914 template <class T> inline const T& MQUALIFIER TSingleLinkedList<T>::getFirstItemConst() const 00915 { 00916 return this->getItemConst(0); 00917 } 00918 00919 /******************************************************************************/ 00922 /******************************************************************************/ 00923 template <class T> inline T& MQUALIFIER TSingleLinkedList<T>::getLastItem() 00924 { 00925 return this->getItem(m_iCounter-1); 00926 } 00927 00928 /******************************************************************************/ 00931 /******************************************************************************/ 00932 template <class T> inline const T& MQUALIFIER TSingleLinkedList<T>::getLastItemConst() const 00933 { 00934 return this->getItemConst(m_iCounter-1); 00935 } 00936 00937 /******************************************************************************/ 00940 /******************************************************************************/ 00941 template <class T> inline bool MQUALIFIER TSingleLinkedList<T>::hasItem(const T& rItem) const 00942 { 00943 return (this->indexOf(rItem) != INVALID_INDEX); 00944 } 00945 00946 /******************************************************************************/ 00949 /******************************************************************************/ 00950 template <class T> bool MQUALIFIER TSingleLinkedList<T>::hasAllItems(const IList<T>& rlstItems) const 00951 { 00952 bool bRetval = true; 00953 00954 TConstIterator<T> It = rlstItems.getConstIterator(); 00955 while(bRetval && It.hasNextItem()) 00956 { 00957 bRetval &= this->hasItem(It.getNextItemConst()); 00958 } 00959 return bRetval; 00960 } 00961 00962 /******************************************************************************/ 00967 /******************************************************************************/ 00968 template <class T> inline T& TSingleLinkedList<T>::operator[](Int iIndex) 00969 { 00970 return getItem(iIndex); 00971 } 00972 00973 00974 /******************************************************************************/ 00979 /******************************************************************************/ 00980 template <class T> inline const T& TSingleLinkedList<T>::operator[](Int iIndex) const 00981 { 00982 return getItemConst(iIndex); 00983 } 00984 00985 00986 /******************************************************************************/ 00991 /******************************************************************************/ 00992 template <class T> inline TSingleLinkedList<T>& TSingleLinkedList<T>::operator=(const TSingleLinkedList<T>& rList) 00993 { 00994 rList.copyToList(*this); 00995 return *this; 00996 } 00997 00998 /******************************************************************************/ 01004 /******************************************************************************/ 01005 template <class T> inline bool TSingleLinkedList<T>::operator==(const TSingleLinkedList<T>& rList) const 01006 { 01007 return this->equals(rList); 01008 } 01009 01010 /******************************************************************************/ 01014 /******************************************************************************/ 01015 template <class T> inline bool TSingleLinkedList<T>::operator!=(const TSingleLinkedList<T>& rList) const 01016 { 01017 return !this->equals(rList); 01018 } 01019 01020 /******************************************************************************/ 01023 /******************************************************************************/ 01024 template <class T> inline void TSingleLinkedList<T>::resetAllIterators() 01025 { 01026 TSingleListIterator* pIt = m_pIterator; 01027 while (pIt != NULL) 01028 { 01029 pIt->reset(); 01030 pIt = pIt->getNextIterator(); 01031 } 01032 } 01033 01034 END_NAMESPACE_Zeus 01035 01036 #endif 01037