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

// Implementation of CMatchData class

// 

//

/**

 @file 

 @publishedAll

 @released

*/

#include <xml/matchdata.h>

#include <xml/xmlframeworkerrors.h>

using namespace Xml;

/**

The maximum length of variant field

@internalComponent

*/

const TInt KXmlMaxVariantLength = 32;

/**

The maximum length of mime type field

@internalComponent

*/

const TInt KXmlMaxMimeTypeLength = 255;

/**

Fields separator for data and opaque data in resource information file

@internalComponent

*/

_LIT8(KXmlDataSeparator, "||");

/**

Set flag macro to simplify bitmap management

@internalComponent

*/

#define SYMBIAN_XML_FLAG_SET(bitmap, flag, setting) \

			bitmap = setting?(bitmap|flag):(bitmap&(~flag))

/**

Rom only flag

To request for rom based parsers only

Default value is FALSE

@internalComponent

*/ 

const TInt32 KXmlRomOnlyFlag = 0x00000001;

/**

Case Sensitivity flag

To specify how case sensitivity should be applied, while performing strings matching

Default value is TRUE

@internalComponent

*/

const TInt32 KXmlCaseSensitivityFlag = 0x00000002;

/**

Leave on many flag

To leave when the query is narrowed down to more than one parser.

If not set, the XML framework will choose a parser.

Default value is FALSE

@internalComponent

*/

const TInt32 KXmlLeaveOnManyFlag = 0x00000004;

/**

Reserved, unused flags in iAddInfo attribute

@internalComponent

*/

const TInt32 KXmlAddInfoReservedFlags = 0xFFFFFFF8;

/**  

Object constructor. Initializes internal state to default values 

@internalComponent

*/

CMatchData::CMatchData(): 

			iMimeType(NULL),

			iVariant(NULL),

			iAddInfo(KXmlCaseSensitivityFlag)

	{

	}

/** 

Object destructor. Deletes allocated heap based memory. 

@internalComponent

*/

CMatchData::~CMatchData()

	{

	if (iMimeType != NULL)

		{

		delete iMimeType;

		iMimeType = NULL;

		}

	if (iVariant != NULL)

		{

		delete iVariant;

		iVariant = NULL;

		}

	}

/**

Creates CMatchData object with its default values. 

@leave KErrNoMemory 	If there is not enough memory to create an object.

@return A pointer to the newly created CMatchData object.

*/

EXPORT_C CMatchData* CMatchData::NewL()

	{

	CMatchData* me = CMatchData::NewLC();

	CleanupStack::Pop(me); 

	return me;

	}

/** 

Creates CMatchData object using heap based stream of externalized object's data. 

@param aPackage Descriptor to the heap based stream of externalized object 

@leave KErrNoMemory 	If there is not enough memory to create an object. 

@leave KErrArgument 	If the argument passed to an object is incorrect.

@return A pointer to the newly created CMatchData object.

@internalComponent

*/

EXPORT_C CMatchData* CMatchData::NewL(const TDesC8& aPackage)

	{

	CMatchData* me = CMatchData::NewLC(aPackage);

	CleanupStack::Pop(me);

	return me;

	}

/**

Creates CMatchData object with its default values. 

Leaves an obeject pointer on a cleanup stack. 

@leave KErrNoMemory If there is not enough memory

@return A pointer to the newly created CMatchData object.

*/

EXPORT_C CMatchData* CMatchData::NewLC()

	{

	CMatchData* me = new (ELeave) CMatchData();

	CleanupStack::PushL(me);

       return me;	

	}

/**

Creates CMatchData object using heap based stream of externalized object's data. 

Leaves an obeject pointer on a cleanup stack. 

@param aPackage Descriptor to the heap based stream of externalized object 

@leave KErrNoMemory 	If there is not enough memory to create an object.

@leave KErrArgument 	If the argument passed to an object is incorrect.

@return A pointer to the newly created CMatchData object.

@internalComponent

*/

EXPORT_C CMatchData* CMatchData::NewLC(const TDesC8& aPackage)

	{

	CMatchData* me = new (ELeave) CMatchData();

	CleanupStack::PushL(me);

	me->ConstructL(aPackage);

	return me;

	}

/**

Standard symbian 2-phase construction method.

It reads a stream stored on a heap and internalize the object. 

@param aPackage Descriptor to the heap based stream of externalized object 

@leave KErrNoMemory 	If there is not enough memory to create an object.

@leave KErrArgument 	If the argument passed to an object is incorrect.

@return A pointer to the newly created CMatchData object.

@internalComponent

*/		

