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

 // Implements a non-default resolver CExampleResolver.

 // 

 //

 /**

  @internalComponent

  @file

 */

 #include <ecom/ecom.h>

 #include "TestUtilities.h"	// For __FILE__LINE__

 #include "ExampleResolver.h"

 #include "RegistryData.h"

 #include "ImplementationProxy.h"

 CExampleResolver* CExampleResolver::NewL(MPublicRegistry& aRegistry)

 	{

 	return new(ELeave) CExampleResolver(aRegistry);

 	}

 CExampleResolver::~CExampleResolver()

 	{

 	if(iImplementationInfoArray)

 		{

 		iImplementationInfoArray->Reset();

 		delete iImplementationInfoArray;

 		}

 	}

 CExampleResolver::CExampleResolver(MPublicRegistry& aRegistry)

 : CResolver(aRegistry)

 	{

 	// Do nothing here

 	}

 TUid CExampleResolver::IdentifyImplementationL(TUid aInterfaceUid, 

 											   const TEComResolverParams& aAdditionalParameters)const 

 	{

 	RImplInfoArray& implementationsInfo = iRegistry.ListImplementationsL(aInterfaceUid);

 	TUid found = KNullUid;

 	if(implementationsInfo.Count())

 		{

 		found = Resolve(implementationsInfo, aAdditionalParameters);

 		}

 	return found;

 	}

 TUid CExampleResolver::Resolve(const RImplInfoArray& aImplementationsInfo, 

 							   const TEComResolverParams& aAdditionalParameters) const

 	{

 	// Loop through the implementations matching on type

 	const TInt count = aImplementationsInfo.Count();

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

 		{

 		const CImplementationInformation& impData = *aImplementationsInfo[index];

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

 		// implementation found.

 		if (Match(impData.DataType(),						// The Datatype of this implementation

 				  aAdditionalParameters.DataType(),			// The type we are trying to find

 				  aAdditionalParameters.IsGenericMatch()))	// If wildcards should be used

 			return impData.ImplementationUid();

 		}

 	return KNullUid;

 	}

 RImplInfoArray* CExampleResolver::ListAllL(TUid aInterfaceUid, 

 										   const TEComResolverParams& aAdditionalParameters) const

 	{

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

 	iImplementationInfoArray = new(ELeave) RImplInfoArray;

 	RImplInfoArray* retList = iImplementationInfoArray;

 	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

 	iImplementationInfoArray = NULL;

 	return retList;

 	}

 TBool CExampleResolver::Match(const TDesC8& aImplementationType, 

 							  const TDesC8& aMatchType, 

 							  TBool aUseWildcards) const

 	{

 	TInt matchPos = KErrNotFound;

 	_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)

 			matchPos = aMatchType.Match(aImplementationType);

 		else

 			matchPos = aMatchType.Compare(aImplementationType);

 		}

 	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)

 				matchPos = aMatchType.Match(dataSection);

 			else

 				matchPos = aMatchType.Compare(dataSection);

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

 			if(matchPos != KErrNotFound)

 				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)

 			matchPos = aMatchType.Match(dataSection);

 		else

 			matchPos = aMatchType.Compare(dataSection);

 		}

 	return matchPos != KErrNotFound;

 	}

 // __________________________________________________________________________

 // Exported proxy for instantiation method resolution

 // Define the interface UIDs

 const TImplementationProxy ImplementationTable[] = 

 	{

 		IMPLEMENTATION_PROXY_ENTRY(0x10244444,CExampleResolver::NewL),

 		IMPLEMENTATION_PROXY_ENTRY(0x10999999,CExampleResolver::NewL)

 	};

 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

 	{

 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

 	return ImplementationTable;

 	}