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

	}