// 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:

// attribute value processing

// 

//

#include <btsdp.h>

#include <es_sock.h>

#include "attrvalueencoded.h"

#include "MAttributeVisitor.h"

#include "sdputil.h"

#include "DataEncoder.h"

const TUint8 KDummyUUIDPointer = 0xff;

// ******************* CSdpAttrValue ********************************

CSdpAttrValue::CSdpAttrValue()

/** Default constructor. */

	{

	}

CSdpAttrValue::~CSdpAttrValue()

/** Destructor. */

	{

	}

void CSdpAttrValue::AcceptVisitorL(MSdpAttributeValueVisitor& aVisitor)

/** Request a call back to pass the attribute value.

When called on attributes that are not lists (not DEA or DES), then this calls 

MSdpAttributeValueVisitor::VisitAttributeValueL(), passing the attribute value 

object itself (i.e. *this), and the value attribute type.

It is more useful when called on a DES or DEA object, as it then provides 

a simple method of enumerating each attribute in a list.

@param aVisitor Abstract interface that can be implemented to receive an enumeration 

of the values in an attribute list.

@see CSdpAttrValueList::AcceptVisitorL()

@see MSdpAttributeValueVisitor::VisitAttributeValueL() */

	{

	aVisitor.VisitAttributeValueL(*this, Type());

	}

// Universal Getters

// Defaults are to Panic -- should only be called when overriden

TUint CSdpAttrValue::Uint() const

/** Gets an unsigned integer attribute value.

The base class implementation panics.

The size of the unsigned integer should be checked with DataSize() before calling.

@return Attribute value */

	{

	DbPanic(ESdpDbBadAttrValueGetter);

	return 0;

	}

/*

UIDs used by the Extension_ method for CSdpAttrValue to identify the function called.

@internalComponent

*/

const TUint KSdpAttrValueUint64FunctionId  = 0x1028654A;

const TUint KSdpAttrValueUint128FunctionId = 0x1028654B;

EXPORT_C void CSdpAttrValue::Uint64(TUint64& aValue) const

/**

Gets the value as an unsigned 64 bit integer

The size of the unsigned integer should be checked with DataSize() before calling.

@param aValue A 64 bit unsigned integer

*/

	{

	TAny* valuePtr = &aValue;

	const_cast<CSdpAttrValue*>(this)->Extension_(KSdpAttrValueUint64FunctionId, valuePtr, NULL);

	}

EXPORT_C void CSdpAttrValue::Uint128(TUint64& aLo, TUint64& aHi) const 

/**

Gets two TUint64s, one being the high 64 bits and one being the low 64 bits of a 128 bit integer

The size of the unsigned integer should be checked with DataSize() before calling.

@param aLo The unsigned 64 bit integer contains the lower bits of the 128 bit integer contained in the descriptor

@param aHi The unsigned 64 bit integer contains the higher bits of the 128 bit integer contained in the descriptor

*/

 	{

	TAny* loPtr = &aLo;

	TAny* hiPtr = &aHi;

	const_cast<CSdpAttrValue*>(this)->Extension_(KSdpAttrValueUint128FunctionId, loPtr, hiPtr);

 	}

TInt CSdpAttrValue::Int() const

/** Gets a signed integer attribute value.

The base class implementation panics.

@return Attribute value */

	{

	DbPanic(ESdpDbBadAttrValueGetter);

	return 0;

	}

TBool CSdpAttrValue::DoesIntFit() const

/** Tests if the attribute can be stored in an integer value.

The base class implementation returns EFalse.

@return True if the attribute can be stored in an integer value */

	{

	return EFalse;

	}

TInt CSdpAttrValue::Bool() const

/** Gets a Boolean attribute value.

The base class implementation panics.

@return Attribute value */

	{

	DbPanic(ESdpDbBadAttrValueGetter);

	return 0;

	}

const TUUID& CSdpAttrValue::UUID() const

/** Gets a UUID attribute value.

The base class implementation panics.

@return Attribute value */

	{

	DbPanic(ESdpDbBadAttrValueGetter);

	return *(TUUID*)(KDummyUUIDPointer);

	}

const TPtrC8 CSdpAttrValue::Des() const

/** Gets a data buffer attribute value.

The base class implementation panics.

@return Attribute value */

	{

	DbPanic(ESdpDbBadAttrValueGetter);

	return TPtrC8(0,0);

	}

