ArrayList.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 : ArrayList 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 #ifndef ArrayListH 00033 #define ArrayListH 00034 00035 #include <zeusbase/System/Interfaces/IArray.hpp> 00036 #include <zeusbase/System/Iterators.hpp> 00037 00038 #if __BCPLUSPLUS__ >= 0x0570 00039 #include <mem.h> 00040 #else 00041 #include <string.h> 00042 #endif 00043 00044 #include <assert.h> 00045 00046 BEGIN_NAMESPACE_Zeus 00047 00048 /*****************************************************************************/ 00056 /*****************************************************************************/ 00057 template <class T> class TArrayList : public IArray<T> 00058 { 00059 public: 00060 00061 TArrayList(Int iSize = 20, EArrayCopyMode eCopyMode = etDeepCopy); 00062 TArrayList(const T* pArray, Int iSize, EArrayCopyMode eCopyMode, bool bAttachPointer = false); 00063 TArrayList(const T& rEmptyItem, Int iSize, EArrayCopyMode eCopyMode); 00064 00065 virtual ~TArrayList(); 00066 00068 TArrayList(const TArrayList<T>& rList); 00069 TArrayList(const IArray<T>* pList); 00070 00071 //Methods of IArray 00072 virtual T* MQUALIFIER getArray() const; 00073 virtual const T* MQUALIFIER getArrayConst() const; 00074 virtual Int MQUALIFIER getArraySize() const; 00075 virtual Retval MQUALIFIER setArray(const T* pArray, Int iSize, bool bAttachPointer = false); 00076 virtual Retval MQUALIFIER appendArray(const T* pArray, Int iSize); 00077 virtual Retval MQUALIFIER copyToArray(IArray<T>& rDest, Int iStart, Int iEnd) const; 00078 virtual EArrayCopyMode MQUALIFIER getCopyMode() const; 00079 virtual Retval MQUALIFIER overwrite(const IArray<T>& rSrc, Int iSrcStart, Int iSrcEnd, Int iDestStart); 00080 00081 //Methods of IList 00082 virtual Int MQUALIFIER add(const T& rItem); 00083 virtual Int MQUALIFIER addAll(const IList<T>& rlstItems); 00084 virtual Int MQUALIFIER addEmptyItem(); 00085 virtual void MQUALIFIER copyToList(IList<T>& rList) const; 00086 virtual void MQUALIFIER clear(); 00087 virtual Retval MQUALIFIER deleteItem(Int iIndex); 00088 virtual Retval MQUALIFIER remove(const T& rItem); 00089 virtual Retval MQUALIFIER removeAll(const IList<T>& rlstItems); 00090 virtual Int MQUALIFIER getCount() const; 00091 virtual T& MQUALIFIER getItem(Int iIndex); 00092 virtual const T& MQUALIFIER getItemConst(Int iIndex) const; 00093 virtual bool MQUALIFIER equalsItem(Int iIndex, const T& rItem) const; 00094 virtual bool MQUALIFIER equals(const IList<T>& rList) const; 00095 virtual Int MQUALIFIER indexOf(const T& rItem) const; 00096 virtual Int MQUALIFIER insert(Int iIndex, const T& rItem); 00097 virtual IListIterator<T>* MQUALIFIER getIterator() const; 00098 virtual const IListIterator<T>* MQUALIFIER getConstIterator() const; 00099 virtual void MQUALIFIER releaseIterator(const IListIterator<T>* pIterator) const; 00100 virtual bool MQUALIFIER isEmpty() const; 00101 virtual T& MQUALIFIER getFirstItem(); 00102 virtual const T& MQUALIFIER getFirstItemConst() const; 00103 virtual T& MQUALIFIER getLastItem(); 00104 virtual const T& MQUALIFIER getLastItemConst() const; 00105 virtual bool MQUALIFIER hasItem(const T& rItem) const; 00106 virtual bool MQUALIFIER hasAllItems(const IList<T>& rlstItems) const; 00107 00108 //Operators 00109 T& operator[](Int iIndex); 00110 TArrayList<T>& operator=(const IList<T>& rList); 00111 TArrayList<T>& operator=(const IList<T>* pList); 00112 TArrayList<T>& operator=(const TArrayList<T>& rList); 00113 TArrayList<T>& operator=(const TArrayList<T>* pList); 00114 bool operator==(const TArrayList<T>& rList) const; 00115 bool operator!=(const TArrayList<T>& rList) const; 00116 void addEmptyItems(Int iCount); 00117 T& getEmptyItem(); 00118 00119 //Copy methods 00120 Retval copyToArray(TArrayList<T>& rDest, 00121 Int iStart = 0, 00122 Int iEnd = INVALID_INDEX) const; 00123 Retval copyToArray(T* pBuffer, 00124 Int iBufferSize, 00125 Int& rCopiedSize, 00126 Int iStart = 0, 00127 Int iEnd = INVALID_INDEX) const; 00128 00129 Retval setArray2(const T* pArray, Int iSize, bool bAttachPointer = false); 00130 void resize(Int iNewSize); 00131 void clearSecure(); 00132 00133 protected: 00134 00135 private: 00136 00137 /*********************************************************************/ 00138 /* COMPILER PROBLEM: 00139 Change this if a compiler fails with : m_tEmpty(T()) (see constructors) 00140 00141 #ifdef A_COMPILER_TYPE 00142 static const T& getDefaultEmpty() 00143 { 00144 static const T Empty; // is initialized by compiler 00145 return Empty; 00146 } 00147 #endif 00148 00149 */ 00150 00151 /*********************************************************************/ 00154 /*********************************************************************/ 00155 class TArrayListIterator : public IListIterator<T> 00156 { 00157 public: 00158 /*****************************************************************/ 00162 /*****************************************************************/ 00163 inline TArrayListIterator(TArrayList& rParent) 00164 { 00165 m_iRefCounter = 1; 00166 m_pParent = &rParent; 00167 m_pNextIterator = NULL; 00168 m_iActElement = 0; 00169 m_tEmpty = m_pParent->getEmptyItem(); 00170 } 00171 00172 /*****************************************************************/ 00176 /*****************************************************************/ 00177 inline TArrayListIterator(const TArrayList& rParent) 00178 { 00179 m_iRefCounter = 1; 00180 m_pParent = const_cast<TArrayList<T>*>(&rParent); 00181 m_pNextIterator = NULL; 00182 m_iActElement = 0; 00183 m_tEmpty = m_pParent->getEmptyItem(); 00184 } 00185 00186 /*****************************************************************/ 00189 /*****************************************************************/ 00190 inline virtual ~TArrayListIterator() 00191 {} 00192 00193 /*****************************************************************/ 00196 /*****************************************************************/ 00197 inline virtual void MQUALIFIER reset() const 00198 { 00199 m_iActElement = 0; 00200 } 00201 00202 /*****************************************************************/ 00205 /*****************************************************************/ 00206 inline virtual T& MQUALIFIER getNextItem() const 00207 { 00208 if (this->hasNextItem()) 00209 { 00210 m_iActElement++; 00211 return m_pParent->getItem(m_iActElement-1); 00212 } 00213 else 00214 { 00215 return m_tEmpty; 00216 } 00217 } 00218 00219 /*****************************************************************/ 00222 /*****************************************************************/ 00223 inline virtual const T& MQUALIFIER getNextItemConst() const 00224 { 00225 return const_cast<const T&>(this->getNextItem()); 00226 } 00227 00228 /*****************************************************************/ 00231 /*****************************************************************/ 00232 inline virtual bool MQUALIFIER hasNextItem() const 00233 { 00234 return (m_pParent != NULL && m_iActElement < m_pParent->getCount()); 00235 } 00236 00237 /*****************************************************************/ 00240 /*****************************************************************/ 00241 inline Retval MQUALIFIER askForInterface(const InterfaceID& /*rInterfaceID*/, IZUnknown*& /*rpIface*/) 00242 { 00243 return RET_UNKNOWN_INTERFACE; 00244 } 00245 00246 /***************************************************************************/ 00249 /***************************************************************************/ 00250 inline void MQUALIFIER addRef() const 00251 { 00252 ++m_iRefCounter; 00253 } 00254 00255 /***************************************************************************/ 00258 /***************************************************************************/ 00259 void MQUALIFIER release() const 00260 { 00261 --m_iRefCounter; 00262 if (m_iRefCounter <= 0) 00263 { 00264 if (m_pParent != NULL) 00265 { 00266 m_pParent->releaseIterator(this); 00267 } 00268 else 00269 { 00270 delete this; 00271 } 00272 } 00273 } 00274 00275 /*****************************************************************/ 00278 /*****************************************************************/ 00279 inline TArrayListIterator* getNextIterator() const 00280 { 00281 return m_pNextIterator; 00282 } 00283 00284 /*****************************************************************/ 00287 /*****************************************************************/ 00288 inline void setNextIterator(TArrayListIterator* pIt) 00289 { 00290 m_pNextIterator = pIt; 00291 } 00292 00293 /*****************************************************************/ 00296 /*****************************************************************/ 00297 inline Int getActElement() 00298 { 00299 return m_iActElement; 00300 } 00301 00302 /*****************************************************************/ 00305 /*****************************************************************/ 00306 inline void setActElement(Int iElement) 00307 { 00308 m_iActElement = iElement; 00309 } 00310 00311 /*****************************************************************/ 00314 /*****************************************************************/ 00315 inline void clearParent() 00316 { 00317 m_pParent = NULL; 00318 } 00319 00320 private: 00321 mutable TArrayList* m_pParent; 00322 mutable TArrayListIterator* m_pNextIterator; 00323 mutable Int m_iActElement; 00324 mutable T m_tEmpty; 00326 mutable Int m_iRefCounter; 00327 }; 00328 00330 T* m_pDataArray; 00332 mutable TArrayListIterator* m_pIterator; 00334 Int m_iCounter; 00336 Int m_iSize; 00338 Int m_iOrigSize; 00340 T m_tEmpty; 00342 EArrayCopyMode m_eCopyMode; 00343 }; 00344 00345 00346 00347 00348 /******************************************************************************/ 00355 /******************************************************************************/ 00356 template <class T> TArrayList<T>::TArrayList(Int iSize, EArrayCopyMode eCopyMode /*= etDeepCopy*/) 00357 /* COMPILER PROBLEM*/ 00358 /*#ifdef A_COMPILER_TYPE 00359 : m_Empty(getDefaultEmpty()) 00360 #else 00361 : m_tEmpty(T()) 00362 #endif 00363 */ 00364 : m_tEmpty(T()) 00365 { 00366 m_eCopyMode = eCopyMode; 00367 m_iSize = iSize; 00368 m_iOrigSize = iSize; 00369 m_iCounter = 0; 00370 m_pIterator = NULL; 00371 m_pDataArray = new T[m_iSize]; 00372 00373 // DO NOT USE MEMSET. This causes memory leaks on complex objects 00374 // memset(&m_tEmpty, 0, sizeof(T)); 00375 assert(m_pDataArray != NULL); 00376 } 00377 00378 /******************************************************************************/ 00388 /******************************************************************************/ 00389 template <class T> TArrayList<T>::TArrayList(const T* pArray, Int iSize, 00390 EArrayCopyMode eCopyMode, 00391 bool bAttachPointer) 00392 /* COMPILER PROBLEM*/ 00393 /*#ifdef A_COMPILER_TYPE 00394 : m_Empty(getDefaultEmpty()) 00395 #else 00396 : m_tEmpty(T()) 00397 #endif 00398 */ 00399 : m_tEmpty(T()) 00400 { 00401 m_eCopyMode = eCopyMode; 00402 m_iSize = iSize; 00403 m_iOrigSize = iSize; 00404 m_pIterator = NULL; 00405 m_pDataArray = NULL; 00406 m_iCounter = 0; 00407 00408 if (!bAttachPointer) 00409 { 00410 setArray2(pArray, iSize); 00411 } //(!bAttachPointer) 00412 00413 else 00414 { 00415 m_pDataArray = const_cast<T*>(pArray); 00416 m_iCounter = iSize; 00417 } //(bAttachPointer) 00418 00419 assert(m_pDataArray != NULL); 00420 } 00421 00422 /******************************************************************************/ 00431 /******************************************************************************/ 00432 template <class T> TArrayList<T>::TArrayList(const T& rEmptyItem, 00433 Int iSize, 00434 EArrayCopyMode eCopyMode) 00435 : m_tEmpty(rEmptyItem) 00436 { 00437 m_eCopyMode = eCopyMode; 00438 m_iSize = iSize; 00439 m_iOrigSize = iSize; 00440 m_iCounter = 0; 00441 m_pIterator = NULL; 00442 m_pDataArray = new T[m_iSize]; 00443 00444 assert(m_pDataArray != NULL); 00445 } 00446 00447 /******************************************************************************/ 00451 /******************************************************************************/ 00452 template <class T> TArrayList<T>::TArrayList(const TArrayList<T>& rList) 00453 /* COMPILER PROBLEM*/ 00454 /*#ifdef A_COMPILER_TYPE 00455 : m_Empty(getDefaultEmpty()) 00456 #else 00457 : m_tEmpty(T()) 00458 #endif 00459 */ 00460 #if defined(__COLINUX__) 00461 : IArray<T>(rList), 00462 m_tEmpty(T()) 00463 #else 00464 : m_tEmpty(T()) 00465 #endif 00466 { 00467 m_eCopyMode = rList.getCopyMode(); 00468 m_iSize = rList.getArraySize(); 00469 m_iOrigSize = m_iSize; 00470 m_iCounter = 0; 00471 m_pIterator = NULL; 00472 m_pDataArray = NULL; 00473 00474 // DO NOT USE MEMSET. This causes memory leaks on complex objects 00475 //memset(&m_tEmpty, 0, sizeof(T)); 00476 00477 this->setArray2(rList.getArray(), rList.getCount()); 00478 00479 assert(m_pDataArray != NULL); 00480 } 00481 00482 /******************************************************************************/ 00486 /******************************************************************************/ 00487 template <class T> TArrayList<T>::TArrayList(const IArray<T>* pList) 00488 /* COMPILER PROBLEM*/ 00489 /*#ifdef A_COMPILER_TYPE 00490 : m_Empty(getDefaultEmpty()) 00491 #else 00492 : m_tEmpty(T()) 00493 #endif 00494 */ 00495 : m_tEmpty(T()) 00496 { 00497 m_eCopyMode = etDeepCopy; 00498 m_iCounter = 0; 00499 m_pIterator = NULL; 00500 m_pDataArray = NULL; 00501 00502 // DO NOT USE MEMSET. This causes memory leaks on complex objects 00503 // memset(&m_tEmpty, 0, sizeof(T)); 00504 if (pList != NULL) 00505 { 00506 m_iSize = pList->getArraySize(); 00507 m_iOrigSize = m_iSize; 00508 m_eCopyMode = pList->getCopyMode(); 00509 this->setArray(pList->getArray(), pList->getCount()); 00510 } 00511 else 00512 { 00513 m_iSize = 20; 00514 m_iOrigSize = 20; 00515 m_pDataArray = new T[m_iSize]; 00516 } 00517 00518 assert(m_pDataArray != NULL); 00519 } 00520 00521 00522 /******************************************************************************/ 00525 /******************************************************************************/ 00526 template <class T> TArrayList<T>::~TArrayList() 00527 { 00528 //Reseten aller Iteratoren 00529 TArrayListIterator* pIt = m_pIterator; 00530 while (pIt != NULL) 00531 { 00532 pIt->clearParent(); 00533 pIt = pIt->getNextIterator(); 00534 } 00535 delete [] m_pDataArray; 00536 } 00537 00538 00539 /******************************************************************************/ 00546 /******************************************************************************/ 00547 template <class T> inline Int MQUALIFIER TArrayList<T>::getArraySize() const 00548 { 00549 return m_iSize; 00550 } 00551 00552 /******************************************************************************/ 00555 /******************************************************************************/ 00556 template <class T> inline T* MQUALIFIER TArrayList<T>::getArray() const 00557 { 00558 return m_pDataArray; 00559 } 00560 00561 /******************************************************************************/ 00564 /******************************************************************************/ 00565 template <class T> inline const T* MQUALIFIER TArrayList<T>::getArrayConst() const 00566 { 00567 return m_pDataArray; 00568 } 00569 00570 /******************************************************************************/ 00573 /******************************************************************************/ 00574 template <class T> inline Retval MQUALIFIER TArrayList<T>::setArray(const T* pArray, Int iSize, bool bAttachPointer /*= false*/) 00575 { 00576 Retval retVal = RET_INVALID_DATA; 00577 00578 if (!bAttachPointer || this->getCopyMode() != etDeepCopy) 00579 { 00580 retVal = setArray2(pArray, iSize, bAttachPointer); 00581 } 00582 00583 return retVal; 00584 } 00585 00586 /******************************************************************************/ 00593 /******************************************************************************/ 00594 template <class T> Retval TArrayList<T>::setArray2(const T* pArray, Int iSize, bool bAttachPointer /*= false*/) 00595 { 00596 Retval retVal = RET_INVALID_PARAMETER; 00597 00598 if (!bAttachPointer) 00599 { 00600 //Speciality: Sets the original size to the new size required and call clear, which will 00601 // free the actual array and allocate the array with original size 00602 m_iOrigSize = iSize+2; 00603 this->clear(); 00605 00606 if (pArray != NULL) 00607 { 00608 //Copy the array 00609 switch(m_eCopyMode) 00610 { 00611 case etShallowCopy: 00612 ::memcpy(m_pDataArray, pArray, sizeof(T)*iSize); 00613 break; 00614 00615 case etDeepCopy : //fall though 00616 default: 00617 for(Int i = 0; i < iSize; i++) 00618 { 00619 m_pDataArray[i] = pArray[i]; 00620 } 00621 break; 00622 } 00623 m_iCounter = iSize; 00624 retVal = RET_NOERROR; 00625 } 00626 } //(!bAttachPointer) 00627 else 00628 { 00629 if (m_pDataArray != NULL) 00630 { 00631 delete [] m_pDataArray; 00632 } 00633 m_pDataArray = const_cast<T*>(pArray); 00634 m_iOrigSize = iSize; 00635 m_iCounter = iSize; 00636 m_iSize = iSize; 00637 00638 //Reseten aller Iteratoren 00639 TArrayListIterator* pIt = m_pIterator; 00640 while (pIt != NULL) 00641 { 00642 pIt->reset(); 00643 pIt = pIt->getNextIterator(); 00644 } 00645 } //(bAttachPointer) 00646 00647 return retVal; 00648 } 00649 00650 /******************************************************************************/ 00653 /******************************************************************************/ 00654 template <class T> Retval MQUALIFIER TArrayList<T>::appendArray(const T* pArray, Int iSize) 00655 { 00656 Retval retVal = RET_INVALID_PARAMETER; 00657 if (pArray != NULL) 00658 { 00659 if (m_iCounter + iSize >= m_iSize) 00660 { 00661 resize(m_iSize + iSize); 00662 } 00663 00664 //append the array 00665 switch(m_eCopyMode) 00666 { 00667 case etShallowCopy: 00668 ::memcpy(&m_pDataArray[m_iCounter], pArray, sizeof(T)*iSize); 00669 break; 00670 00671 case etDeepCopy : //fall though 00672 default: 00673 for(Int i = 0; i < iSize; i++) 00674 { 00675 m_pDataArray[i + m_iCounter] = pArray[i]; 00676 } 00677 break; 00678 } 00679 m_iCounter += iSize; 00680 retVal = RET_NOERROR; 00681 } 00682 return retVal; 00683 } 00684 00685 00686 /******************************************************************************/ 00689 /******************************************************************************/ 00690 template <class T> Retval MQUALIFIER TArrayList<T>::copyToArray(IArray<T>& rDest, Int iStart, Int iEnd) const 00691 { 00692 Retval retVal = RET_INVALID_PARAMETER; 00693 00694 //Not supported for interfaces. For interfaces IArray<Iface> you 00695 // MUST use shallow copy 00696 if (rDest.getCopyMode() == etDeepCopy) 00697 { 00698 retVal = RET_INVALID_DATA; 00699 assert(false); 00700 } 00701 else if (iStart <= iEnd) 00702 { 00703 if (iStart < 0 || iEnd >= m_iCounter) 00704 { 00705 retVal = RET_REQUEST_FAILED; 00706 } 00707 else 00708 { 00709 Int iArraySize = iEnd - iStart + 1; 00710 T* pArr = new T[iArraySize]; 00711 ::memcpy(pArr, &(m_pDataArray[iStart]), sizeof(T)*iArraySize); 00712 rDest.setArray(pArr, iArraySize, false); 00713 retVal = RET_NOERROR; 00714 delete [] pArr; 00715 } 00716 } 00717 00718 return retVal; 00719 } 00720 00721 /******************************************************************************/ 00730 /******************************************************************************/ 00731 template <class T> Retval TArrayList<T>::copyToArray(TArrayList<T>& rDest, 00732 Int iStart /*= 0*/, 00733 Int iEnd /*= INVALID_INDEX*/) const 00734 { 00735 Retval retVal = RET_INVALID_PARAMETER; 00736 if (iEnd == INVALID_INDEX) 00737 { 00738 iEnd = m_iCounter -1; 00739 } 00740 00741 if (iStart <= iEnd) 00742 { 00743 if (iStart < 0 || iEnd >= m_iCounter) 00744 { 00745 retVal = RET_REQUEST_FAILED; 00746 } 00747 else 00748 { 00749 Int iArraySize = iEnd - iStart + 1; 00750 T* pArr = new T[iArraySize]; 00751 00752 //copy the array 00753 switch(m_eCopyMode) 00754 { 00755 case etShallowCopy: 00756 ::memcpy(pArr, &(m_pDataArray[iStart]), sizeof(T)*iArraySize); 00757 break; 00758 00759 case etDeepCopy : //fall though 00760 default: 00761 for(Int i = 0; i < iArraySize; ++i) 00762 { 00763 pArr[i] = m_pDataArray[i + iStart]; 00764 } 00765 break; 00766 } 00767 00768 rDest.setArray2(pArr, iArraySize, true); 00769 retVal = RET_NOERROR; 00770 } 00771 } 00772 return retVal; 00773 } 00774 00775 /******************************************************************************/ 00786 /******************************************************************************/ 00787 template <class T> Retval TArrayList<T>::copyToArray(T* pBuffer, 00788 Int iBufferSize, 00789 Int& rCopiedSize, 00790 Int iStart /*= 0*/, 00791 Int iEnd /*= INVALID_INDEX*/) const 00792 { 00793 Retval retVal = RET_INVALID_PARAMETER; 00794 if (iEnd == INVALID_INDEX) 00795 { 00796 iEnd = m_iCounter -1; 00797 } 00798 00799 if (iStart <= iEnd) 00800 { 00801 Int iArraySize = iEnd - iStart + 1; 00802 if (iArraySize > iBufferSize) 00803 { 00804 iArraySize = iBufferSize; 00805 } 00806 00807 if (iStart < 0 || 00808 iEnd >= m_iCounter) 00809 { 00810 retVal = RET_REQUEST_FAILED; 00811 } 00812 else 00813 { 00814 //copy the array 00815 switch(m_eCopyMode) 00816 { 00817 case etShallowCopy: 00818 ::memcpy(pBuffer, &(m_pDataArray[iStart]), sizeof(T)*iArraySize); 00819 break; 00820 00821 case etDeepCopy : //fall though 00822 default: 00823 for(Int i = 0; i < iArraySize; ++i) 00824 { 00825 pBuffer[i] = m_pDataArray[i + iStart]; 00826 } 00827 break; 00828 } 00829 00830 rCopiedSize = iArraySize; 00831 retVal = RET_NOERROR; 00832 } 00833 } 00834 return retVal; 00835 } 00836 00837 00838 /******************************************************************************/ 00841 /******************************************************************************/ 00842 template <class T> inline EArrayCopyMode MQUALIFIER TArrayList<T>::getCopyMode() const 00843 { 00844 return m_eCopyMode; 00845 } 00846 00847 /******************************************************************************/ 00850 /******************************************************************************/ 00851 template <class T> Retval MQUALIFIER TArrayList<T>::overwrite(const IArray<T>& rSrc, Int iSrcStart, Int iSrcEnd, Int iDestStart) 00852 { 00853 Retval retValue = RET_REQUEST_FAILED; 00854 00855 Int iSrcCount = rSrc.getCount(); 00856 if (iSrcEnd == INVALID_INDEX) 00857 { 00858 iSrcEnd = iSrcCount -1; 00859 } 00860 00861 //Check if the start is smaller than the end index 00862 if (iSrcStart <= iSrcEnd) 00863 { 00864 Int iArraySize = iSrcEnd - iSrcStart + 1; 00865 if (iSrcStart < iSrcCount && 00866 iSrcEnd < iSrcCount && 00867 iDestStart < m_iCounter && 00868 iDestStart + iArraySize - 1 < m_iCounter) 00869 { 00870 if (m_eCopyMode == etShallowCopy && rSrc.getCopyMode() == etShallowCopy) 00871 { 00872 ::memcpy(&(m_pDataArray[iDestStart]), &(rSrc.getArrayConst()[iSrcStart]), sizeof(T)*iArraySize); 00873 } //(m_eCopyMode == etShallowCopy && rSrc.getCopyMode() == etShallowCopy) 00874 else 00875 { 00876 for(Int i = 0; i < iArraySize; ++i) 00877 { 00878 m_pDataArray[i + iDestStart] = rSrc.getItemConst(iSrcStart + i); 00879 } 00880 } //(m_eCopyMode != etShallowCopy || rSrc.getCopyMode() != etShallowCopy) 00881 00882 retValue = RET_NOERROR; 00883 } 00884 } 00885 00886 return retValue; 00887 } 00888 00889 /******************************************************************************/ 00894 /******************************************************************************/ 00895 template <class T> void TArrayList<T>::resize(Int iNewSize) 00896 { 00897 assert(m_pDataArray != NULL); 00898 00899 m_iSize = iNewSize; 00900 if (m_iCounter > m_iSize) 00901 { 00902 m_iCounter = m_iSize; 00903 } 00904 00905 T* pNewArray = new T[m_iSize]; 00906 00907 //Shallow copy using mem copy 00908 if (m_eCopyMode == etShallowCopy) 00909 { 00910 if (m_iCounter > 0) 00911 { 00912 ::memcpy(pNewArray, m_pDataArray, sizeof(T)*m_iCounter); 00913 } 00914 } 00915 //deep copy using assign operator 00916 else 00917 { 00918 for(int i = 0; i < m_iCounter; i++) 00919 { 00920 pNewArray[i] = m_pDataArray[i]; 00921 } 00922 } 00923 delete [] m_pDataArray; 00924 00925 m_pDataArray = pNewArray; 00926 } 00927 00928 00929 /******************************************************************************/ 00932 /******************************************************************************/ 00933 template <class T> Int MQUALIFIER TArrayList<T>::add(const T& rItem) 00934 { 00935 00936 //Vergroessern des Arrays 00937 if (m_iCounter >= m_iSize) 00938 { 00939 resize((Int)(m_iSize*1.5)); 00940 } 00941 00942 m_pDataArray[m_iCounter] = rItem; 00943 m_iCounter++; 00944 00945 return m_iCounter-1; 00946 } 00947 00948 /******************************************************************************/ 00951 /******************************************************************************/ 00952 template <class T> Int MQUALIFIER TArrayList<T>::addAll(const IList<T>& rlstItems) 00953 { 00954 TConstIterator<T> It = rlstItems.getConstIterator(); 00955 while(It.hasNextItem()) 00956 { 00957 this->add(It.getNextItemConst()); 00958 } 00959 00960 return m_iCounter-1; 00961 } 00962 00963 /******************************************************************************/ 00966 /******************************************************************************/ 00967 template <class T> inline Int MQUALIFIER TArrayList<T>::addEmptyItem() 00968 { 00969 return this->add(m_tEmpty); 00970 } 00971 00972 /******************************************************************************/ 00975 /******************************************************************************/ 00976 template <class T> void MQUALIFIER TArrayList<T>::copyToList(IList<T>& rList) const 00977 { 00978 rList.clear(); 00979 00980 Int iCounter = 0; 00981 while (iCounter < m_iCounter) 00982 { 00983 rList.add(m_pDataArray[iCounter]); 00984 iCounter++; 00985 } 00986 } 00987 00988 00989 /******************************************************************************/ 00992 /******************************************************************************/ 00993 template <class T> void MQUALIFIER TArrayList<T>::clear() 00994 { 00995 if (m_pDataArray != NULL) 00996 { 00997 delete [] m_pDataArray; 00998 } 00999 m_pDataArray = new T[m_iOrigSize]; 01000 m_iSize = m_iOrigSize; 01001 01002 //Zuruecksetzen der Liste 01003 m_iCounter = 0; 01004 01005 //Reseten aller Iteratoren 01006 TArrayListIterator* pIt = m_pIterator; 01007 while (pIt != NULL) 01008 { 01009 pIt->reset(); 01010 pIt = pIt->getNextIterator(); 01011 } 01012 } 01013 01014 01015 /******************************************************************************/ 01018 /******************************************************************************/ 01019 template <class T> Retval MQUALIFIER TArrayList<T>::deleteItem(Int iIndex) 01020 { 01021 Retval retVal = RET_REQUEST_FAILED; 01022 01023 if (iIndex >= 0 && iIndex < m_iCounter) 01024 { 01025 for(int i = iIndex; i < m_iCounter-1; i++) 01026 { 01027 m_pDataArray[i] = m_pDataArray[i+1]; 01028 } 01029 m_iCounter--; 01030 01031 //Anpassen aller Iteratoren die den aktuellen Index bereits ueberstiegen 01032 //haben 01033 TArrayListIterator* it = m_pIterator; 01034 while (it != NULL) 01035 { 01036 //Alle Iteratoren welche das aktuelle Element groesser als Index haben 01037 if (it->getActElement() > iIndex) 01038 { 01039 it->setActElement(it->getActElement()-1); 01040 } 01041 it = it->getNextIterator(); 01042 } 01043 retVal = RET_NOERROR; 01044 } 01045 return retVal; 01046 } 01047 01048 01049 /******************************************************************************/ 01052 /******************************************************************************/ 01053 template <class T> Int MQUALIFIER TArrayList<T>::indexOf(const T& rItem) const 01054 { 01055 Int iCounter = 0; 01056 while (iCounter < m_iCounter) 01057 { 01058 if (m_pDataArray[iCounter] == rItem) 01059 { 01060 return iCounter; 01061 } 01062 iCounter++; 01063 } 01064 return INVALID_INDEX; 01065 } 01066 01067 /******************************************************************************/ 01070 /******************************************************************************/ 01071 template <class T> Int MQUALIFIER TArrayList<T>::insert(Int iIndex, const T& rItem) 01072 { 01073 Int iRetval = INVALID_INDEX; 01074 01075 if (iIndex >= 0) 01076 { 01077 01078 //Vergroessern des Arrays 01079 if (m_iCounter >= m_iSize) 01080 { 01081 resize((Int)(m_iSize*1.5)); 01082 } 01083 01084 //Anfuegen eines Items 01085 if (iIndex == m_iCounter) 01086 { 01087 m_pDataArray[m_iCounter] = rItem; 01088 m_iCounter++; 01089 iRetval = m_iCounter-1; 01090 } 01091 01092 //Einfuegen 01093 else if (iIndex < m_iCounter) 01094 { 01095 for(int i = m_iCounter-1; i >= iIndex; i--) 01096 { 01097 m_pDataArray[i+1] = m_pDataArray[i]; 01098 } 01099 m_pDataArray[iIndex] = rItem; 01100 m_iCounter++; 01101 iRetval = iIndex; 01102 } 01103 01104 //Anpassen aller Iteratoren die den aktuellen Index bereits ueberstiegen 01105 //haben 01106 TArrayListIterator* it = m_pIterator; 01107 while (it != NULL) 01108 { 01109 //Alle Iteratoren welche das aktuelle Element groesser als Index haben 01110 if (it->getActElement() >= iIndex) 01111 { 01112 it->setActElement(it->getActElement()+1); 01113 } 01114 it = it->getNextIterator(); 01115 } 01116 } 01117 return iRetval; 01118 } 01119 01120 01121 /******************************************************************************/ 01124 /******************************************************************************/ 01125 template <class T> inline Retval MQUALIFIER TArrayList<T>::remove(const T& rItem) 01126 { 01127 return deleteItem(indexOf(rItem)); 01128 } 01129 01130 /***************************************************************************/ 01133 /***************************************************************************/ 01134 template <class T> Retval MQUALIFIER TArrayList<T>::removeAll(const IList<T>& rlstItems) 01135 { 01136 Retval retValue = RET_REQUEST_FAILED; 01137 bool bOK = false; 01138 TConstIterator<T> It = rlstItems.getConstIterator(); 01139 while(It.hasNextItem()) 01140 { 01141 bOK |= (this->remove(It.getNextItemConst()) == RET_NOERROR); 01142 } 01143 01144 if (bOK) 01145 { 01146 retValue = RET_NOERROR; 01147 } 01148 return retValue; 01149 } 01150 01151 /******************************************************************************/ 01154 /******************************************************************************/ 01155 template <class T> inline Int MQUALIFIER TArrayList<T>::getCount() const 01156 { 01157 return m_iCounter; 01158 } 01159 01160 /******************************************************************************/ 01163 /******************************************************************************/ 01164 template <class T> inline T& MQUALIFIER TArrayList<T>::getItem(Int iIndex) 01165 { 01166 if (iIndex >= 0 && iIndex < m_iCounter) 01167 { 01168 return m_pDataArray[iIndex]; 01169 } 01170 else 01171 { 01172 return m_tEmpty; 01173 } 01174 } 01175 01176 /***************************************************************************/ 01179 /***************************************************************************/ 01180 template <class T> inline const T& MQUALIFIER TArrayList<T>::getItemConst(Int iIndex) const 01181 { 01182 if (iIndex >= 0 && iIndex < m_iCounter) 01183 { 01184 return m_pDataArray[iIndex]; 01185 } 01186 else 01187 { 01188 return m_tEmpty; 01189 } 01190 } 01191 01192 01193 /******************************************************************************/ 01196 /******************************************************************************/ 01197 template <class T> inline bool MQUALIFIER TArrayList<T>::equalsItem(Int iIndex, const T& rItem) const 01198 { 01199 return (iIndex >= 0 && iIndex < m_iCounter && getItemConst(iIndex) == rItem); 01200 } 01201 01202 /******************************************************************************/ 01205 /******************************************************************************/ 01206 template <class T> bool MQUALIFIER TArrayList<T>::equals(const IList<T>& rList) const 01207 { 01208 bool bRetval = (rList.getCount() == m_iCounter); 01209 01210 if (bRetval) 01211 { 01212 for (int i = 0; i < m_iCounter && bRetval; ++i) 01213 { 01214 bRetval &= rList.equalsItem(i, m_pDataArray[i]); 01215 } 01216 } 01217 01218 return bRetval; 01219 } 01220 01221 01222 /******************************************************************************/ 01225 /******************************************************************************/ 01226 template <class T> inline IListIterator<T>* MQUALIFIER TArrayList<T>::getIterator() const 01227 { 01228 TArrayListIterator* pIterator = new TArrayListIterator(*this); 01229 pIterator->setNextIterator(m_pIterator); 01230 m_pIterator = pIterator; 01231 return m_pIterator; 01232 } 01233 01234 /******************************************************************************/ 01237 /******************************************************************************/ 01238 template <class T> inline const IListIterator<T>* MQUALIFIER TArrayList<T>::getConstIterator() const 01239 { 01240 TArrayListIterator* pIterator = new TArrayListIterator(*this); 01241 pIterator->setNextIterator(m_pIterator); 01242 m_pIterator = pIterator; 01243 return m_pIterator; 01244 } 01245 01246 01247 /******************************************************************************/ 01250 /******************************************************************************/ 01251 template <class T> void MQUALIFIER TArrayList<T>::releaseIterator(const IListIterator<T>* pIterator) const 01252 { 01253 TArrayListIterator* pIt = m_pIterator; 01254 TArrayListIterator* pItPrev = NULL; 01255 while (pIt != NULL) 01256 { 01257 if (pIt == pIterator) 01258 { 01259 //Erster Iterator loeschen 01260 if (pItPrev == NULL) 01261 { 01262 m_pIterator = pIt->getNextIterator(); 01263 delete pIt; 01264 } 01265 else 01266 { 01267 pItPrev->setNextIterator(pIt->getNextIterator()); 01268 delete pIt; 01269 } 01270 break; 01271 } 01272 pItPrev = pIt; 01273 pIt = pIt->getNextIterator(); 01274 } 01275 } 01276 01277 /******************************************************************************/ 01280 /******************************************************************************/ 01281 template <class T> inline bool MQUALIFIER TArrayList<T>::isEmpty() const 01282 { 01283 return (m_iCounter == 0); 01284 } 01285 01286 /******************************************************************************/ 01289 /******************************************************************************/ 01290 template <class T> inline T& MQUALIFIER TArrayList<T>::getFirstItem() 01291 { 01292 return this->getItem(0); 01293 } 01294 01295 /******************************************************************************/ 01298 /******************************************************************************/ 01299 template <class T> inline const T& MQUALIFIER TArrayList<T>::getFirstItemConst() const 01300 { 01301 return this->getItemConst(0); 01302 } 01303 01304 /******************************************************************************/ 01307 /******************************************************************************/ 01308 template <class T> inline T& MQUALIFIER TArrayList<T>::getLastItem() 01309 { 01310 return this->getItem(m_iCounter-1); 01311 } 01312 01313 /******************************************************************************/ 01316 /******************************************************************************/ 01317 template <class T> inline const T& MQUALIFIER TArrayList<T>::getLastItemConst() const 01318 { 01319 return this->getItemConst(m_iCounter-1); 01320 } 01321 01322 /******************************************************************************/ 01325 /******************************************************************************/ 01326 template <class T> inline bool MQUALIFIER TArrayList<T>::hasItem(const T& rItem) const 01327 { 01328 return (this->indexOf(rItem) != INVALID_INDEX); 01329 } 01330 01331 /******************************************************************************/ 01334 /******************************************************************************/ 01335 template <class T> bool MQUALIFIER TArrayList<T>::hasAllItems(const IList<T>& rlstItems) const 01336 { 01337 bool bRetval = true; 01338 01339 TConstIterator<T> It = rlstItems.getConstIterator(); 01340 while(bRetval && It.hasNextItem()) 01341 { 01342 bRetval &= this->hasItem(It.getNextItemConst()); 01343 } 01344 return bRetval; 01345 } 01346 01347 /******************************************************************************/ 01352 /******************************************************************************/ 01353 template <class T> inline T& TArrayList<T>::operator[](Int iIndex) 01354 { 01355 return getItem(iIndex); 01356 } 01357 01358 /******************************************************************************/ 01363 /******************************************************************************/ 01364 template <class T> inline TArrayList<T>& TArrayList<T>::operator= (const TArrayList<T>& rList) 01365 { 01366 rList.copyToArray(*this, 0, rList.getCount()-1); 01367 return *this; 01368 } 01369 01370 /******************************************************************************/ 01375 /******************************************************************************/ 01376 template <class T> inline TArrayList<T>& TArrayList<T>::operator= (const TArrayList<T>* pList) 01377 { 01378 if (pList != NULL) 01379 { 01380 pList->copyToArray(*this, 0, pList->getCount()-1); 01381 } 01382 return *this; 01383 } 01384 01385 /******************************************************************************/ 01390 /******************************************************************************/ 01391 template <class T> inline TArrayList<T>& TArrayList<T>::operator= (const IList<T>& rList) 01392 { 01393 rList.copyToList(*this); 01394 return *this; 01395 } 01396 01397 /******************************************************************************/ 01402 /******************************************************************************/ 01403 template <class T> inline TArrayList<T>& TArrayList<T>::operator= (const IList<T>* pList) 01404 { 01405 if (pList != NULL) 01406 { 01407 pList->copyToList(*this); 01408 } 01409 return *this; 01410 } 01411 01412 01413 /******************************************************************************/ 01419 /******************************************************************************/ 01420 template <class T> inline bool TArrayList<T>::operator==(const TArrayList<T>& rList) const 01421 { 01422 return this->equals(rList); 01423 } 01424 01425 /******************************************************************************/ 01429 /******************************************************************************/ 01430 template <class T> inline bool TArrayList<T>::operator!=(const TArrayList<T>& rList) const 01431 { 01432 return !this->equals(rList); 01433 } 01434 01435 /***************************************************************************/ 01439 /***************************************************************************/ 01440 template <class T> inline void TArrayList<T>::addEmptyItems(Int iCount) 01441 { 01442 //Enlagres the memory 01443 if (m_iCounter + iCount >= m_iSize) 01444 { 01445 resize(m_iSize + iCount); 01446 } 01447 01448 //creates empty items 01449 switch(m_eCopyMode) 01450 { 01451 case etShallowCopy: 01452 ::memset(m_pDataArray+m_iCounter, 0x00, sizeof(T)*iCount); 01453 m_iCounter += iCount; 01454 break; 01455 01456 case etDeepCopy : //fall though 01457 default: 01458 for(Int i = 0; i < iCount; i++) 01459 { 01460 this->addEmptyItem(); 01461 } 01462 break; 01463 } 01464 } 01465 01466 /***************************************************************************/ 01469 /***************************************************************************/ 01470 template <class T> inline T& TArrayList<T>::getEmptyItem() 01471 { 01472 return m_tEmpty; 01473 } 01474 01475 /***************************************************************************/ 01478 /***************************************************************************/ 01479 template <class T> inline void TArrayList<T>::clearSecure() 01480 { 01481 //clears the memory to zero 01482 ::memset(m_pDataArray, 0x00, sizeof(T)*m_iSize); 01483 clear(); 01484 } 01485 01486 01487 END_NAMESPACE_Zeus 01488 01489 #endif 01490