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

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\common\des16.cpp

// 

//

#include "common.h"

#include <collate.h>

#ifdef _UNICODE

#include <unicode.h>

#include "collateimp.h"

#endif

#include "compareimp.h"

#define __CHECK_ALIGNMENT(p,c) __ASSERT_DEBUG(!(TUint(p)&1),Des16Panic(c))

enum TDes16Panic

	{

	ETDesC16ConstructCString=0,

	ETDesC16ConstructBufLength=1,

	ETDesC16ConstructBufLengthMax=2,

	ETDesC16FindPtrLen=3,

	ETDesC16FindFPtrLen=4,

	ETDesC16FindCPtrLen=5,

	ETBufCBase16CopyStringMax=6,

	EHBufC16AssignCString=7,

	ETDes16AssignCString=8,

	ETDes16CopyCString=9,

	ETDes16CopyBufLength=10,

	ETDes16AppendBufLength=11,

	ETDes16RepeatBufLength=12,

	ETDes16AppendJustify1=13,

	ETDes16AppendJustify2=14,

	ETPtrC16SetBufLength=15,

	ETPtr16SetBufLengthMax=16,

	ETDesC16Invariant=17,

	ETDesC16Ptr=18

	};

#ifdef _DEBUG

_LIT(KLitDes16Align,"Des16Align");

void Des16Panic(TDes16Panic aPanic)

	{

	PANIC_CURRENT_THREAD(KLitDes16Align,aPanic);

	}

#endif

inline TUint16* memCopy(TUint16* aPtr, const TUint16* aSrc, TInt aLength)

	{

	return (TUint16 *)Mem::Copy(aPtr,aSrc,aLength<<1);

	}

#if !defined( __DES16_MACHINE_CODED__) | defined(__EABI_CTORS__)

inline TInt StringLength(const TUint16* aPtr)

	{

	const TUint16* p = aPtr;

	while (*p)

		++p;

	return p-aPtr;

	}

#endif

inline TDesC16::TDesC16(TInt aType,TInt aLength)

	:iLength(aLength|(aType<<KShiftDesType16))

	{}

inline TInt TDesC16::Type() const

//

// Return the descriptor type

//

	{

	return(iLength>>KShiftDesType16);

	}

inline TDes16::TDes16(TInt aType,TInt aLength,TInt aMaxLength)

	: TDesC16(aType,aLength),iMaxLength(aMaxLength)

	{}

// Class TBufCBase16

inline TBufCBase16::TBufCBase16(TInt aLength)

	:TDesC16(EBufC,aLength)

	{}

inline TUint16* TBufCBase16::WPtr() const

	{return const_cast<TUint16*>(Ptr());}

#if !defined( __DES16_MACHINE_CODED__) | defined(__EABI_CTORS__)

EXPORT_C TPtr16::TPtr16(TBufCBase16& aLcb, TInt aMaxLength)

	: TDes16(EBufCPtr,aLcb.Length(),aMaxLength),iPtr((TUint16*)&aLcb)

	{

	__ASSERT_DEBUG(aLcb.Length()<=aMaxLength,Panic(ETDes16LengthOutOfRange));

	}

#endif

#if !defined( __DES16_MACHINE_CODED__)

/**

Gets a pointer to the data represented by the descriptor.

The data cannot be changed through the returned pointer.

@return A pointer to the data

*/

EXPORT_C const TUint16 *TDesC16::Ptr() const

	{

	const TUint16* p=NULL;

	switch (Type())

		{

	case EBufC:

		p=(&((SBufC16 *)this)->buf[0]); break;

	case EPtrC:

		p=(((SPtrC16 *)this)->ptr); break;

	case EPtr:

		p=(((SPtr16 *)this)->ptr); break;

	case EBuf:

		p=(&((SBuf16 *)this)->buf[0]); break;

	case EBufCPtr:

		p=(&((SBufCPtr16 *)this)->ptr->buf[0]); break;

	default:

		Panic(ETDes16BadDescriptorType);

		}

	__CHECK_ALIGNMENT(p,ETDesC16Ptr);

	return p;

	}

EXPORT_C const TUint16 &TDesC16::AtC(TInt anIndex) const

//

// Return a reference to the character in the buffer.

//

	{

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<Length(),Panic(ETDes16IndexOutOfRange));

	return(Ptr()[anIndex]);

	}

