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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include "UB_STD.H"

typedef union

	{

	const TAny* tany;

	const TInt8* tint8;

	const TInt16* tint16;

	const TInt32* tint32;

	const TInt64* tint64;

	const TUint8* tuint8;

	const TUint16* tuint16;

	const TUint32* tuint32;

	} UPTR;

EXPORT_C const TAny* MBtreeKey::Key(const TAny* anEntry) const

/** Gets the key value for an entry.

@param anEntry Object for which to get the key value

@return Pointer to the key value */

	{

	return anEntry;

	}

EXPORT_C TBtreeKey::TBtreeKey(TInt aLength)

//

// Discriminating key. Does a raw memory comparison on given length

//

	: iKeyOffset(0),iCmpType(ECmpNormal8),iKeyLength(aLength)

	{}

EXPORT_C TBtreeKey::TBtreeKey()

//

// Discriminating key. Does a raw memory comparison on variable length (byte counted)

//

	: iKeyOffset(0),iCmpType(ECmpCollated16+1+ECmpNormal8)

	{}

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

//

// Used to specify a variable length text key, the first character is a count of the actual character data that follows

//

	: iKeyOffset(anOffset),iCmpType(ECmpCollated16+aType+1)

	{

	switch (aType)

		{

	case ECmpNormal:

	case ECmpFolded:

	case ECmpCollated:

		Panic(EInvalidKeyComparison);

	default:

		break;

		}

	}

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

//

// Used for fixed length charecter data. the length is the character count, not the byte size

//

	: iKeyOffset(anOffset),iCmpType(aType),iKeyLength(aLength)

	{

	switch (aType)

		{

	case ECmpNormal:

	case ECmpFolded:

	case ECmpCollated:

		Panic(EInvalidKeyComparison);

	default:

		break;

		}

	}

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

	: iKeyOffset(anOffset),iCmpType(aType)

	{

	switch (aType)

		{

	case ECmpTInt:

	case ECmpTUint:

		Panic(EInvalidKeyComparison);

	default:

		break;

		}

	}

EXPORT_C const TAny* TBtreeKey::Key(const TAny* anEntry) const

	{

	return PtrAdd(anEntry,iKeyOffset);

	}

EXPORT_C TInt TBtreeKey::Compare(const TAny* aLeft,const TAny* aRight) const

//

// do the right thing

//

	{

	UPTR left;

	left.tany=aLeft;

	UPTR right;

	right.tany=aRight;

	switch (iCmpType)

		{

	case ECmpNormal8:

		return Mem::Compare(left.tuint8,iKeyLength,right.tuint8,iKeyLength);

	case ECmpFolded8:

		return Mem::CompareF(left.tuint8,iKeyLength,right.tuint8,iKeyLength);

	case ECmpCollated8:

		return Mem::CompareC(left.tuint8,iKeyLength,right.tuint8,iKeyLength);

	case ECmpNormal16:

		return Mem::Compare(left.tuint16,iKeyLength,right.tuint16,iKeyLength);

	case ECmpFolded16:

		return Mem::CompareF(left.tuint16,iKeyLength,right.tuint16,iKeyLength);

	case ECmpCollated16:

		return Mem::CompareC(left.tuint16,iKeyLength,right.tuint16,iKeyLength);

	case ECmpCollated16+ECmpNormal8+1:

		return Mem::Compare(left.tuint8+1,*left.tuint8,right.tuint8+1,*right.tuint8);

	case ECmpCollated16+ECmpFolded8+1:

		return Mem::CompareF(left.tuint8+1,*left.tuint8,right.tuint8+1,*right.tuint8);

	case ECmpCollated16+ECmpCollated8+1:

		return Mem::CompareC(left.tuint8+1,*left.tuint8,right.tuint8+1,*right.tuint8);

	case ECmpCollated16+ECmpNormal16+1:

		return Mem::Compare(left.tuint16+1,*left.tuint16,right.tuint16+1,*right.tuint16);

	case ECmpCollated16+ECmpFolded16+1:

		return Mem::CompareF(left.tuint16+1,*left.tuint16,right.tuint16+1,*right.tuint16);

	case ECmpCollated16+ECmpCollated16+1:

		return Mem::CompareC(left.tuint16+1,*left.tuint16,right.tuint16+1,*right.tuint16);

	case ECmpTInt8:

		return *left.tint8-*right.tint8;

	case ECmpTUint8:

		return TInt(*left.tuint8)-TInt(*right.tuint8);

	case ECmpTInt16:

		return *left.tint16-*right.tint16;

	case ECmpTUint16:

		return TInt(*left.tuint16)-TInt(*right.tuint16);

	case ECmpTInt32:

		if (*left.tint32<*right.tint32) 

			return -1;

		if (*left.tint32>*right.tint32) 

			return 1;

		break;	   

	case ECmpTUint32:

		if (*left.tuint32<*right.tuint32)

			return -1;

		if (*left.tuint32>*right.tuint32)

			return 1;

		break;

	case ECmpTInt64:

		if (*left.tint64<*right.tint64) 

			return -1;

		if (*left.tint64>*right.tint64) 

			return 1;

		break;	   

	default:

		break;

		}

	return 0;

	}

EXPORT_C void TBtreeKey::Between(const TAny* aLeft,const TAny*  /*aRight*/,TBtreePivot& aPivot) const

	{

//#pragma message( __FILE__ " : 'TBtreeKey::Between()' whizzy pivot generation not implemented" )

	UPTR left;

	left.tany=aLeft;

//	UPTR right=(UPTR)aRight;

	switch (iCmpType)

		{

	case ECmpNormal8:

	case ECmpFolded8:

	case ECmpCollated8:

		aPivot.Copy(left.tuint8,iKeyLength);

		break;

	case ECmpNormal16:

	case ECmpFolded16:

	case ECmpCollated16:

		aPivot.Copy(left.tuint8,iKeyLength<<1);

		break;

	case ECmpCollated16+ECmpNormal8+1:

	case ECmpCollated16+ECmpFolded8+1:

	case ECmpCollated16+ECmpCollated8+1:

		aPivot.Copy(left.tuint8,1+*left.tuint8);	// include length count

		break;

	case ECmpCollated16+ECmpNormal16+1:

	case ECmpCollated16+ECmpFolded16+1:

	case ECmpCollated16+ECmpCollated16+1:

		aPivot.Copy(left.tuint8,(1+*left.tuint16)<<1);	// include length count

		break;

	case ECmpTInt8:

		aPivot.Copy(left.tuint8,sizeof(TInt8));

		break;

	case ECmpTUint8:

		aPivot.Copy(left.tuint8,sizeof(TUint8));

		break;

	case ECmpTInt16:

		aPivot.Copy(left.tuint8,sizeof(TInt16));

		break;

	case ECmpTUint16:

		aPivot.Copy(left.tuint8,sizeof(TUint16));

		break;

	case ECmpTInt32:

		aPivot.Copy(left.tuint8,sizeof(TInt16));

		break;

	case ECmpTUint32:

		aPivot.Copy(left.tuint8,sizeof(TUint32));

		break;

	case ECmpTInt64:

		aPivot.Copy(left.tuint8,sizeof(TInt64));

		break;

	default:

		break;

		}

	}