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

 // DBMS object cache

 // 

 //

 #include "UD_STD.H"

 #include "D32CACHE.H"

 //#include <e32svr.h>

 NONSHARABLE_CLASS(RDbCache::CCache) : private CBase

 	{

 public:

 	static CCache* OpenL( TInt aSize, TBool aUseTimer );

 	void Close();

 //

 	void Flush();

 	void Hold( CBase* aObject, TUint aMicroSeconds );

 	void Release ( const CBase& aObject );

 private:

 	struct TEntry

 		{

 		TEntry* iNext;

 		TInt iDelta;

 		CBase* iObject;

 		};

 	enum { ETimerPriority = -10 };

 	enum { ETimerPeriod = 0x100000 };	// ~1.0s

 private:

 	static inline TInt TlsHandle();

 	CCache( TInt aSize );

 	~CCache();

 //

 	static CCache* NewL( TInt aSize, TBool aUseTimer );

 	inline void Open();

 	void Expire( TInt aElapsedTime );

 	void Remove( TEntry*& aRef );

 	void ExpireFirst();

 	static void DoFlush( TAny* aPtr );

 private:

 	TInt iRef;

 //	CPeriodic* iTimer;

 	TTimeIntervalMicroSeconds32 iTickPeriod;

 	TUint iZeroTime;

 	TEntry* iCache;

 	TEntry* iFree;

 	TEntry iEntries[1];		// or maybe more

 	};

 // Class CDbObjectCache

 //inline TInt RDbCache::CCache::TlsHandle()

 //// use the address of a static function for the handle

 //	{ return TInt( NewL ); }

 TAny* gCachePtr;

 RDbCache::CCache::CCache( TInt aSize )

 //

 // Initialise the free entry list

 //

 	{

 	TEntry* entry = iEntries;

 	while ( --aSize != 0 )

 		{

 		entry[1].iNext = entry;

 		++entry;

 		}

 	iFree = entry;

 	}

 RDbCache::CCache::~CCache()

 	{

 	__ASSERT( iRef < 0 );

 // empty the cache (destory the items now)

 	Expire( KMaxTInt );

 	__ASSERT( iCache == 0 );

 //	delete iTimer;

 	gCachePtr = NULL;

 	}

 const TInt KTickPeriod = 10000000;

 const TTimeIntervalMicroSeconds32 gTickPeriod(KTickPeriod);

 RDbCache::CCache* RDbCache::CCache::NewL( TInt aSize, TBool aUseTimer )

 //

 // Construct a cache with aSize slots and one referee

 //

 	{

 //#warning !! RDbCache::CCache::NewL not implemented (uses UserHal/UserSvr) !!

 	CCache* cache = new( ELeave, sizeof( TEntry ) * ( aSize - 1 ) ) CCache( aSize );	// get the extra size for the cache entries, leaves on error

 	CleanupClosePushL( *cache );

 	cache->iTickPeriod = gTickPeriod;

 	//User::LeaveIfError( UserHal::TickPeriod( cache->iTickPeriod ) );

 	//User::LeaveIfError( UserSvr::DllSetTls( TlsHandle(), cache ) );

 	gCachePtr = cache;

 //	if (aUseTimer)

 //		cache->iTimer = CPeriodic::NewL( ETimerPriority );

 	CleanupStack::Pop();

 	return cache;

 	}

 inline void RDbCache::CCache::Open()

 // add a referee

 	{ ++iRef; }

 void RDbCache::CCache::Close()

 //

 // remove a referee and delete as required

 //

 	{

 	__ASSERT( iRef >= 0 );

 	if ( --iRef < 0 )

 		delete this;

 	}

 RDbCache::CCache* RDbCache::CCache::OpenL( TInt aSize, TBool aUseTimer )

 //

 // Grab a reference to the cache, constructing it if required

 //

 	{

 //	CCache* cache = ( CCache* )UserSvr::DllTls( TlsHandle() );

 	CCache* cache = ( CCache* )gCachePtr;

 	if (!cache)

 		return NewL( aSize, aUseTimer );

 	cache->Open();

 	return cache;

 	}

 void RDbCache::CCache::Hold( CBase* aObject, TUint aMicroSeconds )

 //

 // Hold aObject in the cache or destroy it

 //

 	{

 	Flush();		// Destroy expired entries and re-assess Zero-time

 	TInt ticks = aMicroSeconds / TUint( iTickPeriod.Int() );

 	TEntry* entry = iFree;

 	if ( entry == 0 )

 		{	// no free slots: check the first cache entry

 		__ASSERT( iCache );

 		if ( iCache->iDelta > ticks )

 			{				// aObject expires first

 			delete aObject;

 			return;

 			}

 		ExpireFirst();		// remove the first entry and use it

 		entry = iFree;

 		}

 	iFree = entry->iNext;	// move the free list pointer to the next entry

 	//

 	// find the insertion point in the cache delta-list

 	TEntry** pcache = &iCache;

 	TEntry* cache;

 	for ( ; ; )

 		{

 		__ASSERT( ticks >= 0 );

 		cache = *pcache;

 		if ( !cache )

 			break;				// add to end

 		TInt t = ticks - cache->iDelta;

 		if ( t < 0 )

 			{					// add to the list here

 			cache->iDelta = -t;	// reduce the following delta

 			break;

 			}

 		ticks = t;				// reduce the entry delta

 		pcache = &cache->iNext;

 		}

 	*pcache = entry;				// set up the entry

 	entry->iDelta = ticks;

 	entry->iNext = cache;

 	entry->iObject = aObject;

 //	// kick the timer if we need to

 //	if ( iTimer && !iTimer->IsActive() )

 //		iTimer->Start( ETimerPeriod, ETimerPeriod, TCallBack( ( TInt (*)(TAny*) )DoFlush, this ) );

 	}

 void RDbCache::CCache::Remove( RDbCache::CCache::TEntry*& aRef )

 //

 // Remove the entry at aRef from the cache

 //

 	{

 	TEntry& entry = *aRef;

 	TEntry* next = entry.iNext;

 	entry.iNext = iFree;

 	iFree = &entry;

 	aRef = next;

 	if ( next )

 		next->iDelta += entry.iDelta;

 //	else if ( iTimer )	// the cache is now empty, so stop the timer if we have one

 //		iTimer->Cancel();

 	}

 void RDbCache::CCache::ExpireFirst()

 //

 // Expire the first entry in the cache

 //

 	{

 	__ASSERT( iCache != 0 );

 	// the ordering here is important. Removing the entry first allows the

 	// object d'tor to call Release() without causing re-entrancy problems.

 	CBase* object = iCache->iObject;

 	Remove( iCache );

 	delete object;

 	}

 void RDbCache::CCache::Release( const CBase& aObject )

 //

 // Remove the cache entry for aObject, if it is in the cache

 //

 	{

 	TEntry** pcache = &iCache;

 	for ( ; ; )

 		{

 		TEntry* entry = *pcache;

 		if ( !entry )

 			return;

 		if ( entry->iObject == &aObject )

 			{

 			Remove( *pcache );

 			return;

 			}

 		pcache = &entry->iNext;

 		}

 	}

 void RDbCache::CCache::Expire( TInt aElapsedTime )

 //

 // Destroy entries which expire with aElapsedTime

 //

 	{

 	__ASSERT( aElapsedTime > 0 );

 	if ( iCache && ( iCache->iDelta -= aElapsedTime ) < 0 )

 		{

 		Open();		// This allows the cache to be owned by an object in the cache

 		do ExpireFirst();

 			while ( iCache && iCache->iDelta < 0 );

 		Close();	// The cache may be destroyed now

 		}

 	}

 void RDbCache::CCache::Flush()

 //

 // Check the execution clock and destroy any expired entries

 //

 // Care has to be taken to handle the 32-bit wraparound of the tick-count

 // e.g. iZeroTime = 0xffffffffu, now = 0

 //

 	{

 	TUint now = User::TickCount();

 	TUint elapsed = now - iZeroTime;

 	iZeroTime = now;

 	if ( elapsed )

 		Expire( elapsed <= TUint( KMaxTInt ) ? elapsed : TUint( KMaxTInt ) );

 	}

 void RDbCache::CCache::DoFlush( TAny* aPtr )

 //

 // Callback for the timer

 //

 	{

 	static_cast<CCache*>( aPtr )->Flush();

 	}

 // Class RDbCache

 TInt RDbCache::Open( TInt aSize, TBool aUseTimer )

 //

 // Get a handle on the cache

 //

 	{

 	__ASSERT( aSize > 0 );

 	TRAPD( r, iCache = CCache::OpenL( aSize, aUseTimer ) );

 	return r;

 	}

 void RDbCache::Close()

 //

 // Close this handle on the cache

 //

 	{

 	CCache* cache = iCache;

 	if ( cache )

 		{

 		iCache = 0;

 		cache->Close();

 		}

 	}

 void RDbCache::Hold( CBase* aObject, TUint aMicroSeconds )

 //

 // Hold aObject on the cache, if open

 // We are now responsible for deleting the object

 //

 	{

 	if ( iCache )

 		iCache->Hold( aObject, aMicroSeconds );

 	else

 		delete aObject;	// no cache available

 	}

 void RDbCache::Release( const CBase& aObject ) const

 //

 // Retrieve aObject from the cache

 //

 	{

 	if ( iCache )

 		iCache->Release( aObject );

 	}

 void RDbCache::Flush()

 //

 // Destroy any cached objects which have expired

 //

 	{

 	if ( iCache )

 		iCache->Flush();

 	}