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

#define UNUSED_VAR(a) a = a

const TInt KMemPoolGranularity=16;

EXPORT_C void MPagePool::PushL()
/** Pushes this object onto the cleanup stack. */
	{
	CleanupStack::PushL(TCleanupItem(REINTERPRET_CAST(TCleanupOperation,AcquireL()),this));
		// platform dependency
	}

EXPORT_C void MPagePool::Delete(TPageRef aRef)
/** Deletes a page, ignoring any errors.

@param aRef Reference to the page to delete */
	{
	TRAPD(ignore,DeleteL(aRef));
    UNUSED_VAR(ignore);
	}

EXPORT_C void MPagePool::DeleteL(TPageRef aRef)
/** Deletes a page, leaving if an error occurs.

@param aRef Reference to the page to delete */
	{
	if (aRef!=KNullPageRef)
		DoDeleteL(aRef);
	}

EXPORT_C CMemPagePool* CMemPagePool::NewL()
/** Allocates and constructs a new CMemPagePool object.

@return New CMemPagePool object */
	{
	CMemPagePool* pool=new(ELeave) CMemPagePool;
	return pool;
	}

EXPORT_C CMemPagePool *CMemPagePool::NewLC()
/** Allocates and constructs a new CMemPagePool object, and leaves it on the cleanup 
stack.

@return New CMemPagePool object */
	{
	CMemPagePool* pool=NewL();
	CleanupStack::PushL(pool);
	return pool;
	}

EXPORT_C CMemPagePool::CMemPagePool()
	: iPages(KMemPoolGranularity)
/** Default constructor. */
	{}

EXPORT_C CMemPagePool::~CMemPagePool()
/** Destructor.

On destruction, memory for all pages is freed. */
	{
	for (TInt ii=iPages.Count();--ii>=0;)
		User::Free(iPages[ii]);
	}

EXPORT_C TPageAbandonFunction CMemPagePool::AcquireL()
/** For memory-based pools, there is no need to abandon pages, so the function 
returned does nothing. 

@return Function that does nothing. */
	{
	return &DoAbandon;
	}

EXPORT_C TAny* CMemPagePool::AllocL()
/** Allocates a new unassigned page. 

@return Newly allocated page. */
	{
	TAny* page=User::AllocLC(KPoolPageSize);
	iPages.AppendL(page);
	CleanupStack::Pop();
	return page;
	}

EXPORT_C TAny* CMemPagePool::LockL(TPageRef aRef)
/** Returns a pointer to a specified page.

@param aRef Reference to the page to get
@return Page specified by aRef */
	{
	TAny* page=PageL(aRef);
	if (page==NULL)
		__LEAVE(KErrNotFound);
//
	return page;
	}

EXPORT_C TPageRef CMemPagePool::AssignL(const TAny* __DEBUG(aPage),TPageReclamation)
//
// Assign a reference to a newly allocated page. Supports only a single unassigned page at a time.
//
	{
	__ASSERT_DEBUG(iPages[iPages.Count()-1]==aPage,User::Invariant());
	return TPageRef(iPages.Count());
	}

EXPORT_C void CMemPagePool::UpdateL(const TAny*)
//
// Memory-based pages don't need to be updated.
//
	{}

EXPORT_C void CMemPagePool::Unlock(const TAny*,TPageChange)
//
// Memory-based pages don't need to be unlocked.
//
	{}

EXPORT_C void CMemPagePool::DoDeleteL(TPageRef aRef)
//
// Delete the page denoted by aRef.
//
	{
	TAny*& page=PageL(aRef);
	if (page==NULL)
		__LEAVE(KErrNotFound);
//
	User::Free(page);
	page=NULL;
	}

TAny*& CMemPagePool::PageL(TPageRef aRef)
//
// Return the page slot at aRef.
//
	{
	TInt i=aRef.Value()-1;
	if (i<0||i>=iPages.Count())
		__LEAVE(KErrNotFound);
//
	return iPages[i];
	}

void CMemPagePool::DoAbandon(MPagePool&)
//
// Abandoning memory-based pages is a no-op.
//
	{}