/** 

The extension method provides a polymorphic behaviour to allow interface extension.

The base class implementation panics.

@internalComponent

*/

TInt CSdpAttrValue::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)   

    {

    TInt ret = KErrNone;

    switch(aExtensionId)

        {

        case KSdpAttrValueUint64FunctionId:

        case KSdpAttrValueUint128FunctionId:

            {

        	DbPanic(ESdpDbBadAttrValueGetter);

            }

            break;

        default:

            {

            // Chain to base class

            ret = CBase::Extension_(aExtensionId, a0, a1);

            }

            break;

        }

    return ret;

    }

// ******************* Concrete CSdpAttrValues ************************

// LIST

CSdpAttrValueList::CSdpAttrValueList(MSdpElementBuilder *aParent)

	: iParent(aParent)

	{

	}

void CSdpAttrValueList::ConstructL()

	{

    iList = new (ELeave) CArrayPtrFlat<CSdpAttrValue> (2);

	}

CSdpAttrValueList::~CSdpAttrValueList()

/** Destructor. */

	{

	if ( iList )

		{

		// Destroy all elements on this list

		iList->ResetAndDestroy();

		delete iList;

		}

	}

void CSdpAttrValueList::AcceptVisitorL(MSdpAttributeValueVisitor& aVisitor)

/** Requests a call back to pass the attribute value.

This provides a simple method of enumerating each element in the list.

@param aVisitor Abstract interface that can be implemented to receive an enumeration 

of the values in the attribute list. */

	{

	CSdpAttrValue::AcceptVisitorL(aVisitor);

	aVisitor.StartListL(*this);

	TInt items = iList->Count();

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

		{

		(*iList)[i]->AcceptVisitorL(aVisitor);

		}

	aVisitor.EndListL();

	}

TUint CSdpAttrValueList::DataSize() const

/** Gets the size of the list.

@return Size of the list (in bytes) */

	{

	TUint size = 0;

	for (TInt i = 0; i < iList->Count(); ++i)

		{

		size += TElementEncoder::EncodedSize((*iList)[i]->Type(), (*iList)[i]->DataSize());

		}

	return size;

	}

EXPORT_C void CSdpAttrValueList::AppendValueL(CSdpAttrValue* aValue)

/** Add a new value onto the end on this list.

Ownership of the passed value is transferred to this list. It will be deleted 

when the list is destroyed.

If a leave occurs, aValue will be cleanup up automatically 

@param aValue Attribute value to be added onto this list. */

	{

	CleanupStack::PushL(aValue);

	iList->AppendL(aValue);

	CleanupStack::Pop(); // aValue

	}

MSdpElementBuilder* CSdpAttrValueList::BuildStringL(const TDesC8& aString)

