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

 // T_StreamInStore.inl

 // Demonstrates performance assesment of stream creation in non persistent store

 // Create CStreamStoreA object and CStreamStoreB object, externalize them to

 // a non-persistent store and then destroy the CStreamStoreA object

 // 

 //

 LOCAL_C void doStoreL(CStreamStore& aStore,TStreamId& anId);

 // Create an "empty" CStreamStoreA and CStreamStoreB objects and

 // restore them from the in-memory store

 LOCAL_C void doRestoreL(CStreamStore& aStore,const TStreamId& anId);

 #define STREAMSTORERUNSIZE	121

 // Declare example class CStreamStoreA

 class CStreamStoreA : public CBase

 	{

 public :

 	static CStreamStoreA* NewLC();

 	~CStreamStoreA();

 	void     SetTextL(const TDesC& aData);

 	void     ExternalizeL(RWriteStream& aStream) const;

 	void     InternalizeL(RReadStream& aStream);

 public :

 	HBufC*   iVarBuffer;

 	TInt     iIntValue;

 	TUint    iUintValue;

 	};

 // Declare example class CStreamStoreB

 class CStreamStoreB : public CBase

 	{

 public :

 	static CStreamStoreB* NewLC();

 	~CStreamStoreB();

 	void ExternalizeL(RWriteStream& aStream) const;

 	void InternalizeL(RReadStream& aStream);

 private:

 	void		ConstructL();

 public :

 	TBuf<32> iFixBuffer;

 	TUint    iUintValue;

 	TInt     iIntValue;

 	TReal    iRealValue;

 	CArrayFixFlat<TElement>* iArray;

 	};

 /**

 @SYMTestCaseID          SYSLIB-STORE-PT-1370

 @SYMTestCaseDesc	CR MRLM-6A9DF7. Tests the impact of RFileBuf cache size on CBufStore 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 STREAMRUNSIZE times and prints the execution time. Then internalizes them STREAMSTORERUNSIZE times and prints the execution time. STREAMSTORERUNSIZE is a constant, defined in the source file.

 @SYMTestExpectedResults Test must show a performance improvement

 @SYMPREQ                PREQ1132

 @SYMREQ			REQ4883

 */

 LOCAL_C void doStoreStreamsL()

     {

 	// Stream id, kept in memory and used to access the 

 	// (one and only stream) in non-persistent store

 	TStreamId theId;

 	// construct a CBufStore, an in-memory non-persistent store.

 	CStreamStore* store = CBufStore::NewLC(228 /*granularity*/);

 	TTime start;

 	start.HomeTime();

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

 		{

 		doStoreL(*store,theId);

 		}

 	TTime end;

 	end.HomeTime();

 	TTimeIntervalMicroSeconds us = end.MicroSecondsFrom(start);

 	TheTest.Printf(_L("CBufStore, %d 'write' tests. Time=%ld us\r\n"), STREAMSTORERUNSIZE, us.Int64());

 	start.HomeTime();

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

 		{

 		doRestoreL(*store,theId);

 		}

 	end.HomeTime();

 	us = end.MicroSecondsFrom(start);

 	TheTest.Printf(_L("CBufStore, %d 'read' tests.  Time=%ld us\r\n"), STREAMSTORERUNSIZE, us.Int64());

 	// destroy the CBufStore object

 	CleanupStack::PopAndDestroy();

 	}

 LOCAL_C void doStoreL(CStreamStore& aStore,TStreamId& anId)

 	{

 	// Create CStreamStoreA and put some data into it

 	_LIT(KTxtForClassA,"Text for CStreamStoreA");

 	CStreamStoreA* theA = CStreamStoreA::NewLC();

 	theA->SetTextL(KTxtForClassA);

 	theA->iIntValue  = -1;

 	theA->iUintValue = 2;

 	// Create CStreamStoreB and put some data into it

 	_LIT(KTxtForClassB,"Text for CStreamStoreB");

 	CStreamStoreB* theB = CStreamStoreB::NewLC();

 	theB->iFixBuffer = KTxtForClassB;

 	theB->iIntValue  = -3;

 	theB->iUintValue = 4; 

 	theB->iRealValue = 5.6;

 	TElement theElement;

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

 	TBuf<256> str(KFormatTxt);

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

 		{

 		theElement.iData.Format(KFormatTxt,index);

 		theB->iArray->AppendL(theElement);

 		}

 	// Create the output stream. Stream id (the only one) is kept in memory.

 	RStoreWriteStream outstream;

 	anId = outstream.CreateLC(aStore);

 	outstream  << *theA; 

 	outstream  << *theB;

 	outstream.CommitL();

 						//outstream

 						//theB

 						//theA

 	CleanupStack::PopAndDestroy(3);

 	}

 LOCAL_C void doRestoreL(CStreamStore& aStore,const TStreamId& anId)

 	{

 	__UHEAP_MARK;

 	// Create  an "empty" CStreamStoreA and CStreamStoreB objects

 	CStreamStoreA* theA = CStreamStoreA::NewLC();

 	CStreamStoreB* theB = CStreamStoreB::NewLC();

 	// Create/open the input stream. Access the one and only stream from in-memory store.

 	RStoreReadStream instream;

 	instream.OpenLC(aStore,anId);

 	// Stream in CStreamStoreA object first and then stream in the CStreamStoreB object. 

 	// This is the order in which the objects were streamed out.

 	instream >> *theA;

 	instream >> *theB;

 									// instream

 									// theB

 	CleanupStack::PopAndDestroy(3); // theA 

 	__UHEAP_MARKEND;

 	}

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

 CStreamStoreA* CStreamStoreA::NewLC()

 	{

 	CStreamStoreA* self = new (ELeave) CStreamStoreA;

 	CleanupStack::PushL(self);

 	return self;

 	}

 CStreamStoreA::~CStreamStoreA()

 	{

 	delete iVarBuffer;

 	}

 void CStreamStoreA::SetTextL(const TDesC& aData)

 	{

 	iVarBuffer = aData.AllocL();	

 	}

 void CStreamStoreA::ExternalizeL(RWriteStream& aStream) const

 	{

 	aStream.WriteInt32L(iVarBuffer->Des().MaxLength());

 	aStream << *iVarBuffer;

 	aStream.WriteInt32L(iIntValue);

 	aStream.WriteUint32L(iUintValue);

 	}

 void CStreamStoreA::InternalizeL(RReadStream& aStream)

 	{

 	TInt maxlen;

 	maxlen     = aStream.ReadInt32L();

 	iVarBuffer = HBufC::NewL(aStream,maxlen);

 	iIntValue  = aStream.ReadInt32L();

 	iUintValue = aStream.ReadUint32L();

 	}

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

 CStreamStoreB* CStreamStoreB::NewLC()

 	{

 	CStreamStoreB* self = new (ELeave) CStreamStoreB;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 CStreamStoreB::~CStreamStoreB()

 	{

 	delete iArray;

 	}

 void CStreamStoreB::ConstructL()

 	{

 	iArray = new (ELeave) CArrayFixFlat<TElement> (STREAMSTORERUNSIZE);

 	}

 void CStreamStoreB::ExternalizeL(RWriteStream& aStream) const

 	{

 	aStream << iFixBuffer;

 	aStream.WriteInt32L(iIntValue);

 	aStream.WriteUint32L(iUintValue);

 	aStream.WriteReal64L(iRealValue);

 	TElement theElement;

 	TInt count = iArray->Count();

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

 		{

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

 		aStream.WriteL(theElement.iData, 27);

 		}

 	}

 void CStreamStoreB::InternalizeL(RReadStream& aStream)

 	{

 	aStream >> iFixBuffer;

 	iIntValue  = aStream.ReadInt32L();

 	iUintValue = aStream.ReadUint32L();

 	iRealValue = aStream.ReadReal64L();

 	TElement theElement;

 	iArray->Reset();

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

 		{

 		aStream.ReadL(theElement.iData, 27);

 		iArray->AppendL(theElement);

 		}

 	}