// 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:

//

#include "FileBuf64.h"

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////        PROFILER       ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef _SQLPROFILER

extern TBool TheOsCallTimeDetailedProfileEnabled;//If true, the OS porting layer call details are enabled and for each call an entry will be added to the log file (epocwind.out).

#define PROFILE_READ(pos,amount) \

	do \

		{ \

		if(TheOsCallTimeDetailedProfileEnabled) \

			{ \

			++iFileReadCount; iFileReadAmount += (amount); \

			RDebug::Print(_L(" -- FRead    this=%X, Cnt=%d, Pos=%ld, Amt=%d, Ttl=%ld\r\n"), (TUint32)this, iFileReadCount,  pos, amount, iFileReadAmount); \

			} \

		} while(0)

#define PROFILE_WRITE(pos,amount) \

	do \

		{ \

		if(TheOsCallTimeDetailedProfileEnabled) \

			{ \

			++iFileWriteCount, iFileWriteAmount += (amount); \

			RDebug::Print(_L(" -- FWrite   this=%X, Cnt=%d, Pos=%ld, Amt=%d, Ttl=%ld\r\n"), (TUint32)this, iFileWriteCount, pos, amount, iFileWriteAmount); \

			} \

		} while(0)

#define PROFILE_SIZE() \

	do \

		{ \

		if(TheOsCallTimeDetailedProfileEnabled) \

			{ \

			++iFileSizeCount; \

			RDebug::Print(_L(" -- FSize    this=%X, Cnt=%d\r\n"), (TUint32)this, iFileSizeCount); \

			} \

		} while(0)

#define PROFILE_SETSIZE() \

	do \

		{ \

		if(TheOsCallTimeDetailedProfileEnabled) \

			{ \

			++iFileSetSizeCount; \

			RDebug::Print(_L(" -- FSetSize this=%X, Cnt=%d\r\n"), (TUint32)this, iFileSetSizeCount); \

			} \

		} while(0)

#define PROFILE_FLUSH()	\

	do \

		{ \

		if(TheOsCallTimeDetailedProfileEnabled) \

			{ \

			++iFileFlushCount; \

			RDebug::Print(_L(" -- FFlush   this=%X, Cnt=%d\r\n"), (TUint32)this, iFileFlushCount); \

			} \

		} while(0)

#else

#define PROFILE_READ(pos,amount)	void(0)

#define PROFILE_WRITE(pos,amount)	void(0)

#define PROFILE_SIZE()			void(0)

#define PROFILE_SETSIZE()		void(0)

#define PROFILE_FLUSH()			void(0)

#endif//_SQLPROFILER

/**

This constant is used for initializing the RFileBuf64::iFileSize data member and means that

the iFileSize is not yet initialized with the real file size value. 

(RFileBuf64::iFileSize caches the file size value)

@internalComponent

*/

static const TInt KFileSizeNotSet = -1;

/**

This constant is used as a default initializer for the RFileBuf64::iNextReadFilePos data member,

indicating that the "guessed" file read offset is invalid and should not be used.

@internalComponent

*/

static const TInt KNextReadFilePosNotSet = -1;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////        ASSERTS & INVARIANT      //////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef _DEBUG

#define __FILEBUF64_INVARIANT() Invariant()

/**

String literal used in _DEBUG mode for indicating that the reported panic happened inside the RFileBuf64 implementation.

@see TFileBufPanic64

@internalComponent

*/

_LIT(KPanicCategory, "FBuf64");

/**

Set of numeric constants used together with the KPanicCategory string literal in _DEBUG mode for providing more detailed

information about the reason of the panic.

@see KPanicCategory

@internalComponent

*/

enum TFileBufPanic64

	{

	EFBufPanicCapacity = 1,				//1

	EFBufPanicNullBuf,

	EFBufPanicBufLen,

	EFBufPanicFilePos,

	EFBufPanicFileSize,					//5

	EFBufPanicFileHandle,

	EFBufPanicFsHandle,

	EFBufPanicMsgHandle,

	EFBufPanicMsgIndex,

	EFBufPanicFileNameLen,				//10

	EFBufPanicNullThis,

	EFBufPanicDirty,

	EFBufPanicNextReadFilePos,

	EFBufPanicNextReadFilePosHits,

	EFBufPanicFileBlockSize,			//15

	};

/**

Helper function used in the implementation of the __FBUF64_ASSERT() macro.

In case if the expression in __FBUF64_ASSERT() macro evaluates to false, 

PanicFileBuf64() will use the supplied aLine and aPanicCode arguments together with the KPanicCategory string literal

to prepare and print out a line (including the time of the panic) to the default log. The calling thread will be panic'ed

after that.

@see TFileBufPanic64

@see KPanicCategory

@internalComponent

*/

