FBX SDK Reference Guide: karrayul.h Source File
00001 00004 #ifndef _FBXSDK_KARRAYUL_H_ 00005 #define _FBXSDK_KARRAYUL_H_ 00006 00007 /************************************************************************************** 00008 00009 Copyright © 2001 - 2008 Autodesk, Inc. and/or its licensors. 00010 All Rights Reserved. 00011 00012 The coded instructions, statements, computer programs, and/or related material 00013 (collectively the "Data") in these files contain unpublished information 00014 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 00015 Canada and United States of America federal copyright law and by international 00016 treaties. 00017 00018 The Data may not be disclosed or distributed to third parties, in whole or in 00019 part, without the prior written consent of Autodesk, Inc. ("Autodesk"). 00020 00021 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY. 00022 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO 00023 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING 00024 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 00025 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 00026 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION 00027 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 00028 00029 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS 00030 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES 00031 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER 00032 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE 00033 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND), 00034 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED 00035 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE, 00036 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE, 00037 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS 00038 OR DAMAGE. 00039 00040 **************************************************************************************/ 00041 #include <kbaselib_h.h> 00042 00043 #ifndef K_PLUGIN 00044 #include <klib/kdebug.h> 00045 #endif 00046 00047 #include <string.h> 00048 #include <stdlib.h> 00049 00050 #define KARRAYUL_BLOCKSIZE 4 00051 00052 #include <object/i/iobject.h> 00053 00054 #include <kbaselib_forward.h> 00055 #include <kbaselib_nsbegin.h> // namespace 00056 00057 /*********************************************************************** 00058 CLASS KStaticArray 00059 ************************************************************************/ 00060 template< class Type > class KBaseStaticArray 00061 { 00062 protected: 00063 int mCount; 00064 Type *mArrayBuf; 00065 00066 public: 00067 inline int GetCount() { return mCount; } 00068 00070 inline Type &operator[](int pIndex) 00071 { 00072 #ifndef K_PLUGIN 00073 K_ASSERT_MSG( pIndex >= 0 , "Buffer underflow, appelle ton plombier."); 00074 K_ASSERT_MSG( pIndex < mCount,"Buffer overflow, appelle ton plombier."); 00075 #endif 00076 return mArrayBuf[pIndex]; 00077 } 00078 }; 00079 00080 // Static Array 00081 template< class Type, int Count > class KStaticArray : public KBaseStaticArray<Type> 00082 { 00083 public: 00084 Type mArray[Count]; 00085 inline KStaticArray(){ this->mArrayBuf = mArray; this->mCount = Count;} 00086 }; 00087 00088 template< class Type, int Count1, int Count2 > class KStaticArray2d 00089 { 00090 public: 00091 #if defined(KARCH_DEV_MSC) && (_MSC_VER <= 1200)// VC6 00092 KStaticArray<Type,Count2> *mArray; 00093 00094 KStaticArray2d() { mArray = new KStaticArray<Type,Count2>(Count1); } 00095 ~KStaticArray2d() { delete[] mArray; } 00096 #else 00097 KStaticArray<Type,Count2> mArray[Count1]; 00098 #endif 00099 00100 // Access pointer at given index. 00101 inline KStaticArray< Type, Count2 > &operator[](int pIndex) 00102 { 00103 #ifndef K_PLUGIN 00104 K_ASSERT_MSG( pIndex >= 0 , "Buffer underflow, appelle ton plombier."); 00105 K_ASSERT_MSG( pIndex < Count1,"Buffer overflow, appelle ton plombier."); 00106 #endif 00107 return mArray[pIndex]; 00108 } 00109 }; 00110 00111 /*********************************************************************** 00112 CLASS KArrayTemplate 00113 ************************************************************************/ 00114 class KBaseArraySize { 00115 public: 00116 KBaseArraySize( int pItemSize) 00117 : mItemSize(pItemSize) 00118 { 00119 } 00120 inline int GetTypeSize() const { return mItemSize; } 00121 private: 00122 int mItemSize; 00123 }; 00124 00125 template <class T> class KBaseArraySizeType 00126 { 00127 public: 00128 inline int GetTypeSize() const { return sizeof(T); } 00129 }; 00130 00131 // Helpers 00132 KBASELIB_DLL void KBaseArrayFree(char*); 00133 KBASELIB_DLL char* KBaseArrayRealloc(char*, size_t); 00134 00136 // 00137 // WARNING! 00138 // 00139 // Anything beyond these lines may not be documented accurately and is 00140 // subject to change without notice. 00141 // 00143 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00144 KBASELIB_DLL void* KBaseArrayGetAlloc(); 00145 #endif 00146 00147 template <class TypeSize> class KBaseArray 00148 { 00149 protected: 00150 struct KHeader { 00151 int mArrayCount; 00152 int mBlockCount; 00153 }; 00154 00155 00156 protected: 00161 inline KBaseArray(TypeSize pTypeSize) 00162 : mTypeSize(pTypeSize) 00163 { 00164 mBaseArray = NULL; 00165 #ifndef K_PLUGIN 00166 K_ASSERT( pItemPerBlock > 0 ); 00167 #endif 00168 } 00169 00170 00172 inline ~KBaseArray(){ 00173 Clear (); 00174 } 00175 00183 inline int InsertAt(int pIndex, void *pItem) 00184 { 00185 int lArrayCount = GetArrayCount(); 00186 int lBlockCount = GetBlockCount(); 00187 00188 #ifndef K_PLUGIN 00189 K_ASSERT( pIndex >= 0 ); 00190 #endif 00191 00192 if (pIndex>lArrayCount) { 00193 pIndex = GetArrayCount(); 00194 } 00195 00196 if (lArrayCount>= lBlockCount*KARRAYUL_BLOCKSIZE) 00197 { 00198 // must Alloc.Realloc some new space 00199 00200 // double the number of blocks. 00201 lBlockCount = ( 0 == lBlockCount ) ? 1 : lBlockCount * 2; 00202 mBaseArray = KBaseArrayRealloc(mBaseArray, (size_t) (lBlockCount*KARRAYUL_BLOCKSIZE*GetTypeSize()) + GetHeaderOffset() ); 00203 } 00204 00205 if (pIndex<lArrayCount) 00206 { 00207 // This is an insert 00208 memmove (&(mBaseArray[(pIndex+1)*GetTypeSize()+ GetHeaderOffset() ]), &(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset()] ), GetTypeSize()*(lArrayCount-pIndex)); 00209 } 00210 00211 memmove (&(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset() ]), pItem, GetTypeSize()); 00212 00213 SetArrayCount(lArrayCount+1); 00214 SetBlockCount(lBlockCount); 00215 00216 return pIndex; 00217 } 00218 00219 00226 inline void* GetAt(int pIndex) { return &(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset() ]); } 00227 00234 inline void RemoveAt(int pIndex) 00235 { 00236 00237 #if defined(_DEBUG) && !defined(KARCH_ENV_MACOSX) 00238 if (!ValidateIndex( pIndex )) 00239 { 00240 return; 00241 } 00242 #endif 00243 int lArrayCount = GetArrayCount(); 00244 if (pIndex+1<lArrayCount) 00245 { 00246 memmove (&(mBaseArray[(pIndex)*GetTypeSize()+ GetHeaderOffset() ]), &(mBaseArray[(pIndex+1)*GetTypeSize()+ GetHeaderOffset() ]), GetTypeSize()*(lArrayCount-pIndex-1)); 00247 } 00248 00249 SetArrayCount( lArrayCount-1 ); 00250 00251 #ifdef _DEBUG 00252 memset( &(mBaseArray[(GetArrayCount())*GetTypeSize()+ GetHeaderOffset() ]),0,GetTypeSize()); 00253 #endif 00254 } 00255 00256 00262 inline bool ValidateIndex( int pIndex ) const 00263 { 00264 int lArrayCount = GetArrayCount(); 00265 if (pIndex>=0 && pIndex<lArrayCount) 00266 { 00267 return true; 00268 } else 00269 { 00270 #ifndef K_PLUGIN 00271 K_ASSERT_MSG_NOW(_T("ArrayTemplate : Index out of range")); 00272 #endif 00273 return false; 00274 } 00275 } 00276 00277 00278 public: 00282 inline int GetCount() const { return GetArrayCount(); } 00283 00285 inline void Clear() 00286 { 00287 if (mBaseArray!=NULL) 00288 { 00289 KBaseArrayFree(mBaseArray); 00290 mBaseArray = NULL; 00291 } 00292 } 00293 00294 00296 inline void Empty() 00297 { 00298 #ifndef K_PLUGIN 00299 #ifdef _DEBUG 00300 memset( mBaseArray+ GetHeaderOffset() ,0,GetArrayCount()*GetTypeSize()); 00301 #endif 00302 #endif 00303 SetArrayCount(0); 00304 } 00305 00306 00312 inline int Reserve(int pCapacity) 00313 { 00314 00315 #ifndef K_PLUGIN 00316 K_ASSERT( pCapacity > 0 ); 00317 #endif 00318 00319 if( pCapacity ) 00320 { 00321 const kUInt lTempNewBlockCount = ( (kUInt) (pCapacity + KARRAYUL_BLOCKSIZE - 1 ) / KARRAYUL_BLOCKSIZE ); 00322 const kUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1); 00323 00324 int lArrayCount = GetArrayCount(); 00325 int lBlockCount = GetBlockCount(); 00326 00327 const kUInt lOldArraySize = lArrayCount*GetTypeSize(); 00328 const kUInt lNewArraySize = lNewBlockCount*KARRAYUL_BLOCKSIZE*GetTypeSize(); 00329 00330 if (lNewBlockCount != (kUInt) lBlockCount) 00331 mBaseArray = KBaseArrayRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset() ); 00332 00333 if( lNewBlockCount > (kUInt) lBlockCount ) { 00334 memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) ); 00335 SetArrayCount(lArrayCount); 00336 } else if (pCapacity < lArrayCount) 00337 { 00338 memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pCapacity*GetTypeSize(), 0, (size_t) (lNewArraySize-pCapacity*GetTypeSize()) ); 00339 SetArrayCount(pCapacity); 00340 } 00341 00342 SetBlockCount(lNewBlockCount); 00343 } 00344 00345 return GetBlockCount()*KARRAYUL_BLOCKSIZE; 00346 } 00347 00348 00350 // Differ from SetCount because array capacity can be lowewed. 00351 00357 inline void SetCount (int pCount) 00358 { 00359 #ifndef K_PLUGIN 00360 #ifdef _DEBUG 00361 if (pCount<0) 00362 { 00363 K_ASSERT_MSG_NOW (_T("ArrayUL : Item count can't be negative")); 00364 return ; 00365 } 00366 #endif 00367 #endif 00368 int lArrayCount = GetArrayCount(); 00369 if (pCount > lArrayCount) 00370 { 00371 AddMultiple( pCount-lArrayCount); 00372 } else 00373 { 00374 SetArrayCount(pCount); 00375 } 00376 } 00377 00378 inline void Resize(int pItemCount) 00379 { 00380 #ifndef K_PLUGIN 00381 K_ASSERT( pItemCount >= 0 ); 00382 #endif 00383 00384 const kUInt lTempNewBlockCount = ( (kUInt) (pItemCount + KARRAYUL_BLOCKSIZE - 1 ) / KARRAYUL_BLOCKSIZE ); 00385 const kUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1); 00386 00387 int lArrayCount = GetArrayCount(); 00388 int lBlockCount = GetBlockCount(); 00389 00390 const kUInt lOldArraySize = lArrayCount*GetTypeSize(); 00391 const kUInt lNewArraySize = lNewBlockCount*KARRAYUL_BLOCKSIZE*GetTypeSize(); 00392 00393 if (lNewBlockCount != (kUInt) lBlockCount) 00394 mBaseArray = KBaseArrayRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset() ); 00395 00396 if( lNewBlockCount > (kUInt) lBlockCount ) 00397 memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) ); 00398 else if (pItemCount < lArrayCount) 00399 memset( ((char*)mBaseArray+ GetHeaderOffset() ) + pItemCount*GetTypeSize(), 0, (size_t) (lNewArraySize-pItemCount*GetTypeSize()) ); 00400 00401 SetBlockCount(lNewBlockCount); 00402 SetArrayCount(pItemCount); 00403 } 00404 00405 inline void AddMultiple(int pItemCount) 00406 { 00407 #ifndef K_PLUGIN 00408 K_ASSERT( pItemCount > 0 ); 00409 #endif 00410 00411 if( pItemCount ) 00412 { 00413 int lArrayCount = GetArrayCount(); 00414 int lBlockCount = GetBlockCount(); 00415 const kUInt lTempNewBlockCount = ( (kUInt) (lArrayCount+pItemCount + KARRAYUL_BLOCKSIZE - 1 ) / KARRAYUL_BLOCKSIZE ); 00416 const kUInt lNewBlockCount = (lTempNewBlockCount > 1 ? lTempNewBlockCount : 1); 00417 00418 const kUInt lOldArraySize = lArrayCount*GetTypeSize(); 00419 const kUInt lNewArraySize = lNewBlockCount*KARRAYUL_BLOCKSIZE*GetTypeSize(); 00420 00421 #ifndef K_PLUGIN 00422 K_ASSERT( lOldArraySize < lNewArraySize ); 00423 #endif 00424 00425 if( lNewBlockCount > (kUInt) lBlockCount ) 00426 { 00427 mBaseArray = KBaseArrayRealloc(mBaseArray, (size_t) lNewArraySize+ GetHeaderOffset() ); 00428 lBlockCount = lNewBlockCount; 00429 } 00430 00431 memset( ((char*)mBaseArray+ GetHeaderOffset() ) + lOldArraySize, 0, (size_t) (lNewArraySize-lOldArraySize) ); 00432 SetArrayCount ( lArrayCount + pItemCount ); 00433 SetBlockCount (lBlockCount); 00434 } 00435 } 00436 00437 00438 inline int GetTypeSize() const { return mTypeSize.GetTypeSize(); } 00439 00441 // 00442 // WARNING! 00443 // 00444 // Anything beyond these lines may not be documented accurately and is 00445 // subject to change without notice. 00446 // 00448 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00449 00450 protected: 00451 inline KHeader* const GetHeader() const 00452 { 00453 return (KHeader* const )mBaseArray; 00454 } 00455 inline KHeader* GetHeader() 00456 { 00457 return (KHeader*)mBaseArray; 00458 } 00459 inline int GetHeaderOffset() const 00460 { 00461 return sizeof(KHeader); 00462 } 00463 inline int GetArrayCount() const 00464 { 00465 return GetHeader() ? GetHeader()->mArrayCount : 0; 00466 } 00467 inline void SetArrayCount(int pArrayCount) 00468 { 00469 if (GetHeader()) GetHeader()->mArrayCount=pArrayCount; 00470 } 00471 inline int GetBlockCount() const 00472 { 00473 return GetHeader() ? GetHeader()->mBlockCount : 0; 00474 } 00475 inline void SetBlockCount(int pArrayCount) 00476 { 00477 if (GetHeader()) GetHeader()->mBlockCount=pArrayCount; 00478 } 00479 00480 protected: 00481 char* mBaseArray; 00482 TypeSize mTypeSize; 00483 00484 #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS 00485 00486 }; 00487 00488 00490 #define VC6 00491 00492 template < class Type > class KArrayTemplate : public KBaseArray< KBaseArraySizeType<Type> > 00493 { 00494 typedef KBaseArray< KBaseArraySizeType<Type> > ParentClass; 00495 00496 00497 public: 00501 inline KArrayTemplate() 00502 : ParentClass (KBaseArraySizeType<Type>()) 00503 { 00504 } 00505 00507 inline KArrayTemplate(const KArrayTemplate& pArrayTemplate) 00508 : ParentClass (KBaseArraySizeType<Type>()) 00509 { 00510 *this = pArrayTemplate; 00511 } 00512 00513 inline ~KArrayTemplate() {} 00514 00521 inline int InsertAt(int pIndex, Type pItem) 00522 { 00523 return ParentClass::InsertAt( pIndex,&pItem ); 00524 } 00525 00530 inline Type RemoveAt(int pIndex) 00531 { 00532 Type tmpItem = GetAt(pIndex); 00533 ParentClass::RemoveAt( pIndex ); 00534 return tmpItem; 00535 } 00536 00540 inline Type RemoveLast() 00541 { 00542 return RemoveAt(ParentClass::GetArrayCount()-1); 00543 } 00544 00549 inline bool RemoveIt(Type pItem) 00550 { 00551 int Index = Find (pItem); 00552 if (Index>=0) 00553 { 00554 RemoveAt (Index); 00555 return true; 00556 } 00557 return false; 00558 } 00559 00561 inline Type &operator[](int pIndex) const 00562 { 00563 #if defined(_DEBUG) && !defined(KARCH_ENV_MACOSX) 00564 if (!ParentClass::ValidateIndex( pIndex )) 00565 { 00566 return (Type &)(ParentClass::mBaseArray[(0)*sizeof(Type)+ ParentClass::GetHeaderOffset() ]); 00567 } 00568 #endif 00569 return (Type &)(ParentClass::mBaseArray[(pIndex)*sizeof(Type)+ ParentClass::GetHeaderOffset() ]); 00570 } 00571 00573 inline void SetAt(int pIndex, Type pItem) 00574 { 00575 #if defined(_DEBUG) && !defined(KARCH_ENV_MACOSX) 00576 if (!ParentClass::ValidateIndex( pIndex )) 00577 { 00578 return; 00579 } 00580 #endif 00581 GetArray()[pIndex] = pItem; 00582 } 00583 00585 inline void SetLast(Type pItem) 00586 { 00587 SetAt (ParentClass::GetArrayCount()-1, pItem); 00588 } 00589 00591 inline Type GetAt(int pIndex) const 00592 { 00593 #if defined(_DEBUG) && !defined(KARCH_ENV_MACOSX) 00594 if (!ParentClass::ValidateIndex( pIndex )) 00595 { 00596 return (Type &)(ParentClass::mBaseArray[(0)*sizeof(Type)+ ParentClass::GetHeaderOffset() ]); 00597 } 00598 #endif 00599 return (Type &)(ParentClass::mBaseArray[(pIndex)*sizeof(Type)+ ParentClass::GetHeaderOffset() ]); 00600 } 00601 00605 inline Type GetFirst() const 00606 { 00607 #ifndef K_PLUGIN 00608 K_ASSERT( ParentClass::GetArrayCount() >= 1 ); 00609 #endif 00610 return GetAt(0); 00611 } 00612 00616 inline Type GetLast() const 00617 { 00618 #ifndef K_PLUGIN 00619 K_ASSERT( ParentClass::GetArrayCount() >= 1 ); 00620 #endif 00621 return GetAt(ParentClass::GetArrayCount()-1); 00622 } 00623 00628 inline int Find(Type pItem) const 00629 { 00630 return FindAfter( -1, pItem ); 00631 } 00632 00638 inline int FindAfter(int pAfterIndex, Type pItem) const 00639 { 00640 #ifndef K_PLUGIN 00641 #ifdef _DEBUG 00642 if ( pAfterIndex > ParentClass::GetArrayCount() || pAfterIndex < -1 ) 00643 { 00644 K_ASSERT_MSG_NOW (_T("ArrayUL : Search Begin Index out of range")); 00645 return -1; 00646 } 00647 #endif 00648 #endif 00649 int Count; 00650 for ( Count=pAfterIndex+1; Count<ParentClass::GetArrayCount(); Count++) 00651 { 00652 if (GetAt(Count)==pItem) 00653 { 00654 return Count; 00655 } 00656 } 00657 return -1; 00658 } 00659 00665 inline int FindBefore(int pBeforeIndex, Type pItem) const 00666 { 00667 #ifndef K_PLUGIN 00668 #ifdef _DEBUG 00669 if ( pBeforeIndex > ParentClass::GetArrayCount() || pBeforeIndex <= 0 ) 00670 { 00671 K_ASSERT_MSG_NOW (_T("ArrayUL : Search Begin Index out of range")); 00672 return -1; 00673 } 00674 #endif 00675 #endif 00676 int Count; 00677 for ( Count=pBeforeIndex-1; Count>=0; Count--) 00678 { 00679 if (GetAt(Count)==pItem) 00680 { 00681 return Count; 00682 } 00683 } 00684 return -1; 00685 } 00686 00690 inline int Add(Type pItem) 00691 { 00692 return InsertAt(ParentClass::GetArrayCount(), pItem); 00693 } 00694 00698 inline int AddUnique(Type pItem) 00699 { 00700 int lReturnIndex = Find(pItem); 00701 if (lReturnIndex == -1) 00702 { 00703 lReturnIndex = Add(pItem); 00704 } 00705 return lReturnIndex; 00706 } 00707 00711 inline void AddMultiple( kUInt pItemCount ) 00712 { 00713 ParentClass::AddMultiple( pItemCount ); 00714 } 00715 00716 inline void AddArray(KArrayTemplate<Type> &pArray) 00717 { 00718 int lSourceIndex, lCount = pArray.GetCount(); 00719 if( lCount == 0 ) return; 00720 int lDestinationIndex = ParentClass::GetCount(); 00721 AddMultiple(lCount); 00722 for( lSourceIndex = 0; lSourceIndex < lCount; lSourceIndex++) 00723 { 00724 SetAt(lDestinationIndex++, pArray[lSourceIndex]); 00725 } 00726 } 00727 00728 inline void AddArrayNoDuplicate(KArrayTemplate<Type> &pArray) 00729 { 00730 int i, lCount = pArray.GetCount(); 00731 for( i = 0; i < lCount; i++) 00732 { 00733 Type lItem = pArray[i]; 00734 if (Find(lItem) == -1) 00735 { 00736 Add(lItem); 00737 } 00738 } 00739 } 00740 inline void RemoveArray(KArrayTemplate<Type> &pArray) 00741 { 00742 int lRemoveIndex, lRemoveCount = pArray.GetCount(); 00743 for( lRemoveIndex = 0; lRemoveIndex < lRemoveCount; lRemoveIndex++) 00744 { 00745 RemoveIt(pArray[lRemoveIndex]); 00746 } 00747 } 00748 00750 inline Type* GetArray() const 00751 { 00752 if (ParentClass::mBaseArray == NULL) 00753 return NULL; 00754 00755 return (Type*)(ParentClass::mBaseArray+ ParentClass::GetHeaderOffset()) ; 00756 } 00757 00759 inline KArrayTemplate<Type>& operator=(const KArrayTemplate<Type>& pArrayTemplate) 00760 { 00761 ParentClass::Clear(); 00762 00763 int i, lCount = pArrayTemplate.GetCount(); 00764 00765 for (i = 0; i < lCount; i++) 00766 { 00767 Add(pArrayTemplate[i]); 00768 } 00769 00770 return (*this); 00771 } 00772 00773 #ifdef K_PLUGIN 00775 inline operator Type* () 00776 { 00777 return GetArray(); 00778 } 00779 #endif 00780 }; 00781 00783 // 00784 // WARNING! 00785 // 00786 // Anything beyond these lines may not be documented accurately and is 00787 // subject to change without notice. 00788 // 00790 00791 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00792 00793 template <class Type> inline void DeleteAndClear(KArrayTemplate<Type>& Array) 00794 { 00795 kUInt lItemCount = Array.GetCount(); 00796 while( lItemCount ) 00797 { 00798 lItemCount--; 00799 Type& Item = (Array.operator[](lItemCount)); 00800 delete Item; 00801 Item = NULL; 00802 } 00803 Array.Clear(); 00804 } 00805 /* template <class Type> inline void DeleteAndClear(KArrayTemplate<Type>& Array) 00806 { 00807 kUInt lItemCount = Array.GetCount(); 00808 while( lItemCount ) 00809 { 00810 lItemCount--; 00811 Type& Item = (Array.operator[](lItemCount)); 00812 delete Item; 00813 Item = NULL; 00814 } 00815 Array.Clear(); 00816 } 00817 */ 00818 typedef class KBASELIB_DLL KArrayTemplate<int *> KArrayHkInt; 00819 typedef class KBASELIB_DLL KArrayTemplate<kUInt *> KArrayHkUInt; 00820 typedef class KBASELIB_DLL KArrayTemplate<double *> KArrayHkDouble; 00821 typedef class KBASELIB_DLL KArrayTemplate<float *> KArrayHkFloat; 00822 typedef class KBASELIB_DLL KArrayTemplate<void *> KArrayVoid; 00823 typedef class KBASELIB_DLL KArrayTemplate<char *> KArrayChar; 00824 typedef class KBASELIB_DLL KArrayTemplate<int> KArraykInt; 00825 typedef class KBASELIB_DLL KArrayTemplate<kUInt> KArraykUInt; 00826 typedef class KBASELIB_DLL KArrayTemplate<float> KArraykFloat; 00827 typedef class KBASELIB_DLL KArrayTemplate<double> KArraykDouble; 00828 00829 typedef class KBASELIB_DLL KArrayTemplate<kReference> KArrayUL; 00830 00831 #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS 00832 00833 #include <kbaselib_nsend.h> 00834 00835 #endif // #define _FBXSDK_KARRAYUL_H_ 00836 00837