// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\cbase\ub_array.cpp

// 

//

#include "ub_std.h"

struct SVarRec

	{

	TInt len;

	TAny *data;

	};

NONSHARABLE_CLASS(TSwapArray) : public TSwap

	{

public:

	inline TSwapArray(CBufBase *aBase,TInt aRecordLength);

	TUint8 *At(TInt anIndex) const;

	virtual void Swap(TInt aLeft,TInt aRight) const;

private:

	CBufBase *iBase;

	TInt iLength;

	};

inline TSwapArray::TSwapArray(CBufBase *aBase,TInt aRecordLength)

	: iBase(aBase),iLength(aRecordLength)

	{}

TUint8 *TSwapArray::At(TInt anIndex) const

//

// Return a pointer to the array element

//

	{

	return((TUint8 *)iBase->Ptr(anIndex*iLength).Ptr());

	}

void TSwapArray::Swap(TInt aLeft,TInt aRight) const

//

// Swap two elements of the array.

//

	{

	Mem::Swap(At(aLeft),At(aRight),iLength);

	}

EXPORT_C TKeyArrayFix::TKeyArrayFix(TInt anOffset,TKeyCmpText aType)

	: TKey(anOffset,aType)

/**

Constructs the characteristics of a descriptor key.

No length value is passed as this is taken from the descriptor type key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two descriptor keys.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayFix::TKeyArrayFix(TInt anOffset,TKeyCmpText aType,TInt aLength)

	: TKey(anOffset,aType,aLength)

/**

Constructs the characteristics of a text key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two text keys.

@param aLength The length of the text key.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayFix::TKeyArrayFix(TInt anOffset,TKeyCmpNumeric aType)

	: TKey(anOffset,aType)

/**

Constructs the characteristics of a numeric key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of the numeric key.

@see TKeyCmpNumeric

*/

	{}

EXPORT_C void TKeyArrayFix::Set(CBufBase *aBase,TInt aRecordLength)

//

// Set the base and record length

//

	{

	iBase=aBase;

	iRecordLength=aRecordLength;

	}

EXPORT_C TAny *TKeyArrayFix::At(TInt anIndex) const

//

// Return an address in the array.

//

	{

	if (anIndex==KIndexPtr)

		return((TUint8 *)iPtr+iKeyOffset); 			

	return((TAny *)(iBase->Ptr(anIndex*iRecordLength).Ptr()+iKeyOffset));

	}

EXPORT_C TKeyArrayVar::TKeyArrayVar(TInt anOffset,TKeyCmpText aType)

	: TKey(anOffset,aType)

/**

Constructs the characteristics of a descriptor key.

No length value is passed as this is taken from the descriptor type key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two descriptor keys.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayVar::TKeyArrayVar(TInt anOffset,TKeyCmpText aType,TInt aLength)

	: TKey(anOffset,aType,aLength)

/**

Constructs the characteristics of a text key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two text keys.

@param aLength  The length of the text key.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayVar::TKeyArrayVar(TInt anOffset,TKeyCmpNumeric aType)

	: TKey(anOffset,aType)

/**

Constructs the characteristics of a numeric key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of the numeric key.

@see TKeyCmpNumeric

*/

	{}

EXPORT_C void TKeyArrayVar::Set(CBufBase *aBase)

//

// Set the private variable iBase to aBase.

//

	{

	iBase=aBase;

	}

EXPORT_C TAny *TKeyArrayVar::At(TInt anIndex) const

//

// Return an address in the array.

//

	{

	if (anIndex==KIndexPtr)

		return((TUint8 *)iPtr+iKeyOffset);   

	SVarRec *pV=(SVarRec *)iBase->Ptr(anIndex*sizeof(SVarRec)).Ptr();

	return(((TUint8 *)pV->data)+iKeyOffset);

	}

EXPORT_C TKeyArrayPak::TKeyArrayPak(TInt anOffset,TKeyCmpText aType)

	: TKeyArrayVar(anOffset,aType)

