// Copyright (c) 2004-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:

//

/**

 @file

 @internalComponent

*/

#include "bttypes.h" 

enum TBTDevAddrPanics

	{

	EBTDevAddrBadDescriptor = 0,

	EBTDevAddrBadTInt64 = 1,

	};

void Panic(TBTDevAddrPanics aCode)

	{

	_LIT(KPanicName, "BTDevAddr");

	User::Panic(KPanicName, aCode);

	}

/** 

Default constructor.

The address is initialised to 0. 

*/

EXPORT_C TBTDevAddr::TBTDevAddr()

	{

	Reset();

	}

/** 

Constructs a device address from a data buffer.

The buffer is copied directly into the object. The function panics if aDes 

does not have a length of 6 bytes (48 bits).

@param aDes Data buffer for device address 

*/

EXPORT_C TBTDevAddr::TBTDevAddr(const TDesC8 &aDes)

	{

	__ASSERT_ALWAYS(aDes.Length() == KBTDevAddrSize, Panic(EBTDevAddrBadDescriptor));

	Mem::Copy(&iAddr[0], aDes.Ptr(), KBTDevAddrSize);

	}

/** 

Constructs a device address from a TInt64.

The function panics if the most significant 16 bits of aInt are non-zero, 

as device addresses are 48 bits in size. 

@param aInt Value for device address. 

*/

EXPORT_C TBTDevAddr::TBTDevAddr(const TInt64 &aInt)

	{

	__ASSERT_ALWAYS( (I64HIGH(aInt) & 0xffff0000u) == 0, Panic(EBTDevAddrBadTInt64));

	TInt64 int64 (aInt);

	for (TInt i = KBTDevAddrSize-1; i>=0; --i)

		{

		iAddr[i] = TUint8(I64LOW(int64));

		int64 >>= 8;

		}

	}

/** 

Convert Readable string into a dev addr.

Address may have leading space and "0x" characters.

@param	aSource	Readable Hex representation of address

@return EPOC error code on fail, or else number of characters used from aSource in conversion

**/

EXPORT_C TInt TBTDevAddr::SetReadable(const TDesC& aSource)

	{

	TLex lex(aSource);

	lex.SkipSpaceAndMark();

	if (lex.Get() != '0' || lex.Get() != 'x')

		lex.UnGetToMark();

	TInt64 addr;

	TInt ret = lex.Val(addr, EHex);

	if (ret)

		return ret;

	if (addr > MAKE_TINT64(0x0000ffffu,0xffffffffu))

		return KErrOverflow;

	*this=TBTDevAddr(addr);

	return lex.Offset();

	}

/** 

Extract the Bluetooth device address into a human-readable format, in aDest.

Output is in hexadecimal bigendian format, with optional padding characters.

Note: aDest must be large enough to hold the entire output, or else a

a panic will occur.

@param aDest Descriptor where result is placed.

@param aPrepend Added onto front of output.

@param aByteSeperator Inserted between each byte of address.

@param aAppend Added onto end of output.

*/

EXPORT_C void TBTDevAddr::GetReadable(TDes& aDest, const TDesC& aPrepend, const TDesC& aByteSeperator, const TDesC& aAppend) const

	{

	__ASSERT_ALWAYS(aDest.MaxLength() >= aPrepend.Length() + (KBTDevAddrSize * (2 + aByteSeperator.Length())) - aByteSeperator.Length() + aAppend.Length(), Panic(EBTDevAddrBadDescriptor));

	_LIT(KReadableFormat, "%S%02x%S%02x%S%02x%S%02x%S%02x%S%02x%S");

	aDest.Format(KReadableFormat, &aPrepend, 

				 iAddr[0], &aByteSeperator, 

				 iAddr[1], &aByteSeperator, 

				 iAddr[2], &aByteSeperator, 

				 iAddr[3], &aByteSeperator, 

				 iAddr[4], &aByteSeperator, 

				 iAddr[5], &aAppend);

	}

/**

Comparison operator.

@param aAddr The device address to compare to this object.

@return ETrue if the addresses are equal, EFalse if not.

*/

EXPORT_C TBool TBTDevAddr::operator==(const TBTDevAddr& aAddr) const

	{

	return Mem::Compare(&iAddr[0],KBTDevAddrSize,&aAddr.iAddr[0],KBTDevAddrSize) == 0;

	}

/**

Inequality operator.

@param aAddr The device address to compare to this object.

@return EFalse if the addresses are equal, ETrue if not.

*/

EXPORT_C TBool TBTDevAddr::operator!=(const TBTDevAddr& aAddr) const

	{

	return !(*this==aAddr);

	}

/**

Access a single element of the address.

@param aIndex The index of the element to access.

@return The element.  The reference remains valid as long as this object is in scope.

*/

EXPORT_C const TUint8 &TBTDevAddr::operator[](TInt aIndex) const

	{

	return iAddr[aIndex];

	}

/**

Access a single element of the address.

@param aIndex The index of the element to access.

@return The element.  The reference remains valid as long as this object is in scope.

*/

EXPORT_C TUint8 &TBTDevAddr::operator[](TInt aIndex)

	{

	return iAddr[aIndex];

	}

/**

Reset the data contained within the object.

*/

EXPORT_C void TBTDevAddr::Reset()

	{

	iAddr.Reset();

	}

/**

Access value as a bigendian descriptor.

@return A non-const descriptor.

*/

EXPORT_C TPtr8 TBTDevAddr::Des()

	{

	return TPtr8(&iAddr[0], KBTDevAddrSize, KBTDevAddrSize);

	}

/**

Access value as a bigendian descriptor.

@return A const descriptor.

*/

EXPORT_C const TPtrC8 TBTDevAddr::Des() const

	{

	return TPtrC8(&iAddr[0], KBTDevAddrSize);

	}

/** 

Extract the Bluetooth device address into a human-readable format, in aDest.

Output is in hexadecimal bigendian format, with no padding characters.

Note: aDest must be large enough to hold the entire output, or else a

a panic will occur.

@param aDest Descriptor where result is placed.

**/

EXPORT_C void TBTDevAddr::GetReadable(TDes& aDest) const

	{

	GetReadable(aDest, KNullDesC, KNullDesC, KNullDesC);

	}

/**

Less than operator.

@param aAddr The device address to compare to this object.

@return EFalse if the aAddr is greater than this TBTDevAddr, ETrue if not.

*/

EXPORT_C TBool TBTDevAddr::operator<=(const TBTDevAddr& aAddr) const

	{

	for (TUint index = 0; index < KBTDevAddrSize; index++)

		{

		if (iAddr[index] < aAddr.iAddr[index])

			{

			return ETrue;

			}

		if (iAddr[index] > aAddr.iAddr[index])

			{

			return EFalse;

			}

		}

	// addresses are the same

	return ETrue;

	}

// EOF