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

 //

 #include "UP_STD.H"

 struct SCachePage

 	{

 	TCachePage iPage[1];

 	TUint8 iData[KPoolPageSize];

 	};

 EXPORT_C CPageCache* CPageCache::NewL(TInt aPages)

 /** Allocates and constructs a new page cache.

 @param aPages Number of pages in the cache

 @return New page cache object */

 	{

 	CPageCache* cache=CPageCache::NewLC(aPages);

 	CleanupStack::Pop();

 	return cache;

 	}

 EXPORT_C CPageCache* CPageCache::NewLC(TInt aPages)

 /** Allocates and constructs a new page cache, and leaves it on the cleanup stack.

 @param aPages Number of pages in the cache

 @return New page cache object */

 	{

 	CPageCache* cache=new(ELeave) CPageCache;

 	CleanupStack::PushL(cache);

 	cache->ConstructL(aPages);

 	return cache;

 	}

 EXPORT_C CPageCache::CPageCache()

 	: iFree(_FOFF(TCachePage,iLink)-_FOFF(SCachePage,iPage[1]))/*,iPages(NULL),iEnd(NULL)*/

 /** Default constructor. */

 	{

 #if defined(__PAGE_CACHE_STATS)

 //	iStats.Reset();

 #endif

 	}

 EXPORT_C void CPageCache::ConstructL(TInt aPages)

 /** Second phase construction.

 @param aPages Number of pages in the cache */

 	{

 	SCachePage* page=new(ELeave) SCachePage[aPages];

 	SCachePage* end=page+aPages;

 	iPages=page;

 	iEnd=end;

 	for (;page<end;++page)

 		{

 		page->iPage[0].iOwner=NULL;

 		page->iPage[0].iChange=EPageNoChange;

 		iFree.AddFirst(page->iPage[1]);

 		}

 	}

 EXPORT_C CPageCache::~CPageCache()

 /** Destructor.

 All cache pages are deleted. */

 	{

 #if defined (_DEBUG)

 	for (SCachePage* page=iPages,*end=iEnd;page<end;++page)

 		__ASSERT_DEBUG(page->iPage[0].iOwner==NULL,Panic(EPageCacheInUse));

 #endif

 	delete[] iPages;

 	}

 TCachePage* CPageCache::Find(TCachePagePool* aPool,TPageRef aRef)

 //

 // Find a page in the cache.

 //

 	{

 	for (SCachePage* page=iPages,*end=iEnd;page<end;++page)

 		{

 		if (page->iPage[0].iOwner!=aPool)

 			{

 			__ASSERT_DEBUG(page->iPage[1].IsQued(),User::Invariant());

 				// no other page pool can have locked pages

 			continue;

 			}

 //

 		if (page->iPage[0].iRef==aRef)

 			{

 #if defined(__PAGE_CACHE_STATS)

 			if (page->iPage[1].IsQued())

 				iStats.Hit(); // finding a locked page is not a hit, I'm afraid

 #endif

 			return &page->iPage[1];

 			}

 		}

 #if defined(__PAGE_CACHE_STATS)

 	iStats.Miss();

 #endif

 	return NULL;

 	}

 EXPORT_C TPageAbandonFunction TCachePagePool::AcquireL()

 /** Returns a function that abandons all locked pages for this page pool. 

 @return A function that abandons all locked pages for this page pool. */

 	{

 	return &DoAbandon;

 	}

 EXPORT_C TAny* TCachePagePool::AllocL()

 /** Allocates an unassigned page. 

 @return Newly allocated page. */

 	{

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	TCachePage* page=DoAllocL(cache);

 	page[-1].iOwner=this;

 	__ASSERT_DEBUG(page[-1].iChange==EPageNoChange,User::Invariant());

 	page[-1].iRef=KNullPageRef;

 	page->Deque();

 	return page;

 	}

 EXPORT_C TAny* TCachePagePool::LockL(TPageRef aRef)

 /** Locks a page and returns a pointer to it.

 @param aRef Reference to page to lock

 @return Locked page */

 	{

 	if (aRef==KNullPageRef)

 		__LEAVE(KErrNotFound);

 //

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	TCachePage* page=cache.Find(this,aRef);

 	if (page==NULL)

 		{ // it's not in the cache, allocate a free page

 		page=DoAllocL(cache);

 		page[-1].iOwner=NULL;

 		__ASSERT_DEBUG(page[-1].iChange==EPageNoChange,User::Invariant());

 		ReadL(aRef,page);

 		page[-1].iOwner=this;

 		page[-1].iRef=aRef;

 		}

 	__ASSERT_DEBUG(page->IsQued(),Panic(EPageDoubleLock)); // it mustn't be locked already

 	page->Deque();

 	return page;

 	}

 EXPORT_C TPageRef TCachePagePool::AssignL(const TAny* aPage,TPageReclamation aReclamation)

 /** Assigns a reference to a new page and unlocks it. 

 @param aPage Page to assign

 @param aReclamation Flag for page reclaimation settings

 @return Reference to page */

 	{

 	TCachePage* page=(TCachePage*)aPage;

 	__ASSERT_DEBUG(page!=NULL&&!page->IsQued(),Panic(EPageNotLocked));

 	__ASSERT_DEBUG(page[-1].iOwner==this&&page[-1].iRef==KNullPageRef,User::Invariant());

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	page[-1].iOwner=NULL;

 	__ASSERT_DEBUG(page[-1].iChange==EPageNoChange,User::Invariant());

 	cache.iFree.AddLast(*page);

 	TPageRef ref=ExtendL(page,aReclamation);

 	page[-1].iOwner=this;

 	page[-1].iRef=ref;

 	return ref;

 	}

 EXPORT_C void TCachePagePool::UpdateL(const TAny* aPage)

 /** Updates a page. 

 @param aPage Page to update */

 	{

 	TCachePage* page=(TCachePage*)aPage;

 	__ASSERT_DEBUG(page!=NULL&&!page->IsQued(),Panic(EPageNotLocked));

 	__ASSERT_DEBUG(page[-1].iOwner==this&&page[-1].iRef!=KNullPageRef,User::Invariant());

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	page[-1].iOwner=NULL;

 	page[-1].iChange=EPageNoChange;

 	cache.iFree.AddLast(*page);

 	WriteL(page[-1].iRef,page,EPageUpdate);

 	page[-1].iOwner=this;

 	}

 EXPORT_C void TCachePagePool::Unlock(const TAny* aPage,TPageChange aChange)

 //

 // Unlock a page, depending on aChange:

 //		EPageNoChange: just unlock

 //		EPageDirty: mark the page as dirty

 //		EPageUpdate: mark the page as needing a safe update

 //		EPageAbandon: discard the page

 //

 /** Unlocks a page.

 @param aPage Page to unlock

 @param aChange How the page should be treated once it is unlocked */

 	{

 	TCachePage* page=(TCachePage*)aPage;

 	__ASSERT_DEBUG(page!=NULL&&!page->IsQued(),Panic(EPageNotLocked));

 	__ASSERT_DEBUG(page[-1].iOwner==this&&page[-1].iRef!=KNullPageRef,User::Invariant());

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	if (aChange>page[-1].iChange)

 		page[-1].iChange=aChange;

 	else if (aChange<EPageNoChange)

 		{

 		page[-1].iOwner=NULL;

 		page[-1].iChange=EPageNoChange;

 		}

 	cache.iFree.AddLast(*page);

 	}

 EXPORT_C TInt TCachePagePool::Flush()

 /** Flush all pages in this pool from the cache.

 It ensures that any dirty pages are written into persistent storage, but does 

 not remove them from the cache.

 @return KErrNone if successful, otherwise another of the system-wide error 

 codes. */

 	{

 	TRAPD(r,FlushL());

 	return r;

 	}

 EXPORT_C void TCachePagePool::FlushL()

 /** Flushes all pages in this pool from the cache, leaving with a system-wide error 

 code if an error occurs. */

 	{

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	for (SCachePage* page=cache.iPages,*end=cache.iEnd;page<end;++page)

 		{

 		__ASSERT_DEBUG(page->iPage[1].IsQued(),User::Invariant()); // there mustn't be any locked pages

 		if (page->iPage[0].iOwner!=this)

 			continue;

 //

 		TPageChange change=page->iPage[0].iChange;

 		if (change>EPageNoChange)

 			{

 			WriteL(page->iPage[0].iRef,&page->iPage[1],change);

 			page->iPage[0].iChange=EPageNoChange;

 			}

 		}

 	}

 EXPORT_C void TCachePagePool::Purge()

 /** Purge all pages in this pool from the cache.

 This discards all pages from the cache, without saving dirty pages. */

 	{

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	for (SCachePage* page=cache.iPages,*end=cache.iEnd;page<end;++page)

 		{

 		__ASSERT_DEBUG(page->iPage[1].IsQued(),User::Invariant()); // there mustn't be any locked pages

 		if (page->iPage[0].iOwner!=this)

 			continue;

 //

 		page->iPage[0].iOwner=NULL;

 		page->iPage[0].iChange=EPageNoChange;

 		page->iPage[1].Link().Deque();

 		cache.iFree.AddFirst(page->iPage[1]);

 		}

 	}

 EXPORT_C void TCachePagePool::DoDeleteL(TPageRef aRef)

 //

 // Default implementation removing from cache.

 //

 	{

 	__ASSERT_DEBUG(aRef!=KNullPageRef,User::Invariant());

 	CPageCache& cache=*iCache;

 	__ASSERT_DEBUG(iCache!=NULL,Panic(EPageNotOpen));

 	TCachePage* page=cache.Find(this,aRef);

 	if (page!=NULL)

 		{

 		page[-1].iOwner=NULL;

 		page[-1].iChange=EPageNoChange;

 		page->Link().Deque();

 		cache.iFree.AddFirst(*page);

 		}

 	}

 void TCachePagePool::DoAbandon(MPagePool& aPool)

 //

 // Abandon all locked pages in this page pool.

 //

 	{

 	TCachePagePool& pool=STATIC_CAST(TCachePagePool&,aPool);

 	CPageCache& cache=*pool.iCache;

 	__ASSERT_DEBUG(pool.iCache!=NULL,Panic(EPageNotOpen));

 	for (SCachePage* page=cache.iPages,*end=cache.iEnd;page<end;++page)

 		{

 		if (page->iPage[1].IsQued())

 			continue;

 //

 		__ASSERT_DEBUG(page->iPage[0].iOwner==&pool,User::Invariant());

 			// no other page pool can have locked pages

 		page->iPage[0].iOwner=NULL;

 		page->iPage[0].iChange=EPageNoChange;

 		cache.iFree.AddFirst(page->iPage[1]);

 		}

 	}

 TCachePage* TCachePagePool::DoAllocL(CPageCache& aCache)

 	{

 	__ASSERT_ALWAYS(!aCache.iFree.IsEmpty(),Panic(EPageCacheFull));

 		// too small a cache or pages left locked unnecessarily

 	TCachePage* page=aCache.iFree.First();

 	TPageChange change=page[-1].iChange;

 	if (change>EPageNoChange)

 		{

 		page[-1].iOwner->WriteL(page[-1].iRef,page,change);

 		page[-1].iChange=EPageNoChange;

 		}

 	return page;

 	}