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

// This is the file name, extension and path specification for the file store 

// and should not be used as is

// 

//

_LIT(KStreamsName, "Z:\\STOR-TST\\BMStreams.dat");

extern TFileName TheStreamsFilePath;

// Construct CCompound object and externalize it to a single stream

LOCAL_C void doExternalizeL(const TDesC& aName);

// Internalize CCompound object from the stream

LOCAL_C void doInternalizeL(const TDesC& aName);

#define STREAMRUNSIZE 500

// Declare a class used by the example

class CStreamA

	{

public :

	void ExternalizeL(RWriteStream& aStream) const;

	void InternalizeL(RReadStream& aStream);

public :

	TBuf<32> iBufferA;

	TInt     iXA;

	TUint    iYA;

	};

class TStream

	{

public :

	void ExternalizeL(RWriteStream& aStream) const;

	void InternalizeL(RReadStream& aStream);

public :

	TReal iZC;

	};

class CCompound : public CBase

	{

public :

	~CCompound();

	static		CCompound* NewLC();

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

	static		CCompound* NewL(CStreamStore& aStore,TStreamId anId);

	TStreamId	StoreL(CStreamStore& store);

	void		RestoreL(CStreamStore& aStore,TStreamId anId);

	void		InternalizeL(RReadStream& aStream);

	void		ExternalizeL(RWriteStream& aStream) const;

private:

    void		ConstructL();

	void		ConstructL(CStreamStore& aStore,TStreamId anId);

public :

	CStreamA* iCa;

	TStream  iTc;

	CArrayFixFlat<TElement>* iArray;

	};

/**

@SYMTestCaseID          SYSLIB-STORE-PT-1369

@SYMTestCaseDesc	CR MRLM-6A9DF7. Tests the impact of RFileBuf cache size on CDirectFileStore 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 STREAMRUNSIZE times and prints the execution time.

STREAMRUNSIZE is a constant, defined in the source file.

@SYMTestExpectedResults Test must show a performance improvement

@SYMPREQ                PREQ1132

@SYMREQ			REQ4883

*/

LOCAL_C void doStreamingL()

    {

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

	TParse streamsName;

	streamsName.Set(drive.Name(), &KStreamsName, NULL);

	TheStreamsFilePath.Copy(streamsName.FullName());

	// make sure directory exists

	TheFs.MkDirAll(streamsName.DriveAndPath());

	TTime start;

	start.HomeTime();

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

		{

		doExternalizeL(TheStreamsFilePath);	

		}

	TTime end;

	end.HomeTime();

	TTimeIntervalMicroSeconds us = end.MicroSecondsFrom(start);

	TheTest.Printf(_L("CDirectFileStore, externalise %d streams. Time=%ld ms\r\n"), STREAMRUNSIZE, us.Int64() / 1000);

	start.HomeTime();

	for(int j=0; j<STREAMRUNSIZE;j++)

		{

		doInternalizeL(TheStreamsFilePath);

		}

	end.HomeTime();

	us = end.MicroSecondsFrom(start);

	TheTest.Printf(_L("CDirectFileStore, internalise %d streams. Time=%ld ms\r\n"), STREAMRUNSIZE, us.Int64() / 1000);

	}

LOCAL_C void doExternalizeL(const TDesC& aName)

	{

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

	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs,aName,EFileWrite);

	// Must say what kind of file store

    store->SetTypeL(KDirectFileStoreLayoutUid);

	// Construct an object of type CCompound and prepare some data into it

	CCompound* thecompound = CCompound::NewLC();

	_LIT(KTxtClassAText,"CStreamA text");

	thecompound->iCa->iBufferA = KTxtClassAText;

	thecompound->iCa->iXA      = -1;

	thecompound->iCa->iYA      = 2;

	thecompound->iTc.iZC       = 3.456;

	TElement theElement;

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

	TBuf<256> str(KFormatTxt);

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

		{

		theElement.iData.Format(KFormatTxt,index);

		thecompound->iArray->AppendL(theElement);

		}

	// Store the compound object to a single stream and save the stream id as the root id

	TStreamId  id = thecompound->StoreL(*store);

	// Set the stream id as the root

	store->SetRootL(id);

	// Commit changes to the store

	store->CommitL();

									// thecompound

	CleanupStack::PopAndDestroy(2); // store

	}

