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

 // Implements the default CDefaultResolver class.

 // 

 //

 /**

  @file

  @internalComponent

 */

 #include <ecom/ecom.h>

 #include <ecom/ecomerrorcodes.h>

 #include <ecom/ecomresolverparams.h>

 #include <ecom/implementationinformation.h>

 #include "TestUtilities.h"	// For __FILE__LINE__

 #include "DefaultResolver.h"

 CDefaultResolver* CDefaultResolver::NewL(MPublicRegistry& aRegistry)

 	{

 	return new(ELeave) CDefaultResolver(aRegistry);

 	}

 // Default d'tor

 CDefaultResolver::~CDefaultResolver()

 	{

 	}

 // Default c'tor

 CDefaultResolver::CDefaultResolver(MPublicRegistry& aRegistry)

 : CResolver(aRegistry)

 	{

 	// Do nothing here

 	}

 TUid CDefaultResolver::IdentifyImplementationL(TUid aInterfaceUid, 

 											   const TEComResolverParams& aAdditionalParameters) const

 	{

 	RImplInfoArray* implementationsInfo = ListAllL(aInterfaceUid, aAdditionalParameters);

 	TUid found = Resolve(*implementationsInfo, aAdditionalParameters);

 	implementationsInfo->Reset();

 	delete implementationsInfo;

 	return found;

 	}

 TUid CDefaultResolver::Resolve(const RImplInfoArray& aImplementationsInfo, 

 							   const TEComResolverParams& aAdditionalParameters) const

 	{

 	// Place to store the result if we get a wildcard match

 	TUid wildMatched = KNullUid;

 	TInt wildConfidence = KErrNotFound;

 	const TDesC8& matchType = aAdditionalParameters.DataType();

 	// Loop through the implementations matching on type

 	const TInt count = aImplementationsInfo.Count();

 	TBool isGenericMatch=aAdditionalParameters.IsGenericMatch();

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

 		{

 		const CImplementationInformation& impData = *aImplementationsInfo[index];

 		const TDesC8& dataType = impData.DataType();

 		// As soon as we get a match on the datatype then return uid of the 

 		// implementation found.

 		if(Match(dataType,	// The Datatype of this implementation

 				 matchType,	// The type we are trying to find

 				 EFalse))	// Don't use wildcards first

 			{

 			// We have got an exact match so return this

 			return impData.ImplementationUid();

 			}

 		else if(isGenericMatch) // If the client wants us to use wildcards

 			{

 			if(Match(dataType,

 					 matchType,

 					 ETrue))

 				{

 				// We have matched using wildcards so work out a confidence value

 				TInt confidence = 0;

 				TInt length = Min(matchType.Length(), dataType.Length());

 				while((matchType[confidence] == dataType[confidence]) && 

 					  (++confidence < length))

 					{

 					}

 				if(confidence > wildConfidence)

 					{

 					wildConfidence = confidence;

 					wildMatched = impData.ImplementationUid();

 					}

 				}

 			}

 		}

 	return wildMatched;

 	}

 void CloseAndDeleteRArray(TAny* aObject)

 	{

 	RImplInfoArray* array=reinterpret_cast<RImplInfoArray*>(aObject);

 	if (array)

 		array->Close();

 	delete array;

 	}

 RImplInfoArray* CDefaultResolver::ListAllL(TUid aInterfaceUid, 

 										   const TEComResolverParams& aAdditionalParameters) const

 	{

 	// Use the member var to create the array so that we get proper cleanup behaviour

 	RImplInfoArray* retList = new (ELeave) RImplInfoArray;

 	CleanupStack::PushL(TCleanupItem(CloseAndDeleteRArray,retList));

 	RImplInfoArray& fullList = iRegistry.ListImplementationsL(aInterfaceUid);

 	const TBool useWildcards = aAdditionalParameters.IsGenericMatch();

 	const TDesC8& matchType = aAdditionalParameters.DataType();

 	const TInt numImps = fullList.Count();

 	for(TInt index = 0; index < numImps; ++index)

 		{	

 		if(Match(fullList[index]->DataType(), matchType, useWildcards))

 			{

 			User::LeaveIfError(retList->Append(fullList[index]));

 			}

 		}

 	// Reset the member variable because we are passing ownership back

 	CleanupStack::Pop();

 	return retList;

 	}

 TBool CDefaultResolver::Match(const TDesC8& aImplementationType, 

 							  const TDesC8& aMatchType, 

 							  TBool aUseWildcards) const

 	{

 	// In this function if allowing wildcards then TDesC8::Match is used which returns 

 	// the position of the match or KErrNotFound

 	// If not allowing wildcards then TDesC8::Compare is used which returns a TInt which

 	// indicates if one descriptor is bigger than the other (0 if they are identical)

 	TBool gotMatch = ETrue;

 	if(aMatchType.Length()!=0)

 	{

 		gotMatch = EFalse;

 		_LIT8(dataSeparator, "||");

 		const TInt separatorLength = dataSeparator().Length();

 		// Look for the section separator marker '||'

 		TInt separatorPos = aImplementationType.Find(dataSeparator);

 		if(separatorPos == KErrNotFound)

 			{

 			// Match against the whole string

 			if(aUseWildcards)

 				gotMatch = aMatchType.Match(aImplementationType) != KErrNotFound;

 			else

 				gotMatch = aMatchType.Compare(aImplementationType) == 0;

 			}

 		else

 			{

 			// Find the first section, up to the separator

 			TPtrC8 dataSection = aImplementationType.Left(separatorPos);

 			TPtrC8 remainingData = aImplementationType.Mid(separatorPos + separatorLength);

 			// Match against each section in turn

 			while(separatorPos != KErrNotFound)

 				{

 				// Search this section

 				if(aUseWildcards)

 					gotMatch = aMatchType.Match(dataSection) != KErrNotFound;

 				else

 					gotMatch = aMatchType.Compare(dataSection) == 0;

 				// If we found it then no need to continue, so return

 				if(gotMatch)

 					return ETrue;

 				// Move on to the next section

 				separatorPos = remainingData.Find(dataSeparator);

 				if(separatorPos != KErrNotFound)

 					{

 					dataSection.Set(remainingData.Left(separatorPos));

 					remainingData.Set(remainingData.Mid(separatorPos + separatorLength));

 					}

 				else

 					dataSection.Set(remainingData);

 				}

 			// Check the final part

 			if(aUseWildcards)

 				gotMatch = aMatchType.Match(dataSection) != KErrNotFound;

 			else

 				gotMatch = aMatchType.Compare(dataSection) == 0;

 			}

 		}

 		return gotMatch;

 	}