// Copyright (c) 2008-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:

// Demonstrates performance assesment of CPermanentFileStore

// The Store root stream serves as an example of persistent data structure

// 

//

// The file name, extension and path for the file store

_LIT(KPermFileStoreName,"Z:\\STOR-TST\\BMPermFileStores.dat");

extern TFileName ThePermStoreFilePath;

// Create a permanent file store and initialise its stream structure

LOCAL_C void doPrepareStoreL(const TDesC& aName);

// Use the store, preserving the stream structure

LOCAL_C void doPermFileStoreL(const TDesC& aName);

// Update the data in the store

LOCAL_C void doUpdateStoreL(CPersistentStore& aStore);

#define PFSTORERUNSIZE	1000

typedef TBuf<100> TItem;

// The main object's in-memory representation

class CItemArray : public CBase

	{

public:

	static TStreamId CreateL(CStreamStore& aStore);

	~CItemArray();

	static CItemArray* NewLC(CStreamStore& aStore,TStreamId anId);

	void RestoreL();

	void StoreL() const;

	void ExternalizeL(RWriteStream& aStream) const;

	//

	void AddItemL(const TItem& anItem);

	void RemoveItemL(TInt anIndex);

	TInt Count() const;

	void GetItemL(TItem& anItem,TInt anIndex) const;

protected:

	CItemArray(CStreamStore& aStore);

	void ConstructL();

	void InternalizeL(RReadStream& aStream);

private:

	CStreamStore& iStore;

	TStreamId iMyId;

	CArrayFixFlat<TStreamId>* iArray;

	CArrayFixFlat<TElement>* nArray;

	};

/**

@SYMTestCaseID          SYSLIB-STORE-PT-1371

@SYMTestCaseDesc	CR MRLM-6A9DF7. Tests the impact of RFileBuf cache size on CPermanentFileStore performance. RFileBuf cache size must be set at a build time in EStor_Template.mmh file, DEFAULT_FILE_BUF_SIZE macro definition.

@SYMTestPriority 	High

@SYMTestActions  	The test creates a set of test objects, externalizes them PFSTORERUNSIZE times and prints the execution time. Then internalizes them PFSTORERUNSIZE times and prints the execution time. PFSTORERUNSIZE is a constant, defined in the source file.

@SYMTestExpectedResults Test must show a performance improvement

@SYMPREQ                PREQ1132

@SYMREQ			REQ4883

*/

LOCAL_C void doPermanentFileStoreL()

    {

    TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	

	TParse permFileStoreName;

	permFileStoreName.Set(drive.Name(), &KPermFileStoreName, NULL);

	ThePermStoreFilePath.Copy(permFileStoreName.FullName());

	TheFs.MkDirAll(permFileStoreName.DriveAndPath());

	doPrepareStoreL(ThePermStoreFilePath);

	TTime start;

	start.HomeTime();

	for(int i=0; i<PFSTORERUNSIZE; i++)

		{

		doPermFileStoreL(ThePermStoreFilePath);

		}

	TTime end;

	end.HomeTime();

	TTimeIntervalMicroSeconds us = end.MicroSecondsFrom(start);

	TheTest.Printf(_L("CPermanentFileStore, %d 'write' tests. Time=%ld ms\r\n"), PFSTORERUNSIZE, us.Int64() / 1000);

	}

LOCAL_C void doPrepareStoreL(const TDesC& aName)

	{

				// construct file store object - the file to contain the

				// the store replaces any existing file of the same name.

	CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs,aName,EFileRead|EFileWrite);

				// Easy way to set the layout type

    store->SetTypeL(store->Layout());

				// create the required stream for CItemArray

	TStreamId id=CItemArray::CreateL(*store);

	store->SetRootL(id);

	store->CommitL();

	CleanupStack::PopAndDestroy();

	}

LOCAL_C void doPermFileStoreL(const TDesC& aName)

	{

				// construct file store object - specifying the file

				// containing the store.

				// Do not need to specify the file store type, this is

				// specified by the file itself

	CFileStore* store = CFileStore::OpenL(TheFs,aName,EFileRead|EFileWrite);

				// The standard form for using permanent file stores:

				// 1. The store object is not owned by the updating code

				// 2  Failure at any point during update, including the

				//    final commit, should result in Revert() being called

				//    on the store (before destruction).

	_LIT(KTxtErrorOccurred,"\n** Error %d occured during store update");

	TRAPD(error,doUpdateStoreL(*store));

	if (error!=KErrNone)

		{

		store->Revert();

		TheTest.Printf(KTxtErrorOccurred);

		}

	// the store is not on the cleanup stack

	delete store;

	}

