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

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

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

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

	}

/**

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()

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

	}

/**

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()

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

	}

/**

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)

		{

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

			{

			}

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

				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)

				{

				iFilePos = aFilePos;

				iLength = ptr.Length();	

				iNextReadFilePos = iFilePos + iLength;

				if(iLength == 0)

					{

					break;	

					}

				}

			else

				{

				DoDiscard();	

				}

			}

		}

	aDes.SetLength(aDes.MaxLength() - len);

	__FILEBUF64_INVARIANT();

	return err;

	}

/**

Writes to the file at the specified offset (aFilePos) within the file.

If certain conditions are met, the data will be stored in the buffer - no call to the file server.

@param aFilePos The offset from the start of the file at which the first byte is written. 

                If a position beyond the end of the file is specified, then

                the write operation begins at the end of the file.

                If the position has been locked, then the write fails.

@param aData The descriptor from which binary data is written. The function writes 

             the entire contents of aData to the file.

@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::Write(TInt64 aFilePos, const TDesC8& aData)

	{

	__FBUF64_ASSERT(aFilePos >= 0, EFBufPanicFilePos);

	__FILEBUF64_INVARIANT();

	if(aData.Length() == 0)

		{

		__FILEBUF64_INVARIANT();

		return KErrNone;	

		}

	TInt err = DoFileSize();

	if(err != KErrNone)

		{

		__FILEBUF64_INVARIANT();

		return err;	

		}

	DoDiscardBufferedReadData();

	const TUint8* data = aData.Ptr();

	for(TInt len = aData.Length(); len > 0 && err == KErrNone;)

		{

		//1. The new write pos is before the buffered file pos

		if(aFilePos < iFilePos)

			{

			//If the new data sticks to/overlapps the old data and there is room in the buffer to move the old data 

			//toward the end, then the new data can be copied at the beginning of the buffer.

			if((aFilePos + len) >= iFilePos && (iFilePos - aFilePos) <= (iCapacity - iLength))

				{

				(void)Mem::Copy(iBase + (iFilePos - aFilePos), iBase, iLength);	//Make room - move the existing data toward the end

				(void)Mem::Copy(iBase, data, len);								//of the buffer. Stick the new data to the old data

				iLength += (iFilePos - aFilePos);