// 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 "ExtractorVisitor.h"

#include <btsdp.h>

#include "DataEncoder.h"

#include "SDPDatabase.h"

#include "sdputil.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_SDPDATABASE);

#endif

#ifdef _DEBUG

PANICCATEGORY("extrvst");

#endif

CAttrExtractVisitor *CAttrExtractVisitor::NewLC(TElementEncoder aEncoder)

	{

	CAttrExtractVisitor *self = new(ELeave) CAttrExtractVisitor(aEncoder);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CAttrExtractVisitor *CAttrExtractVisitor::NewL(TElementEncoder aEncoder)

	{

	CAttrExtractVisitor *self = CAttrExtractVisitor::NewL(aEncoder);

	CleanupStack::Pop();

	return self;

	}

CAttrExtractVisitor::CAttrExtractVisitor(TElementEncoder aEncoder)

	: iEncoder(aEncoder)

	{

	}

void CAttrExtractVisitor::ConstructL()

	{

	}

CAttrExtractVisitor::~CAttrExtractVisitor()

	{

	}

// the only entry to this class - creates an instance of itself and then calls the FindAttributes

// method of aList on the record supplied.

EXPORT_C void CAttrExtractVisitor::EncodeAttributesL(TElementEncoder aEncoder, CSdpServRecord &aRec, CSdpAttrIdMatchList &aList)

/**	Encode attributes in aRec that are in the match list aList, using aEncoder.*/

	{

	CAttrExtractVisitor *self = CAttrExtractVisitor::NewLC(aEncoder);

	TRAPD(err, aList.FindAttributesL(aRec, *self));

	// If we ran out of buffer space, a positive leave will have happened in VisitAttributeValueL, below

	// else, the leave was an error, which should be re-thrown

	if (err < 0)

		User::Leave(err);

	CleanupStack::PopAndDestroy(/*self*/);

	}

void CAttrExtractVisitor::AttributeInMatchListL(CSdpAttr &aAttr)

	{

	aAttr.AcceptVisitorL(*this);

	}

void CAttrExtractVisitor::VisitAttributeL(CSdpAttr &aAttribute)

	{

	//FIXME check rem

	iEncoder.WriteUint(aAttribute.AttributeID(), sizeof(TSdpAttributeID));

	}

void CAttrExtractVisitor::VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)

	{

	TUint rem=0;

	switch(aType)

		{

	case ETypeNil:

		rem = iEncoder.WriteNil();

		break;

	case ETypeUint:

	case ETypeInt:

	case ETypeUUID:

	case ETypeString:

	case ETypeURL:

		rem = iEncoder.WriteElement(aType, aValue.Des());

		break;

	case ETypeBoolean:

		rem = iEncoder.WriteBoolean(aValue.Int());

		break;

	case ETypeDES:

		rem = iEncoder.WriteDES(aValue.DataSize());

		break;

	case ETypeDEA:

		rem = iEncoder.WriteDEA(aValue.DataSize());

		break;

	case ETypeEncoded:

		rem= iEncoder.WriteDesc(aValue.Des());

		break;

		}

	if (rem)

		User::Leave(rem);

	}

void CAttrExtractVisitor::StartListL(CSdpAttrValueList &/*aList*/)

	{

	}

void CAttrExtractVisitor::EndListL()

	{

	}

//

// CSdpAttrIdMatchList

//

CSdpAttrIdMatchList::CSdpAttrIdMatchList()

	{

	}

EXPORT_C CSdpAttrIdMatchList* CSdpAttrIdMatchList::NewL()