LOCAL_C void doUpdateStoreL(CPersistentStore& aStore)

	{

				// get the root stream into memory

	CItemArray* array=CItemArray::NewLC(aStore,aStore.Root());

				// Add some items

	_LIT(KTxtHello,"hello");

	_LIT(KTxtWorld," world!");

	TItem item;

	item = KTxtHello;

	array->AddItemL(item);

	item = KTxtWorld;

	array->AddItemL(item);

				// Re-write the root stream with new data

	array->StoreL();

	aStore.CommitL();

				// remove an item

	array->RemoveItemL(1);		// " world!"

				// Re-write the root stream with new data

	array->StoreL();

	aStore.CommitL();

				// Add an item

	_LIT(KTxtCapWorld," WORLD!");

	item= KTxtCapWorld;

	array->AddItemL(item);

				// Re-write the root stream with new data

	array->StoreL();

				// Discard all changes since last store commit

	aStore.Revert();

				// array and aStore are not in snych after revert...

				// restore in-memory version to match store version

	array->RestoreL();

					// Add the item again

	array->AddItemL(item);

				// Re-write the root stream with new data

	array->StoreL();

	aStore.CommitL();

	CleanupStack::PopAndDestroy(); // array

	}

//***************************************************************

CItemArray::~CItemArray()

	{

	delete iArray;

	delete nArray;

	}

CItemArray::CItemArray(CStreamStore& aStore)

	: iStore(aStore)

	{}

TStreamId CItemArray::CreateL(CStreamStore& aStore)

// create the stream representation of the class

	{

				// use a temporary CItemArray

	CItemArray* self=new(ELeave) CItemArray(aStore);

	CleanupStack::PushL(self);

				// construct object

	self->ConstructL();

				// create new stream

	RStoreWriteStream outstream;

	TStreamId id=outstream.CreateLC(aStore);

				// write  external rep

	self->ExternalizeL(outstream);

				// commit stream

	outstream.CommitL();

				// cleanup stream and temporary self

	CleanupStack::PopAndDestroy(2);

	return id;

	}

CItemArray* CItemArray::NewLC(CStreamStore& aStore,TStreamId anId)

// construct a CItemArray from persistent storage

	{

	CItemArray* self=new(ELeave) CItemArray(aStore);

	CleanupStack::PushL(self);

				// construct object

	self->ConstructL();

				// set the stream id for StoreL/RestoreL

	self->iMyId=anId;

				// restore the internal rep.

	self->RestoreL();

	return self;

	}

void CItemArray::StoreL() const

// replace external rep. with internal one

	{

	RStoreWriteStream outstream;

	outstream.ReplaceLC(iStore,iMyId);

	ExternalizeL(outstream);

	outstream.CommitL();

	CleanupStack::PopAndDestroy();

	}

void CItemArray::RestoreL()

// replace internal rep with external one

	{

	iArray->Reset();

	nArray->Reset();

	RStoreReadStream instream;

	instream.OpenLC(iStore,iMyId);

	InternalizeL(instream);

	CleanupStack::PopAndDestroy();

	}

void CItemArray::AddItemL(const TItem& anItem)

// add item to the collection

	{

				// write external rep of item

	RStoreWriteStream outstream;

	TStreamId id=outstream.CreateLC(iStore);

	outstream<<anItem;

	outstream.CommitL();

	CleanupStack::PopAndDestroy();

				// add new stream id to the internal array

	iArray->AppendL(id);

	}

void CItemArray::RemoveItemL(TInt anIndex)

// remove an item from the collection

	{

				// remove the stream from the store

	iStore.DeleteL((*iArray)[anIndex]);

				// remove the entry from the internal array

	iArray->Delete(anIndex);

	}

TInt CItemArray::Count() const

	{

	return iArray->Count();

	}

void CItemArray::GetItemL(TItem& anItem,TInt anIndex) const

	{

				// retrieve an item from the store

	RStoreReadStream instream;

	instream.OpenLC(iStore,(*iArray)[anIndex]);

	instream>>anItem;

	CleanupStack::PopAndDestroy();

	}

void CItemArray::ConstructL()

	{

	iArray=new(ELeave) CArrayFixFlat<TStreamId>(8);

	nArray = new (ELeave) CArrayFixFlat<TElement>(PFSTORERUNSIZE);

	TElement theElement;

	_LIT(KFormatTxt,"BenchMarkingPermanentFileStore%4u");

	TBuf<256> str(KFormatTxt);

	for (TInt index = 0; index < PFSTORERUNSIZE; index++)

		{

		theElement.iData.Format(KFormatTxt,index);

		nArray->AppendL(theElement);

		}

	}

void CItemArray::ExternalizeL(RWriteStream& aStream) const

	{

				// stream out the array

	aStream<<*iArray;

	TInt count = nArray->Count();

	TElement theElement;

	for (TInt index = 0; index < count; index++)

		{

		theElement =((*nArray)[index]);

		aStream.WriteL(theElement.iData, 34);

		}

	}

void CItemArray::InternalizeL(RReadStream& aStream)

	{

				// stream in the array

	aStream>>*iArray;

	TElement theElement;

	TInt count = nArray->Count();

	nArray->Reset();

	for (TInt index = 0; index < count; index++)

		{

		aStream.ReadL(theElement.iData, 34);

		nArray->AppendL(theElement);

		}

	}