Update contrib.
1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
2 // All rights reserved.
3 // This component and the accompanying materials are made available
4 // under the terms of the License "Eclipse Public License v1.0"
5 // which accompanies this distribution, and is available
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
14 // e32\common\array.cpp
19 #ifdef __KERNEL_MODE__
20 #include <kernel/kernel.h>
23 const TInt KDefaultPtrArrayGranularity =8;
24 const TInt KPtrArrayMaxGranularity =0x10000000;
25 const TInt KDefaultSimpleArrayGranularity =8;
26 const TInt KSimpleArrayMaxGranularity =0x10000000;
27 const TInt KSimpleArrayMaxEntrySize =640; // allow room for a unicode TFullName
28 const TInt KMaxArrayGrowBy =65535;
29 const TInt KMinArrayFactor =257;
30 const TInt KMaxArrayFactor =32767;
32 EXPORT_C RPointerArrayBase::RPointerArrayBase()
33 : iCount(0), iEntries(NULL), iAllocated(0), iGranularity(KDefaultPtrArrayGranularity), iSpare1(0), iSpare2(0)
36 EXPORT_C RPointerArrayBase::RPointerArrayBase(TInt aGranularity)
37 : iCount(0), iEntries(NULL), iAllocated(0), iGranularity(aGranularity), iSpare1(0), iSpare2(0)
39 __ASSERT_ALWAYS(aGranularity>0 && aGranularity<=KPtrArrayMaxGranularity,
40 Panic(EBadArrayGranularity));
43 EXPORT_C RPointerArrayBase::RPointerArrayBase(TInt aMinGrowBy, TInt aFactor)
44 : iCount(0), iEntries(NULL), iAllocated(0), iSpare1(0), iSpare2(0)
46 __ASSERT_ALWAYS(aMinGrowBy>0 && aMinGrowBy<=KMaxArrayGrowBy, Panic(EBadArrayMinGrowBy));
47 __ASSERT_ALWAYS(aFactor>=KMinArrayFactor && aFactor<=KMaxArrayFactor, Panic(EBadArrayFactor));
48 iGranularity = aMinGrowBy | (aFactor << 16) | 0x80000000;
51 #ifndef __KERNEL_MODE__
52 EXPORT_C RPointerArrayBase::RPointerArrayBase(TAny** aEntries, TInt aCount)
53 : iCount(aCount), iEntries(aEntries), iAllocated(aCount), iGranularity(aCount), iSpare1(0), iSpare2(0)
55 __ASSERT_ALWAYS(aCount>0,Panic(EBadArrayCount));
59 EXPORT_C void RPointerArrayBase::Close()
62 STD_CLASS::Free(iEntries);
67 EXPORT_C TInt RPointerArrayBase::Count() const
72 #ifndef __ARRAY_MACHINE_CODED__
73 EXPORT_C TAny*& RPointerArrayBase::At(TInt anIndex) const
75 __ASSERT_ALWAYS((anIndex>=0 && anIndex<iCount),Panic(EBadArrayIndex));
76 return iEntries[anIndex];
79 GLDEF_C void PanicBadArrayIndex()
81 Panic(EBadArrayIndex);
85 TInt CalculateArraySizeAfterGrow(TInt aOrigSize, TInt aGranularity, TInt aLimit)
87 if (aGranularity >= 0)
89 if (aOrigSize > aLimit - aGranularity)
90 return KErrNoMemory; // array can't be >2GB
91 return aOrigSize + aGranularity;
93 TUint minStep = (TUint)(aGranularity & 65535);
94 TUint factor = TUint(aGranularity & 0x7fff0000) >> 16;
95 Uint64 na64 = aOrigSize;
96 na64 *= (Uint64)factor;
99 Uint64 min_na64 = (Uint64)aOrigSize + (Uint64)minStep;
102 if (na64 > (Uint64)aLimit)
103 return KErrNoMemory; // array can't be >2GB
107 TInt CalculateArraySizeAfterShrink(TInt aOrigSize, TInt aGranularity, TInt aUsed)
109 TInt step = aGranularity;
112 if (aOrigSize - aUsed < step)
120 TInt RPointerArrayBase::Grow()
122 TInt newAlloc = CalculateArraySizeAfterGrow(iAllocated, iGranularity, KMaxTInt >> 2);
125 TAny** pA = (TAny**)STD_CLASS::ReAlloc(iEntries, newAlloc*sizeof(TAny*));
129 iAllocated = newAlloc;
133 #ifndef __ARRAY_MACHINE_CODED__
134 EXPORT_C TInt RPointerArrayBase::Append(const TAny* anEntry)
136 if (iCount==iAllocated)
142 iEntries[iCount++]=(TAny*)anEntry;
147 EXPORT_C TInt RPointerArrayBase::Insert(const TAny* anEntry, TInt aPos)
149 __ASSERT_ALWAYS((aPos>=0 && aPos<=iCount),Panic(EBadArrayPosition));
150 if (iCount==iAllocated)
156 TInt entries=iCount-aPos;
158 wordmove(iEntries+aPos+1,iEntries+aPos,entries*sizeof(TAny*));
160 iEntries[aPos]=(TAny*)anEntry;
164 EXPORT_C void RPointerArrayBase::Remove(TInt anIndex)
166 __ASSERT_ALWAYS((anIndex>=0 && anIndex<iCount),Panic(EBadArrayIndex));
167 TInt entries=iCount-anIndex-1;
169 wordmove(iEntries+anIndex,iEntries+anIndex+1,entries*sizeof(TAny*));
173 EXPORT_C void RPointerArrayBase::Compress()
176 iEntries=(TAny**)STD_CLASS::ReAlloc(iEntries,iCount*sizeof(TAny*)); // can't fail
179 STD_CLASS::Free(iEntries);
185 #ifndef __KERNEL_MODE__
186 EXPORT_C void RPointerArrayBase::GranularCompress()
188 TInt newAlloc = CalculateArraySizeAfterShrink(iAllocated, iGranularity, iCount);
189 if (newAlloc == iAllocated)
192 iEntries=(TAny**)STD_CLASS::ReAlloc(iEntries,newAlloc*sizeof(TAny*)); // can't fail
195 STD_CLASS::Free(iEntries);
201 EXPORT_C TInt RPointerArrayBase::DoReserve(TInt aCount)
203 __ASSERT_ALWAYS(aCount>=0, Panic(EArrayBadReserveCount));
204 if (aCount <= iAllocated)
205 return KErrNone; // if allocated space is already sufficient, nothing to do
207 const TInt KLimit = TInt(0x80000000u / sizeof(TAny*));
208 if (aCount >= KLimit)
211 TAny** pA = (TAny**)STD_CLASS::ReAlloc(iEntries, aCount*sizeof(TAny*));
220 EXPORT_C void RPointerArrayBase::Reset()
223 STD_CLASS::Free(iEntries);
228 EXPORT_C TInt RPointerArrayBase::BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const
230 return BinarySearch(anEntry, anIndex, anOrder, EArrayFindMode_Any);
233 #ifndef __ARRAY_MACHINE_CODED__
234 EXPORT_C TInt RPointerArrayBase::Find(const TAny* anEntry) const
237 for (i=0; i<iCount; i++)
239 if (iEntries[i]==anEntry)
245 EXPORT_C TInt RPointerArrayBase::Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const
248 for (i=0; i<iCount; i++)
250 if ((*anIdentity)(anEntry,iEntries[i]))
256 EXPORT_C TInt RPointerArrayBase::BinarySearchSigned(TInt anEntry, TInt& anIndex) const
258 return BinarySearchSigned(anEntry, anIndex, EArrayFindMode_Any);
261 EXPORT_C TInt RPointerArrayBase::BinarySearchSigned(TInt anEntry, TInt& anIndex, TInt aMode) const
263 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
266 TInt ret = KErrNotFound;
270 TInt h=(TInt)iEntries[m];
273 if (aMode == EArrayFindMode_Any)
279 if (aMode == EArrayFindMode_First)
293 EXPORT_C TInt RPointerArrayBase::BinarySearchUnsigned(TUint anEntry, TInt& anIndex) const
295 return BinarySearchUnsigned(anEntry, anIndex, EArrayFindMode_Any);
298 EXPORT_C TInt RPointerArrayBase::BinarySearchUnsigned(TUint anEntry, TInt& anIndex, TInt aMode) const
300 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
303 TInt ret = KErrNotFound;
307 TUint h=(TUint)iEntries[m];
310 if (aMode == EArrayFindMode_Any)
316 if (aMode == EArrayFindMode_First)
330 EXPORT_C TInt RPointerArrayBase::BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const
332 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
335 TInt ret = KErrNotFound;
339 TInt k=(*anOrder)(anEntry,iEntries[m]);
342 if (aMode == EArrayFindMode_Any)
348 if (aMode == EArrayFindMode_First)
362 EXPORT_C TInt RPointerArrayBase::FindIsqSigned(TInt anEntry) const
364 return FindIsqSigned(anEntry, EArrayFindMode_Any);
367 EXPORT_C TInt RPointerArrayBase::FindIsqUnsigned(TUint anEntry) const
369 return FindIsqUnsigned(anEntry, EArrayFindMode_Any);
372 EXPORT_C TInt RPointerArrayBase::FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const
374 return FindIsq(anEntry, anOrder, EArrayFindMode_Any);
377 EXPORT_C TInt RPointerArrayBase::FindIsqSigned(TInt anEntry, TInt aMode) const
380 TInt r=BinarySearchSigned(anEntry,i,aMode);
381 return (r==KErrNone)?i:r;
384 EXPORT_C TInt RPointerArrayBase::FindIsqUnsigned(TUint anEntry, TInt aMode) const
387 TInt r=BinarySearchUnsigned(anEntry,i,aMode);
388 return (r==KErrNone)?i:r;
391 EXPORT_C TInt RPointerArrayBase::FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const
394 TInt r=BinarySearch(anEntry,i,anOrder,aMode);
395 return (r==KErrNone)?i:r;
398 extern "C" void PanicBadArrayFindMode()
400 Panic(EBadArrayFindMode);
405 EXPORT_C TInt RPointerArrayBase::FindReverse(const TAny* anEntry) const
410 if (iEntries[i]==anEntry)
416 EXPORT_C TInt RPointerArrayBase::FindReverse(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const
421 if ((*anIdentity)(anEntry,iEntries[i]))
428 EXPORT_C TInt RPointerArrayBase::InsertIsqSigned(TInt anEntry, TBool aAllowRepeats)
431 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
432 TInt r=BinarySearchSigned(anEntry,i,mode);
433 if (r==KErrNotFound || aAllowRepeats)
434 return Insert((const TAny*)anEntry,i);
435 return KErrAlreadyExists;
438 EXPORT_C TInt RPointerArrayBase::InsertIsqUnsigned(TUint anEntry, TBool aAllowRepeats)
441 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
442 TInt r=BinarySearchUnsigned(anEntry,i,mode);
443 if (r==KErrNotFound || aAllowRepeats)
444 return Insert((const TAny*)anEntry,i);
445 return KErrAlreadyExists;
448 EXPORT_C TInt RPointerArrayBase::InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats)
451 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
452 TInt r=BinarySearch(anEntry,i,anOrder,mode);
453 if (r==KErrNotFound || aAllowRepeats)
454 return Insert((const TAny*)anEntry,i);
455 return KErrAlreadyExists;
458 #ifndef __ARRAY_MACHINE_CODED__
459 void HeapSortUnsigned(TUint* aEntries,TInt aCount)
477 aEntries[ss]=aEntries[0];
489 if (jj>=ss || TUint(aEntries[jj-1])>TUint(aEntries[jj]) )
491 if (jj>=ss || TUint(aEntries[jj])<=si)
493 aEntries[ii]=aEntries[jj];
500 #endif // !__ARRAY_MACHINE_CODED__
503 #ifndef __KERNEL_MODE__
504 #ifndef __ARRAY_MACHINE_CODED__
505 EXPORT_C void RPointerArrayBase::HeapSortSigned()
517 si = (TInt)iEntries[sh];
522 si = (TInt)iEntries[ss];
523 iEntries[ss]=iEntries[0];
526 iEntries[0]=(TAny*)si;
535 if (jj>=ss || TInt(iEntries[jj-1])>TInt(iEntries[jj]) )
537 if (jj>=ss || TInt(iEntries[jj])<=si)
539 iEntries[ii]=iEntries[jj];
542 iEntries[ii]=(TAny*)si;
547 EXPORT_C void RPointerArrayBase::HeapSortUnsigned()
549 ::HeapSortUnsigned((TUint*)iEntries,iCount);
552 EXPORT_C void RPointerArrayBase::HeapSort(TGeneralLinearOrder anOrder)
570 iEntries[ss]=iEntries[0];
582 if (jj>=ss || (*anOrder)(iEntries[jj-1],iEntries[jj])>0 )
584 if (jj>=ss || (*anOrder)(iEntries[jj],si)<=0 )
586 iEntries[ii]=iEntries[jj];
595 EXPORT_C TInt RPointerArrayBase::GetCount(const CBase* aPtr)
597 return ((RPointerArrayBase*)aPtr)->Count();
600 EXPORT_C const TAny* RPointerArrayBase::GetElementPtr(const CBase* aPtr, TInt aIndex)
602 return &(((RPointerArrayBase*)aPtr)->At(aIndex));
604 #endif // __KERNEL_MODE__
606 EXPORT_C RArrayBase::RArrayBase(TInt anEntrySize)
607 : iCount(0), iEntries(NULL), iKeyOffset(0), iAllocated(0),
608 iGranularity(KDefaultSimpleArrayGranularity), iSpare1(0), iSpare2(0)
610 __ASSERT_ALWAYS(anEntrySize>0 && anEntrySize<=KSimpleArrayMaxEntrySize,Panic(EBadArrayEntrySize));
611 iEntrySize=(anEntrySize+(TInt)sizeof(TInt)-1)&~((TInt)sizeof(TInt)-1);
614 EXPORT_C RArrayBase::RArrayBase(TInt anEntrySize, TInt aGranularity)
615 : iCount(0), iEntries(NULL), iKeyOffset(0), iAllocated(0),
616 iGranularity(aGranularity), iSpare1(0), iSpare2(0)
618 __ASSERT_ALWAYS(anEntrySize>0 && anEntrySize<=KSimpleArrayMaxEntrySize,Panic(EBadArrayEntrySize));
619 __ASSERT_ALWAYS(aGranularity>0 && (aGranularity*anEntrySize)<=KSimpleArrayMaxGranularity, Panic(EBadArrayGranularity));
620 iEntrySize=(anEntrySize+(TInt)sizeof(TInt)-1)&~((TInt)sizeof(TInt)-1);
623 EXPORT_C RArrayBase::RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount)
624 : iCount(aCount), iEntries(aEntries), iKeyOffset(0), iAllocated(aCount),
625 iGranularity(KDefaultSimpleArrayGranularity), iSpare1(0), iSpare2(0)
627 __ASSERT_ALWAYS(aEntrySize>0 && aEntrySize<=KSimpleArrayMaxEntrySize,Panic(EBadArrayEntrySize));
628 __ASSERT_ALWAYS(aCount>0,Panic(EBadArrayCount));
629 iEntrySize=(aEntrySize+(TInt)sizeof(TInt)-1)&~((TInt)sizeof(TInt)-1);
632 EXPORT_C RArrayBase::RArrayBase(TInt anEntrySize, TInt aGranularity, TInt aKeyOffset)
633 : iCount(0), iEntries(NULL), iKeyOffset(aKeyOffset), iAllocated(0),
634 iGranularity(aGranularity), iSpare1(0), iSpare2(0)
636 __ASSERT_ALWAYS(anEntrySize>0 && anEntrySize<=KSimpleArrayMaxEntrySize,Panic(EBadArrayEntrySize));
637 __ASSERT_ALWAYS(aGranularity>0 && (aGranularity*anEntrySize)<=KSimpleArrayMaxGranularity, Panic(EBadArrayGranularity));
638 __ASSERT_ALWAYS(aKeyOffset>=0 && (aKeyOffset&3)==0 && aKeyOffset<anEntrySize, Panic(EBadArrayKeyOffset));
639 iEntrySize=(anEntrySize+(TInt)sizeof(TInt)-1)&~((TInt)sizeof(TInt)-1);
642 EXPORT_C RArrayBase::RArrayBase(TInt aEntrySize, TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
643 : iCount(0), iEntries(NULL), iKeyOffset(aKeyOffset), iAllocated(0), iSpare1(0), iSpare2(0)
645 __ASSERT_ALWAYS(aEntrySize>0 && aEntrySize<=KSimpleArrayMaxEntrySize, Panic(EBadArrayEntrySize));
646 __ASSERT_ALWAYS(aKeyOffset>=0 && (aKeyOffset&3)==0 && aKeyOffset<aEntrySize, Panic(EBadArrayKeyOffset));
647 __ASSERT_ALWAYS(aMinGrowBy>0 && aMinGrowBy<=KMaxArrayGrowBy, Panic(EBadArrayMinGrowBy));
648 __ASSERT_ALWAYS(aFactor>=KMinArrayFactor && aFactor<=KMaxArrayFactor, Panic(EBadArrayFactor));
649 iEntrySize=(aEntrySize+(TInt)sizeof(TInt)-1)&~((TInt)sizeof(TInt)-1);
650 iGranularity = aMinGrowBy | (aFactor << 16) | 0x80000000;
653 EXPORT_C void RArrayBase::Close()
656 STD_CLASS::Free(iEntries);
661 EXPORT_C TInt RArrayBase::Count() const
666 #ifndef __ARRAY_MACHINE_CODED__
667 EXPORT_C TAny* RArrayBase::At(TInt anIndex) const
669 __ASSERT_ALWAYS((anIndex>=0 && anIndex<iCount),Panic(EBadArrayIndex));
670 return (((TUint8*)iEntries)+anIndex*iEntrySize);
674 TInt RArrayBase::Grow()
676 TInt newAlloc = CalculateArraySizeAfterGrow(iAllocated, iGranularity, KMaxTInt/iEntrySize);
679 TAny** pA = (TAny**)STD_CLASS::ReAlloc(iEntries, newAlloc*iEntrySize);
683 iAllocated = newAlloc;
687 #ifndef __ARRAY_MACHINE_CODED__
688 EXPORT_C TInt RArrayBase::Append(const TAny* anEntry)
690 if (iCount==iAllocated)
696 wordmove((TUint8*)iEntries+iCount*iEntrySize, anEntry, iEntrySize);
702 EXPORT_C TInt RArrayBase::Insert(const TAny* anEntry, TInt aPos)
704 __ASSERT_ALWAYS((aPos>=0 && aPos<=iCount),Panic(EBadArrayPosition));
705 if (iCount==iAllocated)
711 TUint8 *pS=(TUint8*)iEntries+aPos*iEntrySize;
712 TUint8 *pD=pS+iEntrySize;
713 TInt entries=iCount-aPos;
715 wordmove(pD,pS,entries*iEntrySize);
716 wordmove(pS,anEntry,iEntrySize);
721 EXPORT_C void RArrayBase::Remove(TInt anIndex)
723 __ASSERT_ALWAYS((anIndex>=0 && anIndex<iCount),Panic(EBadArrayIndex));
724 TUint8 *pD=(TUint8*)iEntries+anIndex*iEntrySize;
725 TUint8 *pS=pD+iEntrySize;
726 TInt entries=iCount-anIndex-1;
728 wordmove(pD,pS,entries*iEntrySize);
732 EXPORT_C void RArrayBase::Compress()
735 iEntries=STD_CLASS::ReAlloc(iEntries,iCount*iEntrySize); // can't fail
738 STD_CLASS::Free(iEntries);
744 #ifndef __KERNEL_MODE__
745 EXPORT_C void RArrayBase::GranularCompress()
747 TInt newAlloc = CalculateArraySizeAfterShrink(iAllocated, iGranularity, iCount);
748 if (newAlloc == iAllocated)
751 iEntries=STD_CLASS::ReAlloc(iEntries,newAlloc*iEntrySize); // can't fail
754 STD_CLASS::Free(iEntries);
760 EXPORT_C TInt RArrayBase::DoReserve(TInt aCount)
762 __ASSERT_ALWAYS(aCount>=0, Panic(EArrayBadReserveCount));
763 if (aCount <= iAllocated)
764 return KErrNone; // if allocated space is already sufficient, nothing to do
766 Int64 size = Int64(aCount) * Int64(iEntrySize);
767 if (size > Int64(KMaxTInt))
770 TAny** pA = (TAny**)STD_CLASS::ReAlloc(iEntries, aCount*iEntrySize);
779 EXPORT_C void RArrayBase::Reset()
782 STD_CLASS::Free(iEntries);
787 EXPORT_C TInt RArrayBase::BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const
789 return BinarySearch(anEntry, anIndex, anOrder, EArrayFindMode_Any);
792 #ifndef __ARRAY_MACHINE_CODED__
793 EXPORT_C TInt RArrayBase::Find(const TAny* anEntry) const
795 TUint8 *pS=(TUint8*)iEntries+iKeyOffset;
796 TInt match=*(TInt*)((TUint8*)anEntry+iKeyOffset);
798 for (i=0; i<iCount; i++)
808 EXPORT_C TInt RArrayBase::Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const
810 TUint8 *pS=(TUint8*)iEntries;
812 for (i=0; i<iCount; i++)
814 if ((*anIdentity)(anEntry,pS))
821 EXPORT_C TInt RArrayBase::BinarySearchSigned(const TAny* anEntry, TInt& anIndex) const
823 return BinarySearchSigned(anEntry, anIndex, EArrayFindMode_Any);
826 EXPORT_C TInt RArrayBase::BinarySearchSigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const
828 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
829 TInt match=*(TInt*)((TUint8*)anEntry+iKeyOffset);
830 TUint8* pK=(TUint8*)iEntries+iKeyOffset;
833 TInt ret = KErrNotFound;
837 TInt h=*(TInt*)(pK+m*iEntrySize);
840 if (aMode == EArrayFindMode_Any)
846 if (aMode == EArrayFindMode_First)
860 EXPORT_C TInt RArrayBase::BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex) const
862 return BinarySearchUnsigned(anEntry, anIndex, EArrayFindMode_Any);
865 EXPORT_C TInt RArrayBase::BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const
867 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
868 TUint match=*(TUint*)((TUint8*)anEntry+iKeyOffset);
869 TUint8* pK=(TUint8*)iEntries+iKeyOffset;
872 TInt ret = KErrNotFound;
876 TUint h=*(TUint*)(pK+m*iEntrySize);
879 if (aMode == EArrayFindMode_Any)
885 if (aMode == EArrayFindMode_First)
899 EXPORT_C TInt RArrayBase::BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const
901 __ASSERT_DEBUG(TUint(aMode)<TUint(EArrayFindMode_Limit), Panic(EBadArrayFindMode));
904 TInt ret = KErrNotFound;
908 TInt k=(*anOrder)(anEntry,(TUint8*)iEntries+m*iEntrySize);
911 if (aMode == EArrayFindMode_Any)
917 if (aMode == EArrayFindMode_First)
931 EXPORT_C TInt RArrayBase::FindIsqSigned(const TAny* anEntry) const
933 return FindIsqSigned(anEntry, EArrayFindMode_Any);
936 EXPORT_C TInt RArrayBase::FindIsqUnsigned(const TAny* anEntry) const
938 return FindIsqUnsigned(anEntry, EArrayFindMode_Any);
941 EXPORT_C TInt RArrayBase::FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const
943 return FindIsq(anEntry, anOrder, EArrayFindMode_Any);
946 EXPORT_C TInt RArrayBase::FindIsqSigned(const TAny* anEntry, TInt aMode) const
949 TInt r=BinarySearchSigned(anEntry,i,aMode);
950 return (r==KErrNone)?i:r;
953 EXPORT_C TInt RArrayBase::FindIsqUnsigned(const TAny* anEntry, TInt aMode) const
956 TInt r=BinarySearchUnsigned(anEntry,i,aMode);
957 return (r==KErrNone)?i:r;
960 EXPORT_C TInt RArrayBase::FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const
963 TInt r=BinarySearch(anEntry,i,anOrder,aMode);
964 return (r==KErrNone)?i:r;
968 EXPORT_C TInt RArrayBase::FindReverse(const TAny* anEntry) const
970 TUint8 *pS=(TUint8*)iEntries+(iCount-1)*iEntrySize+iKeyOffset;
971 TInt match=*(TInt*)((TUint8*)anEntry+iKeyOffset);
983 EXPORT_C TInt RArrayBase::FindReverse(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const
985 TUint8 *pS=(TUint8*)iEntries+(iCount-1)*iEntrySize;
989 if ((*anIdentity)(anEntry,pS))
996 EXPORT_C TInt RArrayBase::InsertIsqSigned(const TAny* anEntry, TBool aAllowRepeats)
999 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
1000 TInt r=BinarySearchSigned(anEntry,i,mode);
1001 if (r==KErrNotFound || aAllowRepeats)
1002 return Insert((const TAny*)anEntry,i);
1003 return KErrAlreadyExists;
1006 EXPORT_C TInt RArrayBase::InsertIsqUnsigned(const TAny* anEntry, TBool aAllowRepeats)
1009 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
1010 TInt r=BinarySearchUnsigned(anEntry,i,mode);
1011 if (r==KErrNotFound || aAllowRepeats)
1012 return Insert((const TAny*)anEntry,i);
1013 return KErrAlreadyExists;
1016 EXPORT_C TInt RArrayBase::InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats)
1019 TInt mode = aAllowRepeats ? EArrayFindMode_Last : EArrayFindMode_Any;
1020 TInt r=BinarySearch(anEntry,i,anOrder,mode);
1021 if (r==KErrNotFound || aAllowRepeats)
1022 return Insert((const TAny*)anEntry,i);
1023 return KErrAlreadyExists;
1026 #ifndef __KERNEL_MODE__
1027 #ifndef __ARRAY_MACHINE_CODED__
1028 EXPORT_C void RArrayBase::HeapSortSigned()
1030 TUint32 si[KSimpleArrayMaxEntrySize/4];
1040 wordmove(si,(TUint8*)iEntries+sh*iEntrySize,iEntrySize);
1045 wordmove(si,(TUint8*)iEntries+ss*iEntrySize,iEntrySize);
1046 wordmove((TUint8*)iEntries+ss*iEntrySize,iEntries,iEntrySize);
1049 wordmove(iEntries,si,iEntrySize);
1055 TInt sikey=*(TInt*)((TUint8*)si+iKeyOffset);
1059 TUint8* pKey=((TUint8*)iEntries+jj*iEntrySize+iKeyOffset);
1060 if (jj>=ss || (*(TInt*)(pKey-iEntrySize))>*(TInt*)pKey )
1065 if (jj>=ss || *(TInt*)pKey<=sikey)
1067 wordmove((TUint8*)iEntries+ii*iEntrySize,(TUint8*)iEntries+jj*iEntrySize,iEntrySize);
1070 wordmove((TUint8*)iEntries+ii*iEntrySize,si,iEntrySize);
1075 EXPORT_C void RArrayBase::HeapSortUnsigned()
1077 TUint32 si[KSimpleArrayMaxEntrySize/4];
1087 wordmove(si,(TUint8*)iEntries+sh*iEntrySize,iEntrySize);
1092 wordmove(si,(TUint8*)iEntries+ss*iEntrySize,iEntrySize);
1093 wordmove((TUint8*)iEntries+ss*iEntrySize,iEntries,iEntrySize);
1096 wordmove(iEntries,si,iEntrySize);
1102 TUint sikey=*(TUint*)((TUint8*)si+iKeyOffset);
1106 TUint8* pKey=((TUint8*)iEntries+jj*iEntrySize+iKeyOffset);
1107 if (jj>=ss || (*(TUint*)(pKey-iEntrySize))>*(TUint*)pKey )
1112 if (jj>=ss || *(TUint*)pKey<=sikey)
1114 wordmove((TUint8*)iEntries+ii*iEntrySize,(TUint8*)iEntries+jj*iEntrySize,iEntrySize);
1117 wordmove((TUint8*)iEntries+ii*iEntrySize,si,iEntrySize);
1122 EXPORT_C void RArrayBase::HeapSort(TGeneralLinearOrder anOrder)
1124 TUint32 si[KSimpleArrayMaxEntrySize/4];
1134 wordmove(si,(TUint8*)iEntries+sh*iEntrySize,iEntrySize);
1139 wordmove(si,(TUint8*)iEntries+ss*iEntrySize,iEntrySize);
1140 wordmove((TUint8*)iEntries+ss*iEntrySize,iEntries,iEntrySize);
1143 wordmove(iEntries,si,iEntrySize);
1152 TUint8* pJJ=((TUint8*)iEntries+jj*iEntrySize);
1153 if (jj>=ss || (*anOrder)(pJJ-iEntrySize,pJJ)>0)
1158 if (jj>=ss || (*anOrder)(pJJ,si)<=0)
1160 wordmove((TUint8*)iEntries+ii*iEntrySize,(TUint8*)iEntries+jj*iEntrySize,iEntrySize);
1163 wordmove((TUint8*)iEntries+ii*iEntrySize,si,iEntrySize);
1169 EXPORT_C TInt RArrayBase::GetCount(const CBase* aPtr)
1171 return ((RArrayBase*)aPtr)->Count();
1174 EXPORT_C const TAny* RArrayBase::GetElementPtr(const CBase* aPtr, TInt aIndex)
1176 return ((RArrayBase*)aPtr)->At(aIndex);
1178 #endif // __KERNEL_MODE__