// Copyright (c) 2000-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 <bluetooth/logger.h>

#include <es_sock.h>

#include "DataEncoder.h"

#include "sdputil.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_SDPDATABASE);

#endif

#ifdef _DEBUG

PANICCATEGORY("dataenc");

#endif

EXPORT_C TElementEncoder::TElementEncoder(TDes8& aWriteBuffer)

: iWriteBuf(aWriteBuffer)

	{

	}

EXPORT_C TInt TElementEncoder::WriteNil()

	{

	return WriteHeader(ETypeNil, 0);

	}

EXPORT_C TInt TElementEncoder::WriteUint(const TDesC8& aUint)

	{

	return WriteElement(ETypeUint, aUint);

	}

EXPORT_C TInt TElementEncoder::WriteUint(TUint aVal, TInt aNumberOfBytes)

	{

	TBuf8<sizeof(aVal)> val(aNumberOfBytes);

	PutUint(&val[0], aVal, aNumberOfBytes);

	return WriteUint(val);

	}

EXPORT_C TInt TElementEncoder::WriteInt(const TDesC8& aInt)

	{

	return WriteElement(ETypeInt, aInt);

	}

EXPORT_C TInt TElementEncoder::WriteInt(TInt aVal, TInt aNumberOfBytes)

	{

	TBuf8<sizeof(aVal)> val(aNumberOfBytes);

	PutUint(&val[0], static_cast<TInt>(aVal), aNumberOfBytes);

	return WriteInt(val);

	}

EXPORT_C TInt TElementEncoder::WriteUUID(const TUUID& aUUID)

	{

	return WriteElement(ETypeUUID, aUUID.Des());

	}

EXPORT_C TInt TElementEncoder::WriteString(const TDesC8& aString)

	{

	return WriteElement(ETypeString, aString);

	}

EXPORT_C TInt TElementEncoder::WriteBoolean(TBool aBoolean)

	{

	TBuf8<1> val(1);

	val[0] = TUint8(aBoolean ? 1 : 0);

	return WriteElement(ETypeBoolean, val);

	}

EXPORT_C TInt TElementEncoder::WriteDES(TUint aDataSize)

	{

	return WriteHeader(ETypeDES, aDataSize);

	}

EXPORT_C TInt TElementEncoder::WriteDEA(TUint aDataSize)

	{

	return WriteHeader(ETypeDEA, aDataSize);

	}

EXPORT_C TInt TElementEncoder::WriteURL(const TDesC8 &aUrl)

	{

	return WriteElement(ETypeURL, aUrl);

	}

EXPORT_C TInt TElementEncoder::WriteElement(TSdpElementType aType, const TDesC8 &aData)

	{

	TInt n = WriteHeader(aType, aData.Length());

	return n + WriteDesc(aData);

	}

EXPORT_C TInt TElementEncoder::WriteHeader(TSdpElementType aType, TUint aDataSize)

	{

	TUint headLen = HeaderSize(aType, aDataSize);

	ASSERT_DEBUG(headLen < 6);

	TBuf8<5> header(headLen);

	header[0] = TUint8(aType << 3 | SizeDescriptor(aType, aDataSize));

	if (headLen > 1)

		{// Write out the additional size bytes

		PutUint(&header[1], aDataSize, headLen-1);

		}

	return WriteDesc(header);

	}

EXPORT_C TInt TElementEncoder::WriteDesc(const TDesC8 &aDesc)

/**

	Append descriptor onto the write buffer.

	returns the number of bytes that did NOT fit into the write buffer.

**/

	{

	TInt remSpace = iWriteBuf.MaxLength() - iWriteBuf.Length();

	TInt writeLen = Min(aDesc.Length(), remSpace);

	iWriteBuf.Append(aDesc.Left(writeLen));

	return aDesc.Length() - writeLen;

	}

EXPORT_C void TElementEncoder::PutUint(TUint8* aPtr, TUint aUint, TInt aNumberOfBytes)

	{

	TUint test = aNumberOfBytes == 4 ? 1 : !(aUint & (0xffffffff << (aNumberOfBytes * 8)));

	__ASSERT_ALWAYS(test,

					DbPanic(ESdpAttrValueBadSize));

	switch(aNumberOfBytes)

		{

	case 4:

		*aPtr++ = TUint8(aUint>>24);

	case 3:

		*aPtr++ = TUint8(aUint>>16);

	case 2:

		*aPtr++ = TUint8(aUint>>8);

	case 1:

		*aPtr = TUint8(aUint);

		break;

	default:

		DbPanic(ESdpAttrValueBadSize);

		}

	}

EXPORT_C TSdpElementSizeDesc TElementEncoder::SizeDescriptor(TSdpElementType aType, TUint aDataSize)

	{

	__ASSERT_ALWAYS(aType < TInt(sizeof(KSdpElementValidSizes)), DbPanic(ESdpAttrValueBadSize));

	if (aType == ETypeBoolean && aDataSize == 1)

		return ESizeOneByte;

	if (aType == ETypeNil && aDataSize == 0)

		return ESizeOneByte;

	TUint8 validSizes = KSdpElementValidSizes[aType];

	if (validSizes&0x1f)

		{

		//if size is in range [0,4] and aType is not Nil

		//then aDataSize should be non-zero.

		//Indeed the logic in the loop below the "__ASSERT"

		//fails for aDataSize = 0...

		__ASSERT_DEBUG(aDataSize, DbPanic(ESdpAttrValueBadSize)); 

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

			{

			if (TUint((1<<i)&validSizes) == aDataSize)

				return TSdpElementSizeDesc(i);

			}

		}

	if (validSizes&0xe0)

		{

		for (TInt i=ESizeOneAdditional; i <= ESizeFourAdditional; ++i)

			{

			if ((aDataSize >> (8*(i-(ESizeOneAdditional-1))) == 0) && TUint((1<<i)&validSizes))

				return TSdpElementSizeDesc(i);

			}

		}

	DbPanic(ESdpAttrValueBadSize);

	return ESizeOneByte;

	}

EXPORT_C TInt TElementEncoder::HeaderSize(TSdpElementType aType, TUint aDataSize)

	{

	TInt sizeDesc = SizeDescriptor(aType, aDataSize);

	return 1 + (sizeDesc >= 5 ? 1<<(sizeDesc-5) : 0);

	}

EXPORT_C TInt TElementEncoder::EncodedSize(TSdpElementType aType, TUint aDataSize)

	{

	return HeaderSize(aType, aDataSize) + aDataSize;

	}