LOCAL_C void doInternalizeL(const TDesC& aName)

	{

	//Create file store object - specifying the file containing the store.

	CFileStore* store = CDirectFileStore::OpenLC(TheFs,aName,EFileRead);

	// Construct a CCompound object from the root stream created earlier.

	CCompound* thecompound = CCompound::NewL(*store,store->Root());

	// destroy the store object (this also closes the file containing the store) 

	CleanupStack::PopAndDestroy();

	// Now destroy the CCompound object

	delete thecompound;

	}

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

// The CCompound destructor

CCompound::~CCompound()

	{

	delete iCa;

	delete iArray;

	}

CCompound* CCompound::NewLC()

	{

	CCompound* self=new (ELeave) CCompound;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CCompound::ConstructL()

	{

	iCa = new (ELeave) CStreamA;

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

	}

// Construct a new CCompound object from the input stream.

CCompound* CCompound::NewL(CStreamStore& aStore,TStreamId anId)

	{

	CCompound* self=CCompound::NewLC(aStore,anId);

	CleanupStack::Pop();

	return self;

	}

// Construct CCompound object from the root stream of the store

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

	{

	CCompound* self=new (ELeave) CCompound;

	CleanupStack::PushL(self);

	self->ConstructL(aStore,anId);

	return self;

	}

void CCompound::ConstructL(CStreamStore& aStore,TStreamId anId)

	{

	iCa = new (ELeave) CStreamA;

	// Restore here at construction

	RestoreL(aStore,anId);

	}

void CCompound::RestoreL(CStreamStore& aStore,TStreamId anId)

	{

	RStoreReadStream instream;

	instream.OpenLC(aStore,anId);

	InternalizeL(instream);

	// Cleanup the stream object

	CleanupStack::PopAndDestroy();			

	}

// Read the components and data members of the CCompound object from stream

void CCompound::InternalizeL(RReadStream& aStream)

	{

	aStream >> *iCa;

	aStream >> iTc;

	TElement theElement;

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

//	iArray->Count();

//	iArray->Reset();

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

		{

		aStream.ReadL(theElement.iData, 25);

		iArray->AppendL(theElement);

		}

	}

TStreamId CCompound::StoreL(CStreamStore& aStore)

	{

	RStoreWriteStream outstream;

	TStreamId id = outstream.CreateLC(aStore);

	// Stream out this CCompound object

	ExternalizeL(outstream);

	// Commit changes to the stream

	outstream.CommitL();

	// Cleanup the stream object.

	CleanupStack::PopAndDestroy();

	return id;

	}

// Write the components and data members of the CCompound object to stream

void CCompound::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << *iCa;

	aStream << iTc;

	TElement theElement;

	TInt count = iArray->Count();

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

		{

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

		aStream.WriteL(theElement.iData, 25);

		}

	}

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

// Read the data members of the CStreamA  object from the stream.

void CStreamA::InternalizeL(RReadStream& aStream)

	{

	aStream >> iBufferA;

  	iXA = aStream.ReadInt32L();

	iYA = aStream.ReadUint32L();

	}  

// Write the data members of the CStreamA object to the stream

void CStreamA::ExternalizeL(RWriteStream& aStream)const

	{

	aStream << iBufferA;

	aStream.WriteInt32L(iXA);

	aStream.WriteUint32L(iYA);

	}  

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

// Write the data member(s) of the TStream object to the stream

void TStream::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteReal64L(iZC);

	}  

// Read the data member(s) of the TStream object from the stream.

void TStream::InternalizeL(RReadStream& aStream)

	{

	iZC = aStream.ReadReal64L();

	}