/**

Compares this descriptor's data with the specified descriptor's data.

The comparison proceeds on a double-byte for double byte basis.

The result of the comparison is based on the difference of the first pair

of bytes to disagree.

Two descriptors are equal if they have the same length and content. Where 

two descriptors have different lengths and the shorter descriptor's data 

matches the first part of the longer descriptor's data, the shorter is

considered to be less than the longer.

@param aDes The 16-bit non-modifable descriptor whose data is to be compared 

            with this descriptor's data. 

@return Positive. if this descriptor is greater than the specified descriptor.

        Negative. if this descriptor is less than the specified descriptor.

        Zero, if both descriptors have the same length and the their contents

        are the same.

*/

EXPORT_C TInt TDesC16::Compare(const TDesC16 &aDes) const

	{

	return MEM_COMPARE_16(Ptr(),Length(),aDes.Ptr(),aDes.Length());

	}

/**

Compares this descriptor's folded data with the specified descriptor's folded 

data.

Note that folding is locale-independent behaviour. It is also important to 

note that there can be no guarantee that folding is in any way culturally 

appropriate, and should not be used for comparing strings in natural language; 

use CompareC() for this.

@param aDes The 16-bit non-modifable descriptor whose data is to be compared 

            with this descriptor's data. 

@return Positive, if this descriptor is greater than the specified descriptor. 

        Negative, if this descriptor is less than the specified descriptor.

        Zero, if both descriptors have the same length and the their contents

        are the same.

@see TDesC16::Compare()

*/

EXPORT_C TInt TDesC16::CompareF(const TDesC16 &aDes) const

	{

	return(Mem::CompareF(Ptr(),Length(),aDes.Ptr(),aDes.Length()));

	}

/**

Compares this descriptor's data with the specified descriptor's data using 

the standard collation method appropriate to the current locale.

@param aDes The 16-bit non-modifable descriptor whose data is to be compared 

            with this descriptor's data. 

@return Positive, if this descriptor is greater than the specified descriptor. 

        Negative, if this descriptor is less than the specified descriptor.

        Zero, if the content of both descriptors match.

@see TDesC16::Compare()

*/

EXPORT_C TInt TDesC16::CompareC(const TDesC16 &aDes) const

	{

	return(Mem::CompareC(Ptr(),Length(),aDes.Ptr(),aDes.Length()));

	}

#endif

#ifdef _UNICODE

/**

Compares this descriptor's data with the specified descriptor's data to the 

specified maximum collation level and using the specified collation method.

If no collation method is supplied, a default method is used that uses a

locale-independent collation table. This means that sorting and matching will

not be based on the current locale.

This function is only defined for 16-bit (Unicode) build variants. This means 

that the function is not defined for 8-bit build variants, even when an

explicit 16-bit descriptor is used.

Strings may match even if the lengths of their respective descriptors are 

different.

@param aDes             The 16-bit non-modifable descriptor whose data is to

                        be compared with this descriptor's data.

@param aMaxLevel        The maximum collation level. This is an integer with 

                        values: 0, 1, 2 or 3, which, effectively, determines

                        how 'tight' the matching should be. Level 3 is always

                        used if the aim is to sort strings.

@param aCollationMethod A pointer to the collation method or NULL. Collation 

                        methods can be retrieved by calls to

                        Mem::CollationMethodByIndex()

                        and Mem::CollationMethodById(). 

                        Specifying NULL means that the default method is used.

@return Positive, if this descriptor is greater than the specified descriptor. 

        Negative, if this descriptor is less than the specified descriptor.

        Zero, if the content of both descriptors match.

@see Mem::CollationMethodByIndex()

@see Mem::CollationMethodById()

@see TDesC16::Compare()

*/

EXPORT_C TInt TDesC16::CompareC(const TDesC16& aDes, TInt aMaxLevel, const TCollationMethod* aCollationMethod) const

	{

	return Mem::CompareC(Ptr(),Length(),aDes.Ptr(),aDes.Length(),aMaxLevel,aCollationMethod);

	}

/**

Get the normalized decomposed form of this 16 bit descriptor

@return A pointer to the 16-bit heap buffer containing normalized decomposed form

		if creation is successful

@leave KErrNoMemory if not enough memory to construct the output buffer

*/