/**

Constructs the characteristics of a descriptor key.

No length value is passed as this is taken from the descriptor type key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two descriptor keys.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayPak::TKeyArrayPak(TInt anOffset,TKeyCmpText aType,TInt aLength)

	: TKeyArrayVar(anOffset,aType,aLength)

/**

Constructs the characteristics of a text key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of comparison to be made 

                between two text keys.

@param aLength  The length of the text key.

@see TKeyCmpText

*/

	{}

EXPORT_C TKeyArrayPak::TKeyArrayPak(TInt anOffset,TKeyCmpNumeric aType)

	: TKeyArrayVar(anOffset,aType)

/**

Constructs the characteristics of a numeric key.

@param anOffset The offset of the key from the start of an array element.

@param aType    An enumeration which defines the type of the numeric key.

@see TKeyCmpNumeric

*/

	{}

EXPORT_C void TKeyArrayPak::Set(CBufBase *aBase)

//

// Set the private variable iBase to aBase.

//

	{

	iBase=aBase;

	iCacheIndex=0;

	iCacheOffset=0;

	}

EXPORT_C TAny *TKeyArrayPak::At(TInt anIndex) const

//

// Return a pointer to the data in the record with index anIndex.

//

	{

//

// When anIndex is equal to KIndexPtr (HighValues) this means that we should return the address of

// the iPtr+iKeyOffset which will have been set up by the TKeyArrayPak constructor.

//

	if (anIndex==KIndexPtr)

		return((TUint8 *)iPtr+iKeyOffset); 

//

// Otherwise get the offset into the buffer of the record with index anIndex.

//

	TInt offset=0;

 	TInt curIndex=0;

	if (iCacheIndex<=anIndex)

		{

		curIndex=iCacheIndex;

		offset=iCacheOffset;

		}

	TAny *pRecord=(TAny *)iBase->Ptr(offset).Ptr();

	while (curIndex<anIndex)

		{

		TInt lenData=(*(TInt *)pRecord);

		offset+=Align4(lenData)+sizeof(TUint);

		pRecord=(TAny *)iBase->Ptr(offset).Ptr();

		curIndex++;

		}

	(TInt &)iCacheIndex=anIndex;

	(TInt &)iCacheOffset=offset;

	TAny *pData=(TAny *)((TInt *)pRecord + 1);

 	return((TUint8 *)pData+iKeyOffset);

	}

EXPORT_C CArrayFixBase::CArrayFixBase(TBufRep aRep,TInt aRecordLength,TInt aGranularity)

//

// Constructor

//

/**

@internalComponent

*/

	{

	__ASSERT_ALWAYS(aRecordLength>0,Panic(EArrayFixInvalidLength));

	__ASSERT_ALWAYS(aGranularity>0,Panic(EArrayFixInvalidGranularity));

//	iCount=0;

//	iBase=NULL;

	iLength=aRecordLength;

	iGranularity=aGranularity;

	iCreateRep=aRep;

	}

EXPORT_C CArrayFixBase::~CArrayFixBase()

/**

Destructor.

This frees all resources owned by the object, prior to its destruction.

*/

	{

	delete iBase;

	}

EXPORT_C void CArrayFixBase::Compress()

/**

Compresses the array.

The function removes the excess space from the array buffer. The effect is 

to reduce the memory allocated to the array buffer so that it is just

sufficient to contain the elements of the array. This applies to both flat

and segmented array buffers.

If the array is empty, then the memory allocated to the array buffer is freed.

*/

	{

	if (iBase)

		iBase->Compress();

	}

EXPORT_C void CArrayFixBase::Reset()

/**

Deletes all elements from the array and frees the memory allocated 

to the array buffer.

*/

	{

	iCount=0;

	if (iBase)

		iBase->Reset();

	}

EXPORT_C TInt CArrayFixBase::Sort(TKeyArrayFix &aKey)

/**

Sorts the elements of the array into key sequence.

@param aKey The key object defining the properties of the key. 

@return KErrNone if the sort completes successfully.

        KErrGeneral if the stack overflows

*/

	{

	if (iCount==0)

		return KErrNone;

	TSwapArray aSwap(iBase,iLength);

	SetKey(aKey);

	return(User::QuickSort(iCount,aKey,aSwap));

	}

EXPORT_C TAny *CArrayFixBase::At(TInt anIndex) const

//

// Index into the array.

