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

 //

 /**

  @file

  @internalComponent

 */

 #include <e32def.h>

 #include <e32cmn.h>

 #include <hal.h>

 #include "EComDebug.h"

 #include "ImplementationInformation.h"  // CompareTUidValues

 #include "callback.h"

 #include "resolvercache.h"

 #include "EComPatchDataConstantv2.h"

 const TInt KCacheQueueGranularity = 4;

 //

 // TCounterTicks class

 //

 inline TCounterTicks::TCounterTicks(TUint aTicks)

 	: iTicks(aTicks)

 	{

 	}

 /** This substraction calculate elapsed ticks: aEndTick - this */

 inline

 TUint TCounterTicks::ElapsedSinceThis(TUint aEndTick) const

 	{

 	TUint diff;

 	if (aEndTick < iTicks) // wrap around occurred

 		{

 		diff = KMaxTUint - iTicks + aEndTick + 1;

 		}

 	else

 		{

 		diff = aEndTick - iTicks;

 		}

 	return diff;

 	}

 /** default constructor which initializes all member data to 0. */

 RResolverCacheEntry::RResolverCacheEntry()

 	: iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(KNullUid),

 	iNewLFuncPtr(NULL), iFlags(EEntryFlagsNone)

 	{

 	iLibrary.SetHandle(KNullHandle);

 	}

 /** construct RResolverCacheEntry with specific data

 @param aResolverUid TUid of the resolver.

 @param aLib RLibrary with handle open on the resolver DLL.

 @param aNewL Function ptr to instantiate the resolver.

 @param aFlags Special conditions about the cache entry.

 */

 RResolverCacheEntry::RResolverCacheEntry(const TUid aResolverUid,

 										RLibrary aLib,

 										TProxyNewLPtr aNewL,

 										TUint32 aFlags)

 	: iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(aResolverUid),

 	iNewLFuncPtr(aNewL), iFlags(aFlags)

 	{

 	iLibrary.SetHandle(aLib.Handle());

 	}

 /** unallocate resources owned by the RResolverCacheEntry object */

 void RResolverCacheEntry::Close()

 	{

 	iLibrary.Close();

 	}

 /** This method compares two RResolverCacheEntry objects.

 @param aEntry1 first RResolverCacheEntry object.

 @param aEntry2 second RResolverCacheEntry object.

 @return 0 means the two objects are equal.

         positive value means first object is greater than the second.

 		negative vlaue means second object is greater than the first.

 */

 TInt RResolverCacheEntry::CompareUid(const RResolverCacheEntry& aEntry1,

 								     const RResolverCacheEntry& aEntry2)

 	{

 	return CompareTUidValues(aEntry1.iResolverUid.iUid,

 							 aEntry2.iResolverUid.iUid);

 	}

 /** Compare the age of two cache entries.

 @param aOther The RResolverCacheEntry to compare with.

 @param aCurrTick The current system tick. It simplifies handling

 	of system tick wrap around to zero.

 @return ETrue means "this" object is older than aOther.

 	EFalse means aOther is older than "this".

 */

 TBool RResolverCacheEntry::ThisIsOlder(const RResolverCacheEntry& aOther,

 										TUint aCurrTick) const

 	{

 	if (iLastUse.iTicks == aOther.iLastUse.iTicks)

 		{

 		return iLruRank < aOther.iLruRank;

 		}

 	// Because of counter wrap around, it is not safe to directly

 	// compare the two ticks. Drag in the current system tick.

 	return iLastUse.ElapsedSinceThis(aCurrTick) >

 			aOther.iLastUse.ElapsedSinceThis(aCurrTick);

 	}

 //=================================

 // CCustomResolverCache class

 //=================================

 /** CCustomResolverCache constructor

 @param aCacheSize Maximum number of entries allowed to cache.

 */

 CCustomResolverCache::CCustomResolverCache(TUint32 aCacheSize)

 	: CTimer(CActive::EPriorityStandard),

 	iResolvers(KCacheQueueGranularity), 

 	iMaxCacheSize(aCacheSize)

 	{

 	}

 /** static factory method to instantiate CCustomResolverCache

 @param aCacheSize Maximum number of entries allowed to cache.

 @param aCacheTimeout Cache timeout in microseconds.

 @leave Any of the system wide error codes.

 */

 CCustomResolverCache* CCustomResolverCache::NewL(TUint32 aCacheSize, TUint32 aCacheTimeout)

 	{

 	CCustomResolverCache* self = new (ELeave) CCustomResolverCache(aCacheSize);

 	CleanupStack::PushL(self);

 	self->ConstructL(aCacheTimeout);

 	CleanupStack::Pop(self);

 	return self;

 	}

 /** Standard two phase construction to complete construction of

 the CCustomResolverCache object.

 @param aCacheTimeout Cache timeout in microseconds.

 @leave Any of the system wide error codes.

 */

 void CCustomResolverCache::ConstructL(TUint32 aCacheTimeout)

 	{

 	User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod,

 								iSystemTickPeriod));

 	iEntryTimeToLive = (aCacheTimeout + iSystemTickPeriod - 1) / iSystemTickPeriod;

 	CTimer::ConstructL();

 	CActiveScheduler::Add(this);

 	}

 /** CCustomResolverCache destructor */

 CCustomResolverCache::~CCustomResolverCache()

 	{

 	Cancel();

 	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)

 		{

 		iResolvers[i].Close();

 		}

 	iResolvers.Reset();

 	}

 /** Implement the CActive RunL pure virtual */

 void CCustomResolverCache::RunL()

 	{

 	TUint currTickCount = User::TickCount();

 	TUint lruAge = 0;

 	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)

 		{

 		RResolverCacheEntry& resolverEntry = iResolvers[i];

 		TUint age = resolverEntry.iLastUse.ElapsedSinceThis(currTickCount);

 		if (age >= iEntryTimeToLive)

 			{

 			resolverEntry.Close();

 			iResolvers.Remove(i);

 			}

 		else if (age > lruAge)

 			{

 			lruAge = age;

 			}

 		}

 	if (iResolvers.Count() > 0)

 		{

 		After( iSystemTickPeriod * (iEntryTimeToLive - lruAge + 1) );

 		}

 #ifdef __ECOMSERVER_TESTING__

 	// In unit testing notify test bed that cache timer has fired.

 	iTimerExpireCB.CallBack(0, NULL);

 #endif

 	}

 /** Search of a resolver UID in cache

 @param aResolverUid the resolver to search for.

 @return If find is successful, index of the resolver in RArray of cached resolvers.

 		Return KErrNotFound if resolver is not in cache.

 */

 TInt CCustomResolverCache::FindResolver(const TUid aResolverUid) const

 	{

 	RResolverCacheEntry trgt;

 	trgt.iResolverUid = aResolverUid;

 	TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);

 	return iResolvers.FindInOrder(trgt, comparator);

 	}

 /** Add a resolver library to cache 

 @param aResolverUid Implementation UID of the resolver.

 @param aLib	The RLibrary object which has the resolver loaded. The handle

 	of the RLibrary is owned by the cache if call is successful.

 @param aNewL value for the iNewLFuncPtr member data of RResolverCacheEntry.

 @param aFlags value for the iFlags member data of RResolverCacheEntry.

 @return KErrNone if the data is added to cache.

 	KErrNoMemory if fail to insert the data in RArray.

 */

 TInt CCustomResolverCache::CacheResolver(const TUid aResolverUid,

 										  RLibrary aLib,

 										  TProxyNewLPtr aNewL,

 										  TUint32 aFlags)

 	{

 	if (iResolvers.Count() == iMaxCacheSize)

 		{

 		EvictLeastRecentlyUsed();

 		}

 	RResolverCacheEntry entry(aResolverUid, aLib, aNewL, aFlags);

 	SetLastUseTime(entry);

 #ifdef ECOM_TRACE

 	__ECOM_TRACE2("ECOM: adding custom resolver 0x%X to cache. New queue size will be %d.\n", aResolverUid.iUid, 1 + iResolvers.Count());

 #endif

 	TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);

 	TInt err = iResolvers.InsertInOrder(entry, comparator);

 	// if cache was empty before need to start timer

 	if (err == KErrNone && ! IsActive())

 		{

 		After( iSystemTickPeriod * (iEntryTimeToLive + 1) );

 		}

 	return err;

 	}

 /** Check if both queue size and cache timeout are non zero  */

 TBool CCustomResolverCache::CachingEnabled() const

 	{

 	return (iMaxCacheSize && iEntryTimeToLive);

 	}

 /** Remove a cached entry

 @param aIndex position of entry in the array.

 */

 void CCustomResolverCache::Remove(TInt aIndex)

 	{

 	iResolvers[aIndex].Close();

 	iResolvers.Remove(aIndex);

 	}

 /** Search for a resolverUID. If found, return the NewL pointer and

 update time to live of the entry.

 @param aResolverUid the resolver to lookup

 @param aNewLFuncPtr output parameter. If lookup successful it has

 	the function pointer to instantiate the resolver.

 @return True if resolver is in cache. False otherwise.

 @post If cache hit, the timestamp of the entry is updated.

 */

 TBool CCustomResolverCache::CacheLookup(const TUid aResolverUid,

 										TProxyNewLPtr& aNewLFuncPtr)

 	{

 	TInt i = FindResolver(aResolverUid);

 	if (i >= 0)

 		{

 		aNewLFuncPtr = iResolvers[i].iNewLFuncPtr;

 		SetLastUseTime(iResolvers[i]);

 		}

 	return (i >= 0);

 	}

 /** Remove a resolver from cache.

 @param aResolverUid Identify the resolver to remove.

 @return ETrue if aResolverUid is found in cache. EFalse means the

 	resolver is not in cache.

 */

 TBool CCustomResolverCache::Remove(const TUid aResolverUid)

 	{

 	TInt i = FindResolver(aResolverUid);

 	if (i >= 0)

 		{

 		Remove(i);

 		}

 	return (i >= 0);

 	}

 /** Remove cached entries with flags set.

 @param aMask If an entry has any of the bits in aMask set, it is removed.

 */

 void CCustomResolverCache::RemoveItemsWithFlags(TUint32 aMask)

 	{

 	for (TInt i = iResolvers.Count() - 1; i >= 0; i--)

 		{

 		if (iResolvers[i].iFlags & aMask)

 			{

 			Remove(i);

 			}

 		}

 	}

 /** evict the least recently used entry in cache

 */

 void CCustomResolverCache::EvictLeastRecentlyUsed()

 	{

 	TUint curr = User::TickCount();

 	TInt index = 0; // set to first entry in cache.

 	for (TInt i = 1; i < iResolvers.Count(); i++)

 		{

 		RResolverCacheEntry& resolverEntry = iResolvers[i];

 		if (resolverEntry.ThisIsOlder(iResolvers[index], curr))

 			{

 			index = i;

 			}

 		}

 	Remove(index);

 	}

 /** Set the iLastUse field and iLruRank field of the entry.

 The iLruRank field serves as tie breaker when two entries are

 added within the same tick period.

 @param aEntry The entry to update.

 */

 void CCustomResolverCache::SetLastUseTime(RResolverCacheEntry& aEntry)

 	{

 	TUint curr = User::TickCount();

 	aEntry.iLastUse.iTicks = curr;

 	aEntry.iLruRank = 0;

 	if (curr == iMostRecentTimestamp)

 		{

 		// There are entries with same timestamp. So have to step

 		// through each cache entry to resolve senority.

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

 			{

 			RResolverCacheEntry& another = iResolvers[i];

 			if (another.iLastUse.iTicks == curr &&

 				another.iResolverUid != aEntry.iResolverUid &&

 				another.iLruRank >= aEntry.iLruRank)

 				{

 				aEntry.iLruRank = another.iLruRank + 1;

 				}

 			}

 		}

 	else

 		{

 		iMostRecentTimestamp = curr;

 		}

 	}