static void PanicFileBuf64(TInt aLine, TFileBufPanic64 aPanicCode)

	{

	TTime time;

	time.HomeTime();

	TDateTime dt = time.DateTime();

	TBuf<16> tbuf;

	tbuf.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());

	TBuf<64> buf;

	_LIT(KFormat,"**%S:RFileBuf64 panic %d, at line(%d)");

	buf.Format(KFormat, &tbuf, aPanicCode, aLine);

	RDebug::Print(buf);

	User::Panic(KPanicCategory, aPanicCode);

	}

/**

This macro should be used when there is a need to panic the client/server if "expr" condition is not satisfied.

Works in only in debug mode. In release mode evaluates to nothing.

@see TFileBufPanic64

@see KPanicCategory

@see PanicFileBuf64()

@internalComponent

*/

#define __FBUF64_ASSERT(expr, panicCode)	(void)(!(expr) ? ::PanicFileBuf64(__LINE__, panicCode) : void(0))

#else //_DEBUG

#define __FILEBUF64_INVARIANT() void(0)

#define __FBUF64_ASSERT(expr, panicCode) 	void(0)

#endif//_DEBUG

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////        MFileInitializer64    /////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

MFileInitializer64 interface provides only one abstract method - Init() that is used during the initialization of

the RFileBuf64 objects.

Here is what is the problem MFileInitializer64 tries to solve.

RFileBuf64 has 4 different "resource acquisition" methods - Create(), Open() and Temp().

They perform different actions and have different input arguments.

This is the variable part of the RFileBuf64 initialization.

Apart from that, RFileBuf64 has a "fixed" initialization part that does not change whatever the variable part is.

If MFileInitializer64 interface is not used then the following chunk of code has to be duplicated 4 times:

@code

	TInt err = do_fixed_init();

	if(err == KErrNone)

		{

		err = do_variable_init();

		if(err != KErrNone)

			{

			revert_fixed_init();

			}

		}

	return err;

@endcode

In order to avoid the code duplication, the fixed part of the initialization is moved to RFileBuf64::DoInit(), which

is given a reference to a MFileInitializer64 derived class that performas the variable part of the initialization.

4 different MFileInitializer64 derived classes are provided for the 4 different "resource acquisition" methods.

All they store the variable part of the RFileBuf64 initialization parameters and implement MFileInitializer64::Init().

@see RFileBuf64::DoInit()

@internalComponent

*/

struct MFileInitializer64

	{

	virtual TInt Init(RFile64& aFile) = 0;

	};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////        RFileBuf64    /////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Initializes RFileBuf64 data members with their default values.

@param aSize Max file buffer size (capacity) in bytes.

@panic FBuf64 1 In _DEBUG mode - aSize is 0 or negative.

*/

RFileBuf64::RFileBuf64(TInt aSize) :

	iCapacity(aSize),

	iReadAheadSize(RFileBuf64::KDefaultReadAheadSize)

	{

	__FBUF64_ASSERT(aSize > 0, EFBufPanicCapacity);

	}

/**

Initializes the RFileBuf64 object and creates and opens a new file that will be accessed through RFileBuf64 public interface.

If the file already exists, an error is returned.

If the resulting path does not exist, then the operation cannot proceed and the function returns an error code.

@param aFs       The file server session.

@param aFileName The name of the file. Any path components (i.e. drive letter

                 or directory), which are not specified, are taken from

                 the session path.

@param aFileMode The mode in which the file is opened. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Create()

@see MFileInitializer64

@panic FBuf64  7 In _DEBUG mode - Invalid aFs object (null file session handle).

@panic FBuf64 10 In _DEBUG mode - Invalid file name length (zero file name length).

*/

TInt RFileBuf64::Create(RFs& aFs, const TDesC& aFileName, TUint aFileMode)

	{

	__FBUF64_ASSERT(aFs.Handle() != 0, EFBufPanicFsHandle);

	__FBUF64_ASSERT(aFileName.Length() > 0, EFBufPanicFileNameLen);

	struct TFileCreateInitializer64 : public MFileInitializer64

		{

		inline TFileCreateInitializer64(RFs& aFs, const TDesC& aFileName, TUint aFileMode) :

			iFs(aFs),

			iFileName(aFileName),

			iFileMode(aFileMode)

			{

			}

		virtual TInt Init(RFile64& aFile)

			{

			return aFile.Create(iFs, iFileName, iFileMode);

			}

		RFs& 			iFs;

		const TDesC& 	iFileName;

		TUint 			iFileMode;

		} initializer(aFs, aFileName, aFileMode);

	return DoInit(initializer);

	}

