// 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();

	}