EXPORT_C HBufC16* TDesC16::GetNormalizedDecomposedFormL() const

	{

	//pre create a buffer with of size Length

	TInt strLength=Length();

	HBufC16* outBuf=HBufC16::NewL(strLength);

	TUTF32Iterator input(Ptr(),Ptr()+strLength);

	TCanonicalDecompositionIterator output;

	output.Set(input);

	TInt currentAllocateCount=0;

	TUint16* outPtr = (TUint16* )outBuf->Des().Ptr();

	TInt preAllocateCount= outBuf->Des().MaxLength();

	for (;!output.AtEnd();output.Next(),currentAllocateCount++)

		{

		if (currentAllocateCount>=preAllocateCount)

			{

			const TInt KMaxGrowSize=16;

			HBufC16* newOutBuf = outBuf->ReAlloc(preAllocateCount+KMaxGrowSize);

			if(!newOutBuf)

				{

				delete outBuf;

				User::Leave(KErrNoMemory);

				}

			outBuf = newOutBuf;

			preAllocateCount = outBuf->Des().MaxLength();

			}

		outPtr[currentAllocateCount] = (TUint16)(TUint)(output.Current());

		}

	// update the length of the buffer...

	outBuf->Des().SetLength(currentAllocateCount);

	//compress the unused slot

	if (currentAllocateCount<preAllocateCount)

		outBuf = outBuf->ReAlloc(currentAllocateCount); // can't fail to shrink memory

	return outBuf;

	}

/**

Get the folded decomposed form of this 16 bit descriptor

@return A pointer to the 16-bit heap buffer containing folded decomposed form

		if creation is succesful

@leave KErrNoMemory if not enough memory to construct the output buffer

*/	

EXPORT_C HBufC16* TDesC16::GetFoldedDecomposedFormL() const

	{

	//pre create a buffer with of size Length

	TInt strLength=Length();

	HBufC16* outBuf=HBufC16::NewL(strLength);

	TUTF32Iterator input(Ptr(),Ptr()+strLength);

	TFoldedCanonicalIterator output (input);

	TInt currentAllocateCount=0;

	TUint16* outPtr = (TUint16* )outBuf->Des().Ptr();

	TInt preAllocateCount= outBuf->Des().MaxLength();

	const TUnicodeDataSet* charDataSet = GetLocaleCharSet()->iCharDataSet;

	for (;!output.AtEnd();output.Next(charDataSet),currentAllocateCount++)

		{

		if (currentAllocateCount>=preAllocateCount)

			{

			const TInt KMaxGrowSize=16;

			HBufC16* newOutBuf = outBuf->ReAlloc(preAllocateCount+KMaxGrowSize);

			if(!newOutBuf)

				{

				delete outBuf;

				User::Leave(KErrNoMemory);

				}

			outBuf = newOutBuf;

			preAllocateCount = outBuf->Des().MaxLength();

			}

		outPtr[currentAllocateCount] = (TUint16)(TUint)(output.Current());

		}

	// update the length of the buffer...

	outBuf->Des().SetLength(currentAllocateCount);

	//compress the unused slot

	if (currentAllocateCount<preAllocateCount)

		outBuf = outBuf->ReAlloc(currentAllocateCount); // can't fail to shrink memory

	return outBuf;

	}

//some utils function

static void ResetAndDestroyArray(TAny* aPtr)

	{

	(STATIC_CAST(RPointerArray<HBufC8>*,aPtr))->ResetAndDestroy();

	}

/**

Get the collation keys of this 16 bit descriptor for a given collation level

If no collation method is supplied, a default method is used that uses a

locale-independent collation table. 

@param aMaxLevel        The maximum collation level. This is an integer with 

                        values: 0, 1, 2 or 3. Level 3 is always

                        used if the aim is to sort strings.

@param aCollationMethod A pointer to the collation method or NULL. Collation 

                        methods can be retrieved by calls to

                        Mem::CollationMethodByIndex()

                        and Mem::CollationMethodById(). 

                        Specifying NULL means that the default method is used.

@return A pointer to the 8-bit heap buffer containing the collation keys if

		creation is succesful

@leave KErrNoMemory if not enough memory to construct the output buffer		

*/	