/**

Initializes the RFileBuf64 object and opens an existing file that will be accessed through RFileBuf64 public interface.

If the file does not already exist, an error is returned.

@param aFs       The file server session.

@param aFileName The name of the file. Any path components (i.e. drive letter

                 or directory), which are not specified, are taken from

                 the session path.

@param aFileMode The mode in which the file is opened. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Open()

@see MFileInitializer64

@panic FBuf64  7 In _DEBUG mode - Invalid aFs object (null file session handle).

@panic FBuf64 10 In _DEBUG mode - Invalid file name length (zero file name length).

*/

TInt RFileBuf64::Open(RFs& aFs, const TDesC& aFileName, TUint aFileMode)

	{

	__FBUF64_ASSERT(aFs.Handle() != 0, EFBufPanicFsHandle);

	__FBUF64_ASSERT(aFileName.Length() > 0, EFBufPanicFileNameLen);

	struct TFileOpenInitializer64 : public MFileInitializer64

		{

		inline TFileOpenInitializer64(RFs& aFs, const TDesC& aFileName, TUint aFileMode) :

			iFs(aFs),

			iFileName(aFileName),

			iFileMode(aFileMode)

			{

			}

		virtual TInt Init(RFile64& aFile)

			{

			return aFile.Open(iFs, iFileName, iFileMode);

			}

		RFs& 			iFs;

		const TDesC& 	iFileName;

		TUint 			iFileMode;

		} initializer(aFs, aFileName, aFileMode);

	return DoInit(initializer);

	}

/**

Initializes the RFileBuf64 object and creates and opens a temporary file with unique name that will be accessed through 

RFileBuf64 public interface.

@param aFs       The file server session.

@param aPath     The directory in which the file is created.

@param aFileName On return, contains the full path and file name of the file.

                 The filename is guaranteed to be unique within the directory

                 specified by aPath.

@param aFileMode The mode in which the file is opened. The access mode is

                 automatically set to EFileWrite. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Temp()

@see MFileInitializer64

@panic FBuf64  7 In _DEBUG mode - Invalid aFs object (null file session handle).

*/

TInt RFileBuf64::Temp(RFs& aFs, const TDesC& aPath, TFileName& aFileName, TUint aFileMode)

	{

	__FBUF64_ASSERT(aFs.Handle() != 0, EFBufPanicFsHandle);

	struct TFileTempInitializer64 : public MFileInitializer64

		{

		inline TFileTempInitializer64(RFs& aFs, const TDesC& aPath, TFileName& aFileName, TUint aFileMode) :

			iFs(aFs),

			iPath(aPath),

			iFileName(aFileName),

			iFileMode(aFileMode)

			{

			}

		virtual TInt Init(RFile64& aFile)

			{

			return aFile.Temp(iFs, iPath, iFileName, iFileMode);

			}

		RFs& 			iFs;

		const TDesC& 	iPath;

		TFileName& 		iFileName;

		TUint 			iFileMode;

		} initializer(aFs, aPath, aFileName, aFileMode);

	return DoInit(initializer);

	}

/**

Writes to the file the pending data (if the buffer contains pending data), closes the file and releases

the RFileBuf64 resources. 

RFileBuf64::Flush() should be called before RFileBuf64::Close() to ensure that if there are pending data, they will

be written to the file and if the operation fails, the caller will be notified with an appropriate return error.

@see RFileBuf64::Flush()

*/

void RFileBuf64::Close()

	{

	if(iFile.SubSessionHandle() != 0 && iBase != 0)

		{

		(void)DoFileWrite2();

		}

	iFile.Close();

	User::Free(iBase);

	iBase = 0;

	}

/**

Calculates and sets optimal read-ahead buffer size.

@param aBlockSize The size of a file block in bytes

@param aReadRecBufSize The recommended buffer size for optimised reading performance

@return The new read-ahead value

@see TVolumeIOParamInfo

*/

TInt RFileBuf64::SetReadAheadSize(TInt aBlockSize, TInt aReadRecBufSize)

	{

	__FILEBUF64_INVARIANT();

	if(aReadRecBufSize > 0 && (aReadRecBufSize & (aReadRecBufSize - 1)) == 0 && aReadRecBufSize > RFileBuf64::KDefaultReadAheadSize)

		{

		iReadAheadSize = aReadRecBufSize > iCapacity ? iCapacity : aReadRecBufSize;

		}

	else if(aBlockSize > 0 && (aBlockSize & (aBlockSize - 1)) == 0 && aBlockSize > RFileBuf64::KDefaultReadAheadSize)

		{

		iReadAheadSize = aBlockSize > iCapacity ? iCapacity : aBlockSize;

		}

	__FILEBUF64_INVARIANT();

	return iReadAheadSize;

	}

