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

//

	{}