//

/**

@internalComponent

*/

	{

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<iCount,Panic(EArrayIndexOutOfRange));

	return((TAny *)iBase->Ptr(anIndex*iLength).Ptr());

	}

EXPORT_C TAny *CArrayFixBase::End(TInt anIndex) const

//

// Return a pointer past contiguous elements starting at anIndex.

//

/**

@internalComponent

*/

	{

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<=iCount,Panic(EArrayIndexOutOfRange));

	TPtr8 p=iBase->Ptr(anIndex*iLength);

	return((TAny *)(p.Ptr()+p.Length()));

	}

EXPORT_C TAny *CArrayFixBase::Back(TInt anIndex) const

//

// Return a pointer to contiguous elements before anIndex.

//

/**

@internalComponent

*/

	{

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<=iCount,Panic(EArrayIndexOutOfRange));

	TPtr8 p=iBase->BackPtr(anIndex*iLength);

	return((TAny *)p.Ptr());

	}

EXPORT_C void CArrayFixBase::Delete(TInt anIndex)

/**

Deletes a single element from the array at a specified position.

Deleting elements from the array does not cause the array buffer to be

automatically compressed. Call CArrayFixBase::Compress() to return excess space

to the heap.

@param anIndex The position within the array at which to delete the element, 

               This is a value relative to zero. 

@panic E32USER-CBase 21, if anIndex is negative or is greater 

                         than or equal to the number of elements currently

                         in the array.

@see CArrayFixBase::Compress

*/

	{

	Delete(anIndex,1);

	}

EXPORT_C void CArrayFixBase::Delete(TInt anIndex,TInt aCount)

/**

Deletes one or more contiguous elements from the array, starting at a specific 

position.

Deleting elements from the array does not cause the array buffer to be

automatically compressed. Call CArrayFixBase::Compress() to return excess space

to the heap.

@param anIndex The position within the array from where deletion of elements 

               is to start. The position is relative to zero, i.e. zero implies

               that elements, starting with the first, are deleted from the

               array.

@param aCount  The number of contiguous elements to be deleted from the array. 

@panic E32USER-CBase 21, if anIndex is negative, or is greater than or equal to

                         the number of elements currently in the array.

@panic E32USER-CBase 22, if aCount is negative.

@panic E32USER-CBase 29, if the sum of anIndex and aCount is greater than or equal

                         to the number of elements currently in the array.

*/

	{

	if (aCount==0)

		return;

	__ASSERT_ALWAYS(aCount>0,Panic(EArrayCountNegative));

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<iCount,Panic(EArrayIndexOutOfRange));

	__ASSERT_ALWAYS(anIndex+aCount<=iCount,Panic(EArrayCountTooBig));

	iBase->Delete(anIndex*iLength,aCount*iLength);

	iCount-=aCount;

	}

EXPORT_C TAny *CArrayFixBase::ExpandL(TInt anIndex)

//

// Expand the array to make room for a new record at anIndex.

//

/**

@internalComponent

*/

	{

	if (iBase==NULL)

		iBase=(*iCreateRep)(iLength*iGranularity);

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<=iCount,Panic(EArrayIndexOutOfRange));

	iBase->ExpandL(anIndex*iLength,iLength);

	++iCount;

	return((TAny *)iBase->Ptr(anIndex*iLength).Ptr());

	}

EXPORT_C TInt CArrayFixBase::Find(const TAny *aPtr,TKeyArrayFix &aKey,TInt &anIndex) const

//

// Find in the array using a sequential search.

//

/**

@internalComponent

*/

	{

	if (iCount==0)

	    {

	    anIndex=0;

		return(-1);

		}

	aKey.SetPtr(aPtr);

	SetKey(aKey);

	TInt r=1;

	TInt i=0;

	while (i<Count())

		{

		TInt j=aKey.Compare(i,KIndexPtr);

		if (j==0)

			{

			r=j;

			break;

			}

		i++;

		}

	anIndex=i;

	return(r);

	}

EXPORT_C TInt CArrayFixBase::FindIsq(const TAny *aPtr,TKeyArrayFix &aKey,TInt &anIndex) const

//

// Find in the array using a binary search.

//

/**