/**

Reads from the file at the specified position (aFilePos).

If the data to be read is in the buffer, then the data will be taken from the buffer.

@param aFilePos Position of first byte to be read.  This is an offset from

            the start of the file. 

            If aPos is beyond the end of the file, the function returns

            a zero length descriptor.

@param aDes Descriptor into which binary data is read. Any existing contents 

            are overwritten. On return, its length is set to the number of

            bytes read.

@return KErrNone if successful, otherwise one of the other system-wide error  codes.

@panic FBuf64  4 In _DEBUG mode - negative aFilePos value.

See RFileBuf64::Invariant() for other possible panics that may occur when this method is called.

@see RFileBuf64::Invariant()

*/

TInt RFileBuf64::Read(TInt64 aFilePos, TDes8& aDes)

	{

	__FBUF64_ASSERT(aFilePos >= 0, EFBufPanicFilePos);

	__FILEBUF64_INVARIANT();

	aDes.SetLength(0);

	//1. The output buffer max len is 0

	if(aDes.MaxLength() == 0)

		{

		__FILEBUF64_INVARIANT();

		return KErrNone;	

		}

	//2. Initialize the "iFileSize" if it is not initialized yet

	TInt err = DoFileSize();

	if(err != KErrNone)

		{

		__FILEBUF64_INVARIANT();

		return err;	

		}

	//3. Too big "read" request - read directly from the file

	TInt len = aDes.MaxLength();

	if(len > iCapacity)

		{

		if((aFilePos + len) > iFilePos && !(aFilePos >= (iFilePos + iLength)))

			{//Write the pending data if the iDirty flag is set, otherwise preserve the buffer content.

			err = DoFileWrite1(aFilePos);

			}

		if(err == KErrNone)

			{

			err = iFile.Read(aFilePos, aDes);

			PROFILE_READ(aFilePos, aDes.Size());

			}

		__FILEBUF64_INVARIANT();

		return err;

		}

	//4. The requested data size is smaller than the buffer capacity

	TUint8* outptr = const_cast <TUint8*> (aDes.Ptr());

	while(len > 0 && err == KErrNone && aFilePos < iFileSize)

		{

		//1. If part of all of the data is in the buffer - copy the data to the target location

		if(aFilePos >= iFilePos && aFilePos < (iFilePos + iLength))

			{

			TInt l = Min(len, (iFilePos + iLength - aFilePos));

			outptr = Mem::Copy(outptr, iBase + (aFilePos - iFilePos), l);

			len -= l;

			aFilePos += l;

			}

		//2. Perform a read-ahead operation

		else

			{

			//Write the pending data if the iDirty flag is set, otherwise preserve the buffer content.

			err = DoFileWrite1(aFilePos);

			if(err != KErrNone)

				{

				break;	

				}

			if(iNextReadFilePos != aFilePos)

				{//Direct "file read" operation

				iNextReadFilePosHits = 0;

				TPtr8 ptr2(outptr, len);

				err = iFile.Read(aFilePos, ptr2);

				PROFILE_READ(aFilePos, ptr2.Size());

				if(err == KErrNone)

					{

					iNextReadFilePos = aFilePos + len;

					len -= ptr2.Length();

					}

				break;

				}

			//The guessed from the previous "file read" operation file pos is correct. Start reading-ahead.

			const TInt KMaxReadFilePosHits = 8;//The max read-ahead buffer size can be up to 2^8 times the iReadAheadSize

			if(iNextReadFilePosHits < KMaxReadFilePosHits)

				{

				++iNextReadFilePosHits;

				}

			TInt maxReadAhead = iReadAheadSize * (1 << iNextReadFilePosHits);

			TInt align = (aFilePos + len + maxReadAhead) & (iReadAheadSize - 1);

			TInt readahead = maxReadAhead - align;

			if(readahead < 0)

				{

				// if read-ahead doesn't cross block boundary do it all

				readahead = maxReadAhead;	

				}

			TPtr8 ptr(iBase, Min(iCapacity, (len + readahead)));

			err = iFile.Read(aFilePos, ptr);

			PROFILE_READ(aFilePos, ptr.Size());

			if(err == KErrNone)

				{