/** Adds a Text String element.

@internalTechnology

@param aString Attribute to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueString::NewStringL(aString);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildBooleanL(TBool aBool)

/** Adds a Boolean element.

@internalTechnology

@param aBool Attribute to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueBoolean::NewBoolL(aBool);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildDESL()

/** Adds a Data element sequence (DES).

@internalTechnology

This should be followed by a call to StartListL(), and then calls to add elements 

to the list.

@return This attribute value with added element */

	{

	CSdpAttrValueList *val=CSdpAttrValueDES::NewDESL(this);

	AppendValueL(val);

	return val;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildDEAL()

/** Adds a Data element alternative (DEA).

@internalTechnology

This should be followed by a call to StartListL(), and then calls to add elements 

to the list.

@return This attribute value with added element */

	{

	CSdpAttrValueList *val=CSdpAttrValueDEA::NewDEAL(this);

	AppendValueL(val);

	return val;

	}

MSdpElementBuilder* CSdpAttrValueList::StartListL()

/** Indicates that subsequent elements added belong to a DES or DEA.

@internalTechnology

The end of the list should be indicated by a call to EndList().

@return This attribute value */

	{

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::EndListL()

/** Indicates the end of a list started by StartListL().

@internalTechnology

@return Parent of this attribute value */

	{

	return iParent;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildUnknownL(TUint8 /*aType*/, TUint8 /*aSizeDesc*/, const TDesC8& /*aData*/)

/** Does nothing.

@internalTechnology

@return This attribute value */

	{

	//CSdpAttrValue *val=CSdpAttrValueUnknown::NewUnknownL(aType,aSizeDesc,aData);

	//AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildNilL()

/** Adds a null type element.

@internalTechnology

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueNil::NewNilL();

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildUintL(const TDesC8& aUint)

/** Adds an unsigned integer element.

@internalTechnology

@param aUint Attribute to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueUint::NewUintL(aUint);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildIntL(const TDesC8& aInt)

/** Adds a signed integer element.

@internalTechnology

@param aInt Attribute to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueInt::NewIntL(aInt);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildUUIDL(const TUUID& aUUID)

/** Adds a UUID element.

@internalTechnology

@param aUUID Attribute to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueUUID::NewUUIDL(aUUID);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildURLL(const TDesC8& aString)

/** Adds a URL element.

@internalTechnology

@param aString URL to add

@return This attribute value with added element */

	{

	CSdpAttrValue *val=CSdpAttrValueURL::NewURLL(aString);

	AppendValueL(val);

	return this;

	}

MSdpElementBuilder* CSdpAttrValueList::BuildEncodedL(const TDesC8& aString)

/** Encode an attribute value.

@internalTechnology

@param aString The attribute value.

@return This attribute value. */

	{

	CSdpAttrValue* val=CSdpAttrValueEncoded::NewEncodedL(aString);

	AppendValueL(val);

	return this;

	}

// NIL

EXPORT_C CSdpAttrValueNil* CSdpAttrValueNil::NewNilL()

/** Allocates and constructs a new CSdpAttrValueNil object.

@return New CSdpAttrValueNil */

	{

	CSdpAttrValueNil* val=new (ELeave) CSdpAttrValueNil();

	return val;

	}

CSdpAttrValueNil::CSdpAttrValueNil()

	{

	}

CSdpAttrValueNil::~CSdpAttrValueNil()

/** Destructor. */

	{

	}

TSdpElementType CSdpAttrValueNil::Type() const

/** Gets the type of the attribute (always ETypeNil).

@return Type of the attribute */

	{

	return ETypeNil;

	}

TUint CSdpAttrValueNil::DataSize() const

/** Gets the size of the attribute (always 0).

@return Size of the attribute (in bytes). */

	{

	return 0;

	}

// UINT

EXPORT_C CSdpAttrValueUint* CSdpAttrValueUint::NewUintL(const TDesC8 &aUint)

/** Allocates and constructs a new CSdpAttrValueUint object.

@param aUint Buffer containing an unsigned integer value for the attribute

@return New CSdpAttrValueUint object */

	{

	if(aUint.Size()>KSdpMaxUintSize)

		{

		//Check less than or equal to 16 bytes = 128 bits

		User::Leave(KErrArgument);

		}

	CSdpAttrValueUint* val=new (ELeave) CSdpAttrValueUint(aUint);

	return val;

	}

/**

Replaces the current value. 

@param aValue The new value.  The provided value must not exceed KSdpMaxUintSize.

@panic USER 23 if the supplied value is too long.

*/

EXPORT_C void CSdpAttrValueUint::SetUintValue(const TDesC8& aValue)

	{

	// Copies data into iBuffer

	iUint = aValue;

	}

CSdpAttrValueUint::CSdpAttrValueUint(const TDesC8 &aUint)

	: iUint(aUint)

	{

	__ASSERT_DEBUG(aUint.Size()<=KSdpMaxUintSize, User::Panic(_L("CSdpAttrValueUint Constructor"), KErrArgument));

	}

CSdpAttrValueUint::~CSdpAttrValueUint()

/** Destructor. */

	{

	}

TSdpElementType CSdpAttrValueUint::Type() const

/** Gets the attribute type.

@return Attribute type. Always ETypeUint. */

	{

	return ETypeUint;

	}

TUint CSdpAttrValueUint::DataSize() const

/** Gets the size of the attribute.

@return Size of the attribute in bytes */

	{

	return iUint.Length();

	}

TUint CSdpAttrValueUint::Uint() const

/** Gets the value as an unsigned integer type.

The size of the unsigned integer should be checked with DataSize() before calling.

@return Attribute value */

	{

	return SdpUtil::GetUint(iUint);

	}

TBool CSdpAttrValueUint::DoesIntFit() const

/** Tests if the attribute can be stored in an integer value.

@return True if the attribute can be stored in an integer value */

	{

	return (iUint.Length()>16)?EFalse:ETrue;

	}