EXPORT_C HBufC8* TDesC16::GetCollationKeysL(TInt aMaxLevel,const TCollationMethod* aCollationMethod) const

	{

	// Clamp the maximum level of the comparison.

	if(aMaxLevel < 0)

		aMaxLevel = 0;

	if(aMaxLevel > 3)

		aMaxLevel = 3;

	RPointerArray<HBufC8> levelBuffer;

 	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray, &levelBuffer));

  	TInt strLength=Length();

 	TInt outputBufferSize=0;

  	//preallocate some initial buffer size as it is not possible to determine the max buffer

  	//required as a character can be further decomposed and each character can possibly

  	//have up to 8 collation keys and this limit might still change.

	for (TInt i=0;i<=aMaxLevel;i++)

		{

		TInt levelKeySize=TCollationKey::MaxSizePerKey(i);

		HBufC8* buffer=HBufC8::NewLC(strLength*levelKeySize);

		levelBuffer.AppendL(buffer);

		CleanupStack::Pop();

		outputBufferSize+=levelKeySize;

		}

	TCollationMethod clm;

	//if collationMethod is NULL, use the default one

	if (aCollationMethod==NULL)

		{

		clm=*(GetLocaleCharSet()->iCollationDataSet->iMethod);

		}

	else

		{

		clm = *aCollationMethod;			

		}

	//if the main table is empty use the standard table

	if (clm.iMainTable==NULL)

		clm.iMainTable=StandardCollationMethod();	

	TCollationValueIterator tvi(clm);	

  	TUTF32Iterator input(Ptr(),Ptr()+strLength);	

 	tvi.SetSourceIt(input);

	//Expand the buffer by 16 bytes if buffer is exhausted

	const TInt KMaxBufferGrowSize=16;

	TInt currentKeyCount=0;

	TInt preAllocateCount=strLength;

	TCollationKey collateKey;

	for (;tvi.GetCurrentKey(collateKey);tvi.Increment(),currentKeyCount++)

		{

		for (TInt i=0;i<=aMaxLevel;i++)

			{

			if (currentKeyCount==preAllocateCount)

				levelBuffer[i]=levelBuffer[i]->ReAllocL((currentKeyCount+KMaxBufferGrowSize)*TCollationKey::MaxSizePerKey(i));

			collateKey.AppendToDescriptor(levelBuffer[i]->Des(),i);

			}

		if (currentKeyCount==preAllocateCount)

			preAllocateCount+=KMaxBufferGrowSize;

		}

	//append the level separator which is a "\x00\x00" for level 0 and \x00 for other level

	outputBufferSize=(outputBufferSize*currentKeyCount)+(aMaxLevel==0?0:4+(aMaxLevel-1)*2);

	HBufC8* outputResult=HBufC8::NewL(outputBufferSize);

	TPtr8 outputResultPtr(outputResult->Des());

	for (TInt count=0;count<=aMaxLevel;count++)

		{

		outputResultPtr.Append(*levelBuffer[count]);

		if (count!=aMaxLevel)

			{

			if (count==0)

				outputResultPtr.Append(0);

			outputResultPtr.Append(0);

			}

		}

	CleanupStack::PopAndDestroy();

	return outputResult;	

	}	

#endif

/**

Searches for the first occurrence of the specified data sequence within this

descriptor.

Searching always starts at the beginning of this descriptor's data.

@param pS    A pointer to a location containing the data sequence to be searched 

             for.

@param aLenS The length of the data sequence to be searched for. This value 

             must not be negative, otherwise the function raises a panic.

@return The offset of the data sequence from the beginning of this descriptor's 

        data. KErrNotFound, if the data sequence cannot be found.

@panic  USER 17 if aLenS is negative. 

*/

EXPORT_C TInt TDesC16::Find(const TUint16 *pS,TInt aLenS) const

	{

	if (!aLenS)

		return(0);

	__ASSERT_ALWAYS(aLenS>0,Panic(ETDes16LengthNegative));

	__CHECK_ALIGNMENT(pS,ETDesC16FindPtrLen);

	const TUint16 *pB=Ptr();

	TInt aLenB=Length();

	const TUint16 *pC=pB-1;			// using pre-increment addressing

	TInt i=aLenB-aLenS;

	if (i>=0)

		{

		const TUint16* pEndS=pS+aLenS-1;		// using pre-increment addressing

		const TUint16 *pEndB=pB+i;			// using pre-increment addressing

		TUint s=*pS;

		for (;;)

			{

			do

				{

				if (pC==pEndB)

					return KErrNotFound;

				} while (*++pC!=s);

			const TUint16 *p1=pC;

			const TUint16 *p2=pS;

			do

				{

				if (p2==pEndS)

					return (pC-pB);

				} while (*++p1==*++p2);

			}

		}

	return(KErrNotFound);

	}

/**

Searches for the first occurrence of the specified data sequence within this 

descriptor.

Searching always starts at the beginning of this descriptor's 

data.

@param aDes The 16-bit non-modifiable descriptor containing the data sequence 

            to be searched for. 

@return The offset of the data sequence from the beginning of this descriptor's 

        data. KErrNotFound, if the data sequence cannot be found.