void CMatchData::ConstructL(const TDesC8& aPackage)

	{

	RDesReadStream stream(aPackage);

	InternalizeL(stream);

	stream.Close();

	}

/** 

Externalizes the object into RWriteStrem.

@param aStream Stream to write to

@internalComponent

*/		

void CMatchData::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt16L(iMimeType? iMimeType->Length():0);

	if(iMimeType && iMimeType->Length() > 0)

		{

		aStream.WriteL(*iMimeType, iMimeType->Length());

		}

	aStream.WriteInt16L(iVariant?iVariant->Length():0);

	if (iVariant && iVariant->Length() > 0 )

		{

		aStream.WriteL(*iVariant, iVariant->Length());

		}

	aStream.WriteUint32L(iAddInfo);

	}

/** 

Internalizes the object out of RReadStream.

@param aStream Stream to read from 

@leave KErrNoMemory 	If there is not enough memory for new string allocation.

@leave KErrArgument 	If passed descriptor doesn't comply with length constraints.  

@internalComponent

*/	

void CMatchData::InternalizeL(RReadStream& aStream)

	{

	TInt16 temp;

	// read mime type and create the heap buffer for it. 

	// verify constraints

	temp = aStream.ReadInt16L();

	if (temp <=0 || temp > KXmlMaxMimeTypeLength)

		{

		// must not be greater then max

		User::LeaveIfError(KErrArgument);

		}

	// delete current value as it is no longer valid

	if (iMimeType != NULL)

		{

		delete iMimeType;

		iMimeType = NULL;

		}

	// create buffer and read new data if available

	if (temp > 0)

		{

		iMimeType = HBufC8::NewL(temp);

		TPtr8 ptr = iMimeType->Des();

		aStream.ReadL(ptr, temp);

		}

	// read variant and create the heap buffer for it. 

	// verify constarints

	temp = aStream.ReadInt16L();

	if (temp <0 || temp > KXmlMaxVariantLength)

		{

		// must not be greater then max, zero possible. 

		User::LeaveIfError(KErrArgument);

		}

	// delete current value as it is no longer valid

	if (iVariant != NULL)

		{

		delete iVariant;

		iVariant = NULL;

		}

	// create buffer and read new data if available

	if (temp > 0)

		{

		iVariant = HBufC8::NewL(temp);

		TPtr8 ptr = iVariant->Des();

		aStream.ReadL(ptr, temp);	

		}

	// read additional info 

	iAddInfo = aStream.ReadUint32L();

	// check for correctness of the iAddInfo bitmap

	if (iAddInfo & KXmlAddInfoReservedFlags > 0 )

		{

		// Leave as unexpected flags are set. 

		User::LeaveIfError(KErrArgument);

		}	

}

/**

Sets up a mime type attribute to a string given as an aData descriptor. 

@param aData String descriptor

@leave KErrNoMemory 	If there is not enough memory for new string allocation.

@leave KErrArgument 	If passed descriptor doesn't comply with length constraints. 

*/		

EXPORT_C void CMatchData::SetMimeTypeL(const TDesC8& aData)

	{

	// verify constraints

	if (aData.Length() == 0 || aData.Length() > KXmlMaxMimeTypeLength)

		{

		// must not be greater than max

		User::Leave(KErrArgument);

		}

	// delete current value as it is no longer valid

	if (iMimeType != NULL)

		{

		delete iMimeType;

		iMimeType = NULL;

		}

	// allocate required buffer and copy new data

	iMimeType = aData.AllocL();

	}

/**

Sets up a variant attribute to a string given as an aVariant descriptor. 

If this is not set OR is set to a string of length 0 the Variant ID is

not used during parser resolution and hence the variant IDs of plug-in 

parsers are ignored.

@param aData String descriptor

@leave KErrNoMemory 	If there is not enough memory for new string allocation.

@leave KErrArgument 	If passed descriptor doesn't comply with length constraints. 

*/			

EXPORT_C void CMatchData::SetVariantL(const TDesC8& aVariant)

	{

	// verify constraints

	if (aVariant.Length() > KXmlMaxVariantLength)

		{

		// must not be greater than max

		User::Leave(KErrArgument);

		}

	// delete current value as it is no longer valid

	if (iVariant != NULL)

		{

		delete iVariant;

		iVariant = NULL;

		}

	// allocate required buffer and copy new data	

	iVariant = aVariant.AllocL();

	}

/**

Returns a pointer to the mime type string.  

@return A pointer to the mime type string. 

		Pointer to KNullDesC8 is returned if not set up yet.

*/		

