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