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

 		}

 	}