EXPORT_C const TPtrC8 CMatchData::MimeType() const

	{

	TPtrC8 result;

	if(iMimeType)

		result.Set(*iMimeType);

	else

		result.Set(KNullDesC8);

	return result;

	}

/**

Returns a pointer to the variant string.  

@return A pointer to the variant string. 

		Pointer to KNullDesC8 is returned if not set up yet.

*/	

EXPORT_C const TPtrC8 CMatchData::Variant() const

	{

	TPtrC8 result;

	if(iVariant)

		result.Set(*iVariant);

	else

		result.Set(KNullDesC8);

	return result;

	}

/**

Returns a heap based buffer descriptor of an externalized CMatchData object stream. 

The newly created object's ownership is shifted to the caller. 

@leave KErrNoMemory If there is not enough memory to create an heap based buffer. 

@return Heap based buffer descriptor of an externalized object stream.

@internalComponent

*/		

HBufC8* CMatchData::PackToBufferL() const

	{

	//Create new Heap Descriptor with the size of externalized CMatchData

	HBufC8* data = HBufC8::NewLC(	(iMimeType?iMimeType->Size():0)

								+ (iVariant?iVariant->Size():0) 

								+ 2*sizeof(TInt16) 		// length of mime type and variant strings

								+ sizeof(TUint32));		// size of addinfo variable

	// create the stream using allocated buffer

	TPtr8   dataDes = data->Des();

	RDesWriteStream stream(dataDes);

	// pack object into the allocated buffer

	ExternalizeL(stream);

	//cleanup

	stream.Close();

	CleanupStack::Pop(data);

	return data;

	}

/**

Sets the LeaveOnManyFlag flag. 

If set, it notifies customized resolver it should leave when the query is resolved to more than one parser. 

By default this flag is not set, so the framework chooses a parser in this case. 

@param aSetting The setting value. 

*/		

EXPORT_C void CMatchData::SetLeaveOnMany(TBool aSetting) 

	{

	SYMBIAN_XML_FLAG_SET(iAddInfo, KXmlLeaveOnManyFlag, aSetting);

	}

/**

Sets the Rom Only flag. 

If set, it notifies customized resolver the request is for ROM-based parsers only. 

By default this flag is not set, so the framework searches for rom and non-rom based parsers. 

@param aSetting The setting value. 

*/

EXPORT_C void CMatchData::SetRomOnly(TBool aSetting) 

	{

	SYMBIAN_XML_FLAG_SET(iAddInfo, KXmlRomOnlyFlag, aSetting);

	}

/**

Sets the Case Sensitivity flag. 

Customized resolver uses this setting to turn on or off case sensitivity for strings matching.

@param aSetting The setting value. 

*/

EXPORT_C void CMatchData::SetCaseSensitivity(TBool aSetting)

	{

	SYMBIAN_XML_FLAG_SET(iAddInfo, KXmlCaseSensitivityFlag, aSetting);

	}

/**

Static function to sort an array of CImplementationInformation objects, 

in ascending order of their Uid values.

The function is used in CMatchData::ResolveL().

@param aImpInfo1	pointer of first CImplementationInformation object

@param aImpInfo2	pointer of second CImplementationInformation object

@return			zero, if the two objects have equal Uids

@return			a negative value, if the first object's Uid is less than the second object's Uid.

@return			a positive value, if the first object's Uid is greater than the second object's Uid.

@internalComponent

*/	

TInt CMatchData::SortOrder(const CImplementationInformation &aImpInfo1, 

							const CImplementationInformation &aImpInfo2)

	{

    if (aImpInfo1.ImplementationUid().iUid > aImpInfo2.ImplementationUid().iUid)

		{

		return 1;

		}

	if (aImpInfo1.ImplementationUid().iUid < aImpInfo2.ImplementationUid().iUid)

		{

		return -1;

		}

	return 0;		

	}

/**

Performs a parser resolution. 

Following criteria are considered:

 - Case sensitivity for string matching is applied according to the Case Sensitivity flag.

 - Only ROM-based parsers are considered when ROM only flag is set. 

 - Mime type is mandatory as it must match the data field in resource information file.

 - Variant is optional. If present it must match first entry in the opaque data field. 

 - If the query is narrowed down to more than one parser the behaviour is determined in 

    SelectSingleParserL function. 

@param 	aImplList The list of available parsers to choose from. 

@leave 	KErrNoMemory

@leave 	KErrXmlMoreThanOneParserMatched