/** Allocate and construct a new CSdpAttrIdMatchList object.

@return New CSdpAttrIdMatchList object */

	{

	CSdpAttrIdMatchList* self = new (ELeave) CSdpAttrIdMatchList;

	CleanupStack::PushL(self);

	self->iList = new (ELeave) CArrayFixFlat<TAttrRange> (2);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSdpAttrIdMatchList* CSdpAttrIdMatchList::NewL(const CSdpAttrIdMatchList& aAttrMatchList)

/** Allocate and construct a new CSdpAttrIdMatchList object as a copy of another 

CSdpAttrIdMatchList.

@param aAttrMatchList Object to copy

@return New CSdpAttrIdMatchList object */

	{

	CSdpAttrIdMatchList* self = new (ELeave) CSdpAttrIdMatchList;

	CleanupStack::PushL(self);

	self->iList = new (ELeave) CArrayFixFlat<TAttrRange> (2);

	static_cast<CArrayFixFlat<TAttrRange>*>(self->iList)->SetReserveL(aAttrMatchList.Count());

	for(TInt i = 0; i < aAttrMatchList.Count(); ++i)

		{

		self->AddL((aAttrMatchList.iList)->At(i));

		}

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSdpAttrIdMatchList::~CSdpAttrIdMatchList()

/** Destructor. */

	{

	delete iList;

	}

EXPORT_C void CSdpAttrIdMatchList::AddL(TAttrRange aRange)

/** Adds a range of IDs to the list.

@param aRange Range to add */

	{

	if (aRange.iStart > aRange.iEnd)

		{// Bad range

		User::Leave(KErrArgument);

		}

	// Look for insertion point (pos) in the match list. 

	TInt pos = 0; 	// this new item will start the list unless we find an existing

					// range for it to overlap or follow

	// If the start of the range 'aRange' is contiguous with one of the existing match list ranges

	// then the insertion point is the index of that match list range.

	// If not it is one more than the index of the match list range that

	// precedes 'aRange'.

	// N.B. The ranges are stored in ascending order

	TBool bPositionFound = EFalse;

	TBool bStartInRangeOrContiguous = EFalse;	

	// Find the first position in the list in which (or contiguous with) this range lies

	if (FindInOrContiguousWith(aRange.iStart, pos) == 0)

		{

		// the start of this new range overlaps with an existing one (returned in pos) or is contiguous with it

		bPositionFound = ETrue;

		bStartInRangeOrContiguous = ETrue;

		}	

	else

		{

		// find which range this new one will be after

		for (TInt i=iList->Count()-1; i>=0 && !bPositionFound; i-- )

			{

			if (aRange.iStart > (iList->At(i).iEnd + 1 ))

				{

				pos = i+1;

				bPositionFound = ETrue;

				}

			}

		}

	TAttrRange *insert;

	if (bStartInRangeOrContiguous)

		{// Don't actually insert new entry, just grow the existing entry

		insert = &iList->At(pos);

		// NB If the range to add has a start ID which is one less than the current start of range, 

		// the range may grow "downwards", but will never join up with the preceding range because

		// the start ID is known not to be contiguous with THAT range.

		insert->iStart = Min(insert->iStart, aRange.iStart); 

		insert->iEnd = Max(insert->iEnd, aRange.iEnd);

		}

	else

		{// Add a new entry

		iList->InsertL(pos, aRange);

		insert = &iList->At(pos);

		}

	while (pos < iList->Count()-1 && insert->IsContiguousWith(iList->At(pos+1).iStart) )

		{// There's now overlap with following item

		insert->iEnd = Max(insert->iEnd, iList->At(pos+1).iEnd);

		iList->Delete(pos+1);	// which leaves a new range to be checked at (pos+1), so no incrementing of pos is required	

		}

	__TEST_INVARIANT;

	}

EXPORT_C void CSdpAttrIdMatchList::RemoveL(TAttrRange aRange)

/** Removes a range of IDs from the list.

@param aRange Range to remove */

	{

	if (aRange.iStart > aRange.iEnd)

		{// Bad range

		User::Leave(KErrArgument);

		}

	TInt pos = 0; // the deletion point	

	TAttrRange *trim;

	// Find position for the start of the exclude range - is it partway through a current range?

	if ((Find(aRange.iStart, pos) == 0) && (aRange.iStart > (&iList->At(pos))->iStart))

		{

		// Trim a bit off this entry

		trim = &iList->At(pos);

		if (trim->iEnd > aRange.iEnd)

			{

			//It's bigger. Need to split in two

			// Grow first, in case it fails

			iList->InsertL(pos+1, TAttrRange(TSdpAttributeID(aRange.iEnd+1), trim->iEnd));

			trim->iEnd = TSdpAttributeID(aRange.iStart - 1);

			__TEST_INVARIANT;

			return;	// We know this remove range is fully handled now

			}

		trim->iEnd = TSdpAttributeID(aRange.iStart - 1);

		}

	// whether or not the trimming has already started, now move through the rest of the ranges	

	// removing entire entries which lie within the deletion range.

	while (pos < iList->Count() && (aRange.iEnd >= iList->At(pos).iEnd))

		{

		if (aRange.iStart <= iList->At(pos).iStart) 

			{

			// This complete item is not needed

			iList->Delete(pos);		

			}

		else

			{

			// this item is not affected, because we have not yet got to the start of the exclude range

			pos++; 

			}	 

		}

	// Does the end of the deletion range lie within this entry?

	if ( pos < iList->Count() )

		{

		trim = &iList->At(pos);

		if ((trim->iStart >= aRange.iStart) && (trim->iStart <= aRange.iEnd))

			{// The following item is too long -- trim it

			trim->iStart = TSdpAttributeID(aRange.iEnd + 1);

			}

		}

	__TEST_INVARIANT;

	}

TInt CSdpAttrIdMatchList::Find(TSdpAttributeID aAttrId, TInt &aPos) const

/** Tests if the specified attribute ID is in the list, and gets its position.

@param aAttrId Attribute ID to test

@param aPos Position of ID in the list, or unchanged if attribute not found

@return KErrNone if the attribute is in the list, else KErrNotFound */

	{

	__TEST_INVARIANT;

	TAttrRange searchRange;

	TBool bAttribInRange = EFalse;

	TInt ret=KErrNotFound;

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

 		{

 		searchRange = iList->At(i);

 		if (searchRange.IsInRange(aAttrId) )

 			{

 			bAttribInRange = ETrue;

 			aPos = i;

 			ret = KErrNone;

 			}

 		}

	return ret;	

	}

TInt CSdpAttrIdMatchList::FindInOrContiguousWith(TSdpAttributeID aAttrId, TInt &aPos) const

/** Tests if the specified attribute ID is in the list (or next to a range in the list), and gets its position.

@param aAttrId Attribute ID to test

@param aPos Position in the list if the ID is found in a current range, or the lowest range with which the ID is contiguous, or unchanged if neither.

@return KErrNone if the attribute is in the list, else KErrNotFound */

	{

	__TEST_INVARIANT;

	TAttrRange searchRange;

	TBool bAttribInRange = EFalse;

	TInt ret=KErrNotFound;

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

 		{

 		searchRange = iList->At(i);

 		if (searchRange.IsContiguousWith(aAttrId) )

 			{

 			bAttribInRange = ETrue;

 			aPos = i;

 			ret = KErrNone;

 			}

 		}

	return ret;	

	}

EXPORT_C TBool CSdpAttrIdMatchList::InMatchList(TSdpAttributeID aAttrId, TInt &aPos) const

/** Tests if the specified attribute ID is in the list, and gets its position.

	Do not use this - it gives an off-by-one error for aPos

	unless the attribute is the first one in a contiguous range.

	Use InMatchListRange() instead

@param aAttrId Attribute ID to test

@param aPos Position of ID in the list with an off-by-one error for IDs not at the start of a range, or 0 if not found

@return ETrue if the attribute is in the list, else EFalse */

	{

	TKeyArrayFix key (_FOFF(TAttrRange, iStart), ECmpTUint16);

	TAttrRange search(aAttrId);

	TInt ret = iList->FindIsq(search, key, aPos);

	return (ret == 0) || (aPos > 0 && iList->At(aPos-1).IsInRange(aAttrId));

	}

EXPORT_C TBool CSdpAttrIdMatchList::InMatchListRange(TSdpAttributeID aAttrId, TInt &aRange) const

	{

/* Tests if the specified attribute ID is in the list, and gets its position.

Param aAttrId: Attribute ID to test

Param aPos: Position of ID in the list, or 0 if not found

Returns ETrue if the attribute is in the list, else EFalse */

	aRange = 0;	// will not be changed unless the attribute has a match in the list

	TBool bAttribInRange = EFalse;

	TInt ret = Find(aAttrId, aRange);

	if (ret == KErrNone)	

		{

		bAttribInRange = ETrue;  

		}

	return bAttribInRange;

	}

EXPORT_C TUint CSdpAttrIdMatchList::EncodeL(TElementEncoder aEncoder) const

/** Supplies encoder with attribute Ids in the match list

@param aEncoder The encoder set to encode the attribute Ids in this match list

@return Number of bytes of this CSdpAttrIdMatchList for which there was NO space in the encoder

*/

	{

	TUint size = 0;

	TInt i;

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

		{

		TAttrRange& range = (*iList)[i];

		if (range.iStart == range.iEnd)

			size += 3; // 2 byte uint + header

		else

			size += 5; // 4 byte uint + header

		}

	TInt rem = aEncoder.WriteDES(size);

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

		{

		TAttrRange& range = (*iList)[i];

		if (range.iStart == range.iEnd)

			{

			rem += aEncoder.WriteUint(range.iStart, 2);

			}

		else

			{

			rem += aEncoder.WriteUint((range.iStart << 16) | range.iEnd, 4);

			}

		}	

	return rem;

	}

EXPORT_C TBool CSdpAttrIdMatchList::InMatchList(TSdpAttributeID aAttrId) const

	{

	TInt pos;

	return InMatchListRange(aAttrId, pos);

	}

EXPORT_C TInt CSdpAttrIdMatchList::Count() const

	{

	return iList->Count();

	}

void CSdpAttrIdMatchList::FindAttributesL(CSdpServRecord &aRec, MAttributeMatchHandler &aHandler) const

	{

	for(TServAttrIter attrIter(aRec.AttributeIter()); attrIter; attrIter++)

		{// Iterate thru attributes in record

		if (InMatchList((*attrIter).AttributeID()))

			{// this attribute is is the list -- signal it

			aHandler.AttributeInMatchListL(*attrIter);

			}

		}

	}

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

/** This should be one or two 16 bit integers, representing an AttrId of range thereof respectively. */

	{

	TInt len = aUint.Length();

	if (len != 2 && len != 4)

		{// Bad Uint size

		User::Leave(KErrCorrupt);

		}

	// Get either the two or four byte version

	TUint attrId = SdpUtil::GetUint(aUint);

	TAttrRange range;

	range.iStart = TUint16(len == 4 ? attrId >> 16 : attrId);

	range.iEnd = TUint16(attrId);

	// Add in place (optimised for incoming stream ordered -- but we will cope if isn't

	// Will leave if a bad range is supplied

	AddL(range);

	return this;

	}

MSdpElementBuilder* CSdpAttrIdMatchList::BuildDESL()

	{

	// Could assert we only get one of these

	return this;

	}

MSdpElementBuilder* CSdpAttrIdMatchList::StartListL()

	{

	return this;

	}

MSdpElementBuilder* CSdpAttrIdMatchList::EndListL()

/**	Attribute list now complete. Stop the parser by returning 0. */

	{

	return 0;

	}

EXPORT_C void CSdpAttrIdMatchList::__DbgTestInvariant() const

	{

#ifdef _DEBUG

	TInt count = iList->Count();

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

		{

		TAttrRange& range = iList->At(i);

		ASSERT_DEBUG(range.iStart <= range.iEnd);

		if (i < count - 1)

			{

			ASSERT_DEBUG(range.iEnd + 1 < iList->At(i+1).iStart);

			}

		}

#endif

	}